spring整合redis客户端及缓存接口设计

 1 /**
 2  * @ClassName: JedisTemple
 3  * @Description: Jedis 操作模板类，为啥要这个？请参照{@link JdbcTemple} 封装重复不必要的操作
 4  * @author 徐飞
 5  * @date 2016年1月26日 下午2:37:24
 6  *
 7  */
 8 public class JedisTemple {
 9 
10     /** 缓存客户端 **/
11     private JedisPool jedisPool;// 非切片连接池
12 
13     public JedisTemple(JedisPool jedisPool) {
14         this.jedisPool = jedisPool;
15     }
16 
17     /**
18      * @Title: execute
19      * @Description: 执行{@link RedisPoolCallback#doInJedis(Jedis)}的方法
20      * @param action
21      * @return
22      * @author 徐飞
23      */
24     public <T> T execute(RedisPoolCallback<T> action) {
25         T value = null;
26         Jedis jedis = null;
27         try {
28             jedis = jedisPool.getResource();
29             return action.doInJedis(jedis);
30         } catch (Exception e) {
31             // 释放redis对象
32             jedisPool.returnBrokenResource(jedis);
33             e.printStackTrace();
34         } finally {
35             // 返还到连接池
36             returnResource(jedisPool, jedis);
37         }
38 
39         return value;
40     }
41 
42     /** 
43     * 返还到连接池 
44     * @param pool  
45     * @param redis 
46     */
47     private void returnResource(JedisPool pool, Jedis redis) {
48         // 如果redis为空不返回
49         if (redis != null) {
50             pool.returnResource(redis);
51         }
52     }
53 
54     public JedisPool getJedisPool() {
55         return jedisPool;
56     }
57 
58     public void setJedisPool(JedisPool jedisPool) {
59         this.jedisPool = jedisPool;
60     }
61 
62 }

 1 import redis.clients.jedis.Jedis;
 2 
 3 /**
 4  * @ClassName: RedisPoolCallback
 5  * @Description: redis操作回调接口，此接口主要为JedisTemple模板使用
 6  * @author 徐飞
 7  * @date 2016年1月26日 下午2:35:41
 8  *
 9  * @param <T>
10  */
11 public interface RedisPoolCallback<T> {
12     /**
13      * @Title: doInJedis
14      * @Description: 回调执行方法，需要重新此方法，一般推荐使用匿名内部类
15      * @param jedis
16      * @return
17      * @author 徐飞
18      */
19     T doInJedis(Jedis jedis);
20 }

  1 import redis.clients.jedis.Jedis;
  2 import redis.clients.jedis.JedisPool;
  3 import redis.clients.jedis.JedisPoolConfig;
  4 import redis.clients.util.SafeEncoder;
  5 
  6 import com.cxypub.baseframework.sdk.util.ObjectUtils;
  7 
  8 /**
  9  * @ClassName: RedisCacheClient
 10  * @Description: redis缓存客户端
 11  * @author 徐飞
 12  * @date 2015-4-16 上午10:42:32
 13  *
 14  */
 15 public class RedisCacheClient implements SimpleCache {
 16 
 17     private JedisTemple jedisTemple;
 18 
 19     public RedisCacheClient(JedisPoolConfig config, String host, Integer port) {
 20         this.initialPool(config, host, port);
 21     }
 22 
 23     /**
 24      * 初始化非切片池
 25      */
 26     private void initialPool(JedisPoolConfig config, String host, Integer port) {
 27         JedisPool jedisPool = new JedisPool(config, host, port);
 28         this.jedisTemple = new JedisTemple(jedisPool);
 29     }
 30 
 31     @Override
 32     public boolean add(final String key, final Object valueObject) {
 33         try {
 34             jedisTemple.execute(new RedisPoolCallback<Boolean>() {
 35                 @Override
 36                 public Boolean doInJedis(Jedis jedis) {
 37                     jedis.set(SafeEncoder.encode(key), ObjectUtils.object2Byte(valueObject));
 38                     return true;
 39                 }
 40 
 41             });
 42         } catch (Exception e) {
 43             e.printStackTrace();
 44             return false;
 45         }
 46         return true;
 47     }
 48 
 49     @Override
 50     public Object get(final String key) {
 51 
 52         return jedisTemple.execute(new RedisPoolCallback<Object>() {
 53             @Override
 54             public Object doInJedis(Jedis jedis) {
 55                 byte[] cacheValue = jedis.get(SafeEncoder.encode(key));
 56                 if (cacheValue != null) {
 57                     return ObjectUtils.byte2Object(cacheValue);
 58                 }
 59                 return null;
 60             }
 61 
 62         });
 63     }
 64 
 65     @Override
 66     public long delete(final String key) {
 67         return jedisTemple.execute(new RedisPoolCallback<Long>() {
 68             @Override
 69             public Long doInJedis(Jedis jedis) {
 70                 return jedis.del(key);
 71             }
 72         });
 73     }
 74 
 75     @Override
 76     public boolean add(final String key, Object value, final int seconds) {
 77         try {
 78             this.add(key, value);
 79             jedisTemple.execute(new RedisPoolCallback<Long>() {
 80                 @Override
 81                 public Long doInJedis(Jedis jedis) {
 82                     return jedis.expire(key, seconds);
 83                 }
 84             });
 85         } catch (Exception e) {
 86             e.printStackTrace();
 87             return false;
 88         }
 89         return true;
 90     }
 91 
 92     @Override
 93     public boolean exists(final String key) {
 94         return jedisTemple.execute(new RedisPoolCallback<Boolean>() {
 95             @Override
 96             public Boolean doInJedis(Jedis jedis) {
 97                 return jedis.exists(key);
 98             }
 99         });
100     }
101 
102 }

 1 # Redis settings
 2 redis.host=192.168.1.215
 3 redis.port=6379
 4 redis.pass=
 5 
 6 # 控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
 7 # 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
 8 redis.maxTotal=600
 9 # 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
10 redis.maxIdle=300
11 # 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
12 redis.maxWaitMillis=1000
13 # 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
14 redis.testOnBorrow=true

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"
    default-autowire="autodetect" default-lazy-init="false">

    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
        <property name="maxIdle" value="${redis.maxIdle}" />  
        <property name="maxTotal" value="${redis.maxTotal}" />  
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />  
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
    </bean>
    
    <bean id="jedisClient" class="com.cxypub.baseframework.sdk.cache.RedisCacheClient">
        <constructor-arg ref="jedisPoolConfig" />
        <constructor-arg value="${redis.host}" />
        <constructor-arg value="${redis.port}" type="java.lang.Integer" />
    </bean>
    

</beans>

 1 public class RedisTest {
 2     public static void main(String[] args) {
 3         JedisPoolConfig config = new JedisPoolConfig();
 4         config.setMaxTotal(500);
 5         config.setMaxIdle(5);
 6         config.setMaxWaitMillis(1000 * 100);
 7         config.setTestOnBorrow(true);
 8         RedisCacheClient client = new RedisCacheClient(config, "192.168.1.215", 6379);
 9         Dictionary dict = new Dictionary();
10         dict.setId("qwertryruyrtutyu");
11         dict.setDictChineseName("上海");
12         dict.setCreateTime(new Date());
13         client.add("xufei", dict);
14         Dictionary dict2 = (Dictionary) client.get("xufei");
15         System.out.println(dict2);
16         System.out.println(dict == dict2);
17     }
18 }