org.springframework.data.redis.core.RedisConnectionUtils Java Examples

public static int updateAndGetVersion(
    RedisConnectionFactory redisConnectionFactory, String versionDbKey, int defaultVersion) {
  RedisConnection connection = RedisConnectionUtils.getConnection(redisConnectionFactory);
  byte[] versionKey = versionDbKey.getBytes();
  byte[] versionFromDb = connection.get(versionKey);
  if (SerializationUtils.isEmpty(versionFromDb)) {
    Long count =
        connection.eval(
            "return #redis.pcall('keys', 'rqueue-*')".getBytes(), ReturnType.INTEGER, 0);
    if (count != null && count > 0L) {
      int version = 1;
      connection.set(versionKey, String.valueOf(version).getBytes());
      return version;
    }
    connection.set(versionKey, String.valueOf(defaultVersion).getBytes());
    return defaultVersion;
  }
  return Integer.parseInt(new String(versionFromDb));
}
 

private ICacheManager createRedisCacheManager(AutoloadCacheProperties config, ISerializer<Object> serializer, JedisConnectionFactory connectionFactory) {
    RedisConnection redisConnection = null;
    try {
        redisConnection = connectionFactory.getConnection();
        AbstractRedisCacheManager cacheManager = null;
        if (redisConnection instanceof JedisClusterConnection) {
            JedisClusterConnection redisClusterConnection = (JedisClusterConnection) redisConnection;
            // 优先使用JedisCluster; 因为JedisClusterConnection 批量处理，需要使用JedisCluster
            JedisCluster jedisCluster = redisClusterConnection.getNativeConnection();
            cacheManager = new JedisClusterCacheManager(jedisCluster, serializer);
        } else {
            cacheManager = new SpringRedisCacheManager(connectionFactory, serializer);
        }
        // 根据需要自行配置
        cacheManager.setHashExpire(config.getJedis().getHashExpire());
        return cacheManager;
    } catch (Throwable e) {
        log.error(e.getMessage(), e);
        throw e;
    } finally {
        RedisConnectionUtils.releaseConnection(redisConnection, connectionFactory);
    }
}
 

@Override
protected boolean setnx(String key, String val, int expire) {
    if (null == redisConnectionFactory || null == key || key.isEmpty()) {
        return false;
    }
    RedisConnection redisConnection = getConnection();
    try {
        Expiration expiration = Expiration.from(expire, TimeUnit.SECONDS);
        return redisConnection.stringCommands().set(STRING_SERIALIZER.serialize(key), STRING_SERIALIZER.serialize(val), expiration, RedisStringCommands.SetOption.SET_IF_ABSENT);
    } catch (Exception ex) {
        logger.error(ex.getMessage(), ex);
    } finally {
        RedisConnectionUtils.releaseConnection(redisConnection, redisConnectionFactory);
    }
    return false;
}
 

/**
 * 查找匹配key
 * @param pattern key
 * @return /
 */
