Java连接redis

一.依赖包

jedis-2.1.0.jar   commons-pool-1.6.jar

二.实例

//连接参数
public class RedisConfig
{
    public static int Maxactive=0;
    public static int RetryNum=0;
    public static int Maxidle=0;
    public static int Maxwait=0;
    public static int Timeout=0;

    public static String ip="";
    public static int port=0;
}

public class RedisUtil  {  

    protected Logger log = LoggerFactory.getLogger(getClass());  

    private static Map<String,JedisPool> maps  = new HashMap<String,JedisPool>();  

    /**
     * 私有构造器.
     */
    private RedisUtil() {  

    }  

    /**
     * 获取连接池.
     * @return 连接池实例
     */
    private static JedisPool getPool(String ip,int port) {
        String key = ip+":" +port;
        JedisPool pool = null;
        if(!maps.containsKey(key)) {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxActive(RedisConfig.Maxactive);
            config.setMaxIdle(RedisConfig.Maxidle);
            config.setMaxWait(RedisConfig.Maxwait);
            config.setTestOnBorrow(true);
            config.setTestOnReturn(true);
            try{
                /**
                 *如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
                 *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
                 */
                pool = new JedisPool(config, ip, port,RedisConfig.Timeout);
                maps.put(key, pool);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }else{
            pool = maps.get(key);
        }
        return pool;
    }

    public static JedisPool getPool()
    {
        return getPool(RedisConfig.ip,RedisConfig.port);
    }

    /**
     *类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     *没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
     */
    private static class RedisUtilHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static RedisUtil instance = new RedisUtil();
    }  

    /**
     *当getInstance方法第一次被调用的时候，它第一次读取
     *RedisUtilHolder.instance，导致RedisUtilHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静
     *态域，从而创建RedisUtil的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。
     *这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。
     */
    public static RedisUtil getInstance() {
        return RedisUtilHolder.instance;
    }  

    /**
     * 获取Redis实例.
     * @return Redis工具类实例
     */
    private static Jedis getJedis(String ip, int port) {
        Jedis jedis = null;
        int count = 0;
        do {
            try {
                jedis = getPool(ip, port).getResource();
                // log.info("get redis master1!");
            } catch (Exception e) {
                // log.error("get redis master1 failed!", e);
                // 销毁对象
                getPool(ip, port).returnBrokenResource(jedis);
            }
            count++;
        } while (jedis == null && count < RedisConfig.RetryNum);
        return jedis;
    }  

    //重载一下
    public static Jedis getJedis()
    {
        return getJedis(RedisConfig.ip,RedisConfig.port);
    }

    /**
     * 释放redis实例到连接池.
     * @param jedis redis实例
     */
    private static void closeJedis(Jedis jedis,String ip,int port) {
        if(jedis != null) {
            getPool(ip,port).returnResource(jedis);
        }
    }  

    public static void closeJedis(Jedis jedis)
    {
        closeJedis(jedis,RedisConfig.ip,RedisConfig.port);
    }

    /**
     * 退出然后关闭Jedis连接。如果Jedis为null则无动作。
     */
    public static void closeJedisDirectly(Jedis jedis) {
        if ((jedis != null) && jedis.isConnected()) {
            try {
                try {
                    jedis.quit();
                } catch (Exception e) {
                }
                jedis.disconnect();
            } catch (Exception e) {

            }
        }
    }

}