io.lettuce.core.api.StatefulConnection Java Examples

public LettuceFactory(String key, Class<?> clazz) {
    this.clazz = clazz;
    if (AbstractRedisClient.class.isAssignableFrom(clazz)) {
        key += ".client";
    } else if (StatefulConnection.class.isAssignableFrom(clazz)) {
        key += ".connection";
    } else if (RedisClusterCommands.class.isAssignableFrom(clazz)) {
        // RedisCommands extends RedisClusterCommands
        key += ".commands";
    } else if (RedisClusterAsyncCommands.class.isAssignableFrom(clazz)) {
        // RedisAsyncCommands extends RedisClusterAsyncCommands
        key += ".asyncCommands";
    } else if (RedisClusterReactiveCommands.class.isAssignableFrom(clazz)) {
        // RedisReactiveCommands extends RedisClusterReactiveCommands
        key += ".reactiveCommands";
    } else {
        throw new IllegalArgumentException(clazz.getName());
    }
    this.key = key;
}
 

protected BaseRedisCommands sync(StatefulConnection conn) {
    if(conn instanceof StatefulRedisClusterConnection)
        return ((StatefulRedisClusterConnection)conn).sync();
    else if(conn instanceof StatefulRedisConnection)
        return ((StatefulRedisConnection)conn).sync();
    return null;
}
 

public StatefulConnection connection(AbstractRedisClient redisClient) {
    LettuceObjects lo = getLettuceObjectsFromMap(redisClient);
    if (lo.connection == null) {
        if (redisClient instanceof RedisClient) {
            lo.connection = ((RedisClient) redisClient).connect(new JetCacheCodec());
        } else if (redisClient instanceof RedisClusterClient) {
            lo.connection = ((RedisClusterClient) redisClient).connect(new JetCacheCodec());
        } else {
            throw new CacheConfigException("type " + redisClient.getClass() + " is not supported");
        }
    }
    return lo.connection;
}
 

public void init(AbstractRedisClient redisClient, StatefulConnection connection) {
    map.computeIfAbsent(redisClient, key -> {
        LettuceObjects lo = new LettuceObjects();
        lo.connection = connection;
        return lo;
    });
}
 

@Override
public void clear() {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisKeyCommands<String, byte[]> cmd = (RedisKeyCommands)super.sync(connection);
        Collection<String> keys = keys(cmd);
        if(keys != null && keys.size() > 0)
            cmd.del(keys.stream().toArray(String[]::new));
    }
}
 

@Override
public void evict(String... keys) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisKeyCommands<String, byte[]> cmd = (RedisKeyCommands)super.sync(connection);
        cmd.del(Arrays.stream(keys).map(k -> _key(k)).toArray(String[]::new));
    }
}
 

/**
 * 批量设置带 TTL 的缓存数据
 * @param bytes  cache data
 * @param timeToLiveInSeconds cache ttl
 */
@Override
public void setBytes(Map<String,byte[]> bytes, long timeToLiveInSeconds) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisStringCommands<String, byte[]> cmd = (RedisStringCommands)super.sync(connection);
        if (timeToLiveInSeconds > 0)
            bytes.forEach((k,v)->cmd.setex(_key(k), timeToLiveInSeconds, v));
        else
            bytes.forEach((k,v)->cmd.set(_key(k), v));
    }
}
 

/**
 * 设置缓存数据字节数组（带有效期）
 * @param key  cache key
 * @param bytes cache data
 * @param timeToLiveInSeconds cache ttl
 */
@Override
public void setBytes(String key, byte[] bytes, long timeToLiveInSeconds){
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisStringCommands<String, byte[]> cmd = (RedisStringCommands)super.sync(connection);
        if (timeToLiveInSeconds > 0)
            cmd.setex(_key(key), timeToLiveInSeconds, bytes);
        else
            cmd.set(_key(key), bytes);
    }
}
 

@Override
public void setBytes(Map<String, byte[]> bytes) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisStringCommands<String, byte[]> cmd = (RedisStringCommands)super.sync(connection);
        cmd.mset(bytes.entrySet().stream().collect(Collectors.toMap(k -> _key(k.getKey()), Map.Entry::getValue)));
    }
}
 

@Override
public void setBytes(String key, byte[] bytes) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisStringCommands<String, byte[]> cmd = (RedisStringCommands)super.sync(connection);
        cmd.set(_key(key), bytes);
    }
}
 

@Override
public List<byte[]> getBytes(Collection<String> keys) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisStringCommands<String, byte[]> cmd = (RedisStringCommands)super.sync(connection);
        return cmd.mget(keys.stream().map(k -> _key(k)).toArray(String[]::new)).stream().map(kv -> kv.hasValue()?kv.getValue():null).collect(Collectors.toList());
    }
}
 

public LettuceGenericCache(String namespace, String region, GenericObjectPool<StatefulConnection<String, byte[]>> pool, int scanCount) {
    if (region == null || region.isEmpty())
        region = "_"; // 缺省region

    super.pool = pool;
    this.namespace = namespace;
    this.region = getRegionName(region);
    this.scanCount = scanCount;
}
 

