redis的使用：获取redis实例的工具类

package com.wanhua.util;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;

import play.Play;

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

/**
 * Redis工具类,用于获取RedisPool. 参考官网说明如下： You shouldn't use the same instance from different threads because you'll have strange errors. And sometimes creating lots of Jedis instances is not good enough because it means lots of sockets and connections, which leads to strange errors as well. A single Jedis instance is not threadsafe! To avoid these problems, you should use JedisPool, which is a threadsafe pool of network connections. This way you can overcome those strange errors and achieve great performance. To use it, init a pool: JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost"); You can store the pool somewhere statically, it is thread-safe. JedisPoolConfig includes a number of helpful Redis-specific connection pooling defaults. For example, Jedis with JedisPoolConfig will close a connection after 300 seconds if it has not been returned.
 *
 * @author bqwang
 */
public class JedisUtil {
    private static Logger logger = Logger.getLogger(JedisUtil.class.getName()); // logger

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

    }

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

    /**
     * 获取连接池.
     *
     * @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.setMaxIdle(Integer.parseInt(Play.configuration.getProperty("redis.pool.maxIdle")));
            config.setMaxTotal(Integer.parseInt(Play.configuration.getProperty("redis.pool.maxTotal")));
            config.setTestOnBorrow(Play.configuration.getProperty("redis.pool.testOnBorrow") == "true" ? true : false);
            config.setTestOnReturn(Play.configuration.getProperty("redis.pool.testOnReturn") == "true" ? true : false);
            try {
                /**
                 * 如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息 请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
                 */
                pool = new JedisPool(config, ip, port, Integer.parseInt(Play.configuration.getProperty("redis.pool.timeout")));
                maps.put(key, pool);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            pool = maps.get(key);
        }
        return pool;
    }

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

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

    /**
     * 获取Redis实例.
     *
     * @return Redis工具类实例
     */
    public Jedis getJedis() {
        // logger.info("get getJedis------");
        Jedis jedis = null;
        int count = 0;
        do {
            String ip = Play.configuration.getProperty("redis.server.ip");
            // logger.info("get ip------"+ip);
            int port = Integer.parseInt(Play.configuration.getProperty("redis.server.port"));
            // logger.info("get port------"+port);
            try {
                jedis = getPool(ip, port).getResource();
            } catch (Exception e) {
                logger.info("get redis master1 failed!" + e);
                // 销毁对象
                getPool(ip, port).returnBrokenResource(jedis);
            }
            count++;
        } while (jedis == null && count < Integer.parseInt(Play.configuration.getProperty("redis.pool.retryTimes")));

        // logger.info("get jedis success------");
        return jedis;
    }

    /**
     * 释放redis实例到连接池.
     *
     * @param jedis
     *            redis实例
     */
    public static void closeJedis(Jedis jedis) {
        String ip = Play.configuration.getProperty("redis.server.ip");
        int port = Integer.parseInt(Play.configuration.getProperty("redis.server.port"));
        if (jedis != null) {
            getPool(ip, port).returnResource(jedis);
        }
    }

    public static void main(String args[]) {
        Jedis jds = JedisUtil.getInstance().getJedis();
        // 向redis中添加数据
        jds.sadd("mb", "test");
        // 从redis中取数据
        Set<String> resultSet = jds.smembers("mb");
        System.out.println("--get--result--from--redis---" + resultSet.toString());
        // 清空redis中指定key的消息
        jds.del("mb");
        // 清空所有redis中消息
        jds.flushDB();

    }

}

在配置文件中添加以下配置：

redis.pool.maxIdle=200
redis.pool.maxTotal=100
redis.pool.timeout=30000
redis.pool.retryTimes=5
redis.pool.testOnBorrow=true
redis.pool.testOnReturn=true
redis.server.ip = 10.10.103.208
redis.server.port = 6378