Java RedisClient.create方法代码示例

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
public Database(String serverID, String hostname, String password, int port, int dbnumber) {
    this.serverID = serverID;

    RedisURI redisURI = RedisURI.builder()
                                .withHost(hostname)
                                .withPassword(password)
                                .withPort(port)
                                .withDatabase(dbnumber)
                                .withClientName("rmanager-" + serverID)
                                .build();

    redisClient = RedisClient.create(redisURI);

    syncCommands = redisClient.connect().sync();

    new RedisMessenger(serverID, redisURI);
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@Test
public void sync() {
  RedisClient client = RedisClient.create("redis://localhost");

  StatefulRedisConnection<String, String> connection =
      new TracingStatefulRedisConnection<>(client.connect(), mockTracer, false);
  RedisCommands<String, String> commands = connection.sync();

  assertEquals("OK", commands.set("key", "value"));
  assertEquals("value", commands.get("key"));

  connection.close();

  client.shutdown();

  List<MockSpan> spans = mockTracer.finishedSpans();
  assertEquals(2, spans.size());
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
private void start() {
	DefaultClientResources clientResources = DefaultClientResources.builder() //
			.dnsResolver( new DirContextDnsResolver() ) // Does not cache DNS lookups (needed for ElasticCache)
			.build();

	redisClient = RedisClient.create( clientResources, server );
	connection = redisClient.connect();
	asyncCommands = connection.async();
	reactiveCommands = connection.reactive();

	/*
	 * Run the global clean up scheduler,
	 * which cleans expired keys from all regions in the Redis instance in background
	 */
	runGlobalCleanupScheduler();

	if ( cfEngine.thisPlatform != null )
		cfEngine.log( getName() + " server: " + server + "; WaitTimeSeconds: " + waitTimeSeconds );
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@Test
public void test() {
    RedisClient client = RedisClient.create("redis://127.0.0.1");
    LettuceConnectionManager m = LettuceConnectionManager.defaultManager();
    Assert.assertSame(m.commands(client), m.commands(client));
    Assert.assertSame(m.asyncCommands(client), m.asyncCommands(client));
    Assert.assertSame(m.reactiveCommands(client), m.reactiveCommands(client));
    m.removeAndClose(client);
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@Test
public void testSentinel() throws Exception {
    RedisURI redisUri = RedisURI.Builder
            .sentinel("127.0.0.1", 26379, "mymaster")
            .withSentinel("127.0.0.1", 26380)
            .withSentinel("127.0.0.1", 26381)
            .build();
    RedisClient client = RedisClient.create(redisUri);
    test(client);
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@Test
public void testWithMultiLevelCache() throws Exception {
    Cache l1Cache = CaffeineCacheBuilder.createCaffeineCacheBuilder()
            .limit(10)
            .expireAfterWrite(500, TimeUnit.MILLISECONDS)
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .buildCache();
    RedisClient client = RedisClient.create("redis://127.0.0.1");
    Cache l2Cache = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
            .redisClient(client)
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(JavaValueEncoder.INSTANCE)
            .valueDecoder(JavaValueDecoder.INSTANCE)
            .keyPrefix(new Random().nextInt() + "")
            .expireAfterWrite(500, TimeUnit.MILLISECONDS)
            .buildCache();
    cache = MultiLevelCacheBuilder.createMultiLevelCacheBuilder()
            .expireAfterWrite(500, TimeUnit.MILLISECONDS)
            .addCache(l1Cache, l2Cache)
            .buildCache();
    baseTest();
    expireAfterWriteTest(500);

    LoadingCacheTest.loadingCacheTest(MultiLevelCacheBuilder.createMultiLevelCacheBuilder()
            .expireAfterWrite(5000, TimeUnit.MILLISECONDS)
            .addCache(l1Cache, l2Cache), 50);
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@Override
protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
    Map<String, Object> map = ct.subTree("uri"/*there is no dot*/).getProperties();
    AbstractRedisClient client = null;
    if (map == null || map.size() == 0) {
        throw new CacheConfigException("uri is required");
    } else if (map.size() == 1) {
        String uri = (String) map.values().iterator().next();
        client = RedisClient.create(uri);
    } else {
        List<RedisURI> list = map.values().stream().map((k) -> RedisURI.create(URI.create(k.toString())))
                .collect(Collectors.toList());
        client = RedisClusterClient.create(list);
    }

    ExternalCacheBuilder externalCacheBuilder = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
            .redisClient(client);
    parseGeneralConfig(externalCacheBuilder, ct);

    // eg: "remote.default.client"
    autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".client", client);
    LettuceConnectionManager m = LettuceConnectionManager.defaultManager();
    autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".connection", m.connection(client));
    autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".commands", m.commands(client));
    autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".asyncCommands", m.asyncCommands(client));
    autoConfigureBeans.getCustomContainer().put(cacheAreaWithPrefix + ".reactiveCommands", m.reactiveCommands(client));
    return externalCacheBuilder;
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
public void initialize(Bootstrap<Configuration> bootstrap) {
    redisClient = RedisClient.create("redis://localhost");
    RequestRateLimiterFactory factory = new RedisRateLimiterFactory(redisClient);

    //RequestRateLimiterFactory factory = new InMemoryRateLimiterFactory();

    bootstrap.addBundle(new RateLimitBundle(factory));
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@Test
public void testSimple() throws Exception {
    RedisClient client = RedisClient.create("redis://127.0.0.1");
    test(client);
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@Test
public void async() throws Exception {
  RedisClient client = RedisClient.create("redis://localhost");

  StatefulRedisConnection<String, String> connection =
      new TracingStatefulRedisConnection<>(client.connect(), mockTracer, false);

  RedisAsyncCommands<String, String> commands = connection.async();

  assertEquals("OK", commands.set("key2", "value2").get(15, TimeUnit.SECONDS));

  assertEquals("value2", commands.get("key2").get(15, TimeUnit.SECONDS));

  connection.close();

  client.shutdown();

  List<MockSpan> spans = mockTracer.finishedSpans();
  assertEquals(2, spans.size());
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@BeforeAll
static void beforeAll() {
    client = RedisClient.create("redis://localhost");
    connection = client.connect();
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
@BeforeAll
static void beforeAll() {
    client = RedisClient.create("redis://localhost");
    connect = client.connect();
}
 

import io.lettuce.core.RedisClient; //导入方法依赖的package包/类
public SessionStorageRedisCacheImpl( String appName, String _connectionUri ) throws Exception {
	super( "session:" + appName + ":" );

	this.uri = _connectionUri;

	DefaultClientResources clientResources = DefaultClientResources.builder() //
			.dnsResolver( new DirContextDnsResolver() ) // Does not cache DNS lookups (needed for ElasticCache)
			.build();

	rediscache = RedisClient.create( clientResources, _connectionUri );

	connection = rediscache.connect();
	asyncCommands = connection.async();

	cfEngine.log( "SessionStorageRedisCache: Created " + _connectionUri );
}