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);
            }

        });
    }