项目启动时自动加载redis缓存

男娘i 2023-09-26 19:27 49阅读 0赞

## 1.配置文件MyCacheConfig ##

@Configuration
    @EnableCaching //开启spring缓存
    public class MyCacheConfig extends CachingConfigurerSupport {
    
        /**
         * @Description: 使用@Cacheable注解的时候会将返回的对象缓存起来，默认缓存的值是二进制的，
         * 为此我们自定义序列化配置，改成JSON格式的
         */
        @Bean
        public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {
            RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisTemplate.getConnectionFactory());
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofHours(1))// 设置缓存有效期一小时
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));
            return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
        }
    
        /**
         *自己的RedisTemplate
         */
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate();
            template.setConnectionFactory(factory);
            //序列化配置
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);过时
            om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                    ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            //String的序列化
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            // key采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            // hash的key也采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);
            // value序列化方式采用jackson
            template.setValueSerializer(jackson2JsonRedisSerializer);
            // hash的value序列化方式采用jackson
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
            return template;
        }
    
    
        @Override
        public KeyGenerator keyGenerator() {
            return  new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... objects) {
                    //1.缓冲
                    StringBuilder sb = new StringBuilder();
                    //2.类名
                    sb.append(target.getClass().getSimpleName());
                    //3.方法名
                    sb.append(method.getName());
                    //4.参数值
                    for (Object obj : objects) {
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
    
        }
    }

其中解决了@Cacheable注解的时候会将返回的对象缓存起来，**默认缓存的值是*二进制*的问题**

## 2.最主要的实现ApplicationRunner ，项目启动的时候回自动加载 ##

import java.lang.annotation.*;
    
    @Component
    //@Slf4j
    public class CacheLoader implements ApplicationRunner {
        private Logger logger = LoggerFactory.getLogger(CacheLoader.class);
    
        @Autowired
        private DictService dictService;
    
        public CacheLoader() {
            logger.info("创建缓存加载器ApplicationRunner：CacheLoader");
        }
    
        @Override
        public void run(ApplicationArguments args){
            logger.info("CacheLoader.run()");
            logger.info("预加载字典数据到缓存");
            dictService.loadDictToCache();
        }
    }

## 3.使用正常逻辑三步走，清缓存，查询数据库，放入到到缓存中 ##

@Override
        public void loadDictToCache() {
            // 删除所有的dict的reids的key
            Set<String> keys = iDictRedisRepository.getAllKeys();
            //根据key删除所有的dict的redis
            iDictRedisRepository.deleteAll(keys);
    
            // 查询出dict表中的所有行数据
            List<Dict> list = this.list();
    
            //将dict放入到redis中 ，有两大类：dict 和 pdict
            iDictRedisRepository.putAllList(list);
    
            System.out.println("loadDictToCache finish ...");
        }

## 3.具体实现 ##

package com.mehow.n302.userservice.repository.impl;
    
    import com.mehow.n302.redisService.repository.IDictRedisRepository;
    import com.mehow.n302.redisService.service.DictService;
    import com.mehow.n302.redisServiceapis.entity.Dict;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Repository;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    
    @Repository
    public class IDictRedisRepositoryImpl implements IDictRedisRepository {
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        @Override
        public Set<String> getAllKeys() {
            //获取所有 dict:code 和 pdict:c.k.pk: 的keys
            Set<String> deleteKeys = redisTemplate.keys(DICT_LIST_KEY+"*");
            return deleteKeys;
        }
    
        @Override
        public Long deleteAll(Collection<String> keys) {
            return redisTemplate.delete(keys);
        }
    
    
        @Override
        public void putAllList(List<Dict> dicts) {
            //value值内容 去除p_id=0的数据
            List<Dict> listByCodes = dicts.stream().filter(d->!"0".equals(d.getParentId())).collect(Collectors.toList());
            //根据sort排序存放到redis中
    
            listByCodes.sort(Comparator.comparing(Dict::getCode).thenComparing(Dict::getSort));
    
          
            List<Dict> dictInput = new ArrayList<>();
            String searchCode = "";
            for (int i=0;i<listByCodes.size();i++) {
                if(i!=0 && !searchCode.equals(listByCodes.get(i).getCode())){
                    //不为第一个值(因为肯定不等)，且code不相等 则searchCode代表dictInput里面已经放了所有的searchCode,
                    redisTemplate.opsForValue().set( DICT_LIST_KEY + searchCode, dictInput);
    
                    searchCode = listByCodes.get(i).getCode();
                    dictInput.clear();
                }
                dictInput.add(listByCodes.get(i));
                searchCode = listByCodes.get(i).getCode();
    
                if(i==listByCodes.size()-1){
                    redisTemplate.opsForValue().set( DICT_LIST_KEY + searchCode, dictInput);
                }
        }
    }

**注：具体实现可根据自己系统的业务逻辑**