Jedis集成到项目中

　　Jedis整合到项目中，就可以在项目中使用redis了，作为Java程序狗，这个可以会，贴代码了，不截图了，哈哈

一、maven中的pom.xml中添加依赖

 <dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>2.6.0</version>
 </dependency>

二、spring和Jedis整合

 　　 <!-- 连接池配置 -->
     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
         <property name="maxTotal" value="${redis.maxTotal}"/>
     </bean>

     <!-- 分片式集群连接池 -->
     <bean class="redis.clients.jedis.ShardedJedisPool">
         <constructor-arg index="0" ref="jedisPoolConfig" />
         <constructor-arg index="1">
             <list>
                 <bean class="redis.clients.jedis.JedisShardInfo">
                     <constructor-arg index="0" value="${redis.node1.host}"></constructor-arg>
                     <constructor-arg index="1" value="${redis.node1.port}"></constructor-arg>
                 </bean>
             </list>
         </constructor-arg>
     </bean>

三、封装RedisService

注意：这个是待优化的代码，只有jedis分片对象ShardedJedis调用不同的方法而已，其他的代码完全一样，这个是可以优化的，这个优化方法很巧妙

 @Service
 publicclass RedisService {

 　　@Autowired
 　　private ShardedJedisPool shardedJedisPool;

 　　/**
      * 执行set操作
      *
      * @param key
      * @param value
      * @return
      */
 　　public String set(String key, String value) {
         ShardedJedis shardedJedis = null;
 　　try {
 　　　　// 从连接池中获取到jedis分片对象
 　　　　shardedJedis = shardedJedisPool.getResource();
 　　　　return shardedJedis.set(key, value);
         } finally {
 　　　　　　if (null != shardedJedis) {
 　　　　　　// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
 　　　　　　shardedJedis.close();
           }
         }
     }

 　　/**
      * 执行get操作
      *
      * @param key
      * @return
      */
 　　public String get(String key) {
         ShardedJedis shardedJedis = null;
 　　try {
 　　　　// 从连接池中获取到jedis分片对象
 　　　　shardedJedis = shardedJedisPool.getResource();
 　　　　return shardedJedis.get(key);
         } finally {
 　　　　　　if (null != shardedJedis) {
 　　　　　　// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
 　　　　　　shardedJedis.close();
             }
         }
     }

 }

四、优化RedisService

1、定义接口，借助泛型

public interface Function<T, E> {

    public T callback(E e);

}

2、定义一个通用方法，减少相同代码的编写

     @Autowired
     private ShardedJedisPool shardedJedisPool;

     private <T> T execute(Function<T, ShardedJedis> fun) {
         ShardedJedis shardedJedis = null;
         try {
             // 从连接池中获取到jedis分片对象
             shardedJedis = shardedJedisPool.getResource();
             return fun.callback(shardedJedis);
         } finally {
             if (null != shardedJedis) {
                 // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
                 shardedJedis.close();
             }
         }
     }

3、调用通用的代码，实现不同的逻辑

注意：这个方法有点太巧妙了，有木有，这里面用到了JavaScript中的回调函数的思想，第一次感到代码之美

     /**
      * 执行set操作，设置数据
      *
      * @param key
      * @param value
      * @return
      */
     public String set(String key, String value) {
         return this.execute(new Function<String, ShardedJedis>() {

             @Override
             public String callback(ShardedJedis e) {
                 return e.set(key, value);
             }

         });
     }

     /**
      * 执行set操作，设置数据，并且设置生存时间，单位：秒
      *
      * @param key
      * @param value
      * @param seconds
      * @return
      */
     public String set(String key, String value, Integer seconds) {
         return this.execute(new Function<String, ShardedJedis>() {

             @Override
             public String callback(ShardedJedis e) {
                 String str = e.set(key, value);
                 e.expire(key, seconds);
                 return str;
             }
         });
     }

     /**
      * 执行get操作，获取数据
      *
      * @param key
      * @return
      */
     public String get(String key) {
         return this.execute(new Function<String, ShardedJedis>() {

             @Override
             public String callback(ShardedJedis e) {
                 return e.get(key);
             }

         });
     }

     /**
      * 删除一个key
      *
      * @param key
      * @return
      */
     public Long del(String key) {
         return this.execute(new Function<Long, ShardedJedis>() {

             @Override
             public Long callback(ShardedJedis e) {
                 return e.del(key);
             }

         });
     }

     /**
      * 设置生存时间，单位：秒
      *
      * @param key
      * @param seconds
      * @return
      */
     public Long expire(String key,Integer seconds) {
         return this.execute(new Function<Long, ShardedJedis>() {

             @Override
             public Long callback(ShardedJedis e) {
                 return e.expire(key, seconds);
             }

         });
     }