封装redis连接池 ( Jedis )

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_36898043/article/details/82155202

一、由来

java操作redis，常用的是 jedis，，作为一个缓存数据库，或者称之为nosql类型的数据库，，redis也有连接对象，
那么，问题来了，我们通过连接对象访问redis的时候，不应该不断的创建和销毁连接对象，

此时，就用到了redis连接池技术，jedis中提供了jedis pool，但是为了操作方便，我们需要自己实现一下，这种思路和mysql 那些数据库连接池的思路是一摸一样的，用到了单例模式。。。

（本文实现了连接池以及操作字符串类型数据，以后会在其他文章中慢慢补充其他类型的数据，list set hash等，还有操作key的一些技巧）补充：相关文章已经写好，亲们可以点击redis分类进行查看

话不对说，码上代码：

二、项目结构

pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>me.ele</groupId>
    <artifactId>redis_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--Jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.1</version>
        </dependency>
    </dependencies>


</project>

三、具体代码

1、配置信息类（当然也可以写成配置文件，甚至是接口的方式）

package me.ele.redis;

/**
 * 配置信息
 *
 * @author LZJ
 * @create 2018-08-28 20:56
 **/
public class RedisPoolConfig {

    //最大连接数
    public static int CONNECTION_MAX_TOTAL = 100;

    //最大空闲连接数
    public static int CONNECTION_MAX_IDLE = 50;

    //初始化连接数（最小空闲连接数）
    public static int CONNECTION_MIN_IDLE = 10;

    //等待连接的最大等待时间
    public static int CONNECTION_MAX_WAIT = 2000;

    //borrow前 是否进行alidate操作，设置为true意味着borrow的均可用
    public static boolean TEST_ON_BORROW = true;

    //return前 是否进行alidate操作
    public static boolean TEST_ON_RETURN = true;

}

2、连接池类：单例模式

package me.ele.redis;

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

/**
 * redis 连接池，用来管理redis实例
 *
 * @author LZJ
 * @create 2018-08-28 20:48
 **/
public class MyRedisPool {

    private static MyRedisPool myRedisPool = null;

    //redis 自带的 连接池
    private static JedisPool jedisPool = null;

    private MyRedisPool(String ipAddress, int port, String password) {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(RedisPoolConfig.CONNECTION_MAX_TOTAL);
        jedisPoolConfig.setMaxIdle(RedisPoolConfig.CONNECTION_MAX_IDLE);
        jedisPoolConfig.setMinIdle(RedisPoolConfig.CONNECTION_MIN_IDLE);
        jedisPoolConfig.setMaxWaitMillis(RedisPoolConfig.CONNECTION_MAX_WAIT);
        jedisPoolConfig.setTestOnBorrow(RedisPoolConfig.TEST_ON_BORROW);
        jedisPoolConfig.setTestOnReturn(RedisPoolConfig.TEST_ON_RETURN);

        if ("".equals(password.trim())) {
            //无密码
            jedisPool = new JedisPool(jedisPoolConfig, ipAddress, port);
        } else {
            //有密码
            int waitTime = 10000;
            jedisPool = new JedisPool(jedisPoolConfig, ipAddress, port, waitTime, password);
        }
    }

    /**
     * 双重锁定获取 my redis pool 实例
     * 在生成的过程中 生成了 redis pool 实例
     * @param ipAddress
     * @param port
     * @param password
     * @return
     */
    public static MyRedisPool getRedisPoolInstance(String ipAddress, int port, String password) {
        if (myRedisPool == null) {
            synchronized (MyRedisPool.class) {
                if (myRedisPool == null) {
                    myRedisPool = new MyRedisPool(ipAddress, port, password);
                }
            }
        }
        return myRedisPool;
    }

    /**
     * 获取JedisPool 实例
     * @return
     */
    public static JedisPool getJedisPool(){
        return jedisPool;
    }

    /**
     * 获取一个jedis
     * @return
     */
    public Jedis borrowJedis(){
        return jedisPool.getResource();
    }

    /**
     * 返还一个jedis
     * @param jedis
     */
    public void returnJedis(Jedis jedis){
        jedis.close();
    }
}