@Override
public void clear() {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisKeyCommands<String, byte[]> cmd = (RedisKeyCommands)super.sync(connection);
        cmd.del(this.region);
    }
}
 

@Override
public void evict(String... keys) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisHashCommands<String, byte[]> cmd = (RedisHashCommands)super.sync(connection);
        cmd.hdel(this.region, keys);
    }
}
 

@Override
public Collection<String> keys() {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisHashCommands<String, byte[]> cmd = (RedisHashCommands)super.sync(connection);
        return cmd.hkeys(this.region);
    }
}
 

@Override
public void setBytes(Map<String, byte[]> bytes) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisHashCommands<String, byte[]> cmd = (RedisHashCommands)super.sync(connection);
        cmd.hmset(this.region, bytes);
    }
}
 

@Override
public void setBytes(String key, byte[] bytes) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisHashCommands<String, byte[]> cmd = (RedisHashCommands)super.sync(connection);
        cmd.hset(this.region, key, bytes);
    }
}
 

@Override
public List<byte[]> getBytes(Collection<String> keys) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisHashCommands<String, byte[]> cmd = (RedisHashCommands)super.sync(connection);
        return cmd.hmget(this.region, keys.stream().toArray(String[]::new)).stream().map(kv -> kv.hasValue()?kv.getValue():null).collect(Collectors.toList());
    }
}
 

@Override
public byte[] getBytes(String key) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisStringCommands<String, byte[]> cmd = (RedisStringCommands)super.sync(connection);
        return cmd.get(_key(key));
    }
}
 

@Override
public byte[] getBytes(String key) {
    try(StatefulConnection<String, byte[]> connection = super.connect()) {
        RedisHashCommands<String, byte[]> cmd = (RedisHashCommands)super.sync(connection);
        return cmd.hget(this.region, key);
    }
}
 

public LettuceHashCache(String namespace, String region, GenericObjectPool<StatefulConnection<String, byte[]>> pool) {
    if (region == null || region.isEmpty())
        region = "_"; // 缺省region

    super.pool = pool;
    super.namespace = namespace;
    super.region = getRegionName(region);
}
 

protected StatefulConnection connect() {
    try {
        return pool.borrowObject();
    } catch (Exception e) {
        throw new CacheException(e);
    }
}
 

public void setConnection(StatefulConnection connection) {
    getConfig().setConnection(connection);
}
 

public StatefulConnection connection() {
    return this.connection;
}
 

public RedisSession(AbstractRedisClient client, StatefulConnection connection, RedisClusterAsyncCommands<byte[], byte[]> asyncCommands) {
    this.client = client;
    this.connection = connection;
    this.asyncCommands = asyncCommands;
}
 

public StatefulConnection connection() {
  return this.connection;
}
 

RedisSessionImpl(AbstractRedisClient client, StatefulConnection connection, RedisClusterAsyncCommands<byte[], byte[]> asyncCommands, RedisConnectorConfig config) {
  this.client = client;
  this.connection = connection;
  this.asyncCommands = asyncCommands;
  this.config = config;
}
 

private void test(AbstractRedisClient client, StatefulConnection connection) throws Exception {
    cache = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
            .redisClient(client)
            .connection(connection)
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(JavaValueEncoder.INSTANCE)
            .valueDecoder(JavaValueDecoder.INSTANCE)
            .keyPrefix(new Random().nextInt() + "")
            .expireAfterWrite(500, TimeUnit.MILLISECONDS)
            .buildCache();
    baseTest();
    expireAfterWriteTest(cache.config().getExpireAfterWriteInMillis());
    fastjsonKeyCoverterTest();
    testUnwrap(client);

    LoadingCacheTest.loadingCacheTest(RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
            .redisClient(client)
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(JavaValueEncoder.INSTANCE)
            .valueDecoder(JavaValueDecoder.INSTANCE)
            .keyPrefix(new Random().nextInt() + ""), 50);

    cache = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
            .redisClient(client)
            .keyConvertor(null)
            .valueEncoder(KryoValueEncoder.INSTANCE)
            .valueDecoder(KryoValueDecoder.INSTANCE)
            .keyPrefix(new Random().nextInt() + "")
            .buildCache();
    nullKeyConvertorTest();

    int thread = 10;
    int time = 3000;
    cache = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
            .redisClient(client)
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(KryoValueEncoder.INSTANCE)
            .valueDecoder(KryoValueDecoder.INSTANCE)
            .keyPrefix(new Random().nextInt() + "")
            .buildCache();
    ((RedisLettuceCacheConfig) cache.config()).setAsyncResultTimeoutInMillis(1100);
    concurrentTest(thread, 500, time);
    LettuceConnectionManager.defaultManager().removeAndClose(client);
}
 

public void setConnection(StatefulConnection connection) {
    this.connection = connection;
}
 

public StatefulConnection getConnection() {
    return connection;
}