Redis通用模块

由于 Redis 在很多模块中都可能会用到，因此需要将其抽取出来单独的作为一个模块 ruoyi-common-redis， 别的模块想使用 Redis，只需要引入自定义的 ruoyi-common-redis 模块即可。

创建通用模块的父模块

通用的模块可能不止 一个，因此需要创建 通用模块的父工程 ruoyi-common，其余通用模块继承它就可以。
新建模块 ruoyi-common ，其 pom.xml 内容为：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>ruoyi</artifactId>
  7.         <groupId>com.ruoyi</groupId>
  8.         <version>1.0.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <packaging>pom</packaging>
  13.     <modules>
  14.         <module>ruoyi-common-redis</module>
  15.     </modules>
  17.     <artifactId>ruoyi-common</artifactId>
  19. </project>

创建Redis通用模块

创建 ruoyi-common-redis 模块，其父模块为 ruoyi-common。其 pom.xml 文件内容：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>ruoyi-common</artifactId>
  7.         <groupId>com.ruoyi</groupId>
  8.         <version>1.0.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>ruoyi-common-redis</artifactId>
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.springframework.boot</groupId>
  17.             <artifactId>spring-boot-starter-data-redis</artifactId>
  18.         </dependency>
  19.     </dependencies>
  21. </project>

版本号声明

在 父工程 ruoyi 中定义 ruoyi-common-redis 模块的版本号。

  1.             <properties>
  2.                 <ruoyi.version>1.0.0</ruoyi.version>
  3.              </properties>
  5.                         <dependency>
  6.                 <groupId>com.ruoyi</groupId>
  7.                 <artifactId>ruoyi-common-redis</artifactId>
  8.                 <version>${ruoyi.version}</version>
  9.             </dependency>

Redis使用

在 ruoyi-system 模块中使用 Redis

引入依赖

  1.         <dependency>
  2.             <groupId>com.ruoyi</groupId>
  3.             <artifactId>ruoyi-common-redis</artifactId>
  4.         </dependency>

编写测试代码

  1. package com.ruoyi.system.controller;
  3. import com.ruoyi.system.api.domain.SysUser;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.RedisTemplate;
  6. import org.springframework.data.redis.core.StringRedisTemplate;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  10. @RestController
  11. public class TestRedisController {
  13.     @Autowired
  14.     private RedisTemplate redisTemplate;
  16.     @Autowired
  17.     private StringRedisTemplate stringRedisTemplate;
  19.     @GetMapping("/testStringRedisTemplate")
  20.     public void testStringRedisTemplate() {
  21.         stringRedisTemplate.opsForValue().set("name","马小六");
  22.     }
  24.     @GetMapping("/testRedisTemplate")
  25.     public void testRedisTemplate() {
  26.         SysUser user = new SysUser();
  27.         user.setUserId(1L);
  28.         user.setNickName("张无忌");
  29.         user.setUserName("zwj");
  30.         user.setEmail("23@qq.com");
  31.         redisTemplate.opsForValue().set("user",user);
  32.     }
  34. }

测试结果

请求：http://localhost:9201/testRedisTemplate
image.png

优化改进

从上图中的测试结果，我们可以看出当我们把一个 Object对象存放到 Redis 中是，它的 Key 和 value 都是这种十六进制的。我们希望 key 是字符串， value 是 JSON 格式的对象

Redis 配置

引入依赖

在 ruoyi-common-redis 模块中引入依赖

  1.         <!-- Jackson -->
  2.         <dependency>
  3.             <groupId>com.fasterxml.jackson.core</groupId>
  4.             <artifactId>jackson-databind</artifactId>
  5.         </dependency>
  6.         <!-- Alibaba Fastjson -->
  7.         <dependency>
  8.             <groupId>com.alibaba</groupId>
  9.             <artifactId>fastjson</artifactId>
  10.         </dependency>

版本号声明

  1.             <properties>
  2.                                 <fastjson.version>1.2.75</fastjson.version>
  3.                         </properties>
  5.                         <!-- JSON 解析器和生成器 -->
  6.             <dependency>
  7.                 <groupId>com.alibaba</groupId>
  8.                 <artifactId>fastjson</artifactId>
  9.                 <version>${fastjson.version}</version>
  10.             </dependency>

