jedis 單點配置

pom引入jar包

<!-- redis start -->
        <dependency> 
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
<!-- redis end -->

spring 配置

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.pool.maxActive}" />
        <property name="maxIdle" value="${redis.pool.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.pool.maxWait}" />
        <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
    </bean>

    <bean id="jedis.shardInfo" class="redis.clients.jedis.JedisShardInfo">
        <constructor-arg index="0" value="${redis.ip}" />
        <constructor-arg index="1" value="${redis.port}" />
        <constructor-arg index="2" value="${redis.timeout}"
            type="int" />
    </bean>

    <bean id="jedisPool" class="redis.clients.jedis.ShardedJedisPool">
        <constructor-arg index="0" ref="jedisPoolConfig" />
        <constructor-arg index="1">
            <list>
                <ref bean="jedis.shardInfo" />
            </list>
        </constructor-arg>
    </bean>

    <bean id="redisUtil" class="com.redis.RedisUtil">
        <property name="shardedJedisPool" ref="jedisPool" />
    </bean>

redis.properties配置文件

redis.ip=127.0.0.1
redis.port=6379
redis.timeout=10000
#最大分配的對象數
redis.pool.maxActive=1024
#最大可以保持idel狀態的對象數
redis.pool.maxIdle=50
#當池內沒有返回對象時，最大等待時間
redis.pool.maxWait=2000
#當調用borrow Object方法時，是否進行有效性檢查
redis.pool.testOnBorrow=true

RedisUtil.java工具類

/**
 *Class Description:
 *
 */
package com.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**
 * 鏈接和使用redis資源的工具類
 * 
 * @author 
 * 
 */

public class RedisUtil {
    private static final Logger log = LoggerFactory.getLogger(RedisUtil.class);

    private static int connCount = 0;// 當前鏈接的個數

    /**
     * 切片客戶端連接池
     */
    private ShardedJedisPool shardedJedisPool;

    /**
     * 獲取切片客戶端連接池
     * 
     * @return conn
     */
    public ShardedJedis getConnFromShardedPool() {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = shardedJedisPool.getResource();
        } catch (Exception e) {
            log.error("Get ShardedJedis from ShardedJedisPool failed...", e);
            e.printStackTrace();
        }
        return shardedJedis;
    }

    /**
     * @功能:獲取安全切片客戶端連接池
     * 
     * @return conn
     */
    public ShardedJedis getSafeConnFromShardedPool() {
        // 獲取不到鏈接時等待一秒繼續嘗試,最多嘗試20次
        int maxTryCount = 20;
        ShardedJedis shardedJedis = null;
        for (int i = 0; i < maxTryCount; i++) {
            try {
                shardedJedis = shardedJedisPool.getResource();
                break;
            } catch (Exception e) {
                // 超過最多的嘗試次數則退出
                if (i == maxTryCount) {
                    break;
                }
                log.error(
                        "==========>>Get ShardedJedis from ShardedJedisPool failed.,第"
                                + (i + 1) + "次嘗試,最多嘗試" + maxTryCount
                                + ",如超過最多的嘗試次數則退出執行。", e);
                e.printStackTrace();
                try {
                    // 出現異常等待1秒鐘再次嘗試
                    Thread.sleep(1000);
                } catch (Exception e2) {
                    log.error("", e);
                }
            }
        }
        if (shardedJedis != null) {
            synchronized (this) {
                connCount++;
                log.info("Get ShardedJedis from ShardedJedisPool success.... 當前使用鏈接數="
                        + connCount);
            }

        }
        return shardedJedis;
    }

    /**
     * 關閉切片客戶端連接
     * 
     * @param conn
     */
    public void closeConnShardedJedis(ShardedJedis shardedJedis) {
        if (null != shardedJedis) {
            try {
                shardedJedisPool.returnResource(shardedJedis);
            } catch (Exception e) {
                log.error("Close shardedJedis connection failed.");
                e.printStackTrace();
            }
        }
        synchronized (this) {
            connCount--;
            log.info("==========>>Close ShardedJedis from ShardedJedisPool success.... 當前使用鏈接數="
                    + connCount);
        }
    }

    /**
     * 設置數據
     * 
     * @param conn
     */
    public boolean setData(String key, String value) {
        try {
            ShardedJedis jedis = shardedJedisPool.getResource();
            jedis.set(key, value);
            shardedJedisPool.returnResource(jedis);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 獲取數據
     * 
     * @param conn
     */
    public String getData(String key) {
        String value = null;
        try {
            ShardedJedis jedis = shardedJedisPool.getResource();
            value = jedis.get(key);
            shardedJedisPool.returnResource(jedis);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return value;
    }

    /**
     * 獲取切片客戶端連接池
     * 
     * @return 數據源
     */
    public ShardedJedisPool getShardedJedisPool() {
        return shardedJedisPool;
    }

    /**
     * 設置切片客戶端連接池
     * 
     * @return 數據源
     */
    public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {
        this.shardedJedisPool = shardedJedisPool;
    }
}

使用方法

@Autowired
    private RedisUtil redisUtil;

public static void main(String[] args) {

    ShardedJedis sj = null;
        try {
            sj = redisUtil.getSafeConnFromShardedPool();
                sj.set("testkey","testvalue");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (sj != null) {
                    redisUtil.closeConnShardedJedis(sj);
              }
        }

}