redis在Java web项目的简单应用

最新推荐文章于 2024-05-11 12:58:00 发布
最新推荐文章于 2024-05-11 12:58:00 发布
阅读量1.4w 收藏 20
点赞数 7
分类专栏： Java资料 SSH 
一.准备要使用的的jar包,我使用了以下jar包，关于json的jar包是方便存储和转换redis用到的值;

二.编写加载redis是要用到的实例类

package com.redis;  
  
import redis.clients.jedis.ShardedJedis;  
  
/**   
 * @Title: RedisDataSource.java 
 * @copyright  
 * @Package com.cy.redis 
 * @Description: 该接口用于获取redis客户端实例，通过该实例操作redis数据源 
 * @author  
 * @date 2016-10-21 下午04:22:41 
 */  
public interface RedisDataSource {  
      
    public abstract ShardedJedis getRedisClient();  
      
    public void returnResource(ShardedJedis shardedJedis);  
      
        public void returnResource(ShardedJedis shardedJedis,boolean broken);  
  
}  


package com.redis;  
  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
  
import redis.clients.jedis.ShardedJedis;  
import redis.clients.jedis.ShardedJedisPool;  
  
/**   
 * @Title: RedisDataSourceImpl.java 
 * @copyright  
 * @Package com.cy.redis 
 * @Description: 获取redis客户端实例，通过该实例操作redis数据源 
 * @author  
 * @date 2016-10-21 下午04:22:54 
 */  
public class RedisDataSourceImpl implements RedisDataSource{  
  
    private static final org.slf4j.Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);  
      
    @Autowired  
    private ShardedJedisPool shardedJedisPool;  
      
    public ShardedJedisPool getShardedJedisPool() {  
        return shardedJedisPool;  
    }  
  
    public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {  
        this.shardedJedisPool = shardedJedisPool;  
    }  
  
    /** 
     * 获取redis客户端 
     */  
    public ShardedJedis getRedisClient() {  
        try {  
            ShardedJedis shardedJedis=shardedJedisPool.getResource();  
            return shardedJedis;  
        } catch (Exception e) {  
            log.error("getRedisClient ,error",e);  
            e.printStackTrace();  
        }  
        return null;  
    }  
  
    /** 
     * 将资源返还给pool 
     */  
    @SuppressWarnings("deprecation")  
    public void returnResource(ShardedJedis shardedJedis) {  
        shardedJedisPool.returnResource(shardedJedis);  
          
    }  
  
    /** 
     * 出现异常后返回资源给pool 
     */  
    @SuppressWarnings("deprecation")  
    public void returnResource(ShardedJedis shardedJedis, boolean broken) {  
        if(broken){  
            shardedJedisPool.returnBrokenResource(shardedJedis);  
        }else{  
            shardedJedisPool.returnResource(shardedJedis);  
        }  
          
    }  
  
} 


package com.redis;  
  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisShardInfo;  
import redis.clients.jedis.ShardedJedis;  
  
/**   
 * @Title: RedisClientTemplate.java 
 * @copyright  
 * @Package com.cy.redis 
 * @Description: 用于操作redis取值、存值操作的工具类 
 * @author  
 * @date 2016-10-21 下午04:21:59 
 */  
public class RedisClientTemplate {  
      
    private static final org.slf4j.Logger log=LoggerFactory.getLogger(RedisClientTemplate.class);  
      
    @Autowired  
    private RedisDataSource redisDataSource;  
  
    public RedisDataSource getRedisDataSource() {  
        return redisDataSource;  
    }  
  
    public void setRedisDataSource(RedisDataSource redisDataSource) {  
        this.redisDataSource = redisDataSource;  
    }  
      
    public void disconnect(){  
        ShardedJedis shardedJedis=redisDataSource.getRedisClient();  
        shardedJedis.disconnect();  
    }  
      
