SpringBoot整合Redis（Lettuce客户端）

快来打我* 2022-10-29 13:28 18阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70_pic_center]

### 文章目录 ###

*  一. 问题背景
 *  二. 版本说明
 *  三. 解决方案
 *   *  3.1 引入依赖
     *  3.2 配置Redis
     *  3.3 封装关于Redis的操作
     *   *  3.3.1 定义接口
         *  3.3.2 实现接口
     *  3.4 测试前期准备
     *   *  3.4.1 创建controller层
         *  3.4.2 创建Service层
     *  3.5 部署Redis
     *   *  3.5.1 安装Redis
         *  3.5.2 配置redis.conf
         *  3.5.3 创建并启动Redis容器
     *  3.6 测试

# 一. 问题背景 #

> 了解完了[关于Redis的架构][Redis]后，尝试动手写代码，SpringBoot整合Redis。Redis的客户端有Jedis以及Lettuce，SpringBoot2.x版本默认使用Lettuce了，可见Lettuce效果比较好。

参考自：

*  [mall整合Redis实现缓存功能][mall_Redis]
 *  [SpringBoot整合Lettuce Redis][SpringBoot_Lettuce Redis]

# 二. 版本说明 #

<table> 
 <thead> 
  <tr> 
   <th>技术栈</th> 
   <th>版本</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SpringBoot</td> 
   <td>2.x以上版本</td> 
  </tr> 
  <tr> 
   <td>Redis</td> 
   <td>6.0.10（以Docker方式运行）</td> 
  </tr> 
 </tbody> 
</table>

# 三. 解决方案 #

## 3.1 引入依赖 ##

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

## 3.2 配置Redis ##

> 在yml文件中，**spring节点下**，配置Redis的信息：

redis:
      host: xx.xx.xx.xx # Redis服务器地址
      database: 0 # Redis数据库索引（默认为0）
      port: 6379 # Redis服务器连接端口
      password: 'xxx' # Redis服务器连接密码（默认为空）
      lettuce:
        pool:
          max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
          max-wait: -1ms # 连接池最大阻塞等待时间（使用负值表示没有限制）
          max-idle: 8 # 连接池中的最大空闲连接
          min-idle: 0 # 连接池中的最小空闲连接
      timeout: 3000ms # 连接超时时间（毫秒）
      key:
        prefix:
          authCode: "portal:authCode:"
        expire:
          authCode: 20 # 验证码超期时间

> 注：上面代码中的`prefix authCode`以及`expire authCode`的值随便填

> 自定义RedisTemplate，否则中文的value存到redis里面会乱码，获取出来也会乱码：