public List<String> scan(String pattern) {
    ScanOptions options = ScanOptions.scanOptions().match(pattern).build();
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection rc = Objects.requireNonNull(factory).getConnection();
    Cursor<byte[]> cursor = rc.scan(options);
    List<String> result = new ArrayList<>();
    while (cursor.hasNext()) {
        result.add(new String(cursor.next()));
    }
    try {
        RedisConnectionUtils.releaseConnection(rc, factory);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
 

/**
 * 分页查询 key
 * @param patternKey key
 * @param page 页码
 * @param size 每页数目
 * @return /
 */
public List<String> findKeysForPage(String patternKey, int page, int size) {
    ScanOptions options = ScanOptions.scanOptions().match(patternKey).build();
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection rc = Objects.requireNonNull(factory).getConnection();
    Cursor<byte[]> cursor = rc.scan(options);
    List<String> result = new ArrayList<>(size);
    int tmpIndex = 0;
    int fromIndex = page * size;
    int toIndex = page * size + size;
    while (cursor.hasNext()) {
        if (tmpIndex >= fromIndex && tmpIndex < toIndex) {
            result.add(new String(cursor.next()));
            tmpIndex++;
            continue;
        }
        // 获取到满足条件的数据后,就可以退出了
        if(tmpIndex >=toIndex) {
            break;
        }
        tmpIndex++;
        cursor.next();
    }
    try {
        RedisConnectionUtils.releaseConnection(rc, factory);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
 

@Override
protected void del(String key) {
    if (null == redisConnectionFactory || null == key || key.length() == 0) {
        return;
    }
    RedisConnection redisConnection = getConnection();
    try {
        redisConnection.keyCommands().del(STRING_SERIALIZER.serialize(key));
    } catch (Exception ex) {
        logger.error(ex.getMessage(), ex);
    } finally {
        RedisConnectionUtils.releaseConnection(redisConnection, redisConnectionFactory);
    }
}
 

/**
 * 分页获取指定格式key，使用 scan 命令代替 keys 命令，在大数据量的情况下可以提高查询效率
 *
 * @param patternKey  key格式
 * @param currentPage 当前页码
 * @param pageSize    每页条数
 * @return 分页获取指定格式key
 */
public PageResult<String> findKeysForPage(String patternKey, int currentPage, int pageSize) {
    ScanOptions options = ScanOptions.scanOptions()
            .match(patternKey)
            .build();
    RedisConnectionFactory factory = stringRedisTemplate.getConnectionFactory();
    RedisConnection rc = factory.getConnection();
    Cursor<byte[]> cursor = rc.scan(options);

    List<String> result = Lists.newArrayList();

    long tmpIndex = 0;
    int startIndex = (currentPage - 1) * pageSize;
    int end = currentPage * pageSize;
    while (cursor.hasNext()) {
        String key = new String(cursor.next());
        if (tmpIndex >= startIndex && tmpIndex < end) {
            result.add(key);
        }
        tmpIndex++;
    }

    try {
        cursor.close();
        RedisConnectionUtils.releaseConnection(rc, factory);
    } catch (Exception e) {
        log.warn("Redis连接关闭异常，", e);
    }

    return new PageResult<>(result, tmpIndex);
}
 

protected void initRedisKeysCache(RedisTemplate redisTemplate, String serverName , int dbIndex) {
	RedisConnection connection = RedisConnectionUtils.getConnection(redisTemplate.getConnectionFactory());
	connection.select(dbIndex);
	Set<byte[]> keysSet = connection.keys("*".getBytes());
	connection.close();
	List<RKey> tempList = new ArrayList<RKey>();
	ConvertUtil.convertByteToString(connection, keysSet, tempList);
	Collections.sort(tempList);
	CopyOnWriteArrayList<RKey> redisKeysList = new CopyOnWriteArrayList<RKey>(tempList);
	if(redisKeysList.size()>0) {
		redisKeysListMap.put(serverName+DEFAULT_SEPARATOR+dbIndex, redisKeysList);
	}
}
 

private Object getKV(String serverName, int dbIndex, String key) {
	RedisTemplate redisTemplate = RedisApplication.redisTemplatesMap.get(serverName);
	RedisConnection connection = RedisConnectionUtils.getConnection(redisTemplate.getConnectionFactory());
	connection.select(dbIndex);
	DataType dataType = connection.type(key.getBytes());
	connection.close();
	Object values = null;
	switch(dataType) {
	case STRING:
		values = redisDao.getSTRING(serverName, dbIndex, key);
		break;
	case LIST:
		values = redisDao.getLIST(serverName, dbIndex, key);
		break;
	case SET:
		values = redisDao.getSET(serverName, dbIndex, key);
		break;
	case ZSET:
		values = redisDao.getZSET(serverName, dbIndex, key);
		break;
	case HASH:
		values = redisDao.getHASH(serverName, dbIndex, key);
		break;
	case NONE:
		//never be here
		values = null;
	}
	return values;
}
 

private String getDataType(String serverName, int dbIndex, String key) {
	RedisTemplate redisTemplate = RedisApplication.redisTemplatesMap.get(serverName);
	RedisConnection connection = RedisConnectionUtils.getConnection(redisTemplate.getConnectionFactory());
	connection.select(dbIndex);
	DataType dataType = connection.type(key.getBytes());
	connection.close();
	return dataType.name().toUpperCase();
}
 

/**
 * 释放连接
 * @param redisConnection
 */
private void releaseConnection(RedisConnection redisConnection){
    if(null!=redisConnection && null!=redisTemplate){
        RedisConnectionFactory redisConnectionFactory = redisTemplate.getConnectionFactory();

        if(null!=redisConnectionFactory){
            RedisConnectionUtils.releaseConnection(redisConnection, redisConnectionFactory);
        }
    }
}
 

/**
 * 释放连接
 * @param redisConnection
 */
private void releaseConnection(RedisConnection redisConnection){
    if(null!=redisConnection && null!=redisTemplate){
        RedisConnectionFactory redisConnectionFactory = redisTemplate.getConnectionFactory();

        if(null!=redisConnectionFactory){
            RedisConnectionUtils.releaseConnection(redisConnection, redisConnectionFactory);
        }
    }
}
 

@Override
public void heartbeat( int _idx ){
    database( _idx );
    try{
        tpl.opsForValue().get( "heartbeat" );
    }catch ( Exception e ){
        log.error( "heartbeat 发生错误：IDX=[" + _idx + "]" + e.toString(), e );
    }finally {
        if( tpl != null && tpl.getConnectionFactory() != null ){
            RedisConnectionUtils.unbindConnection( tpl.getConnectionFactory() );
        }
    }
}
 

/**
 * 分页获取指定格式key，使用 scan 命令代替 keys 命令，在大数据量的情况下可以提高查询效率
 *
 * @param patternKey  key格式
 * @param currentPage 当前页码
 * @param pageSize    每页条数
 * @return 分页获取指定格式key
 */
public PageResult<String> findKeysForPage(String patternKey, int currentPage, int pageSize) {
    ScanOptions options = ScanOptions.scanOptions()
            .match(patternKey)
            .build();
    RedisConnectionFactory factory = stringRedisTemplate.getConnectionFactory();
    RedisConnection rc = factory.getConnection();
    Cursor<byte[]> cursor = rc.scan(options);

    List<String> result = Lists.newArrayList();

    long tmpIndex = 0;
    int startIndex = (currentPage - 1) * pageSize;
    int end = currentPage * pageSize;
    while (cursor.hasNext()) {
        String key = new String(cursor.next());
        if (tmpIndex >= startIndex && tmpIndex < end) {
            result.add(key);
        }
        tmpIndex++;
    }

    try {
        cursor.close();
        RedisConnectionUtils.releaseConnection(rc, factory);
    } catch (Exception e) {
        log.warn("Redis连接关闭异常，", e);
    }

    return new PageResult<>(result, tmpIndex);
}
 

/**
 * 分页获取指定格式key，使用 scan 命令代替 keys 命令，在大数据量的情况下可以提高查询效率
 *
 * @param patternKey  key格式
 * @param currentPage 当前页码
 * @param pageSize    每页条数
 * @return 分页获取指定格式key
 */
public PageResult<String> findKeysForPage(String patternKey, int currentPage, int pageSize) {
    ScanOptions options = ScanOptions.scanOptions()
            .match(patternKey)
            .build();
    RedisConnectionFactory factory = stringRedisTemplate.getConnectionFactory();
    RedisConnection rc = factory.getConnection();
    Cursor<byte[]> cursor = rc.scan(options);

    List<String> result = Lists.newArrayList();

    long tmpIndex = 0;
    int startIndex = (currentPage - 1) * pageSize;
    int end = currentPage * pageSize;
    while (cursor.hasNext()) {
        String key = new String(cursor.next());
        if (tmpIndex >= startIndex && tmpIndex < end) {
            result.add(key);
        }
        tmpIndex++;
    }

    try {
        cursor.close();
        RedisConnectionUtils.releaseConnection(rc, factory);
    } catch (Exception e) {
        log.warn("Redis连接关闭异常，", e);
    }

    return new PageResult<>(result, tmpIndex);
}
 

public void changeDatabase( LettuceConnectionFactory _lcf ){
    RedisConnectionUtils.unbindConnection( tpl.getConnectionFactory() );
    tpl.setConnectionFactory( _lcf );
    index = _lcf.getDatabase();
    heartbeat();
}
 

public RedisConnectionClient(RedisConnectionFactory redisConnectionFactory, AbstractRedisCacheManager cacheManager) {
    this.redisConnectionFactory = redisConnectionFactory;
    this.redisConnection = RedisConnectionUtils.getConnection(redisConnectionFactory);
    // TransactionSynchronizationManager.hasResource(redisConnectionFactory);
    this.cacheManager = cacheManager;
}
 

@Override
public void close() {
    RedisConnectionUtils.releaseConnection(redisConnection, redisConnectionFactory);
}
 

private RedisConnection getConnection() {
    return RedisConnectionUtils.getConnection(redisConnectionFactory);
}
 

public static void setVersion(
    RedisConnectionFactory connectionFactory, String versionKey, int version) {
  RedisConnection connection = RedisConnectionUtils.getConnection(connectionFactory);
  byte[] versionKeyBytes = versionKey.getBytes();
  connection.set(versionKeyBytes, String.valueOf(version).getBytes());
}