redis集群配置

Spring配置文件中redis集群配置
 <!-- 连接池配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
       <!--  最大连接数 -->
        <property name="maxTotal" value="1000"/>
        <!-- 最大空闲连接数 -->
        <property name="maxIdle" value="50"/>
        <property name="minIdle" value="20"/>
       <!--  等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException   -->
        <property name="maxWaitMillis" value="10000" />  
       <!--  逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1 -->
        <property name="timeBetweenEvictionRunsMillis" value="1000"/>
        <!-- 逐出连接的最小空闲时间 默认1800000毫秒(30分钟) -->
        <property name="minEvictableIdleTimeMillis" value="1000"/>
       <!--  在获取连接的时候检查有效性, 默认false -->
        <property name="testOnBorrow" value="true"/>
        <!-- 在空闲时检查有效性, 默认false -->
        <property name="testWhileIdle" value="true"/>
    </bean>

    <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">
        <constructor-arg name="nodes">
            <set>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host1}" />
                    <constructor-arg name="port" value="${redis.port1}" />
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host2}" />
                    <constructor-arg name="port" value="${redis.port2}" />
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host3}" />
                    <constructor-arg name="port" value="${redis.port3}" />
                </bean>
            </set>
        </constructor-arg>
        <constructor-arg name="timeout" value="10000" type="int" />
        <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
    </bean>

创建一个redisservice

public interface RedisClusterService {

    Long incr(String key);

    void addSet(String key,String ... values);

    Long getSetLength(String key);

    Long getLong(String key);

    boolean delString(String key);

    Long decr(String key);

    void expire(String key, int seconds);

    String flushAll();

    boolean setString(String key, String value);

    String getString(String key);

    void setex(String key, int seconds, String value);

    void set(String key, String value);

    String get(String key);

}

RedisServise实现类

@Service("redisService")
public class RedisClusterServiceImpl implements RedisClusterService {
    protected static Logger logger = Logger.getLogger(RedisClusterServiceImpl.class);
    private static final Long LONG_0=0L;
    @Autowired
    private JedisCluster jedisCluster;
    /** 
     *通过键获取值
     * @param key 
     * @param values 
     */  
    @Override
    public String get(String key) {  
         
        try{
           String string = jedisCluster.get(key);
           return string;
        }catch(Exception e){
            logger.error("redis add set error,key["+key+"]", e);
            return null;
        }
    }
    /** 
     * 向Redis中添加键值
     * @param key 
     * @param values 
     */  
    @Override
    public  void set(String key, String value) {  
        if(null == key || value == null) {  
            return;  
        }  
        try{
            jedisCluster.set(key, value);
        }catch(Exception e){
            logger.error("redis add set error,key["+key+"]", e);
        }
    }
    /** 
     * redis递增操作
     * @param key
     * @param value
     */  
    @Override
    public void setex(String key, int seconds, String value) {
        
        try{
             jedisCluster.setex(key,seconds,value);
        }catch(Exception e){
            logger.error("redis incr error and key = " + key, e);
        }
    }
    /** 
     * redis递增操作
     * @param key
     * @param value
     */  
    @Override
    public Long incr(String key) {
        
        try{
             return jedisCluster.incr(key);
        }catch(Exception e){
            logger.error("redis incr error and key = " + key, e);
            return LONG_0;
        }
    }
    /** 
     * 向Redis中添加set集合 
     * @param key 
     * @param values 
     */  
    @Override
    public  void addSet(String key, String ... values) {  
        if(null == key || values == null) {  
            return;  
        }  
         
        try{
            jedisCluster.sadd(key, values);
        }catch(Exception e){
            logger.error("redis add set error,key["+key+"]", e);
        }
    }
    /** 
     * 返回Set集合中的元素个数 
     * @param key 
     * @return 
     */  
    @Override
    public Long getSetLength(String key) {  
        if(null == key) {
            return LONG_0;
        }
        try{
            return jedisCluster.scard(key);
        }catch(Exception e){
            logger.error("redis get set size error,key["+key+"]", e);
            return LONG_0;
        }
    }  
    /** 
     * 获取String类型的值 
     * @param key 键的值 
     * @return 
     */ 
    @Override
    public  Long getLong(String key) {
        if(null == key) {
            return LONG_0;  
        }  
        
        String val = jedisCluster.get(key);
        if(val == null) {
            return LONG_0;  
        }  
        return Long.valueOf(val);
    } 
    /** 
     * 操作字符串类型(String),删除键 
     * @param key 
     * @return 
     */  
    @Override
    public boolean delString(String key) {  
         try{
             jedisCluster.del(key);
             return true;  
         }catch(Exception e){
             logger.error("redis del key error!key["+key+"]", e);
             return false;
         }  
    }
    /** 
     * redis递减操作
     * @param key
     * @param value
     */  
    @Override
    public Long decr(String key) {
       
        try{
             return jedisCluster.decr(key);
        }catch(Exception e){
            logger.error("redis incr error and key = " + key, e);
            return LONG_0;
        }
    }

    /**
     * 设置过期时间
     *
     * @param key
     * @param seconds
     */
    @Override
    public void expire(String key, int seconds) {
        if (seconds <= 0) {
            return;
        }
       
        try{
            jedisCluster.expire(key, seconds);
        }catch(Exception e){
            logger.error("redis expire error and key = " + key, e);
        }
    }

    /**
     * 清空所有key
     */
    @Override
    public String flushAll() {
       
        String stata=StringUtils.EMPTY;
        try{
            stata = ((BasicCommands) jedisCluster).flushAll();
            return stata;
        }catch(Exception e){
            logger.error("redis clear all key error", e);
            return stata;
        }
    }

    
    /** 
     * 向redis新增字符串键值对
     * @param key
     * @param value
     */  
    @Override
    public boolean setString(String key, String value) {  
         if(null == key || value == null ) {
             return false;  
         }
         try{
             jedisCluster.set(key, value);
             return true;  
         }catch(Exception e){
             logger.error("redis set key error,key["+key+"]", e);
             return false;
         }  
    }     
    /** 
     * 获取String类型的值 
     * @param key 键的值 
     * @return 
     */ 
    @Override
    public String getString(String key) {
        if(null == key) {
            return null;  
        }  
        try{
            return jedisCluster.get(key);
        }catch(Exception e){
            logger.error("redis getBytes error!", e);
            return null;
        }  
    }  
}