实现redis缓存与数据库之前同步

阳光穿透心脏的1/2处 2021-11-22 06:52 266阅读 0赞

**一.**  
通过注解的方式，Spring3以上提供了注解的方式进行缓存编程  
@Cacheable：查询时使用，注意Long类型需转换为Sting类型，否则会抛异常

@CachePut：更新时使用，使用此注解，一定会从DB上查询数据

@CacheEvict：删除时使用；

@Caching：组合用法 具体注解的使用可参考官网

注意：注解方式虽然能使我们的代码简洁，但是注解方式有局限性：对key的获取，以及嵌套使用时注解无效，  
//使用getUserByName方式调用getIdByName 和getUser方法来实现查询，但是如果用此方式在controller中直接调用

//getUserByName方法，缓存效果是不起作用的，必须是直接调用getIdByName和getUser方法才能起作用

public User getUserByName(String name) {
        //通过name 查询到主键  再由主键查询实体
        return getUser(Long.valueOf(getIdByName(name)));
    }

**二.**  
非注解方式实现

1.先定义一个RedisCacheConfig类用于生成RedisTemplate和对CacheManager的管理

@Configuration
    public class RedisCacheConfig  extends CachingConfigurerSupport {
    
        /*定义缓存数据 key 生成策略的bean
         *包名+类名+方法名+所有参数
        */
        @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();
                }
            };
        }
    
         //@Bean
         public CacheManager cacheManager(
                 @SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
             //RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
               //cacheManager.setDefaultExpiration(60);//设置缓存保留时间（seconds）
             return cacheManager;
         }
    
        //1.项目启动时此方法先被注册成bean被spring管理
        @Bean
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
    
            StringRedisTemplate template = new StringRedisTemplate(factory);
            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);
            template.setValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
            return template;
        }
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(connectionFactory);
    
            //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
            Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
    
            System.out.println("==============obj:"+Object.class.getName());
            ObjectMapper mapper = new ObjectMapper();
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(mapper);
    
            template.setValueSerializer(serializer);
            //使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
            template.afterPropertiesSet();
            return template;
        }
    }

2.定义一个redisUtil类用于存取缓存值

@Component
    public class RedisCacheUtil {
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        /**
         * 存储字符串
         * @param key string类型的key
         * @param value String类型的value
         */
        public void set(String key, String value) {
            stringRedisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 存储对象
         * @param key String类型的key
         * @param value Object类型的value
         */
        public void set(String key, Object value) {
            redisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 存储对象
         * @param key String类型的key
         * @param value Object类型的value
         */
        public void set(String key, Object value,Long timeOut) {
            redisTemplate.opsForValue().set(key, value,timeOut, TimeUnit.SECONDS);
        }
    
        /**
         * 根据key获取字符串数据
         * @param key
         * @return
         */
        public String getValue(String key) {
            return stringRedisTemplate.opsForValue().get(key);
        }
    
    //    public Object getValue(String key) {
    //        return redisTemplate.opsForValue().get(key);
    //    }
        /**
         * 根据key获取对象
         * @param key
         * @return
         */
        public Object getValueOfObject(String key) {
            return redisTemplate.opsForValue().get(key);
        }
        /**
         * 根据key删除缓存信息
         * @param key
         */
        public void delete(String key) {
            redisTemplate.delete(key);
        }
        /**
         * 查询key是否存在
         * @param key
         * @return
         */
        @SuppressWarnings("unchecked")
        public boolean exists(String key) {
            return redisTemplate.hasKey(key);
        }
    }

3.实现类\`/\*\*  
\*  
\*

*  在Impl基础上+ 防止缓存雪崩和缓存穿透功能  
    \*/  
    @Service(value = “userServiceImpl4”)  
    public class UserServiceImpl4 implements UserService \{
    
    @Autowired  
    UserMapper userMapper;
    
    @Autowired  
    RedisCacheUtil redisCacheUtil;
    
    @Value("$\{timeOut\}")  
    private long timeOut;
    
    @Override  
    public User getUser(Long userId) \{
    
        String key = "user" + userId;
         User user = (User) redisCacheUtil.getValueOfObject(key);
         String keySign = key + "_sign";
         String valueSign = redisCacheUtil.getValue(keySign);
         if(user == null){//防止第一次查询时返回时空结果
             //防止缓存穿透
             if(redisCacheUtil.exists(key)){
                 return  null;
             }
             user = userMapper.selectByPrimaryKey(userId);
        
             redisCacheUtil.set(key,user);
             redisCacheUtil.set(keySign,"1",timeOut *(new Random().nextInt(10) + 1));

// redisCacheUtil.set(keySign,“1”,0L); //过期时间不能设置为0，必须比0大的数  
return user;  
\}

if(valueSign != null){
            return user;
        }else {
            //设置标记的实效时间
            Long tt = timeOut * (new Random().nextInt(10) + 1);
            System.out.println("tt:"+tt);
            redisCacheUtil.set(keySign,"1",tt);
            //异步处理缓存更新  应对与高并发的情况，会产生脏读的情况
            ThreadPoolUtil.getExecutorService().execute(new Runnable(){
                public void run() { //
                    System.out.println("-----执行异步操作-----");
                    User user1 = userMapper.selectByPrimaryKey(userId);
                    redisCacheUtil.set(key,user1);
                }
            });

// new Thread()\{  
// public void run() \{ //应对与高并发的情况，会产生脏读的情况  
// System.out.println("-----执行异步操作-----");  
// User user1 = userMapper.selectByPrimaryKey(userId);  
// redisCacheUtil.set(key,user1);  
// \}  
// \}.start();  
\}  
return user;  
\}  
\}\`