jedis操作redis

封装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;
    }
 
 
}

---

jedis操作redis中的list（封装）

以下转自 https://blog.csdn.net/qq_36898043/article/details/82181654

本文主要是封装一些 操作 redis中 list 的相关方法。。。。。。

代码

package me.ele.redis;
 
import redis.clients.jedis.BinaryClient;
import redis.clients.jedis.Jedis;
 
import java.util.List;
 
/**
 * 操作redis中的List
 *
 * @author LZJ
 * @create 2018-08-29 12:37
 **/
public class ListRedisOperator {
 
    /**
     * 根据 list的 key
     * 返回 list的 长度
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static long length(MyRedisPool redisPool, String key) {
        Jedis jedis = redisPool.borrowJedis();
        Long listLength = jedis.llen(key);
        redisPool.returnJedis(jedis);
        return listLength;
    }
 
    /**
     * 在 list 指定位置 插入值
     * 覆盖原有的值
     *
     * @param redisPool
     * @param key list的key
     * @param index 指定位置
     * @param value
     * @return
     */
    public static String set(MyRedisPool redisPool, String key, int index, String value) {
        Jedis jedis = redisPool.borrowJedis();
        String result = jedis.lset(key, index, value);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 在 list的 某个元素前或者后插入元素
     * 如果key不存在，即为空列表，不进行任何操作
     * 如果value不存在，不进行任何操作
     *
     * @param redisPool
     * @param key list的key
     * @param position 前插还是后插
     * @param pivot list中相对位置的value
     * @param value 插入的内容
     * @return 更新后 list的长度  如果没有进行任何操作，返回-1
     */
    public static long insert(MyRedisPool redisPool, String key, BinaryClient.LIST_POSITION position, String pivot, String value) {
        Jedis jedis = redisPool.borrowJedis();
        long returnStatus = jedis.linsert(key, position, pivot, value);
        redisPool.returnJedis(jedis);
        return returnStatus;
    }
 
    /**
     * List头部追加记录
     * 将一个或多个值 value 插入到列表 key 的表头
     * 如果list不存在，则创建list 并进行push 操作
     *
     * @param redisPool
     * @param key
     * @param value
     * @return
     */
    public static long lPush(MyRedisPool redisPool,String key,String... value){
        Jedis jedis = redisPool.borrowJedis();
        long resultStatus = jedis.lpush(key,value);
        redisPool.returnJedis(jedis);
        return  resultStatus;
    }
 
    /**
     * List尾部追加记录
     * 将一个或多个值 value 插入到列表 key 的表尾(最右边)
     * 如果list不存在，一个空列表会被创建并执行 RPUSH 操作
     *
     * @param redisPool
     * @param key
     * @param value
     * @return
     */
    public static long rPush(MyRedisPool redisPool,String key,String... value){
        Jedis jedis = redisPool.borrowJedis();
        long resultStatus = jedis.rpush(key,value);
        redisPool.returnJedis(jedis);
        return resultStatus;
    }
 
    /**
     * 获取list中 指定位置的值
     * index从0开始
     * 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil
     *
     * @param redisPool
     * @param key
     * @param index
     * @return
     */
    public static String get(MyRedisPool redisPool,String key,int index){
        Jedis jedis = redisPool.borrowJedis();
        String result = jedis.lindex(key,index);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 获取指定范围的记录
     * lrange 下标从0开始 -1表示最后一个元素
     *
     * @param redisPool
     * @param key
     * @param start
     * @param end
     * @return
     */
    public static List<String> lRange(MyRedisPool redisPool, String key, long start, long end){
        Jedis jedis = redisPool.borrowJedis();
        List<String> result = jedis.lrange(key,start,end);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 移除并返回列表 key 的 第一个值
     * 当 key 不存在时，返回 nil
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static String lPop(MyRedisPool redisPool,String key){
        Jedis jedis = redisPool.borrowJedis();
        String result = jedis.lpop(key);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 移除并返回列表 key 的 最后一个值
     * 当 key 不存在时，返回 nil
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static String rPop(MyRedisPool redisPool,String key){
        Jedis jedis = redisPool.borrowJedis();
        String result = jedis.rpop(key);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 清空List数据
     * ltrim 让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除
     * start和end为0时，即清空list
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static String clear(MyRedisPool redisPool,String key){
        Jedis jedis = redisPool.borrowJedis();
        String result = jedis.ltrim(key,0,0);
        jedis.lpop(key);
        redisPool.returnJedis(jedis);
        return result;
    }
 
 
}

---

jedis操作redis中的set（封装）

以下转自 https://blog.csdn.net/qq_36898043/article/details/82181793

本文主要是封装一些 操作 redis中 set的相关方法。。。。。。

代码

package me.ele.redis;
 
import redis.clients.jedis.Jedis;
 
import java.util.Set;
 
/**
 * 操作redis中的set
 *
 * @author LZJ
 * @create 2018-08-29 12:45
 **/
public class SetRedisOperator {
 
    /**
     * 向set中 添加记录，如果已经存在，返回0 否则返回1
     * sadd 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 value 元素将被忽略。
     *
     * @param redisPool
     * @param key
     * @param value
     * @return
     */
    public static long add(MyRedisPool redisPool, String key, String... value) {
        Jedis jedis = redisPool.borrowJedis();
        long status = jedis.sadd(key, value);
        redisPool.returnJedis(jedis);
        return status;
    }
 
    /**
     * 删除set中 指定的元素
     *
     * @param redisPool
     * @param key
     * @param member
     * @return
     */
    public static long delete(MyRedisPool redisPool, String key, String... member) {
        Jedis jedis = redisPool.borrowJedis();
        long returnStatus = jedis.srem(key, member);
        redisPool.returnJedis(jedis);
        return returnStatus;
    }
 
    /**
     * 返回set中 的元素数量
     * 如果set不存在，返回0
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static long length(MyRedisPool redisPool, String key) {
        Jedis jedis = redisPool.borrowJedis();
        long length = jedis.scard(key);
        redisPool.returnJedis(jedis);
        return length;
    }
 
    /**
     * 判断元素是否存在
     *
     * @param redisPool
     * @param key
     * @param value
     * @return
     */
    public static boolean ifExist(MyRedisPool redisPool, String key, String value) {
        Jedis jedis = redisPool.borrowJedis();
        boolean result = jedis.sismember(key, value);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 获取set 中的所有元素
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static Set<String> getAllValues(MyRedisPool redisPool, String key) {
        Jedis jedis = redisPool.borrowJedis();
        Set<String> result = jedis.smembers(key);
        redisPool.returnJedis(jedis);
        return result;
    }
 
 
}

---

jedis操作redis中的hash（封装）

以下转自 https://blog.csdn.net/qq_36898043/article/details/82181987

本文主要是封装一些 操作 redis中 hash的相关方法。。。。。。

代码

package me.ele.redis;
 
import redis.clients.jedis.Jedis;
 
import java.util.List;
import java.util.Map;
 
/**
 * 操作redis中的hash
 *
 * @author LZJ
 * @create 2018-08-29 13:20
 **/
public class HashRedisOperator {
 
 
    /**
     * 添加一条记录 如果map_key存在 则更新value
     * hset 如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。
     * 如果字段已经存在于哈希表中，旧值将被覆盖
     *
     * @param pool
     * @param key
     * @param field
     * @param value
     * @return
     */
    public static long set(MyRedisPool pool, String key, String field, String value) {
        Jedis jedis = pool.borrowJedis();
        long returnStatus = jedis.hset(key, field, value);
        pool.returnJedis(jedis);
        return returnStatus;
    }
 
    /**
     * 批量添加记录
     * hmset 同时将多个 field-value (域-值)对设置到哈希表 key 中。
     * 此命令会覆盖哈希表中已存在的域。
     * 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
     *
     * @param pool
     * @param key
     * @param map
     * @return
     */
    public static String setAll(MyRedisPool pool, String key, Map<String, String> map) {
        Jedis jedis = pool.borrowJedis();
        String result = jedis.hmset(key, map);
        pool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 删除hash中 field对应的值
     * hdel 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略
     *
     * @param pool
     * @param key
     * @param field
     * @return
     */
    public static long delete(MyRedisPool pool, String key, String... field) {
        Jedis jedis = pool.borrowJedis();
        long returnStatus = jedis.hdel(key, field);
        pool.returnJedis(jedis);
        return returnStatus;
    }
 
    /**
     * 获取hash中 指定的field的值
     * hmget 返回哈希表 key 中，一个或多个给定域的值。
     * 如果给定的域不存在于哈希表，那么返回一个 nil 值。
     * 不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
     *
     * @param pool
     * @param key
     * @param field
     * @return
     */
    public static List<String> get(MyRedisPool redisPool, String key, String... field) {
        Jedis jedis = redisPool.borrowJedis();
        List<String> result = jedis.hmget(key, field);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 获取hash中 所有的field value
     *
     * @param redisPool
     * @param key
     * @return 在返回值里，紧跟每个字段名(field name)之后是字段的值(value)，所以返回值的长度是哈希表大小的两倍。
     */
    public static Map<String, String> getAll(MyRedisPool redisPool, String key) {
        Jedis jedis = redisPool.borrowJedis();
        Map<String, String> result = jedis.hgetAll(key);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 判断hash中 指定的field是否存在
     *
     * @param redisPool
     * @param key
     * @param field
     * @return 如果哈希不包含字段或key不存在 返回0，如果哈希包含字段 返回1
     */
    public static boolean ifExist(MyRedisPool redisPool, String key, String field) {
        Jedis jedis = redisPool.borrowJedis();
        boolean result = jedis.hexists(key, field);
        redisPool.returnJedis(jedis);
        return result;
    }
 
    /**
     * 获取hash 的size
     * hlen 获取哈希表中字段的数量
     *
     * @param redisPool
     * @param key
     * @return
     */
    public static long size(MyRedisPool redisPool, String key) {
        Jedis jedis = redisPool.borrowJedis();
        long size = jedis.hlen(key);
        redisPool.returnJedis(jedis);
        return size;
    }
 
 
}