分布式医疗挂号系统(十) | 使用SpringCache+Redis为数据字典添加缓存

港控/mmm° 2023-01-13 04:04 200阅读 0赞

### 使用SpringCache+Redis为数据字典添加缓存 ###

*  一、SpringCache介绍
 *  二、项目集成Spring Cache
 *   *  1.添加缓存相关依赖
     *  2.添加redis配置类
     *  3.添加redos配置
 *  三、数据字典配置Spring Cache
 *   *  1.缓存@Cacheable
     *  2.缓存@CachePut
     *  3.缓存@CacheEvict
 *  四、测试缓存是否添加成功

--------------------

# 一、SpringCache介绍 #

`Spring Cache 是一个优秀的缓存组件`。自Spring 3.1起，提供了类似于@Transactional注解事务的注解Cache支持，且提供了Cache抽象，方便切换各种底层Cache（如：redis）

使用Spring Cache的好处：

*  提供基本的Cache抽象，方便切换各种底层Cache。
 *  通过注解Cache可以实现类似于事务一样，缓存逻辑透明的应用到我们的业务代码上，且只需要更少的代码就可以完成。
 *  提供事务回滚时也自动回滚缓存。
 *  支持比较复杂的缓存逻辑。

# 二、项目集成Spring Cache #

## 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.6.0</version>
            </dependency>

## 2.添加redis配置类 ##

@Configuration
    @EnableCaching
    public class RedisConfig { 
        /** * 自定义key规则 * @return */
        @Bean
        public KeyGenerator keyGenerator() { 
            return new KeyGenerator() { 
                @Override
                public Object generate(Object target, Method method, Object... params) { 
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) { 
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    
        /** * 设置RedisTemplate规则 * @param redisConnectionFactory * @return */
        @Bean
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { 
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    
            //解决查询缓存转换异常的问题
            ObjectMapper om = new ObjectMapper();
            // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
    
            //序列号key value
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    
        /** * 设置CacheManager缓存规则 * @param factory * @return */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory factory) { 
            RedisSerializer<String> redisSerializer = new StringRedisSerializer();
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    
            //解决查询缓存转换异常的问题
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
    
            // 配置序列化（解决乱码的问题）,过期时间600秒
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofSeconds(600))
                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                    .disableCachingNullValues();
    
            RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                    .cacheDefaults(config)
                    .build();
            return cacheManager;
        }
    }

## 3.添加redos配置 ##

spring.redis.host=[主机地址]
    spring.redis.port=6379
    spring.redis.database= 0
    spring.redis.timeout=1800000
    
    spring.redis.lettuce.pool.max-active=20
    spring.redis.lettuce.pool.max-wait=-1
    #最大阻塞等待时间(负数表示没限制)
    spring.redis.lettuce.pool.max-idle=5
    spring.redis.lettuce.pool.min-idle=0

# 三、数据字典配置Spring Cache #

## 1.缓存@Cacheable ##

> `@Cacheable注解`：根据方法对其返回结果进行缓存，下次请求时，如果缓存存在，则直接读取缓存数据返回；如果缓存不存在，则执行方法，并把返回的结果存入缓存中。`一般用在查询方法上。`
> 
>  *  value ：缓存名，必填，指定了缓存存放在哪块命名空间。
>  *  cacheNames ：与value差不多，二选一即可。
>  *  key：可选属性，可以使用SpEL标签自定义缓存的key。

*  根据id查询子数据列表属于查询方法，添加`@Cacheable`注解表示方法执行时对返回结果进行缓存。

/** * 根据id查询子数据列表 * @param id * @return list */
        @Override
        @Cacheable(value = "dict",keyGenerator = "keyGenerator")
        public List<Dict> findChildData(Long id) { 
            QueryWrapper<Dict> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id", id);
            List<Dict> dictList = baseMapper.selectList(queryWrapper);
            for (Dict dict : dictList) { 
                // 得到每一条记录的id值
                Long dictId = dict.getId();
                // 调用hasChildren方法判断是否包含子节点
                boolean flag = this.hasChildren(dictId);
                // 为每条记录设置hasChildren属性
                dict.setHasChildren(flag);
            }
            return dictList;
        }

## 2.缓存@CachePut ##

> `@CachePut注解`：使用该注解标志的方法，每次都会执行，并将结果存入指定的缓存中。其他方法可以直接从响应的缓存中读取缓存数据，而不需要再去查询数据库。`一般用在新增方法上。`
> 
>  *  value ： 缓存名，必填，指定了缓存存放在哪块命名空间。
>  *  cacheNames ：与value 差不多，二选一即可。
>  *  key：可选属性，可以使用 SpEL 标签自定义缓存的key。

## 3.缓存@CacheEvict ##

> `@CacheEvict注解`：使用该注解标志的方法，会清空指定的缓存。`一般用在更新或者删除方法上。`
> 
>  *  value：缓存名，必填，指定了缓存存放在哪块命名空间。
>  *  cacheNames 与 value 差不多，二选一即可。
>  *  key 可选属性，可以使用 SpEL 标签自定义缓存的key。
>  *  allEntries：是否清空所有缓存，默认为 false。若为true，则方法调用后将立即清空所有的缓存。
>  *  beforeInvocation：是否在方法执行前就清空，默认为 false。若为true，则在方法执行前就会清空缓存。

*  将数据字典导入网页属于更新方法，添加`@CacheEvict`注解，表示方法执行时要清空缓存。

/** * 导入数据字典到网页 * @param file */
        @Override
        @CacheEvict(value = "dict", allEntries=true)
        public void importDictData(MultipartFile file) { 
            try { 
                EasyExcel.read(file.getInputStream(), DictVo.class, new DictListener(baseMapper)).sheet().doRead();
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }

# 四、测试缓存是否添加成功 #

将项目重新启动，单击数据字典按钮，此时页面成功出现数据库中的数据。打开Redis客户端，可以看到数据成功注入Redis中：  
![Redis中成功加入内容][Redis]

至此，使用SpringCache+Redis为数据字典添加缓存就演示完成了。

[Redis]: /images/20221022/c5ac876843864827967ec36c33f7570f.png