Springboot怎么快速集成Redis？

朴灿烈づ我的快乐病毒、 2024-03-26 19:50 58阅读 0赞

![3ff63599b7cc47bcba4fdde3c47547e6.png][]

## **前言** ##

其实在Springboot中集成redis是一个非常简单的事情，但是为什么要单独输出一篇文章来记录这个过程呢？第一个原因是，我记性不是太好，这次把这个过程记录下，在新的项目搭建的时候或者需要在本地集成redis做一些其他相关联技术的测试分析的时候，可以很快找到集成方法；第二个原因是，最早我记得Spring项目里集成redis的时候，用的是jedis作为客户端，而在Springboot2.0后，这一事实改变了，默认的是lettuce。作为一个成熟的程序员来说，我是乐于拥抱变化的，改变意味着新的可能。

> 文章示例环境配置信息  
> jdk版本:1.8  
> 开发工具：Intellij iDEA 2020.1  
> springboot:2.3.9.RELEASE

## **依赖配置** ##

Springboot本身已经提供好了关于redis的starter，即spring-boot-starter-data-redis，在使用redis连接池的时候会依赖到commons-pool2包。

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>

## **application.properties配置** ##

### **单机模式** ###

redis单机模式下，配置的连接参数是比较简单的，有主机ip、端口、连接验证密码，如果使用了连接池，再加连接池的几个参数就算配置完成了;

#单机模式
    #redis主机ip
    spring.redis.host=localhost
    #redis对外提供服务端口
    spring.redis.port=6379
    #redis连接验证密码
    spring.redis.password=fanfu123
    #redis连接池配置-最大保持闲置的连接数
    spring.redis.lettuce.pool.max-idle=16
    #redis连接池配置-最大活跃的连接数
    spring.redis.lettuce.pool.max-active=20
    #redis连接池配置-最大等待时间，单位毫秒
    spring.redis.lettuce.pool.max-wait=1

### **集群模式** ###

集群模式下与单机模式的连接参数配置最大的区别就在于，这里配置的是多个节点主机ip+端口，多个节点之间英文逗号隔开；另外就是一些集群模式特有的参数，如重定向次数、集群刷新等；

#集群模式
    #集群节点ip+端口，多个节点之间以英文逗号隔开
    spring.redis.cluster.nodes=172.18.229.61:6380,172.18.229.61:6381,172.18.229.61:6382,172.18.229.61:6383,172.18.229.61:6384,172.18.229.61:6385;
    #密码
    spring.redis.password=fanfu123
    #最大重定向次数
    spring.redis.cluster.max-redirects=5
    #是否开启集群刷新功能
    spring.redis.lettuce.cluster.refresh.adaptive=false
    #集群刷新间隔
    spring.redis.lettuce.cluster.refresh.period=10M

redis密码更新

redis的配置文件，我本机操作系统是windows，使用了redis.windows.conf配置文件，更改内容如下：

requirepass fanfu123

## **单元测试** ##

1、在redis.windows.conf配置文件中配置好密码，然后启动redis，这里我写了一个windwos上的批处理文件start.bat来启动redis，start.bat内容如下：

title redis-6385
    redis-server.exe redis.windows.conf

2、在项目里增加依赖配置spring-boot-starter-data-redis和commons-pool2，并在application.properties中配置好redis的连接信息；

3、编写单元测试，使用redisTemplate对象往redis中设置一个key-value的键值对并读取；RedisTemplate是spring-data-redis提供的一个操作reids的类，可以直接注入单元测试或其他spring的bean中使用；

@RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class RedisTest {
        @Autowired
        private RedisTemplate redisTemplate;
        @Test
        public void test() {
            redisTemplate.opsForValue().set("username", "凡夫");
            String name = redisTemplate.opsForValue().get("name").toString();
            Assert.isTrue(name.equals("凡夫"), "xxxx");
        }
    }

单元测试执行结果，发现key是这样的“\\xAC\\xED\\x00\\x05t\\x00\\x08username”，出现这样类似乱码的现象是因为注入的redisTemplate对象使用了默认的序列化方式JdkSerializationRedisSerializer，具体就是使用redisTemplate对象把key存储到redis中的时候，就会先使用JdkSerializationRedisSerializer对key进行序列化，序列后的结果存储在redis服务端；

![e79437a8959f4f859daf3463099b29b9.png][]

