com.lingdonge.redis.service.RedisPoolUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cloud-redis Show documentation
Redis一键集成
There is a newer version: 3.0.5
package com.lingdonge.redis.service;

import com.alibaba.fastjson.JSON;
import com.lingdonge.core.convert.ConvertUtil;
import com.lingdonge.redis.RedisConfigUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Tuple;

import java.util.*;

/**
 * 基于官方配置创建的Jedis原生支持库
 */
//@Component
@Slf4j
public class RedisPoolUtil {

    private static RedisProperties properties;

    public RedisPoolUtil() {
    }

    public RedisPoolUtil(RedisProperties pro) {
        RedisPoolUtil.properties = pro;
        this.afterPropertySet();//注入和生成实例
        log.info("正在加载Redis配置文件：" + properties);
    }

    private volatile JedisPool pool;

    private static volatile RedisPoolUtil instance;

    /**
     * 单例模式，线程安全
     *
     * @return
     */
    public static RedisPoolUtil getInstance() {
        // 对象实例化时与否判断（不使用同步代码块，instance不等于null时，直接返回对象，提高运行效率）
        if (instance == null) {
            //同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建）
            synchronized (RedisPoolUtil.class) {
                //未初始化，则初始instance变量
                if (instance == null) {
                    instance = new RedisPoolUtil();
                    instance.afterPropertySet();//初始化配置和Pool池
                }
            }
        }
        return instance;
    }

    /**
     * 实例化完成之后执行
     */
    public void afterPropertySet() {

        // Spring 1.x
//        pool = new JedisPool(config, properties.getHost(), properties.getPort(), properties.getTimeout(), properties.getPassword(), properties.getDatabase());

        // Spring 2.x
        pool = new JedisPool(RedisConfigUtil.getJedisPoolGenericConfig(properties), properties.getHost(), properties.getPort(), ((int) (properties.getTimeout().toMillis())), properties.getPassword(), properties.getDatabase());
    }

    /**
     * 获取一个JedisPool对象
     *
     * @return
     * @throws Exception
     */
    public synchronized static JedisPool getJedisPool() {
        RedisPoolUtil redis = getInstance();
        return redis.pool;
    }

