Jedis+JedisPool+JedisPoolConfig：完美“掌控“Redis

一、背景介绍

    在使用Java+Maven+Selenium+TestNg+Jedis+Jenkins做WebUI自动化测试的过程中，想要不同功能类数据可以关联使用。例如：现金流量项中取到的现金流量项代码需要在现金事务分类功能对应的类中取到。所以使用Redis来存储数据，然后通过Jedis工具类来存储和读取数据。

二、Redis相关

2.1 Redis基本概念

• Redis是一个开源的key-value内存数据库。
• Redis读写速度快。
  

2.2 Redis下载安装

Redis解压版下载：Redis.rar
安装：解压到指定目录即可

2.3 启动Redis服务(Windows本地)

    进入Redis解压后的文件夹，使用redis-server.exe redis.windows.conf命令可以启动Redis服务。为了后续方便操作，可以在桌面创建一个Redis_server.bat文件，内容如下（根据自己的解压路径修改）:

d:
cd D:\Redis\Redis
redis-server.exe redis.windows.conf

2.4 启动Redis客户端（Windows本地）

    进入Redis解压后的文件夹，使用redis-cli.exe命令可以启动Redis服务。为了后续方便操作，可以在桌面创建一个Redis_client.bat文件，内容如下（根据自己的解压路径修改）:

d:
cd D:\Redis\Redis
redis-cli.exe

2.5 Redis基本命令

• 存储值：set key value
• 取值：get key
  

三、Jedis相关

3.1 Maven依赖

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>3.0.1</version>
</dependency>

3.2 Jedis基本使用

public class Test_Jedis {
    public static void main(String[] args) {
        /*创建Jedis对象，参数为Redis服务的ip和端口*/
        Jedis jedis = new Jedis("127.0.0.1",6379);
        /*通过输出jedis.ping() 若输出PONG 则可以成功连接Redis服务*/
        System.out.println(jedis.ping());
        /**
         * 通过jedis的set方法存储值、get方法获取值
         * */
        jedis.set("a","999");
        System.out.println(jedis.get("a"));
    }
}

四、Jedis连接池-JedisPool

4.1 Jedis连接池

• 初始化连接比较消耗资源，为了节省资源，使用JedisPool。
• 创建JedisPool对象时候、参数除了需要Redis的IP、端口之外，还需要JedisPoolConfig对象。
• 在JedisPool使用完Jedis连接对象后，尽量将Jedis对象归还给连接池，也就是调用一下Jedis的close方法。
  

4.2 JedisPoolConfig常用参数

    下面为几个常用设置的参数，具体相关参数可以参考Jedis的API文档（找到JedisPoolConfig，不过是英文文档）：https://tool.oschina.net/uploads/apidocs/

参数名	含义
maxTotal	控制一个pool可分配多少个jedis实例；如果赋值为-1，则表示不限制； 如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
maxIdle	控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
maxWaitMillis	最大等待毫秒数；表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException。
setTestOnBorrow	在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的。

实例代码：

public class Test_JedisPool {
    public static void main(String[] args) {
        /*1.创建JedisPool配置类对象*/
        JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
        jedisPoolConfig.setMaxWaitMillis(3000);
        jedisPoolConfig.setMaxTotal(1000);
        jedisPoolConfig.setMaxIdle(500);
        /*2.创建JedisPool对象*/
        JedisPool jedisPool=new JedisPool(jedisPoolConfig,"127.0.0.1",6379);
        /*3.从Jedis连接池JedisPool获取Jedis实例*/
        Jedis jedis=jedisPool.getResource();
        /*4.存取值*/
        jedis.set("a","999");
        System.out.println(jedis.get("a"));
        /*5.将jedis实例归还给jedis连接池*/
        jedis.close();
    }
}

4.3 JedisPool封装

    在项目中封装好的操作Redis的一个类。其中ThreadLocalUtil是为了线程安全的ThreadLocal的工具类，PropertyReader为读取paoperties文件的类。主要看JedisPool、Jedis、JedisPoolConfig相关的代码。

@Slf4j
public class JedisBase {

    /**
     * 创建的jedisPoolConfig、jedisPool对象
     * */
    private JedisPoolConfig jedisPoolConfig;
    private JedisPool jedisPool;

    private Jedis jedis;
    private String redisIp;
    private String redisPassword;
    private int redisPort;
    private int jedisPoolMaxTotal;
    private int jedisPoolMaxIdle;
    private int jedisPoolMaxWaitMillis;
    private Boolean jedisPoolTestOnBorrow;
    private Boolean jedisPoolTestOnReturn;