这样在观察redis中存储的key时不太直观，为了解决redis中key使用默认序列化产生类似乱码的现象，需要重新定义redisTemplate对象并注入到Spring容器中，这里key的序列化使用StringRedisSerializer的方式，就可以消除上面类似乱码的现象；value类型是String，默认的序列化方式是StringRedisSerializer；value的类型是object，默认的序列化方式是JdkSerializationRedisSerializer；而一般经常使用的对象序列化方式是Jackson2JsonRedisSerializer；

这里再简单梳理一下redis本身提供的几种序列化方式 ：

GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化

Jackson2JsonRedisSerializer: 序列化object对象为json字符串

JdkSerializationRedisSerializer: 序列化java对象

StringRedisSerializer: 简单的字符串序列化

@Configuration
    public class RedisConfig {
            @Bean(name = "redisTemplate")
            public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
                RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
                redisTemplate.setConnectionFactory(factory);
                //key采用string的序列化方式
                StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
                redisTemplate.setKeySerializer(stringRedisSerializer);
                Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
                ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
                objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                        ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
                jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
                jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
                //value的序列化方式采用jackson
                redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
                //hash的key也采用string的序列化方式
                redisTemplate.setHashKeySerializer(stringRedisSerializer);
                //hash的value也采用jackson的序列化方式
                redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
                redisTemplate.afterPropertiesSet();
                return redisTemplate;
            }
    }

## **工具类封装** ##

redis有五种数据类型，分别是String、hash、list、set、zset，spring-data-redis中的redisTemplate针对每种类型value的操作命令都进行封装，如下：

ValueOperations valueOperations = redisTemplate.opsForValue();//string
    HashOperations hashOperations = redisTemplate.opsForHash();//hash
    ListOperations listOperations = redisTemplate.opsForList();//list
    SetOperations setOperations = redisTemplate.opsForSet();//set
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();//zset

为了方便使用，可以单独封装成一个工具类，使用的时候直接通过工具类来操作，如下：