Redis值的序列号

  1. package com.ruoyi.common.redis.configure;
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.parser.ParserConfig;
  5. import com.alibaba.fastjson.serializer.SerializerFeature;
  6. import com.fasterxml.jackson.databind.JavaType;
  7. import com.fasterxml.jackson.databind.ObjectMapper;
  8. import com.fasterxml.jackson.databind.type.TypeFactory;
  9. import org.springframework.data.redis.serializer.RedisSerializer;
  10. import org.springframework.data.redis.serializer.SerializationException;
  11. import org.springframework.util.Assert;
  13. import java.nio.charset.Charset;
  15. public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
  17.     @SuppressWarnings("unused")
  18.     private ObjectMapper objectMapper = new ObjectMapper();
  20.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  22.     private Class<T> clazz;
  24.     static {
  25.         ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
  26.     }
  28.     public FastJson2JsonRedisSerializer(Class<T> clazz) {
  29.         super();
  30.         this.clazz = clazz;
  31.     }
  33.     @Override
  34.     public byte[] serialize(T t) throws SerializationException {
  35.         if (t == null) {
  36.             return new byte[0];
  37.         }
  38.         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  39.     }
  41.     @Override
  42.     public T deserialize(byte[] bytes) throws SerializationException {
  43.         if (bytes == null || bytes.length <= 0) {
  44.             return null;
  45.         }
  46.         String str = new String(bytes, DEFAULT_CHARSET);
  48.         return JSON.parseObject(str, clazz);
  49.     }
  51.     public void setObjectMapper(ObjectMapper objectMapper) {
  52.         Assert.notNull(objectMapper, "'objectMapper' must not be null");
  53.         this.objectMapper = objectMapper;
  54.     }
  56.     protected JavaType getJavaType(Class<?> clazz) {
  57.         return TypeFactory.defaultInstance().constructType(clazz);
  58.     }
  59. }

Redis配置类

key使用 StringRedisSerializer 序列号， value 使用 FastJson2JsonRedisSerializer 序列号

  1. package com.ruoyi.common.redis.config;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import com.ruoyi.common.redis.configure.FastJson2JsonRedisSerializer;
  7. import org.springframework.cache.annotation.CachingConfigurerSupport;
  8. import org.springframework.cache.annotation.EnableCaching;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.data.redis.connection.RedisConnectionFactory;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.data.redis.serializer.StringRedisSerializer;
  15. @Configuration
  16. @EnableCaching
  17. public class RedisConfig extends CachingConfigurerSupport {
  19.     @Bean
  20.     @SuppressWarnings(value = {"unchecked", "rawtypes", "deprecation"})
  21.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
  22.         RedisTemplate<Object, Object> template = new RedisTemplate<>();
  23.         template.setConnectionFactory(connectionFactory);
  25.         FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
  27.         ObjectMapper mapper = new ObjectMapper();
  28.         mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  29.         mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  30.         serializer.setObjectMapper(mapper);
  32.         template.setValueSerializer(serializer);
  33.         // 使用StringRedisSerializer来序列化和反序列化redis的key值
  34.         template.setKeySerializer(new StringRedisSerializer());
  35.         template.afterPropertiesSet();
  36.         return template;
  37.     }
  39. }