    /** 
    * @Description: 在redis里设置单个值 
    * @author Mr.chen 
    * @date 2016-10-21 下午04:37:06 
     */  
    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) {  
            broken=true;  
            e.printStackTrace();  
        }finally{  
            redisDataSource.returnResource(shardedJedis, broken);  
        }  
          
        return result;  
    }  
      
    /** 
    * @Description: 获取redis单个值  
    * @author Mr.chen 
    * @date 2016-10-21 下午04:40:57 
     */  
    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;  
    }  
      
    /** 
    * @Description: 判断redis是否存在key 
    * @author Mr.chen 
    * @date 2016-10-21 下午04:41:39 
     */  
    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;  
    }  
      
    /** 
    * @Description: 获取key返回存储值的类型  
    * @author Mr.chen 
    * @date 2016-10-21 下午04:42:08 
     */  
    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;  
    }  
      
    /** 
    * @Description: 在某段时间后实现 
    * @author Mr.chen 
    * @date 2016-10-21 下午04:43:25 
     */  
    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;  
    }  
  
    /** 
    * @Description: 在某个时间点失效  
    * @author Mr.chen 
    * @date 2016-10-21 下午04:43:40 
     */  
    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;  
    }  
  
    /** 
    * @Description: 以秒为单位，返回给定 key 的剩余生存时间 
    * @author Mr.chen 
    * @date 2016-10-21 下午04:44:00 
     */  
    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;  
    }  
  
    /** 
    * @Description: 将 key 的值设为 value ，当且仅当 key 不存在 
    * @author Mr.chen 
    * @date 2016-10-21 下午04:44:17 
     */  
    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;  
    }  
    /** 
     * 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位) 
     * @param key 
     * @param seconds 
     * @param value 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将 key 所储存的值减去减量 integer  
     * @param key 
     * @param integer 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将 key 中储存的数字值减一。 
     * @param key 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将 key 所储存的值加上增量 integer  
     * @param key 
     * @param integer 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将 key 中储存的数字值增一 
     * @param key 
     * @return 
     */  
    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;  
    }  
    /** 
     * 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。 
     * 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。 
     * @param key 
     * @param value 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回名称为key的string的value的子串 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将哈希表 key 中的域 field 的值设为 value  
     * @param key 
     * @param field 
     * @param value 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回哈希表 key 中给定域 field 的值 
     * @param key 
     * @param field 
     * @return 
     */  
    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;  
    }  
    /** 
     * 同时将多个 field-value (域-值)对设置到哈希表 key 中。 
     * @param key 
     * @param hash 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回哈希表 key 中，一个或多个给定域的值 
     * @param key 
     * @param fields 
     * @return 
     */  
    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;  
    }  
    /** 
     * 为哈希表 key 中的域 field 的值加上增量 value 
     * @param key 
     * @param field 
     * @param value 
     * @return 
     */  
    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;  
    }  
    /** 
     * 查看哈希表 key 中，给定域 field 是否存在。 
     * @param key 
     * @param field 
     * @return 
     */  
    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;  
    }  
    /** 
     * 删除key 
     * @param key 
     * @return 
     */  
    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;  
    }  
    /** 
     * 删除哈希表 key 中的一个或多个指定域。 
     * @param key 
     * @param field 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回哈希表 key 中域的数量。 
     * @param key 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回哈希表 key 中的所有域。 
     * @param key 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回哈希表 key 中所有域的值。 
     * @param key 
     * @return 
     */  
    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;  
    }  
     /** 
      * 返回哈希表 key 中，所有的域和值。 
      * @param key 
      * @return 
      */  
    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====================  
    /** 
     * 将一个或多个值 value 插入到列表 key 的表尾(最右边) 
     * @param key 
     * @param string 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将一个或多个值 value 插入到列表 key 的表头 
     * @param key 
     * @param string 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回列表 key 的长度。 
     * @param key 
     * @return 
     */  
    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;  
    }  
     /** 
      * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定 
      * @param key 
      * @param start 
      * @param end 
      * @return 
      */  
    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;  
    }  
    /** 
     * 只保留指定区间内的元素，不在指定区间之内的元素都将被删除 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回列表 key 中，下标为 index 的元素。 
     * @param key 
     * @param index 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将列表 key 下标为 index 的元素的值设置为 value 
     * @param key 
     * @param index 
     * @param value 
     * @return 
     */  
    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;  
    }  
  
  /** 
   * 移除并返回列表 key 的头元素 
   * @param key 
   * @return 
   */  
    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;  
    }  
    /** 
     * 移除并返回列表 key 的尾元素。 
     * @param key 
     * @return 
     */  
    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  
    /** 
     * 将一个或多个 member 元素加入到集合 key 当中 
     * @param key 
     * @param member 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回集合 key 中的所有成员。 
     * @param key 
     * @return 
     */  
    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;  
    }  
  
    /** 
     * 返回集合 key 的基数(集合中元素的数量) 
     * @param key 
     * @return 
     */  
    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;  
    }  
    /** 
     * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 
     * @param key 
     * @param score 
     * @param member 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回有序集 key 中，指定区间内的成员 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    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;  
    }  
    /** 
     * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略 
     * @param key 
     * @param member 
     * @return 
     */  
    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;  
    }  
    /** 
     * 为有序集 key 的成员 member 的 score 值加上增量 member 。 
     * @param key 
     * @param score 
     * @param member 
     * @return 
     */  
    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;  
    }  
    /** 
     * 回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列 
     * @param key 
     * @param member 
     * @return 
     */  
    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;  
    }  
    /** 
     * 返回有序集 key 的基数 
     * @param key 
     * @return 
     */  
        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;  
    }  
    /** 
     * 返回有序集 key 中，成员 member 的 score 值。 
     * @param key 
     * @param member 
     * @return 
     */  
    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;  
    }  
  
   /** 
    * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量 
    * @param key 
    * @param min 
    * @param max 
    * @return 
    */  
    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;  
    }  
  
    /** 
     * 批量存储 
     * @param key 
     * @param value 
     * @return 
     */  
    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;  
    }  
    /** 
     * 获取多个key的值 
     * @param key 
     * @return 
     */  
    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;  
    }  
    /** 
     * 判断多个key存在 
     * @param key 
     * @return 
     */  
    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 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 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;  
    }  
  
   /** 
    * 批量增加到hash 
    * @param key 
    * @param field 
    * @param value 
    * @return 
    */  
    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;  
    }  
    /** 
     * 批量获取field域值 
     * @param key 
     * @param field 
     * @return 
     */  
    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 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 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;  
    }  
    /** 
     * 批量删除hash的key 
     * @param key 
     * @param field 
     * @return 
     */  
    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 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 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;  
    }  
  /** 
   *   批量增加到set 
   * @param key 
   * @param member 
   * @return 
   */  
    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 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 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 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 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 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;  
    }  
  
}