3、使用连接池，操作字符串

package me.ele.redis;

import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Set;

/**
 * 操作redis中的string
 *
 * @author LZJ
 * @create 2018-08-28 21:30
 **/
public class StringRedisOperator {

    /**
     * 根据key 获取 string
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static String get(MyRedisPool redisPool, String key) {
        Jedis jedis = redisPool.borrowJedis();
        String value = jedis.get(key);
        redisPool.returnJedis(jedis);
        return value;
    }

    /**
     * 根据 key 和 value 添加一条数据
     * 如果key 已经存在，会覆盖原来的值
     *
     * @param redisPool
     * @param key
     * @param value
     * @return
     */
    public static String set(MyRedisPool redisPool, String key, String value) {
        Jedis jedis = redisPool.borrowJedis();
        String returnStatus = jedis.set(key, value);
        redisPool.returnJedis(jedis);
        return returnStatus;
    }

    /**
     * 根据 key 和 value 添加一条数据
     * 如果key 已经存在，则不添加
     *
     * @param redisPool
     * @param key
     * @param value
     * @return
     */
    public static long setOnlyKeyNotExist(MyRedisPool redisPool, String key, String value) {
        Jedis jedis = redisPool.borrowJedis();
        Long returnStatus = jedis.setnx(key, value);
        redisPool.returnJedis(jedis);
        return returnStatus;
    }

    /**
     * 批量插入数据
     *
     * @param redisPool
     * @param keysValues 格式为: "key1","value1","key2","value2"
     * @return
     */
    public static String set(MyRedisPool redisPool,String... keysValues){
        Jedis jedis = redisPool.borrowJedis();
        String status = jedis.mset(keysValues);
        redisPool.returnJedis(jedis);
        return status;
    }

    /**
     * 根据 keys 批量获取 value
     * 返回一个list 如果某一个key的值不存在，
     * 则在list对应的位置为null
     * @param redisPool
     * @param keys
     * @return
     */
    public static List<String> get(MyRedisPool redisPool, String... keys){
        Jedis jedis = redisPool.borrowJedis();
        List<String> result = jedis.mget(keys);
        redisPool.returnJedis(jedis);
        return result;
    }

    /**
     * 设置 有时间限制 即生存时间的 key
     * 将value关联到key, 并将key的生存时间设为seconds(以秒为单位)。
     * 如果key 已经存在，SETEX将重写旧值
     * @param redisPool
     * @param key
     * @param time
     * @param value
     * @return
     */
    public static String setLifeTime(MyRedisPool redisPool, String key, int time, String value){
        Jedis jedis = redisPool.borrowJedis();
        String status = jedis.setex(key, time, value);
        redisPool.returnJedis(jedis);
        return status;
    }

    public static long setList(MyRedisPool redisPool, String key, List<String> list){
        Jedis jedis = redisPool.borrowJedis();
        long size = 0L;
        for(String each : list){
            size = jedis.lpush(key, each);
        }
        redisPool.returnJedis(jedis);
        return size;
    }

    /**
     * lrange 第二个参数为 -1
     * 读取 list中的所有数据
     * @param redisPool
     * @param key
     * @return
     */
    public static List<String> getList(MyRedisPool redisPool, String key){
        Jedis jedis = redisPool.borrowJedis();
        List<String> size = null;
        size = jedis.lrange(key,0,-1);
        redisPool.returnJedis(jedis);
        return size;
    }

    /**
     * 存入set类型的数据
     * @param redisPool
     * @param key
     * @param set
     * @return
     */
    public static long setSet(MyRedisPool redisPool, String key, Set<String> set){
        Jedis jedis = redisPool.borrowJedis();
        for(String each : set){
            jedis.sadd(key,each);
        }
        Set<String> result = jedis.smembers(key);
        redisPool.returnJedis(jedis);
        return result.size();
    }

    /**
     * 取出set类型的数据
     * @param redisPool
     * @param key
     * @return
     */
    public static Set<String> getSet(MyRedisPool redisPool, String key){
        Jedis jedis = redisPool.borrowJedis();
        Set<String> size = jedis.smembers(key);
        redisPool.returnJedis(jedis);
        return size;
    }


}