随笔（十五）『SpringBoot 整合 Redis』

一、添加依赖

<!--   redis启动器   -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

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

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.4</version>
</dependency>

二、配置文件

spring:
  redis:
    # redis服务器地址
    host: 192.168.56.10
    # redis服务器端口
    port: 6379
    # 使用的数据库索引（0-15），默认使用：0
    database: 0
    # 密码，默认为空
    password:
    # 超时时间（毫秒）
    timeout: 10000ms
    jedis:
      pool:
        # 最大阻塞等待时间，负数表示没有限制
        max-wait: -1ms
        # 连接池中的最大空闲连接
        max-idle: 10
        # 连接池中的最小空闲连接
        min-idle: 5
        # 连接池中最大连接数，负数表示没有限制
        max-active: 200

三、编写配置类

package com.baihua.my_redis.config;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;


@Configuration
public class RedisConfig {

    @Bean
//    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 创建模板
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer =
                new GenericJackson2JsonRedisSerializer();
        // key和 hashKey采用 string序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        // value和 hashValue采用 JSON序列化
        redisTemplate.setValueSerializer(jsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jsonRedisSerializer);

        return redisTemplate;

    }

}

四、RedisUtil工具类

package com.baihua.my_redis.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * redis 工具类
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 不设置失效时间
    public final static long NOT_EXPIRE = -1L;

    // TODO 设置失效时间
    // 默认失效时间，24小时
    public final static long DEFAULT_EXPIRE = 24 * 60 * 60;

    /********    Common start     ********/
    /**
     * 判断key是否存在
     *
     * @param key 键key
     * @return true存在，false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存（单个）
     *
     * @param key 键key
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 删除缓存（集合）
     *
     * @param keys 键keys
     */
    public void delete(Collection<String> keys) {
        redisTemplate.delete(keys);
    }

    /**
     * 获取某个形式的所有键keys
     *
     * @param pattern 某个形式
     * @return 匹配的键keys
     */
    public Set<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     *  设置缓存失效时间
     *
     * @param key 键key
     * @param expire 失效时间（单位：秒）
     */
    public void expire(String key, long expire) {
        redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }
    /********    Common end       ********/


    /********    String start     ********/
    /**
     * 普通缓存存入
     *
     * @param key 键key
     * @param value 值value
     */
    public void set(String key, Object value) {
        set(key, value, DEFAULT_EXPIRE);
    }

    /**
     * 普通缓存存入并设置失效时间
     *
     * @param key 键key
     * @param value 值value
     * @param expire 失效时间（单位：秒）
     */
    public void set(String key, Object value, long expire) {
        redisTemplate.opsForValue().set(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * 获取普通缓存
     *
     * @param key 键key
     * @return 值value
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存递增
     *
     * @param key 键key
     * @param delta 递增的值
     */
    public void incre(String key, long delta) {
        incre(key, delta, DEFAULT_EXPIRE);
    }

    /**
     * 普通缓存递增指定失效时间
     *
     * @param key 键key
     * @param delta 递增的值
     * @param expire 失效时间（单位：秒）
     */
    public void incre(String key, long delta, long expire) {
        redisTemplate.opsForValue().increment(key, delta);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }
    /********    String end       ********/


    /********    Hash(Map) start  ********/
    /**
     * hash缓存存入map集合
     *
     * @param key 键key
     * @param map 集合map，多个键值
     */
    public void hMSet(String key, Map<String, Object> map) {
        hMSet(key, map, DEFAULT_EXPIRE);
    }

    /**
     * hash缓存存入map集合，并指定失效时间
     *
     * @param key 键key
     * @param map 集合map，多个键值
     * @param expire 失效时间
     */
    public void hMSet(String key, Map<String, Object> map, long expire) {
        redisTemplate.opsForHash().putAll(key, map);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * hash缓存存入单个键值对
     *
     * @param key 键key
     * @param hashKey hash表键key
     * @param value hash表值value
     */
    public void hSet(String key, String hashKey, Object value) {
        hSet(key, hashKey, value, DEFAULT_EXPIRE);
    }

    /**
     *  hash缓存存入单个键值对，并指定失效时间
     *
     * @param key 键key
     * @param hashKey hash表键key
     * @param value hash表值value
     * @param expire 失效时间（单位：秒）【如果已存在的hash表有时间，这里将会替换原有的时间】
     */
    public void hSet(String key, String hashKey, Object value, long expire) {
        redisTemplate.opsForHash().put(key, hashKey, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * 获取hash缓存的整个map集合
     *
     * @param key 键key
     * @return map集合
     */
    public Map<String, Object> hMGet(String key) {
        HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
        return hashOperations.entries(key);
    }

    /**
     * 获取hash缓存指定键的值
     *
     * @param key 键key
     * @param hashKey hash表键key
     * @return hash表值value
     */
    public Object hGet(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 判断hash表中的key是否存在
     *
     * @param key 键key
     * @param hashKey hash表键key
     * @return true存在，false不存在
     */
    public boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 删除hash表中的key
     *
     * @param key 键key
     * @param hashKeys hash表键key
     */
    public void hDelete(String key, Object... hashKeys) {
        redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * hash递增
     *
     * @param key 键key
     * @param hashKey hash表键key
     * @param delta 递增的值
     */
    public void hIncre(String key, String hashKey, long delta) {
        redisTemplate.opsForHash().increment(key, hashKey, delta);
    }
    /********    Hash(Map) end    ********/


    /********    Set start        ********/
    /**
     * Set缓存存入
     *
     * @param key 键key
     * @param values 存入的值，可以是多个
     * @return 成功存入的个数
     */
    public long sSet(String key, Object... values) {
        return sSet(key, DEFAULT_EXPIRE, values);
    }

    /**
     * Set缓存存入，指定失效时间
     *
     * @param key 键key
     * @param expire 失效时间（单位：秒）
     * @param values 存入的值，可以是多个
     * @return 成功存入的个数
     */
    public long sSet(String key, long expire, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (expire != NOT_EXPIRE) {
                expire(key, expire);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取Set缓存的所有值
     *
     * @param key 键key
     * @return Set缓存的所有值
     */
    public Set<Object> sGet(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 获取Set缓存的长度
     *
     * @param key 键key
     * @return Set缓存的长度
     */
    public long sGetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除Set缓存中的值
     *
     * @param key 键key
     * @param values 需移除的值，可以是多个
     * @return 移除成功的个数
     */
    public long sRemove(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().remove(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取2个Set缓存交集
     *
     * @param key 键key
     * @param otherKey 另一个键key
     * @return 2个缓存的交集
     */
    public Set<Object> sIntersect(String key, String otherKey) {
        try {
            Set<Object> intersect = redisTemplate.opsForSet().intersect(key, otherKey);
            return intersect;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取2个Set缓存并集
     *
     * @param key 键key
     * @param otherKey 另一个键key
     * @return 2个缓存的交集
     */
    public Set<Object> sUnion(String key, String otherKey) {
        try {
            Set<Object> union = redisTemplate.opsForSet().union(key, otherKey);
            return union;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /********    Set end          ********/


    /********    List start       ********/
    /**
     * 从集合左边插入值
     *
     * @param key 键key
     * @param value 插入的值value
     */
    public void leftPush(String key, Object value) {
        leftPush(key, value, DEFAULT_EXPIRE);
    }

    /**
     * 从集合左边插入值，指定失效时间
     *
     * @param key 键key
     * @param value 插入的值value
     * @param expire 失效时间（单位：秒）
     */
    public void leftPush(String key, Object value, long expire) {
        redisTemplate.opsForList().leftPush(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * 从集合右边插入值
     *
     * @param key 键key
     * @param value 插入的值value
     */
    public void rightPush(String key, Object value) {
        rightPush(key, value, DEFAULT_EXPIRE);
    }

    /**
     * 从集合右边插入值，指定失效时间
     *
     * @param key 键key
     * @param value 插入的值value
     * @param expire 失效时间（单位：秒）
     */
    public void rightPush(String key, Object value, long expire) {
        redisTemplate.opsForList().rightPush(key, value);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
    }

    /**
     * 从集合右边插入集合list，指定失效时间
     *
     * @param key 键key
     * @param list 集合list
     * @param expire 失效时间（单位：秒）
     */
    public void setList(String key, List<Object> list, long expire) {
        if (!CollectionUtils.isEmpty(list)) {
            redisTemplate.opsForList().rightPushAll(key, list);
            if (expire != NOT_EXPIRE) {
                expire(key, expire);
            }
        }
    }

    /**
     * 获取List缓存的所有元素
     *
     * @param key 键key
     * @return List缓存的所有数据
     */
    public List<Object> getList(String key) {
        return hasKey(key) ? redisTemplate.opsForList().range(key, 0, -1) : null;
    }

    /**
     * 获取List缓存的部分元素
     *
     * @param key 键key
     * @param start 开始下标
     * @param end 结束下标
     * @return List缓存的部分元素
     */
    public List<Object> getRangeList(String key, long start, long end) {
        return hasKey(key) ? redisTemplate.opsForList().range(key, start, end) : null;
    }

    /**
     * 获取List缓存的部分元素（分页）
     *
     * @param key 键key
     * @param page 当前页
     * @param limit 每页元素个数
     * @return List缓存的分页数据
     */
    public List<Object> getPage(String key, int page, int limit) {
        Long start = Long.valueOf((page - 1) * limit);
        Long end = Long.valueOf(page * limit - 1);
        return hasKey(key) ? redisTemplate.opsForList().range(key, start, end) : null;
    }

    /**
     * 截取list集合元素，保留长度内的数据
     *
     * @param key 键key
     * @param start 开始下标
     * @param end 结束下标
     */
    public void trim(String key, long start, long end) {
        try {
            redisTemplate.opsForList().trim(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 移除List缓存的最右边的一个元素
     *
     * @param key 键key
     * @return 被移除的元素
     */
    public Object rightPop(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 获取List缓存的长度
     *
     * @param key 键key
     * @return List缓存的长度
     */
    public Long getListTotal(String key) {
        return hasKey(key) ? redisTemplate.opsForList().size(key) : null;
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /********    List end         ********/


    /********    sortedSet(zSet) start  ********/
    /**
     *  向指定key中添加元素，按照score值由小到大进行排列
     *  (集合中对应元素已存在，会被覆盖，包括score)
     *
     * @param key 键key
     * @param value 值value
     * @param score 分数score
     */
    public void zSet(String key, Object value, double score) {
        try {
            redisTemplate.opsForZSet().add(key, value, score);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取key对应集合中value元素的score值
     *
     * @param key 键key
     * @param value 值value
     * @return 分数score
     */
    public Double zGetScore(String key, Object value) {
        try {
            return redisTemplate.opsForZSet().score(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取集合的元素, 从大到小排序, 并返回score值（分页）
     *
     * @param key   key
     * @param page  当前页
     * @param limit  每页记录数
     *
     * @return 分页数据
     */
    public Set<ZSetOperations.TypedTuple<Object>> zReverseRangePage(String key, long page, long limit) {
        try {
            Long start = Long.valueOf((page - 1) * limit);
            Long end = Long.valueOf(page * limit - 1);
            Set<ZSetOperations.TypedTuple<Object>> typedTuples = redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
            return typedTuples;
        }catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 增加元素的score值，并返回增加后的值
     *
     * @param key   key
     * @param value 值
     * @param delta 增加的权值
     *
     * @return 操作的权值
     */
    public Double zIncrementScore(String key, String value, double delta) {
        try {
            return redisTemplate.opsForZSet().incrementScore(key, value, delta);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取集合的大小
     *
     * @param key 键key
     * @return 集合大小
     */
    public Long zSize(String key) {
        try {
            return redisTemplate.opsForZSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取指定score区间的值
     *
     * @param key 键key
     * @param min 开始score
     * @param max 结束score
     * @return 指定score区间的值
     */
    public Set<Object> zGetByScore(String key, double min, double max) {
        try {
            Set<Object> set = redisTemplate.opsForZSet().rangeByScore(key, min, max);
            return set;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 移除集合中指定的值
     *
     * @param key 键key
     * @param values 指定的值value（可以多个）
     */
    public void zRemove(String key, Object... values) {
        try {
            redisTemplate.opsForZSet().remove(key, values);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /********    sortedSet(zSet) end    ********/



}