@Component
    public class RedisService {
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        /**
         * 给一个指定的 key 值附加过期时间
         * @param key
         * @param time
         * @return
         */
        public boolean expire(String key, long time) {
            return redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    
        /**
         * 根据key 获取过期时间
         * @param key
         * @return
         */
        public long getTime(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /**
         * 判断指定的key是否存在
         * @param key
         * @return
         */
        public boolean hasKey(String key) {
            return redisTemplate.hasKey(key);
        }
    
        /**
         * 移除指定key的过期时间
         * @param key
         * @return
         */
        public boolean persist(String key) {
            return redisTemplate.boundValueOps(key).persist();
        }
    
        /**
         * 根据key获取值
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 将值放入缓存
         * @param key   键
         * @param value 值
         * @return true成功 false 失败
         */
        public void set(String key, String value) {
            redisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 将值放入缓存并设置时间
         * @param key   键
         * @param value 值
         * @param time  时间(秒) -1为无期限
         * @return true成功 false 失败
         */
        public void set(String key, String value, long time) {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                redisTemplate.opsForValue().set(key, value);
            }
        }
    
        /**
         * 批量添加 key (重复的键会覆盖)
         * @param keyAndValue
         */
        public void batchSet(Map<String, String> keyAndValue) {
            redisTemplate.opsForValue().multiSet(keyAndValue);
        }
    
        /**
         * 批量添加 key-value 只有在键不存在时,才添加
         * map 中只要有一个key存在,则全部不添加
         * @param keyAndValue
         */
        public void batchSetIfAbsent(Map<String, String> keyAndValue) {
            redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
        }
    
        /**
         * 对一个 key-value 的值进行加减操作,
         * 如果该 key 不存在 将创建一个key 并赋值该 number
         * 如果 key 存在,但 value 不是长整型 ,将报错
         * @param key
         * @param number
         */
        public Long increment(String key, long number) {
            return redisTemplate.opsForValue().increment(key, number);
        }
    
        /**
         * 对一个 key-value 的值进行加减操作,
         * 如果该 key 不存在 将创建一个key 并赋值该 number
         * 如果 key 存在,但 value 不是 纯数字 ,将报错
         * @param key
         * @param number
         */
        public Double increment(String key, double number) {
            return redisTemplate.opsForValue().increment(key, number);
        }
    
        /**
         * 将数据放入set缓存
         * @param key 键
         * @return
         */
        public void sSet(String key, String value) {
            redisTemplate.opsForSet().add(key, value);
        }
    
        /**
         * 获取变量中的值
         * @param key 键
         * @return
         */
        public Set<Object> members(String key) {
            return redisTemplate.opsForSet().members(key);
        }
    
        /**
         * 随机获取变量中指定个数的元素
         * @param key   键
         * @param count 值
         * @return
         */
        public List randomMembers(String key, long count) {
            List list = redisTemplate.opsForSet().randomMembers(key, count);
            return list;
        }
    
        /**
         * 随机获取变量中的元素
         * @param key 键
         * @return
         */
        public Object randomMember(String key) {
            return redisTemplate.opsForSet().randomMember(key);
        }
    
        /**
         * 弹出变量中的元素
         * @param key 键
         * @return
         */
        public Object pop(String key) {
            return redisTemplate.opsForSet().pop("setValue");
        }
    
        /**
         * 获取变量中值的长度
         * @param key 键
         * @return
         */
        public long setSize(String key) {
            return redisTemplate.opsForSet().size(key);
        }
    
        /**
         * 根据value从一个set中查询,是否存在
         * @param key   键
         * @param value 值
         * @return true 存在 false不存在
         */
        public boolean sHasKey(String key, Object value) {
            return redisTemplate.opsForSet().isMember(key, value);
        }
    
        /**
         * 检查给定的元素是否在变量中
         * @param key 键
         * @param obj 元素对象
         * @return
         */
        public boolean isMember(String key, Object obj) {
            return redisTemplate.opsForSet().isMember(key, obj);
        }
    
        /**
         * 转移变量的元素值到目的变量
         * @param key     键
         * @param value   元素对象
         * @param destKey 元素对象
         * @return
         */
        public boolean move(String key, String value, String destKey) {
            return redisTemplate.opsForSet().move(key, value, destKey);
        }
    
        /**
         * 批量移除set缓存中元素
         * @param key    键
         * @param values 值
         * @return
         */
        public void remove(String key, Object... values) {
            redisTemplate.opsForSet().remove(key, values);
        }
    
        /**
         * 通过给定的key求2个set变量的差值
         * @param key     键
         * @param destKey 键
         * @return
         */
        public Set difference(String key, String destKey) {
            return redisTemplate.opsForSet().difference(key, destKey);
        }
    
        /**
         * 加入缓存
         * @param key 键
         * @param map 键
         * @return
         */
        public void add(String key, Map<String, String> map) {
            redisTemplate.opsForHash().putAll(key, map);
        }
    
        /**
         * 获取 key 下的 所有  hashkey 和 value
         * @param key 键
         * @return
         */
        public Map<Object, Object> getHashEntries(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * 验证指定 key 下 有没有指定的 hashkey
         * @param key
         * @param hashKey
         * @return
         */
        public boolean hashKey(String key, String hashKey) {
            return redisTemplate.opsForHash().hasKey(key, hashKey);
        }
    
        /**
         * 获取指定key的值string
         * @param key     键
         * @param hashKey 键
         * @return
         */
        public String getMapString(String key, String hashKey) {
            return redisTemplate.opsForHash().get(key, hashKey).toString();
        }
    
        /**
         * 获取指定的值Int
         * @param key     键
         * @param hashKey 键
         * @return
         */
        public Integer getMapInt(String key, String hashKey) {
            return (Integer) redisTemplate.opsForHash().get(key, hashKey);
        }
    
        /**
         * 弹出元素并删除
         * @param key 键
         * @return
         */
        public String popValue(String key) {
            return redisTemplate.opsForSet().pop(key).toString();
        }
    
        /**
         * 删除指定 hash 的 HashKey
         * @param key
         * @param hashKeys
         * @return 删除成功的 数量
         */
        public Long delete(String key, String... hashKeys) {
            return redisTemplate.opsForHash().delete(key, hashKeys);
        }
    
        /**
         * 给指定 hash 的 hashkey 做增减操作
         * @param key
         * @param hashKey
         * @param number
         * @return
         */
        public Long increment(String key, String hashKey, long number) {
            return redisTemplate.opsForHash().increment(key, hashKey, number);
        }
    
        /**
         * 给指定 hash 的 hashkey 做增减操作
         * @param key
         * @param hashKey
         * @param number
         * @return
         */
        public Double increment(String key, String hashKey, Double number) {
            return redisTemplate.opsForHash().increment(key, hashKey, number);
        }
    
        /**
         * 获取 key下的所有hashkey字段
         * @param key
         * @return
         */
        public Set<Object> hashKeys(String key) {
            return redisTemplate.opsForHash().keys(key);
        }
    
        /**
         * 获取指定hash下面的键值对数量
         *
         * @param key
         * @return
         */
        public Long hashSize(String key) {
            return redisTemplate.opsForHash().size(key);
        }
    
    
        /**
         * 在变量左边添加元素值
         *
         * @param key
         * @param value
         * @return
         */
        public void leftPush(String key, Object value) {
            redisTemplate.opsForList().leftPush(key, value);
        }
    
        /**
         * 获取集合指定位置的值。
         *
         * @param key
         * @param index
         * @return
         */
        public Object index(String key, long index) {
            return redisTemplate.opsForList().index("list", 1);
        }
    
        /**
         * 获取指定区间的值。
         *
         * @param key
         * @param start
         * @param end
         * @return
         */
        public List<Object> range(String key, long start, long end) {
            return redisTemplate.opsForList().range(key, start, end);
        }
    
        /**
         * 如果pivot值存在于集合内，把一个value值放到第一个出现的pivot值的前面
         *
         * @param key
         * @param pivot
         * @param value
         * @return
         */
        public void leftPush(String key, String pivot, String value) {
            redisTemplate.opsForList().leftPush(key, pivot, value);
        }
    
        /**
         * 向左边批量添加参数元素。
         *
         * @param key
         * @param values
         * @return
         */
        public void leftPushAll(String key, String... values) {
            redisTemplate.opsForList().leftPushAll(key, values);
        }
    
        /**
         * 向集合最右边添加元素。
         *
         * @param key
         * @param value
         * @return
         */
        public void leftPushAll(String key, String value) {
            redisTemplate.opsForList().rightPush(key, value);
        }
    
        /**
         * 向左边批量添加参数元素。
         *
         * @param key
         * @param values
         * @return
         */
        public void rightPushAll(String key, String... values) {
            redisTemplate.opsForList().rightPushAll(key, values);
        }
    
        /**
         * 向已存在的集合中添加元素。
         *
         * @param key
         * @param value
         * @return
         */
        public void rightPushIfPresent(String key, Object value) {
            redisTemplate.opsForList().rightPushIfPresent(key, value);
        }
    
        /**
         * 向已存在的集合中添加元素。
         *
         * @param key
         * @return
         */
        public long listLength(String key) {
            return redisTemplate.opsForList().size(key);
        }
    
        /**
         * 移除集合中的左边第一个元素。
         *
         * @param key
         * @return
         */
        public void leftPop(String key) {
            redisTemplate.opsForList().leftPop(key);
        }
    
        /**
         * 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
         *
         * @param key
         * @return
         */
        public void leftPop(String key, long timeout, TimeUnit unit) {
            redisTemplate.opsForList().leftPop(key, timeout, unit);
        }
    
        /**
         * 移除集合中右边的元素。
         *
         * @param key
         * @return
         */
        public void rightPop(String key) {
            redisTemplate.opsForList().rightPop(key);
        }
    
        /**
         * 在等待的时间里移除集合中右边的元素，如果超过等待的时间仍没有元素则退出。
         *
         * @param key
         * @return
         */
        public void rightPop(String key, long timeout, TimeUnit unit) {
            redisTemplate.opsForList().rightPop(key, timeout, unit);
        }
    }

## **Jedis和Lettuce** ##

jedis和Lettuce都是Redis的客户端，它们都可以连接Redis服务器，但是在SpringBoot2.0之后默认都是使用的Lettuce这个客户端连接Redis服务器。因为当使用Jedis客户端连接Redis服务器的时候，每个线程都要拿自己创建的Jedis实例去连接Redis客户端，当有很多个线程的时候，不仅开销大需要反复的创建关闭一个Jedis连接，而且也是线程不安全的，一个线程通过Jedis实例更改Redis服务器中的数据之后会影响另一个线程。

但是如果使用Lettuce这个客户端连接Redis服务器的时候，就不会出现上面的情况，Lettuce底层使用的是Netty，当有多个线程都需要连接Redis服务器的时候，可以保证只创建一个Lettuce连接，使所有的线程共享这一个Lettuce连接，这样可以减少创建关闭一个Lettuce连接时候的开销；而且这种方式也是线程安全的，不会出现一个线程通过Lettuce更改Redis服务器中的数据之后而影响另一个线程的情况

## **总结** ##

通过这篇文章可以了解到什么呢？

1、springboot集成redis时的依赖引入、连接参数是如何配置的？

2、如何选择redisTemplate中key-value序列化方式；

3、redis的五种数据类型常用操作对应的java封装；

[3ff63599b7cc47bcba4fdde3c47547e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c7921af20edc46efa1f9666bc4cdb2ee.png
[e79437a8959f4f859daf3463099b29b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/cc44e6988e3b442ca9463cec68e47311.png