package com.ganzalang.gmall.redis.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /** * @Author Androidla * @Date 2021/2/14 13:40 * @Description **/
    @Configuration
    @Slf4j
    public class RedisConfig { 
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { 
            log.info("RedisConnectionFactory class: {}", redisConnectionFactory.getClass());
            RedisSerializer<Object> serializer = redisSerializer();
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(serializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(serializer);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    
        @Bean
        public RedisSerializer<Object> redisSerializer() { 
            // 创建JSON序列化器
            Jackson2JsonRedisSerializer<Object> serializer =
                    new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            // 必须设置，否则无法将json转化为对象，会转化为Map类型
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                    ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(objectMapper);
            return serializer;
        }
    }

## 3.3 封装关于Redis的操作 ##

### 3.3.1 定义接口 ###

package com.ganzalang.gmall.service;
    
    /** * redis操作Service, * 对象和数组都以json形式进行存储 */
    public interface RedisService { 
    
        /** * 存储数据 * @param key * @param value */
        void set(String key, String value);
    
        /** * 获取数据 * @param key * @return */
        String get(String key);
    
        /** * 设置超时时间 * @param key * @param expire * @return */
        boolean expire(String key, long expire);
    
        /** * 删除数据 * @param key */
        void remove(String key);
    
        /** * 自增操作 * @param key * @param delta * @return */
        Long increment(String key, long delta);
    
    }

### 3.3.2 实现接口 ###

package com.ganzalang.gmall.service.impl;
    
    import com.ganzalang.gmall.service.RedisService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Service;
    
    import java.util.concurrent.TimeUnit;
    
    /** * redis操作Service的实现类 */
    @Service
    public class RedisServiceImpl implements RedisService { 
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        @Override
        public void set(String key, String value) { 
            stringRedisTemplate.opsForValue().set(key, value);
        }
    
        @Override
        public String get(String key) { 
            return stringRedisTemplate.opsForValue().get(key);
        }
    
        @Override
        public boolean expire(String key, long expire) { 
            return stringRedisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    
        @Override
        public void remove(String key) { 
            stringRedisTemplate.delete(key);
        }
    
        @Override
        public Long increment(String key, long delta) { 
            return stringRedisTemplate.opsForValue().increment(key, delta);
        }
    }

## 3.4 测试前期准备 ##

### 3.4.1 创建controller层 ###

package com.ganzalang.gmall.controller;
    
    import com.ganzalang.gmall.service.impl.TestServiceImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /** * 测试redis是否整合成功 */
    @RestController
    @RequestMapping("/test")
    public class TestController { 
    
        @Autowired
        private TestServiceImpl testService;
    
        @GetMapping("/redis")
        public String testRedis() { 
            testService.testRedis();
            return "success";
        }
    
    }

### 3.4.2 创建Service层 ###

package com.ganzalang.gmall.service.impl;
    
    import com.ganzalang.gmall.service.RedisService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    
    @Service
    @Slf4j
    public class TestServiceImpl { 
    
        @Autowired
        private RedisService redisService;
    
        @Value("${spring.redis.key.prefix.authCode}")
        private String REDIS_KEY_PREFIX_AUTH_CODE;
    
        @Value("${spring.redis.key.expire.authCode}")
        private Long AUTH_CODE_EXPIRE_SECONDS;
    
        private static String username = "10010";
    
        public void testRedis() { 
            log.info("testRedis start......");
            log.info("REDIS_KEY_PREFIX_AUTH_CODE: {}", REDIS_KEY_PREFIX_AUTH_CODE);
            log.info("AUTH_CODE_EXPIRE_SECONDS: {}", AUTH_CODE_EXPIRE_SECONDS);
    
            // 设置缓存
            redisService.set(getAuthKey(), "管理员权限");
            // 设置过期时间
            redisService.expire(getAuthKey(), AUTH_CODE_EXPIRE_SECONDS);
            // 获取缓存
            String auth = redisService.get(getAuthKey());
            log.info("auth: {}", auth);
        }
    
        // 构造redis的key
        private String getAuthKey() { 
            String key = REDIS_KEY_PREFIX_AUTH_CODE + username;
            return key;
        }
    }

## 3.5 部署Redis ##

### 3.5.1 安装Redis ###

> 用Docker方式部署：

# 下载最新版的redis的docker镜像
    docker pull redis
    
    # 创建挂载数据的地方
    mkdir /mydata/redis/data

### 3.5.2 配置redis.conf ###

> **必须以指定redis.conf方式启动redis容器，否则后面会有一堆报错**。

> **去网上下载redis.conf文件，并放到`/mydata/redis/`下，并修改redis.conf的某些内容**，修改如下：

1. 注释掉 bind 127.0.0.1
    2. 将protected-mode yes改为no，否则无法远程登陆redis
    3. 将daemonize yes 改为no，否则启动redis容器会一直失败
    4. 强烈建议设置redis密码，在requirepass处设置自己的密码

### 3.5.3 创建并启动Redis容器 ###

docker run -p xxxx:6379 --name redis \
    -v /mydata/redis/redis.conf:/etc/redis/redis.conf \
    -v /mydata/redis/data:/data \
    -d redis redis-server /etc/redis/redis.conf \
    --appendonly yes

> 解释：
> 
> 1.  `-p xxxx:6379`：前者是宿主机的端口，后者是容器的端口。**强烈建议修改宿主机的端口**
> 2.  `--name`：对创建出来的容器起别名
> 3.  `-v`：挂载容器数据到宿主机，实现宿主机与容器数据互通
> 4.  `-d`：后台运行
> 5.  `--appendonly yes`：数据持久化

## 3.6 测试 ##

启动程序，可以看到如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70_pic_center 1]  
整合成功

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/f53179e9bef54fe1867b2bc465a332c8.png
[Redis]: https://zilianggan.gitee.io/docs/#/redis/%E5%85%B3%E4%BA%8ERedis%E7%9A%84%E6%9E%B6%E6%9E%84
[mall_Redis]: http://www.macrozheng.com/#/architect/mall_arch_03?id=mall%E6%95%B4%E5%90%88redis%E5%AE%9E%E7%8E%B0%E7%BC%93%E5%AD%98%E5%8A%9F%E8%83%BD
[SpringBoot_Lettuce Redis]: https://blog.csdn.net/qq_41603102/article/details/89839501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/38168eef312248ca8dc345b7d0a620ef.png