Java:Redis安装(Windows),以及Spring MVC与Redis整合

最新推荐文章于 2021-07-23 18:08:45 发布
最新推荐文章于 2021-07-23 18:08:45 发布
阅读量292 收藏
点赞数 1
分类专栏： redis 文章标签： spring mvc redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014772219/article/details/74340504
版权

菜鸟必看教程  从安装到测试大笑

本文参考http://www.cnblogs.com/tankaixiong/p/3660075.html 的博客文章，部分xml和部分java代码可进这个博客复制


开讲！！！！！！！！！！



一 Redis安装


1.Redis下载:http://download.csdn.net/detail/chainisit/9400072

2.解压

3.启动服务器（进入解压的文件夹中，cmd执行指令）



4.启动客户端（进入解压的文件夹中，cmd执行指令，测试保存字符串:get Mykey之前先set Mykey）



二 Redis 可视化工具下载安装


下载地址：http://download.csdn.net/detail/li295214001/9398955

操作界面：



三：Redis与Spring MVC 整合


1.Redis相关jar包（两个）下载

下载路径:http://download.csdn.net/detail/a403071690/8624931


2.整合

首先在application.xml中配置下连接池(注意${redis.host}等数据要引入对应的properties),如果要设置密码，需要先在redis的客户和服务端的conf文件下先配置密码，然后在

JedisShardInfo bean中添加<property name="password" value="${redis.pass}"></property>属性即可




在dao层创建获取资源的方法(直接贴源码了)

接口类

import redis.clients.jedis.ShardedJedis;

public interface RedisDataSource {
    public abstract ShardedJedis getRedisClient();  //取得redis的客户端，可以执行命令了
    public void returnResource(ShardedJedis shardedJedis); //将资源返还给pool
    public void returnResource(ShardedJedis shardedJedis,boolean broken); //出现异常后，将资源返还给pool （其实不需要第二个方法）
}

实现类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;


import net.ptnetwork.dao.RedisDataSource;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;


@Repository("redisDataSourceImpl")
public class RedisDataSourceImpl implements RedisDataSource {


    private static final Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);


    @Autowired
    private ShardedJedisPool shardedJedisPool;


    public ShardedJedis getRedisClient() {
        try {
            ShardedJedis shardJedis = shardedJedisPool.getResource();
            return shardJedis;
        } catch (Exception e) {
            log.error("getRedisClent error", e);
        }
        return null;
    }


    public void returnResource(ShardedJedis shardedJedis) {
        shardedJedisPool.returnResource(shardedJedis);
    }


    public void returnResource(ShardedJedis shardedJedis, boolean broken) {
        if (broken) {
            shardedJedisPool.returnBrokenResource(shardedJedis);
        } else {
            shardedJedisPool.returnResource(shardedJedis);
        }
    }
}


server层封装，命令实现(下面给出全部代码了)


import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;


import javax.annotation.Resource;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;


import net.ptnetwork.dao.RedisDataSource;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Tuple;


@Repository("redisClientTemplate")
public class RedisClientTemplate {


private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);


@Resource(name = "redisDataSourceImpl")
private RedisDataSource redisDataSource;


public void disconnect() {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
shardedJedis.disconnect();
}