三.配置spring xml文件 

<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="  
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd  
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  
    
      
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
       <property name="maxTotal" value="2048" />    
       <property name="maxIdle" value="200" />    
       <property name="numTestsPerEvictionRun" value="1024"/>    
       <property name="timeBetweenEvictionRunsMillis" value="30000" />    
       <property name="minEvictableIdleTimeMillis" value="-1" />    
       <property name="softMinEvictableIdleTimeMillis" value="10000" />    
       <property name="maxWaitMillis" value="1500"/>    
       <property name="testOnBorrow" value="true" />    
       <property name="testWhileIdle" value="true"/>    
       <property name="testOnReturn" value="false"/>    
       <property name="jmxEnabled" value="true"/>    
       <property name="blockWhenExhausted" value="false"/>   
    </bean>  
  
    <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">  
        <constructor-arg index="0" ref="jedisPoolConfig" />  
        <constructor-arg index="1">  
            <list>  
                <bean class="redis.clients.jedis.JedisShardInfo">  
                    <constructor-arg name="host" value="127.0.0.1" />  
                    <constructor-arg name="port" value="6379" />  
                    <constructor-arg name="timeout" value="10000" />  
                </bean>  
            </list>  
        </constructor-arg>  
    </bean>  
    <bean id="redisDataSource" class="redis.dao.RedisDataSourceImpl">  
        <property name="shardedJedisPool" ref="shardedJedisPool"></property>  
    </bean>  
    <bean id="redisClientTemplate" class="redis.dao.RedisClientTemplate">  
        <property name="redisDataSource" ref="redisDataSource"></property>  
    </bean>  
</beans>

四.代码中的使用，原则就是在执行service时，先通过key到redis里检测是否存在，如果存在则在

redis里去数据,如果没有则到数据库去数据,然后存到redis里


public class StudentinfoServiceImpl implements StudentinfoService{  
      
    private StudentinfoDao studentinfoDao;  
      
    private RedisClientTemplate redisClientTemplate;  
      
    private static final ObjectMapper mapper=new ObjectMapper();  
      
