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

}