    /**
     * 创建ThreadLocalUtil和ThreadLocal，用于存储Jedis对象
     * */
    private static ThreadLocalUtil<Jedis> jedisThreadLocalUtil = new ThreadLocalUtil<>();
    private static ThreadLocal<Jedis> threadJedis = new ThreadLocal<>();

    /**
     * 读取properties文件，赋值
     * */
    public void setValue(){
        this.redisIp = PropertyReader.getProperty("redis.ip");
        this.redisPort = Integer.valueOf( PropertyReader.getProperty("redis.port"));
        this.redisPassword = PropertyReader.getProperty("redis.password");
        this.jedisPoolMaxTotal = Integer.valueOf( PropertyReader.getProperty("jedis.pool.maxTotal"));
        this.jedisPoolMaxIdle = Integer.valueOf( PropertyReader.getProperty("jedis.pool.maxIdle"));
        this.jedisPoolMaxWaitMillis = Integer.valueOf( PropertyReader.getProperty("jedis.pool.maxWaitMillis"));
        this.jedisPoolTestOnBorrow = Boolean.valueOf( PropertyReader.getProperty("jedis.pool.testOnBorrow") );
        this.jedisPoolTestOnReturn = Boolean.valueOf( PropertyReader.getProperty("jedis.pool.testOnReturn") );
    }

    /**
     * 获得JedisPool对象
     * */
    public JedisPool getJedisPool() throws Exception{
        /**
         * 1 调用方法获取配置文件中数据
         * */
        setValue();
        /**
         *2 创建JedisPoolConfig对象 并设置
         * */
        jedisPoolConfig = new JedisPoolConfig();
        /*设置一个pool最多可用分配多少个jedis实例*/
        jedisPoolConfig.setMaxTotal( jedisPoolMaxTotal );
        /*设置一个pool最多能有多少个状态空闲的jedis实例*/
        jedisPoolConfig.setMaxIdle( jedisPoolMaxIdle);
        /*设置获取jedis实例的时候最大等待毫秒数*/
        jedisPoolConfig.setMaxWaitMillis( jedisPoolMaxWaitMillis );
        /*设置获取jedis实例的时候检查可用性（ping）*/
        jedisPoolConfig.setTestOnBorrow( jedisPoolTestOnBorrow );
        /*设置return jedis实例的时候检查可用性（ping）*/
        jedisPoolConfig.setTestOnReturn( jedisPoolTestOnReturn );
        /**
         * 3.使用JedisPollConfig和相关参数创建jedisPool对象并返回
         * */
        createJedisPool();
        return jedisPool;
    }

    /**
     * 创建JedisPool
     * */
    public JedisPool createJedisPool(){
        if(null==jedisPool){
            synchronized (JedisBase.class){
                if(null==jedisPool){
                    try {
                        /*创建JedisPool对象*/
                        if(this.redisPassword.equals( "" ) || this.redisPassword == null){
                            // 无需密码连接
                            jedisPool = new JedisPool(jedisPoolConfig, redisIp, redisPort );
                        }else{
                            // 需要密码连接
                            jedisPool = new JedisPool( jedisPoolConfig, redisIp, redisPort ,3000, redisPassword);
                        }
                        /**
                         *  设置ThreadLocal对象的值,通过jedisPool.getResource()获取
                         * */
                        jedisThreadLocalUtil.setThreadValue( threadJedis, jedisPool.getResource());
                        log.info("成功连接到redis服务器");
                    }catch (Exception e){
                        e.printStackTrace();
                        log.info("连接redis服务器失败");
                    }
                }
            }
        }
        return jedisPool;
    }


    /**
     * 获得jedis对象
     * */
    public Jedis getJedis() {
        return jedisThreadLocalUtil.getThreadValue( threadJedis );
    }

    /**
     * 设置jedis
     * */
    public void setJedis(Jedis jedis){
        this.jedis = jedis;
    }

    /**
     * 设置key对应的value值以及key的过期时间10min
     * */
    public String getKey(String key){
        return getJedis().get( key );
    }

    /**
     * 设置key对应的value值以及key的过期时间10min
     * */
    public void setKey(String key, String value){
        getJedis().set( key, value );
        getJedis().expire( key, 600 );
    }

    /**
     * 归还jedis对象
     * */
    public void returnJedis(){
        setJedis(getJedis());
        if (jedis != null && jedisPool != null){
        		/*清空Jedis中所有的key*/
            jedis.flushAll();
            /*归还Jedis实例给Jedis连接池*/
            jedis.close();
            log.info("成功归还jedis对象");
            threadJedis.remove();
        }
    }
}

---