一、Redis（Jedis）的RedisPool的使用

RedisConfig.java配置文件

package main.java.com.smart.dao.redis;

public class RedisConfig {

    public static int MAX_IDLE = 50;//最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。

    public static int MIN_IDLE = 5;

    public static int MAX_ACTIVE = 5;//连接池的最大数据库连接数。设为0表示无限制。

    public static int TIME_OUT = 1000;//最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。

    public static int RETRY_NUM = 6;//重新连接次数
}

JedisApi.java

package main.java.com.smart.dao.redis;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mysql.jdbc.log.Log;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/** 
 * 在不同的线程中使用相同的Jedis实例会发生奇怪的错误。但是创建太多的实现也不好因为这意味着会建立很多sokcet连接， 
 * 也会导致奇怪的错误发生。单一Jedis实例不是线程安全的。为了避免这些问题，可以使用JedisPool, 
 * JedisPool是一个线程安全的网络连接池。可以用JedisPool创建一些可靠Jedis实例，可以从池中拿到Jedis的实例。 
 * 这种方式可以解决那些问题并且会实现高效的性能 
 * 思路：1)创建JedisPool对象pool  2)通过pool.getResource获取一个Jedis实例 3)将所有的jedisPool保存在一张Map中 
 */

public class JedisApi {
    protected static final Logger LOG = LoggerFactory.getLogger(JedisApi.class);

    private volatile static JedisApi jedisApi;//可见性修饰，保证对线程之间具有可见性

    /**
     * 保存多个连接源
     */
    private static Map<String, JedisPool> poolMap = new HashMap<String, JedisPool>();

    /**
     * jedisPool
     * 
     * @param ip
     * @param port
     * @return
     */
    private static JedisPool getPool(String ip, int port){

        try {
            String key = ip + ":" + port;
            JedisPool pool = null;
            if(!poolMap.containsKey(key)) {
                System.out.println("触发poolMap模块");
                JedisPoolConfig config = new JedisPoolConfig();//需要依赖common-pool-ver.jar
                config.setMaxIdle(RedisConfig.MAX_IDLE);
                config.setMinIdle(RedisConfig.MIN_IDLE);
                config.setMaxTotal(RedisConfig.MAX_ACTIVE);
                //在获取连接的时候检查有效性，默认为false
                config.setTestOnBorrow(true);
                //在空闲时检查有效性,默认为false
                config.setTestOnReturn(true);
                //连接池耗尽的时候，是否阻塞，false会抛出异常，true阻塞直到超时，会抛出超时异常，默认为true
                config.setBlockWhenExhausted(true);
                pool = new JedisPool(config, ip, port, RedisConfig.TIME_OUT);
                System.out.println("key:"+key+" pool:"+pool.toString());
                poolMap.put(key, pool);
            } else {
                pool = poolMap.get(key);
            }
            return pool;
        } catch (Exception e) {
            LOG.error("Init jedis pool failed!"+e.getMessage(),e);
        }
        return null;
    }

    /**
     * 线程安全单例模式
     * @return
     */
    public static JedisApi getRedisApi() {

        if(jedisApi == null){
            synchronized (JedisApi.class) {
                if(jedisApi == null){
                    jedisApi = new JedisApi();
                }
            }
        }
        return jedisApi;
    }

    /**
     * 获取一个jedis实例
     * 
     * @param ip
     * @param port
     * @return
     */
    public Jedis getRedis(String ip, int port) {
        Jedis jedis = null;
        int count = 0;
        while(jedis == null && count <= RedisConfig.RETRY_NUM) {
            try {
                jedis = getPool(ip, port).getResource();
                LOG.info(ip+":"+port+"JedisPool is status:"+jedis.ping(),jedis);
            } catch (Exception e) {
                LOG.error("Get redis failed!" + e.getMessage(),e);
                count++;
            }
        }
        return jedis;
    }

    /**
     * 释放jedis到jedisPool中
     * @param jedis
     */
    public void closeRedis(Jedis jedis) {

        if(jedis != null) {
            try {
                jedis.close();
            } catch (Exception e) {
                LOG.error("Close jedis failed!" + e.getMessage(), e);
            }
        }
    }

    public static Map<String, JedisPool> getPoolMap() {
        return poolMap;
    }       
}

JedisDao.java

package main.java.com.smart.dao.redis;

import java.util.Map;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class JedisDao {

    //单例模式,每台服务器只能有一个JedisPool对象,可多个Jedis对象
    static JedisApi jedisApi = JedisApi.getRedisApi();
    //同一JedisPool池的不同对象(此处应该通过配置引入对象)
    static Jedis jpool = jedisApi.getRedis("localhost", 6379);

    /**
     * 返回JedisPool列表，查看有多少服务器
     * @return
     */
    public Map<String, JedisPool> printJedisPool(){
        Map<String, JedisPool> poolMap = JedisApi.getPoolMap();
        return poolMap;
    }

    public static void main(String[] args) {
        JedisDao jd = new JedisDao();
        jpool.set("zoo", "cats");
        System.out.println(jpool.get("zoo"));
        for(String key : jd.printJedisPool().keySet()) {
            System.out.println("key="+key);
        }
        jedisApi.closeRedis(jpool);//
    }
}

---