spring项目整合jedis及注意事项

首先我们需要引入jedis相关的包：（版本跟redis版本无关，不用担心版本问题）

<span style="white-space:pre">		</span><dependency>
		    <groupId>redis.clients</groupId>
		    <artifactId>jedis</artifactId>
		    <version>2.5.2</version>
		</dependency> 

接下来我们要在spring的配置文件中配置jedispool（缓存池）跟jedis的bean

  <!-- 使用redis缓存 -->    
   <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
       <property name="maxTotal" value="50000" />  
       <property name="maxIdle" value="50000" />  
       <property name="minIdle" value="100" /> 
       <property name="maxWaitMillis" value="15000"/>  
       <property name="testOnBorrow" value="true" />  
   </bean> 

    <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"  scope="singleton">
        <constructor-arg index="0" ref="jedisPoolConfig" />
        <constructor-arg index="1">
            <list>
                <bean class="redis.clients.jedis.JedisShardInfo">
                    <constructor-arg name="host" value="127.0.0.1" />
                    <constructor-arg name="port" value="6379" />
                     <constructor-arg name="timeout" value="3000" />
                    <constructor-arg name="weight" value="1" />
                </bean>
            </list>
        </constructor-arg>
    </bean>
      <!-- end使用redis缓存 -->   

maxIdle：jedis最大活跃数   ， maxTotal ：jedis最大连接数   ， minIdle ： jedis最小空闲数（连接池中最少保留的jedis连接数），testOnBorrow ：在borrow一个jedis的时候验证其是否可用，可用则返回，不可用则废弃重新创建一个 

注：当并发比较大的时候，如果maxTotal小于并发请求数，程序在jedispool中去borrow一个jedis时获取不到，则会报Could not get a resource from the pool
at redis.clients.util.Pool.getResource异常

接下来我们看一下如何调用jedis进行操作

RedisDataSource 接口：

package com.smc.topic.redis;

import redis.clients.jedis.ShardedJedis;

public interface RedisDataSource {
    public abstract ShardedJedis getRedisClient();
    public void returnResource(ShardedJedis shardedJedis);
    public void returnResource(ShardedJedis shardedJedis,boolean broken);
}

RedisDataSource实现类：

package com.smc.topic.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

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

@Repository("redisDataSource")
public class RedisDataSourceImpl implements RedisDataSource {

    private static final Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);

    @Autowired
    private ShardedJedisPool  shardedJedisPool;

    
    public ShardedJedis getRedisClient() {
        try {
            ShardedJedis shardJedis = shardedJedisPool.getResource();
            return shardJedis;
        } catch (Exception e) {
            log.error("getRedisClent error", e);
        }
        return null;
    }

    public void returnResource(ShardedJedis shardedJedis) {
        shardedJedisPool.returnResource(shardedJedis);
    }

    public void returnResource(ShardedJedis shardedJedis, boolean broken) {
        if (broken) {
            shardedJedisPool.returnBrokenResource(shardedJedis);
        } else {
            shardedJedisPool.returnResource(shardedJedis);
        }
    }
}

package com.smc.topic.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

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

@Repository("redisClientTemplate")
public class RedisClientTemplate {

    private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);

    
    @Autowired
    private ShardedJedisPool  shardedJedisPool;

    
    public ShardedJedis getRedisClient() {
        try {
            ShardedJedis shardJedis = shardedJedisPool.getResource();
            return shardJedis;
        } catch (Exception e) {
            log.error("getRedisClent error", e);
        }
        return null;
    }
    
    /**
     * 获取单个值
     * 
     * @param key
     * @return
     */
    public String get(String key) {
        String result = null;
        ShardedJedis shardedJedis = shardedJedisPool.getResource();
        if (shardedJedis == null) {
            return result;
        }

        boolean broken = false;
        try {
            result = shardedJedis.get(key);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }
    
    
    public String get(String key,ShardedJedis shardedJedis,boolean isReturn) {
        String result = null;
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.get(key);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
        	if(isReturn){
        		returnResource(shardedJedis, broken);
        	}
        }
        return result;
    }
    
    public String set(String key, Object value,ShardedJedis shardedJedis,boolean isReturn) {
        String result = null;
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.set(key.getBytes(), SerializeUtils.serialize(value));
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
        	if(isReturn){
        		returnResource(shardedJedis, broken);
        	}
        }
        return result;
    }
    
    /**
     * 设置单个值
     * 
     * @param key
     * @param value
     * @return
     */
    public String set(String key, Object value) {
        String result = null;

        ShardedJedis shardedJedis = shardedJedisPool.getResource();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.set(key.getBytes(), SerializeUtils.serialize(value));
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }
    
    
    
    public String setsx(String key, String value,Integer seconds) {
        String result = null;

        ShardedJedis shardedJedis = shardedJedisPool.getResource();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.setex(key,seconds, value);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }
    
    public String setsx(String key, String value,Integer seconds,ShardedJedis shardedJedis,boolean isReturn) {
        String result = null;
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.setex(key,seconds, value);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
        	if(isReturn){
        		returnResource(shardedJedis, broken);
        	}
        }
        return result;
    }

    
    

    public void returnResource(ShardedJedis shardedJedis) {
        shardedJedisPool.returnResource(shardedJedis);
    }

    public void returnResource(ShardedJedis shardedJedis, boolean broken) {
        if (broken) {
            shardedJedisPool.returnBrokenResource(shardedJedis);
        } else {
            shardedJedisPool.returnResource(shardedJedis);
        }
    }
    
    
    
    public void disconnect() {
        ShardedJedis shardedJedis = shardedJedisPool.getResource();
        shardedJedis.disconnect();
    }

    

    public Boolean exists(String key) {
        Boolean result = false;
        ShardedJedis shardedJedis = getRedisClient();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.exists(key);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }

    public String type(String key) {
        String result = null;
        ShardedJedis shardedJedis = getRedisClient();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.type(key);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }

    /**
     * 在某段时间后失效
     * 
     * @param key
     * @param unixTime
     * @return
     */
    public Long expire(String key, int seconds) {
        Long result = null;
        ShardedJedis shardedJedis = getRedisClient();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.expire(key, seconds);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }

    /**
     * 在某个时间点失效
     * 
     * @param key
     * @param unixTime
     * @return
     */
    public Long expireAt(String key, long unixTime) {
        Long result = null;
        ShardedJedis shardedJedis = getRedisClient();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.expireAt(key, unixTime);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }

    public Long del(String key) {
        Long result = null;
        ShardedJedis shardedJedis = getRedisClient();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.del(key);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            returnResource(shardedJedis, broken);
        }
        return result;
    }
 
}

注意：1.每次使用完jedis后一定要return，不然会一直占用这jedis资源，导致很多问题的出现。

    2.在一个方法中多次调用jedis的get，set方法时，最好使用一个jedis（即调用带isReturn参数的方法，在最后一次调用时传入isReturn为true即可），这样会少了多次去连接池拿实例的过程，提高程序效率。