/**
* 设置单个值
* 
* @param key
* @param value
* @return
*/
public String set(String key, String value) {
String result = null;


ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.set(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


/**
* 获取单个值
* 
* @param key
* @return
*/
public String get(String key) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}


boolean broken = false;
try {
result = shardedJedis.get(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Boolean exists(String key) {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.exists(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String type(String key) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.type(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


/**
* 在某段时间后实现
* 
* @param key
* @param unixTime
* @return
*/
public Long expire(String key, int seconds) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expire(key, seconds);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


/**
* 在某个时间点失效
* 
* @param key
* @param unixTime
* @return
*/
public Long expireAt(String key, long unixTime) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expireAt(key, unixTime);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long ttl(String key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ttl(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public boolean setbit(String key, long offset, boolean value) {


ShardedJedis shardedJedis = redisDataSource.getRedisClient();
boolean result = false;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setbit(key, offset, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public boolean getbit(String key, long offset) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
boolean result = false;
if (shardedJedis == null) {
return result;
}
boolean broken = false;


try {
result = shardedJedis.getbit(key, offset);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public long setrange(String key, long offset, String value) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
long result = 0;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setrange(key, offset, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String getrange(String key, long startOffset, long endOffset) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
String result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getrange(key, startOffset, endOffset);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String getSet(String key, String value) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getSet(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long setnx(String key, String value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setnx(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String setex(String key, int seconds, String value) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setex(key, seconds, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long decrBy(String key, long integer) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decrBy(key, integer);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long decr(String key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decr(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long incrBy(String key, long integer) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incrBy(key, integer);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long incr(String key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incr(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long append(String key, String value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.append(key, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String substr(String key, int start, int end) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.substr(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hset(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hset(key, field, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String hget(String key, String field) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hget(key, field);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hsetnx(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hsetnx(key, field, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String hmset(String key, Map<String, String> hash) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmset(key, hash);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<String> hmget(String key, String... fields) {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmget(key, fields);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hincrBy(String key, String field, long value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hincrBy(key, field, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Boolean hexists(String key, String field) {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hexists(key, field);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long del(String key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.del(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hdel(String key, String field) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hdel(key, field);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hlen(String key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hlen(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> hkeys(String key) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hkeys(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<String> hvals(String key) {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hvals(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Map<String, String> hgetAll(String key) {
Map<String, String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hgetAll(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


// ================list ====== l表示 list或 left, r表示right====================
public Long rpush(String key, String string) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpush(key, string);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long lpush(String key, String string) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpush(key, string);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long llen(String key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.llen(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<String> lrange(String key, long start, long end) {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lrange(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String ltrim(String key, long start, long end) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ltrim(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String lindex(String key, long index) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lindex(key, index);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String lset(String key, long index, String value) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lset(key, index, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long lrem(String key, long count, String value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lrem(key, count, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String lpop(String key) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpop(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String rpop(String key) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpop(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


// return 1 add a not exist value ,
// return 0 add a exist value
public Long sadd(String key, String member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sadd(key, member);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> smembers(String key) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.smembers(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long srem(String key, String member) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();


Long result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srem(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String spop(String key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
String result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.spop(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long scard(String key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
Long result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.scard(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Boolean sismember(String key, String member) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
Boolean result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sismember(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String srandmember(String key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
String result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srandmember(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zadd(String key, double score, String member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zadd(key, score, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> zrange(String key, int start, int end) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrange(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zrem(String key, String member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrem(key, member);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Double zincrby(String key, double score, String member) {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zincrby(key, score, member);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zrank(String key, String member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrank(key, member);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zrevrank(String key, String member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrank(key, member);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> zrevrange(String key, int start, int end) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrange(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrangeWithScores(String key, int start, int end) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeWithScores(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeWithScores(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zcard(String key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zcard(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Double zscore(String key, String member) {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zscore(key, member);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<String> sort(String key) {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.sort(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<String> sort(String key, SortingParams sortingParameters) {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.sort(key, sortingParameters);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zcount(String key, double min, double max) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zcount(key, min, max);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> zrangeByScore(String key, double min, double max) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScore(key, min, max);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> zrevrangeByScore(String key, double max, double min) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScore(key, max, min);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> zrangeByScore(String key, double min, double max, int offset, int count) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScore(key, min, max, offset, count);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScore(key, max, min, offset, count);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScoreWithScores(key, min, max);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zremrangeByRank(String key, int start, int end) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zremrangeByRank(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zremrangeByScore(String key, double start, double end) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zremrangeByScore(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long linsert(String key, LIST_POSITION where, String pivot, String value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.linsert(key, where, pivot, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String set(byte[] key, byte[] value) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.set(key, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] get(byte[] key) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.get(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Boolean exists(byte[] key) {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.exists(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String type(byte[] key) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.type(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long expire(byte[] key, int seconds) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.expire(key, seconds);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long expireAt(byte[] key, long unixTime) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.expireAt(key, unixTime);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long ttl(byte[] key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.ttl(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] getSet(byte[] key, byte[] value) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.getSet(key, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long setnx(byte[] key, byte[] value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.setnx(key, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String setex(byte[] key, int seconds, byte[] value) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.setex(key, seconds, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long decrBy(byte[] key, long integer) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.decrBy(key, integer);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long decr(byte[] key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.decr(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long incrBy(byte[] key, long integer) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.incrBy(key, integer);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long incr(byte[] key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.incr(key);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long append(byte[] key, byte[] value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.append(key, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] substr(byte[] key, int start, int end) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.substr(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hset(byte[] key, byte[] field, byte[] value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hset(key, field, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] hget(byte[] key, byte[] field) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hget(key, field);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hsetnx(byte[] key, byte[] field, byte[] value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hsetnx(key, field, value);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String hmset(byte[] key, Map<byte[], byte[]> hash) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hmset(key, hash);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<byte[]> hmget(byte[] key, byte[]... fields) {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hmget(key, fields);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hincrBy(byte[] key, byte[] field, long value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hincrBy(key, field, value);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Boolean hexists(byte[] key, byte[] field) {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hexists(key, field);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hdel(byte[] key, byte[] field) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hdel(key, field);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long hlen(byte[] key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hlen(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> hkeys(byte[] key) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hkeys(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Collection<byte[]> hvals(byte[] key) {
Collection<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hvals(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Map<byte[], byte[]> hgetAll(byte[] key) {
Map<byte[], byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.hgetAll(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long rpush(byte[] key, byte[] string) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.rpush(key, string);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long lpush(byte[] key, byte[] string) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.lpush(key, string);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long llen(byte[] key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.llen(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<byte[]> lrange(byte[] key, int start, int end) {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.lrange(key, start, end);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String ltrim(byte[] key, int start, int end) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.ltrim(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] lindex(byte[] key, int index) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.lindex(key, index);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String lset(byte[] key, int index, byte[] value) {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.lset(key, index, value);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long lrem(byte[] key, int count, byte[] value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.lrem(key, count, value);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] lpop(byte[] key) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.lpop(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] rpop(byte[] key) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.rpop(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long sadd(byte[] key, byte[] member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.sadd(key, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> smembers(byte[] key) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.smembers(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long srem(byte[] key, byte[] member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.srem(key, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] spop(byte[] key) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.spop(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long scard(byte[] key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.scard(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Boolean sismember(byte[] key, byte[] member) {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.sismember(key, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public byte[] srandmember(byte[] key) {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.srandmember(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zadd(byte[] key, double score, byte[] member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zadd(key, score, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> zrange(byte[] key, int start, int end) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrange(key, start, end);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zrem(byte[] key, byte[] member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrem(key, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Double zincrby(byte[] key, double score, byte[] member) {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zincrby(key, score, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zrank(byte[] key, byte[] member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrank(key, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zrevrank(byte[] key, byte[] member) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrank(key, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> zrevrange(byte[] key, int start, int end) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrange(key, start, end);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeWithScores(key, start, end);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeWithScores(key, start, end);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zcard(byte[] key) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zcard(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Double zscore(byte[] key, byte[] member) {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zscore(key, member);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<byte[]> sort(byte[] key) {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.sort(key);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.sort(key, sortingParameters);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zcount(byte[] key, double min, double max) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zcount(key, min, max);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScore(key, min, max);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScore(key, min, max, offset, count);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScoreWithScores(key, min, max);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScore(key, max, min);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScore(key, max, min, offset, count);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zremrangeByRank(byte[] key, int start, int end) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zremrangeByRank(key, start, end);


} catch (Exception e) {


log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long zremrangeByScore(byte[] key, double start, double end) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.zremrangeByScore(key, start, end);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {


result = shardedJedis.linsert(key, where, pivot, value);


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
List<Object> result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.pipelined(shardedJedisPipeline);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Jedis getShard(byte[] key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
Jedis result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShard(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Jedis getShard(String key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
Jedis result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShard(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public JedisShardInfo getShardInfo(byte[] key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
JedisShardInfo result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShardInfo(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public JedisShardInfo getShardInfo(String key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
JedisShardInfo result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShardInfo(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public String getKeyTag(String key) {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
String result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getKeyTag(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Collection<JedisShardInfo> getAllShardInfo() {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
Collection<JedisShardInfo> result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getAllShardInfo();


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


public Collection<Jedis> getAllShards() {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
Collection<Jedis> result = null;
if (shardedJedis == null) {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getAllShards();


} catch (Exception e) {
log.error(e.getMessage(), e);
broken = true;
} finally {
redisDataSource.returnResource(shardedJedis, broken);
}
return result;
}


}



最后测试代码


完工。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

座蝎天
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis+springMVC
04-18
最近在使用redis和java结合做缓存处理，自己参照例子写了个web程序，供大家参考，包括redis-2.8.19.zip包。
Spring mvc整合redis实例(redis连接池)
09-19
将Spring MVC与Redis结合，可以有效提升应用的响应速度和数据处理能力。本文将详细介绍如何在Spring MVC中整合Redis，并利用连接池来优化性能。 首先，我们需要引入Redis的相关依赖。在Maven项目中，可以在pom.xml...
windows下Redis的安装和java测试
十八楼的三室二厅
06-10 788
centos安装好redis的时候再试一下window的，编写程序也好测试 1、windows版：https://github.com/mythz/redis-windows 2、..\redis-windows-master\redis-windows-master\downloads目录下找到合适的版本，解压放到合适的目录即可 3、启动第一个dos，运行-cmd即可，cd到redis目录下
redis-windows安装-java实例
苏叶的专栏
10-13 2798
redis
springmvc整合redis的小案例
十八楼的三室二厅
06-12 3756
之前看网上的springmvc和redis整合怎么都搞不好，就自己仿造着按照自己的项目结构试着重写了一下，成功了，这里记录一下，以备以后参考。 * springmvc.xml的bean标签添加两个schema： xmlns:p=”http://www.springframework.org/schema/p” xmlns:jee=”http://www.springframew
Windows下安装Redis并整合进spring框架中
jorl23的博客
10-26 204
## Windows下安装Redis并整合进spring框架中 ####1.下载Redis-x64-3.2.100.msi镜像文件, 安装都自定义或默认目录 ####2.下载对应jar包, maven配置如下:         &lt;!-- redis相关 --&gt;         &lt;!-- 非必须, 但下载此包能更便于操作数据 --&gt;         &lt;dependenc...
spring-mvc-redis-session:带有redis的spring-mvc http会话
05-11
spring-mvc-redis-session Spring-mvc session with redis. 使用redis作为session的持久化媒介。 特别说明 注意修改RedisHttpSession中的参数： COOKIE=session id DOMAIN=域名
Spring mvc整合redis实例（测试通过）
09-07
一款封装比较全的 sping 整合 redis实例。 不是Spring-date-redis的，是另一种集成方式，从网上整理的代码，测试已跑通。
Hibernate OGM redis项目与Spring MVC集成.zip
01-10
- 安装Redis：确保本地或服务器上已经安装并运行了Redis实例。 - 配置Hibernate OGM：在Hibernate配置文件中，指定使用的NoSQL数据库为Redis，并设置相应的连接参数。 - 实体类映射：创建与Redis中数据结构对应的...
Java面试大厂-redis-mysql-spring-zookeeper
最新发布
02-24
"Java面试大厂-redis-mysql-spring-zookeeper"这个主题涵盖了四大关键的技术领域：Java、MySQL、Redis以及Spring和Zookeeper。这五个关键词代表了现代互联网应用开发中的核心技术栈，下面我们将对这些技术进行详细的...
java操作Redis之windows平台
逝秋的专栏
11-11 2964
java操作Redis数据库[key,Value]之windows平台开发环境,学习是一个漫长的旅程,一个自我沉淀的过程.基础没有打好就追求着比较潮流的技术容易载跟头
Redis Windows版安装及整合Spring
輕描淡寫
05-30 599
简介 1.Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。 2.Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 3.Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。 4.Redis支持数据的备份，即master-slave模式的数据备份。
windows环境下 springMVC+jdbc+redis整合配置
热门推荐
jyf211314的专栏
03-20 1万+
好久不写写博客了,最近不是很忙,就给自己充充电,研究研究redis,最近一些项目也有类似的问题出现,用户频繁访问数据库,并且用户需要的很多数据并不频繁更行,没必要每次都去查询数据库,否则数据库亚历山大啊，尤其是手机平板客户端的一些数据需要频繁交互却又不会频繁更新，对于数据库的鸭梨很大,于是就想着把那些常用的数据放到缓存里，对于缓存框架目前我所知道的只有memcached和redis,redis,一
redis有序集合系列之二
Sunny
06-04 353
目录 zrange zrevrange zrangebyscore zrevrangebyscore zrange 1.语法zrange key start stop [withscores] 2.解析 返回有序集key中,指定区间内的成员 其中成员的位置按score值递增来排序 具有相同score值的成员按字典序来排列 如果你需要成员按score值递增来排序,请使用zrevr...
redis zrange 与 zrangebyscore的区别
jfqqqqq的博客
11-01 1万+
前言 想做一个在redis中获取数据时分页的功能，从网上查找到了zrange和zrangebyscore两个函数，对于这两个函数的理解，在刚刚读完官方文档后，还是不太懂： zrange: “ordered from highest to lowest score”https://redis.io/commands/zrange zrangebyscore:"The elements ar...
Redis学习之zrangebyscore命令
爱喝水的qdy的博客
12-15 2662
目录zrangebyscore命令语法返回值例子 zrangebyscore命令 Redis zrangebyscore， 命令返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员 Redis 有序集成员按 score 值递增(从小到大)次序排列。 具有相同 score 值的成员按字典序(lexicographical order...
Redis从基础命令到实战之有序集合类型(SortedSet)
weixin_30314793的博客
06-23 202
有序集合类型是Redis五种数据类型中最高级的、也是最复杂的类型。有序集合具有集合类型的特性，在其基础上给每个元素关联了一个分值，或称为权重，操作时既可以在添加元素时指定分值，也可以单独修改集合中某一个元素的分值。使用时可以按分值排序(从低到高或从高到低)并顺序读取全部或某一范围内的元素，或者获得某一分值范围内的元素。利用这一特点，可以很方便的实现排行榜、热门文章等功能。 在本节的实例中...
jedis zrangebyscore的返回值踩坑记
MyySophia的博客
07-23 1032
最近在使用jedis 操作redis，在处理一个sortedset key的返回值时遇到一个棘手的问题。 有如下报错: java.lang.ClassCastException: java.lang.String cannot be cast to redis.clien 具体操作是这样子: zrangebyscore 返回的是一个数据集合，如果要接这个返回值，你又不想new 一个bean, tuple 是一个不错的选择。 需求中需要将该方法的返回值的第三个字段截取出来放入List<St..
Java操作Redis
xusanyao的博客
03-07 251
目前Jedis是官方推荐的比较好的Redis操作API包，我们这里结合Spring来看下如何使用Redis这一神器。 1、在pom文件中引入jredis包：   redis.clients   jedis   2.8.1 2、在Spring的resource目录中增加Redis的配置文件/src/main/resources/redis.properties #
Java面试精华：基础、Spring、Redis及SpringCloud问题与答案
Java是一门广泛应用于企业级应用开发的高级编程语言，其面试题涉及多个领域，包括Java基础、Spring框架、Redis缓存、以及Spring Cloud和阿里巴巴的解决方案。以下是关于这些主题的一些关键知识点： 1. **Java基础**...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值