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