    public List<Studentinfo> getStudentinfoByStu(Studentinfo stu) {  
        String key="getStudentinfoByStu:usernumber:"+stu.getUsernumber()+":name:"+stu.getName()+":idnumber:"+stu.getIdnumber();  
        try {  
            boolean flag=redisClientTemplate.exists(key);  
            if(flag){  
                String stuJsonStr=redisClientTemplate.get(key);  
                List<Studentinfo> list=mapper.readValue(stuJsonStr, new TypeReference<List<Studentinfo>>() {});  
                return list;  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        String hql="from Studentinfo where 1=1";  
        if(stu!=null){  
            if(stu.getUsernumber()!=null){  
                hql+=" and usernumber like '%"+stu.getUsernumber()+"%' ";  
            }  
        }  
        List<Studentinfo> list = studentinfoDao.getStudentinfoByStu(hql);  
        try {  
            String stuJsonStr=mapper.writeValueAsString(list);  
            redisClientTemplate.setex(key, 60, stuJsonStr);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return list;  
    }  
      
  
    public StudentinfoDao getStudentinfoDao() {  
        return studentinfoDao;  
          
    }  
  
    public void setStudentinfoDao(StudentinfoDao studentinfoDao) {  
        this.studentinfoDao = studentinfoDao;  
    }  
  
    public RedisClientTemplate getRedisClientTemplate() {  
        return redisClientTemplate;  
    }  
  
    public void setRedisClientTemplate(RedisClientTemplate redisClientTemplate) {  
        this.redisClientTemplate = redisClientTemplate;  
    }  
  
}


原文

nicknailo
关注
  • 7
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Redis详解及在项目中应用
weixin_43816557的博客
08-16 6327
本人目前写的所有文章都是基于springboot项目中可能用到的框架技术，如有需要，可在专栏中寻找。本文从简单介绍redis的基本操刀到在项目中redis的应用，再到缓存预热的介绍，最后介绍了创建更新缓存计划内容，由浅入深逐步剖析。...
redis的详细安装说明以及javaweb项目集成实例
02-13
redis的详细安装说明以及javaweb项目集成实例
【干货】Redis在Java开发中的基本使用和巧妙用法
Dark_orange的博客
02-23 2454
本文介绍了Redis在Java中的巧妙用法，包括基本数据类型和Jedis API的基本用法，以及高级用法如连接池、事务和发布/订阅模式等。同时，还介绍了使用Spring Data Redis的方法，使得在Spring应用程序中使用Redis变得更加容易。这些方法可以帮助Java开发人员更好地使用Redis实现高效、可靠的缓存。参考资料Redis官网：https://redis.io/Jedis GitHub仓库：https://github.com/redis/jedis。
2024年Web前端最全在项目中加入redis缓存（学习总结），2024年最新Web前端驱动工程师面试题
最新发布
2401_84616533的博客
05-11 654
好了，这就是整理的前端从入门到放弃的学习笔记，还有很多没有整理到，我也算是边学边去整理，后续还会慢慢完善，这些相信够你学一阵子了。做程序员，做前端工程师，真的是一个学习就会有回报的职业，不看出身高低，不看学历强弱，只要你的技术达到应有的水准，就能够得到对应的回报。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】学习从来没有一蹴而就，都是持之以恒的，正所谓活到老学到老，真正懂得学习的人，才不会被这个时代的洪流所淘汰。#最大阻塞等待时间(负数表示没限制)
Lz03-Java中操作redis实践
Me3_1415926535的博客
12-10 1452
文章目录Redis 客户端概述准备工作Jedis的基本应用简介准备工作Jedis基本应用实践RedisTemplate基本应用简介准备工作RedisTemplate对象应用实践StringRedisTemplate对象应用实践基于业务定制RedisTemplate对象（拓展） Redis 客户端 概述 Redis 是一种C/S 架构的分布式缓存数据库，它有自带的命令行客户端，也有对应的Java或其它语言客户端，可以在这些客户端中通过一些API对redis进行读写操作。 准备工作 第一步： 创建工程。 创建m
数据库讨论（二）：Redis在Java项目中使用（从安装到运用）
xiaogangpi的专栏
03-20 441
目录 本来是只写在Java中的使用，有时间就多写点（感谢帅哥同事的建议）。 - redis安装与使用 - 基本数据类型介绍 -JEDIS基本数据操作 - 事务处理 - 主从复制 - 发布订阅 安装和使用 简介 Redis是一个使用C语言写成的，开源key-value数据库。它是一个小而美的数据库，主要用在内存缓存中，读写性能极佳，缓存与简单是其市场定位。 Redis...
Redis在Java web中的应用
cogo_Time的博客
10-25 405
一般而言 Redis 在 Java Web 应用中存在两个主要的场景，一个是缓存常用的数据，另一个是在需要高速读/写的场合使用它快速读/写，比如一些需要进行商品抢购和抢红包的场合。 由于在高并发的情况下，需要对数据进行高速读/写的场景，一个最为核心的问题是数据一致性和访问控制。 ##缓存 在对数据库的读/写操作中，现实的情况是读操作的次数远超写操作，一般是 1:9 到 3:7 ...
redis的java项目应用.zip
06-30
java项目中redis的应用,写的一个小例子，可以参考借鉴.
Java web 项目电子商城
05-30
springboot、springmvc、mybatis-plus、lombok、vue2.0，redis 准备环境： windows/mac、Idea jdk1.8、 mysql、maven、redis 功能说明 前台： 购买首页：展示商品信息 商品分类：按分类展示商品信息 我的...
Java简单实现session保存到redis的方法示例
08-27
Java简单实现session保存到redis的方法示例是将Java应用程序的session数据保存到Redis缓存服务器的方法，解决了在负载均衡情况下用户session不一致的问题。该方法通过配置web.xml文件中的过滤器，使用RedisTemplate...
系统设计、分布式、数据库（MySQL、Redis）、Java 项目实战等.zip
01-12
软件开发设计：应用软件开发、系统软件开发、移动应用开发、网站开发C++、Java、python、web、C#等语言的项目开发与学习资料 硬件与设备：单片机、EDA、proteus、RTOS、包括计算机硬件、服务器、网络设备、存储设备...
如何在 Java 中实现一个 redis 缓存服务
08-25
在 web 应用的简单结构中，用户的请求通过用户层来到业务层，业务层在从数据层获取数据，返回给用户层。在用户量小，数据量不太大的情况下，这个系统运行得很顺畅。但是随着用户量越来越大，数据库中的数据越来越多...
redis的使用 Java_redis在java项目中的使用
weixin_28931449的博客
02-12 980
在上一篇文章中已经讲了redis的spring配置，这篇将会描述redis在java项目中的使用。redis存储形式都是key-value(键值对)，按照存储的内容分为两种，一种是存简单数据，即数字，字符串等，可以用string-value的形式存储；另一种是存对象、集合等，最好用序列化的方式来存储。1、存储简单数据try{Jedis jedis= newJedis();jedis.set("na...
java web项目中Spring整合Redis的使用
biaozhun90的博客
03-10 7937
一、添加Redis Maven依赖 redis.clients jedis 2.6.2 org.springframework.data spring-data-redis 1.7.1.RELE
Redis在实际项目中的使用
炫的博客
01-08 7178
redis: host: 172.27.15.23 port: 6379 database: 0 pool: max-idle: 20 min-idle: 1 max-active: 20 max-wait: 60000 import org.springframework.cache.CacheManager; i
java web 中如何使用redis_<Web> 如何给web项目添加redis服务
weixin_39855634的博客
02-24 584
前言这两天项目用到redis，而我自己也正准备看这个，所以就从头开始学习了一遍。既然要用，说明已经对redis是干什么的，特点是什么，对项目有什么好处，需要缓存什么东西等问题都了解过了，所以我们直接开搞：怎么获取redis安装redis，linux下wget到github的源码，然后直接make就行了，比较简单。我是在windows下用的，所以来说下：到从redis官网连接过去的redisServ...
Redis在项目中的应用
Wangyunqian_piu的博客
12-03 1704
2021SC@SDUSC 在本项目中使用Redis解决应用服务器的cpu和内存压力，减少io的读操作，减轻io的压力。 RedisTemplate配置 public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) { // 设置序列化 Jackson2JsonRedisSerializer<Object> jackson2Js.
redis 和 java
10-16
Java是一种广泛使用的编程语言，常用于开发Web应用程序、移动应用程序和企业级应用程序。 Java可以通过Jedis等Redis客户端库与Redis进行交互，使用Java开发的应用程序可以利用Redis的高速缓存和数据结构存储功能来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值