Redis操作类

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.extra.spring.SpringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis操作类
 */
public class RedisUtils {

    private static final Logger logger = LoggerFactory.getLogger(RedisUtils.class);
    private static StringRedisTemplate stringRedisTemplate;
    static {
        stringRedisTemplate=SpringUtil.getBean(StringRedisTemplate.class);
    }
    /**
     * 将参数中的字符串值设置为键的值，不设置过期时间
     * @param key
     * @param value 必须要实现 Serializable 接口
     */
    public static void set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    /**
     * 将参数中的字符串值设置为键的值，设置过期时间
     * @param key
     * @param value 必须要实现 Serializable 接口
     * @param timeout
     */
    public static void set(String key, String value, Long timeout) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 获取与指定键相关的值
     * @param key
     * @return
     */
    public static Object get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 设置某个键的过期时间
     * @param key 键值
     * @param ttl 过期秒数
     */
    public static boolean expire(String key, Long ttl) {
        return stringRedisTemplate.expire(key, ttl, TimeUnit.SECONDS);
    }

    /**
     * 判断某个键是否存在
     * @param key 键值
     */
    public static boolean hasKey(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    /**
     * 向集合添加元素
     * @param key
     * @param value
     * @return 返回值为设置成功的value数
     */
    public static Long sAdd(String key, String... value) {
        return stringRedisTemplate.opsForSet().add(key, value);
    }

    /**
     * 获取集合中的某个元素
     * @param key
     * @return 返回值为redis中键值为key的value的Set集合
     */
    public static Set<String> sGetMembers(String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }

    //===============================zset=================================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return Set
     */
    public static Set<String> getZSet(String key) {
        try {
            return stringRedisTemplate.opsForZSet().range(key, 0, -1);
        } catch (Exception e) {
            logger.error("redis 操作失败，失败原因：", e);
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public static Double getZSetScore(String key, Object value) {
        try {
            return stringRedisTemplate.opsForZSet().score(key,value);
        } catch (Exception e) {
            logger.error("redis 操作失败，失败原因：", e);
            return 0d;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static double setZSet(String key, String values) {
        try {
            return stringRedisTemplate.opsForZSet().incrementScore(key, values, 1);
        } catch (Exception e) {
            logger.error("redis 操作失败，失败原因：", e);
            return 0;
        }
    }
    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static boolean setZSet(String key, String values,double score) {
        try {
            return stringRedisTemplate.opsForZSet().add(key, values,score);
        } catch (Exception e) {
            logger.error("redis 操作失败，失败原因：", e);
            return false;
        }
    }

    /**
     * 删除指定的键
     * @param key
     * @return
     */
    public static Boolean delete(String key) {
        return stringRedisTemplate.delete(key);
    }

    /**
     * 删除多个键
     * @param keys
     * @return
     */
    public static Long delete(Collection<String> keys) {
        return stringRedisTemplate.delete(keys);
    }

    /**
     * 查询所有的key
     * @param matchKey
     * @return
     */
    public Set<String> scan(String matchKey) {
        Set<String> keys = stringRedisTemplate.execute((RedisCallback<Set<String>>) connection -> {
            Set<String> keysTmp = new HashSet<>();
            Cursor<byte[]> cursor = connection.scan(new ScanOptions.ScanOptionsBuilder().match("*" + matchKey + "*").count(1000).build());
            while (cursor.hasNext()) {
                keysTmp.add(new String(cursor.next()));
            }
            return keysTmp;
        });
        return keys;
    }

    /**
     * 查询所有的key
     * @param matchKey
     * @return
     */
    public int scanCount(String matchKey,int size) {
        int count = stringRedisTemplate.execute((RedisCallback<Integer>) connection -> {
            int num=0;
            Cursor<byte[]> cursor = connection.scan(new ScanOptions.ScanOptionsBuilder().match("*" + matchKey + "*").count(size).build());
            while (cursor.hasNext()) {
                byte[] next = cursor.next();
                num += next.length;
            }
            return num;
        });
        return count;
    }

    /**
     * 递增
     *
     * @param key   键
     * @return long
     */
    public static long incr(String key) {
        return stringRedisTemplate.opsForValue().increment(key);
    }
    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return long
     */
    public static long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return stringRedisTemplate.opsForValue().increment(key, delta);
    }
    /**
     * 递增
     * @param key   键
     * @return long
     */
    public static long incrAndExpire(String key,long time) {
        return stringRedisTemplate.execute((RedisCallback<Long>) connection -> {
            byte[] bytes = key.getBytes(StandardCharsets.UTF_8);
            Long incr = connection.incr(bytes);
            connection.expire(bytes,time);
            return incr;
        });
    }
    /**
     * 递增
     * @param key   键
     * @return long
     */
    public static long incrAndExpire(String key,long delta,long time) {
        return stringRedisTemplate.execute((RedisCallback<Long>) connection -> {
            byte[] bytes = key.getBytes(StandardCharsets.UTF_8);
            Long incr = connection.incrBy(bytes,delta);
            connection.expire(bytes,time);
            return incr;
        });
    }
    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return long
     */
    public static long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return stringRedisTemplate.opsForValue().increment(key, -delta);
    }



    /**
     * 生成公单
     * 递增
     * @param key   键
     * @return long
     */
    public static long getOrderIdNum(String key,long delta,long time) {
        String format = DateUtil.format(new Date(), DatePattern.PURE_DATE_FORMAT);

        return stringRedisTemplate.execute((RedisCallback<Long>) connection -> {
            byte[] bytes = key.getBytes(StandardCharsets.UTF_8);
            Long incr = connection.incrBy(bytes,delta);
            connection.expire(bytes,time);
            return incr;
        });
    }

}