//连接参数
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) {

            }

        }

    }

}