redisTemplate 二次封装

  1. package com.ruoyi.common.redis.service;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.BoundSetOperations;
  5. import org.springframework.data.redis.core.HashOperations;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.core.ValueOperations;
  8. import org.springframework.stereotype.Component;
  10. import java.util.*;
  11. import java.util.concurrent.TimeUnit;
  13. @Component
  14. public class RedisService {
  16.     @Autowired
  17.     public RedisTemplate redisTemplate;
  19.     /**
  20.      * 缓存基本的对象，Integer、String、实体类等
  21.      *
  22.      * @param key   缓存的键值
  23.      * @param value 缓存的值
  24.      */
  25.     public <T> void setCacheObject(final String key, final T value) {
  26.         redisTemplate.opsForValue().set(key, value);
  27.     }
  29.     /**
  30.      * 缓存基本的对象，Integer、String、实体类等
  31.      *
  32.      * @param key      缓存的键值
  33.      * @param value    缓存的值
  34.      * @param timeout  时间
  35.      * @param timeUnit 时间颗粒度
  36.      */
  37.     public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit) {
  38.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  39.     }
  41.     /**
  42.      * 设置有效时间
  43.      *
  44.      * @param key     Redis键
  45.      * @param timeout 超时时间
  46.      * @return true=设置成功；false=设置失败
  47.      */
  48.     public boolean expire(final String key, final long timeout) {
  49.         return expire(key, timeout, TimeUnit.SECONDS);
  50.     }
  52.     /**
  53.      * 设置有效时间
  54.      *
  55.      * @param key     Redis键
  56.      * @param timeout 超时时间
  57.      * @param unit    时间单位
  58.      * @return true=设置成功；false=设置失败
  59.      */
  60.     public boolean expire(final String key, final long timeout, final TimeUnit unit) {
  61.         return redisTemplate.expire(key, timeout, unit);
  62.     }
  64.     /**
  65.      * 获得缓存的基本对象。
  66.      *
  67.      * @param key 缓存键值
  68.      * @return 缓存键值对应的数据
  69.      */
  70.     public <T> T getCacheObject(final String key) {
  71.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  72.         return operation.get(key);
  73.     }
  75.     /**
  76.      * 删除单个对象
  77.      *
  78.      * @param key
  79.      */
  80.     public boolean deleteObject(final String key) {
  81.         return redisTemplate.delete(key);
  82.     }
  84.     /**
  85.      * 删除集合对象
  86.      *
  87.      * @param collection 多个对象
  88.      * @return
  89.      */
  90.     public long deleteObject(final Collection collection) {
  91.         return redisTemplate.delete(collection);
  92.     }
  94.     /**
  95.      * 缓存List数据
  96.      *
  97.      * @param key      缓存的键值
  98.      * @param dataList 待缓存的List数据
  99.      * @return 缓存的对象
  100.      */
  101.     public <T> long setCacheList(final String key, final List<T> dataList) {
  102.         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
  103.         return count == null ? 0 : count;
  104.     }
  106.     /**
  107.      * 获得缓存的list对象
  108.      *
  109.      * @param key 缓存的键值
  110.      * @return 缓存键值对应的数据
  111.      */
  112.     public <T> List<T> getCacheList(final String key) {
  113.         return redisTemplate.opsForList().range(key, 0, -1);
  114.     }
  116.     /**
  117.      * 缓存Set
  118.      *
  119.      * @param key     缓存键值
  120.      * @param dataSet 缓存的数据
  121.      * @return 缓存数据的对象
  122.      */
  123.     public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
  124.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  125.         Iterator<T> it = dataSet.iterator();
  126.         while (it.hasNext()) {
  127.             setOperation.add(it.next());
  128.         }
  129.         return setOperation;
  130.     }
  132.     /**
  133.      * 获得缓存的set
  134.      *
  135.      * @param key
  136.      * @return
  137.      */
  138.     public <T> Set<T> getCacheSet(final String key) {
  139.         return redisTemplate.opsForSet().members(key);
  140.     }
  142.     /**
  143.      * 缓存Map
  144.      *
  145.      * @param key
  146.      * @param dataMap
  147.      */
  148.     public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
  149.         if (dataMap != null) {
  150.             redisTemplate.opsForHash().putAll(key, dataMap);
  151.         }
  152.     }
  154.     /**
  155.      * 获得缓存的Map
  156.      *
  157.      * @param key
  158.      * @return
  159.      */
  160.     public <T> Map<String, T> getCacheMap(final String key) {
  161.         return redisTemplate.opsForHash().entries(key);
  162.     }
  164.     /**
  165.      * 往Hash中存入数据
  166.      *
  167.      * @param key   Redis键
  168.      * @param hKey  Hash键
  169.      * @param value 值
  170.      */
  171.     public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
  172.         redisTemplate.opsForHash().put(key, hKey, value);
  173.     }
  175.     /**
  176.      * 获取Hash中的数据
  177.      *
  178.      * @param key  Redis键
  179.      * @param hKey Hash键
  180.      * @return Hash中的对象
  181.      */
  182.     public <T> T getCacheMapValue(final String key, final String hKey) {
  183.         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
  184.         return opsForHash.get(key, hKey);
  185.     }
  187.     /**
  188.      * 获取多个Hash中的数据
  189.      *
  190.      * @param key   Redis键
  191.      * @param hKeys Hash键集合
  192.      * @return Hash对象集合
  193.      */
  194.     public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
  195.         return redisTemplate.opsForHash().multiGet(key, hKeys);
  196.     }
  198.     /**
  199.      * 获得缓存的基本对象列表
  200.      *
  201.      * @param pattern 字符串前缀
  202.      * @return 对象列表
  203.      */
  204.     public Collection<String> keys(final String pattern) {
  205.         return redisTemplate.keys(pattern);
  206.     }
  208. }

组件扫描

默认情况下，SpringBoot包扫描的路径为 main 方法所在类的包及其子包。在这里也就是扫描 com.ruoyi.system 包及其子包，而我们的 RedisService 组件是在 com.ruoyi.common.redis.service。为了能够扫描到，我们需求修改包扫描路径为：com.ruoyi

  1. @MapperScan("com.ruoyi.system.mapper")
  2. @EnableDiscoveryClient
  3. @SpringBootApplication(scanBasePackages = {"com.ruoyi"})
  4. public class RuoYiSystemApplication {

测试

测试类

  1.        @Autowired
  2.     private RedisService redisService;
  4.     @GetMapping("/testRedisService")
  5.     public void testRedisService() {
  6.         SysUser user = new SysUser();
  7.         user.setUserId(1L);
  8.         user.setNickName("张无忌");
  9.         user.setUserName("zwj");
  10.         user.setEmail("23@qq.com");
  11.         redisService.setCacheObject("user",user);
  12.     }

测试结果

image.png