    /**
     * 获取Jedis实例
     *
     * @return
     */
    public synchronized Jedis getJedis() {
        try {
            if (pool != null) {
                Jedis resource = pool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 关闭当前连接实例，将连接返回连接池
     *
     * @param jedis redis连接实例
     */
    public static void close(Jedis jedis) {
        try {
            if (null != jedis) {
                jedis.close();
            }
        } catch (Exception e) {
            log.error("close jedis failed!", e);
        }
    }

    /**
     * 关闭整个pool
     */
    public void closePool() {
        try {
            if (pool != null) {
                pool.close();
            }
        } catch (Exception e) {
            log.error("close jedis pool failed!", e);
        }
    }

    /**
     * 返回满足pattern表达式的所有key
     *
     * @param keyPattern 键值
     * @return
     */
    public Set keys(String keyPattern) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.keys(keyPattern);
        } catch (Exception e) {
            log.error("redis keys failed!", e);
            return new HashSet();
        } finally {
            close(jedis);
        }
    }


    /**
     * @param key     键值
     * @param seconds
     * @return
     */
    public Long expire(String key, int seconds) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.expire(key.getBytes(), seconds);
        } catch (Exception e) {
            log.error("redis expire failed!", e);
            return 0L;
        } finally {
            close(jedis);
        }
    }

    /**
     * 通过key判断值得类型
     *
     * @param key 键值
     * @return
     */
    public String type(String key) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.type(key);
        } catch (Exception e) {
            log.error("redis type failed!", e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 判断key是否存在
     *
     * @param key key
     * @return true:存在，false:不存在
     */
    public boolean exists(String key) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.exists(key);
        } catch (Exception e) {
            log.error("redis exists failed!", e);
            return false;
        } finally {
            close(jedis);
        }
    }


    /**
     * 删除redis中key对应数据,可以指定多个key
     *
     * @param key 键值
     * @return 成功\失败
     */
    public boolean delete(String... key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.del(key);
        } catch (Exception e) {
            log.error("redis delete failed!", e);
            return false;
        } finally {
            close(jedis);
        }
        return true;
    }

    /**
     * 删除redis中key对应数据
     *
     * @param key 键值
     * @return 删除的条数
     */
    public long deleteRegEx(String key) {
        Jedis jedis = null;
        long count = 0;

        try {
            jedis = getJedis();
            Set keys = jedis.keys(key);

            if (keys == null || keys.isEmpty()) {
                return 0;
            }

            for (String sigleKey : keys) {
                jedis.del(sigleKey);
                count++;
            }
            return count;

        } catch (Exception e) {
            log.error("redis deleteRegEx failed", e);
            return -1;
        } finally {
            close(jedis);
        }
    }


    /**
     * 获取key的剩余过期时间，单位：秒
     *
     * @param key 键值
     * @return
     */
    public Long getExpireSeconds(String key) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.ttl(key.getBytes());

        } catch (Exception e) {
            log.error("redis getExpireSeconds failed!", e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 获取数据
     *
     * @param key 键值
     * @return
     */
    public String get(String key) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.get(key);
        } catch (Exception e) {
            log.error("redis get failed!", e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 获取数据
     *
     * @param key 键值
     * @return
     */
    public  T get(String key, Class clazz) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            byte[] value = jedis.get(key.getBytes());

            if (value != null) {
                return ConvertUtil.unserialize(value, clazz);
            } else {
                return null;
            }
        } catch (Exception e) {
            log.error("redis get failed!", e);
            return null;
        } finally {
            close(jedis);
        }
    }


    /**
     * 设置key的值,并返回一个旧值
     *
     * @param key   键值
     * @param value
     * @return 旧值 如果key不存在 则返回null
     */
    public String getset(String key, String value) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = getJedis();
            res = jedis.getSet(key, value);
        } catch (Exception e) {
            log.error("redis getset failed!", e);
        } finally {
            close(jedis);
        }
        return res;
    }


    /**
     * 通过下标 和key 获取指定下标位置的 value
     *
     * @param key         键值
     * @param startOffset 开始位置 从0 开始 负数表示从右边开始截取
     * @param endOffset
     * @return 如果没有返回null
     */
    public String getrange(String key, int startOffset, int endOffset) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = getJedis();
            res = jedis.getrange(key, startOffset, endOffset);
        } catch (Exception e) {
            log.error("redis getrange failed!", e);
        } finally {
            close(jedis);
        }
        return res;
    }

    /**
     * 设置字符串，不设过期时间
     *
     * @param key   键值
     * @param value
     * @return
     */
    public String setString(String key, String value) {
        return setString(key, value, -1);
    }

    /**
     * 设置字符串，可设过期时间
     *
     * @param key     键值
     * @param value
     * @param seconds
     * @return
     */
    public String setString(String key, String value, int seconds) {
        Jedis jedis = null;
        try {
            value = StringUtils.isEmpty(value) ? "" : value;

            jedis = getJedis();
            if (seconds > 0) {
                return jedis.setex(key, seconds, value);
            } else {
                return jedis.set(key, value);
            }
        } catch (Exception e) {
            log.error("redis setString failed!", e);
            return null;
        } finally {
            close(jedis);
        }
    }


    /**
     * 向redis中存入数据
     *
     * @param key    键值
     * @param object 数据
     * @return
     */
    public  boolean set(String key, T object) {
        return set(key, object, -1);
    }

    /**
     * 向redis中存入数据
     *
     * @param key    键值
     * @param object 数据
     * @return
     */
    public  boolean set(String key, T object, int seconds) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (seconds > 0) {
                jedis.setex(key.getBytes(), seconds, ConvertUtil.serialize(object));
            } else {
                jedis.set(key.getBytes(), ConvertUtil.serialize(object));
            }
        } catch (Exception e) {
            log.error("redis set failed!", e);
            return false;
        } finally {
            close(jedis);
        }
        return true;
    }


    /**
     * @param key     键值
     * @param value
     * @param seconds
     * @return
     */
    public boolean setnxString(String key, String value, int seconds) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            Long res = jedis.setnx(key, value);
            if (new Long(1L).equals(res)) {
                // 设定过期时间，最多30秒自动过期，防止长期死锁发生
                jedis.expire(key, seconds);
                return true;
            }
            return false;
        } catch (Exception e) {
            log.error("redis setnxString failed!", e);
            return false;
        } finally {
            close(jedis);
        }
    }


    /**
     * 指定的 key 不存在时，为 key 设置指定的值。
     * 设置key value,如果key已经存在则返回0,nx==> not exist
     *
     * @param key key
     * @return true:存在，false:不存在
     */
    public boolean setnx(String key, Object object) {
        return setnx(key, object, 30);
    }

    /**
     * 指定的 key 不存在时，为 key 设置指定的值。
     *
     * @param key     键值
     * @param object
     * @param seconds
     * @return true:存在，false:不存在
     */
    public boolean setnx(String key, Object object, int seconds) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            Long res = jedis.setnx(key, object.toString());
            if (new Long(1L).equals(res)) {
                // 设定过期时间，最多30秒自动过期，防止长期死锁发生
                jedis.expire(key.getBytes(), seconds);
                return true;
            }
            return false;
        } catch (Exception e) {
            log.error("redis setnx failed!", e);
            return false;
        } finally {
            close(jedis);
        }
    }

    /**
     * @param key     键值
     * @param value
     * @param seconds
     * @return
     */
    public String setexString(String key, String value, int seconds) {
        Jedis jedis = null;
        try {
            value = StringUtils.isEmpty(value) ? "" : value;
            jedis = getJedis();
            return jedis.setex(key, seconds, value);

        } catch (Exception e) {
            log.error("redis setexString failed!", e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 通过key 和offset 从指定的位置开始将原先value替换
     * 下标从0开始,offset表示从offset下标开始替换
     * 如果替换的字符串长度过小则会这样
     * example:
     * value : [email protected]
     * str : abc
     * 从下标7开始替换  则结果为
     * RES : bigsea.abc.cn
     *
     * @param key    键值
     * @param str
     * @param offset 下标位置
     * @return 返回替换后  value 的长度
     */
    public Long setrange(String key, String str, int offset) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.setrange(key, offset, str);
        } catch (Exception e) {
            log.error("redis setrange failed!", e);
            return 0L;
        } finally {
            close(jedis);
        }
    }


    /**
     * 通过批量的key获取批量的value
     *
     * @param keys string数组 也可以是一个key
     * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空
     */
    public List mget(String... keys) {
        Jedis jedis = null;
        List values = null;
        try {
            jedis = getJedis();
            values = jedis.mget(keys);
        } catch (Exception e) {
            log.error("redis mget failed!", e);
        } finally {
            close(jedis);
        }
        return values;
    }

    /**
     * 批量的设置key:value,可以一个
     * example:
     * obj.mset(new String[]{"key2","value1","key2","value2"})
     *
     * @param keysvalues
     * @return 成功返回OK 失败 异常 返回 null
     */
    public String mset(String... keysvalues) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = getJedis();
            res = jedis.mset(keysvalues);
        } catch (Exception e) {
            log.error("redis mset failed!", e);
        } finally {
            close(jedis);
        }
        return res;
    }

    /**
     * 批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚
     * example:
     * obj.msetnx(new String[]{"key2","value1","key2","value2"})
     *
     * @param keysvalues
     * @return 成功返回1 失败返回0
     */
    public Long msetnx(String... keysvalues) {
        Jedis jedis = null;
        Long res = 0L;
        try {
            jedis = getJedis();
            res = jedis.msetnx(keysvalues);
        } catch (Exception e) {
            log.error("redis msetnx failed!", e);
        } finally {
            close(jedis);
        }
        return res;
    }

    /**
     * 通过key向指定的value值追加值
     *
     * @param key   键值
     * @param value
     * @return 成功返回 添加后value的长度 失败 返回 添加的 value 的长度  异常返回0L
     */
    public long append(String key, String value) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.append(key, value);
        } catch (Exception e) {
            log.error("redis append failed!", e);
            return -1;
        } finally {
            close(jedis);
        }
    }

    /**
     * 通过key获取value值的长度
     *
     * @param key 键值
     * @return 失败返回null
     */
    public Long strlen(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = getJedis();
            res = jedis.strlen(key);
        } catch (Exception e) {
            log.error("redis strlen failed!", e);
        } finally {
            close(jedis);
        }
        return res;
    }

    /**
     * 自增
     *
     * @param key key
     * @return 0:失败，非0:成功
     */
    public Long incr(String key) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.incr(key);
        } catch (Exception e) {
            log.error("redis incr failed!", e);
            return 0L;
        } finally {
            close(jedis);
        }
    }

    /**
     * 通过key给指定的value加值,如果key不存在,则这是value为该值
     *
     * @param key  键值
     * @param incr
     * @return
     */
    public Long incrBy(String key, Long incr) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.incrBy(key, incr);
        } catch (Exception e) {
            log.error("redis incrBy failed!", e);
            return 0L;
        } finally {
            close(jedis);
        }
    }

    /**
     * 自减
     *
     * @param key key
     * @return 0:失败，非0:成功
     */
    public Long decr(String key) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.decr(key);
        } catch (Exception e) {
            log.error("redis decr failed!", e);
            return 0L;
        } finally {
            close(jedis);
        }
    }

    /**
     * 自减
     *
     * @param key  键值
     * @param decr
     * @return
     */
    public Long decrBy(String key, Long decr) {
        Jedis jedis = null;

        try {
            jedis = getJedis();
            return jedis.decrBy(key, decr);
        } catch (Exception e) {
            log.error("redis decrBy failed!", e);
            return 0L;
        } finally {
            close(jedis);
        }
    }

    /**
     * 添加数据到Set里面
     * 添加一条数据，返回添加的新元素的数量
     * 0代表已经有重复，1代表添加成功一条没有的记录
     *
     * @param key   键值
     * @param value 可以是一个String 也可以是一个String数组
     * @return 添加成功的个数
     */
    public long sadd(String key, String... value) {
        Jedis jedis = null;
        try {
            jedis = getJedis();

            jedis.pipelined();

            return jedis.sadd(key, value);

        } catch (Exception e) {
            log.error("redis sadd failed!", e);
            return -1;
        } finally {
            close(jedis);
        }
    }

    /**
     * 使用管道批量操作数据，自动过滤空值
     *
     * @param key        键值
     * @param listValues
     * @return
     */
    public boolean saddPipeLine(String key, List listValues) {
        Jedis jedis = null;
        try {
            jedis = getJedis();

            Pipeline p = jedis.pipelined();
            for (String item : listValues) {
                if (StringUtils.isEmpty(item)) {
                    continue;
                }
                p.sadd(key, item);
            }
            p.sync();

        } catch (Exception e) {
            log.error("redis saddPipeLine failed!", e);
            return false;
        } finally {
            close(jedis);
        }
        return true;
    }

    /**
     * 批量添加Object对象
     *
     * @param key        键值
     * @param listValues
     * @return
     */
    public boolean saddPipeLineObj(String key, List