12、MySQL,Redis双写一致性,数据库更新后再删除缓存就够了吗?

0. 引言

最近线上的一个状态修改功能出现了问题,一开始是运营找了过来,运营告知某条数据的状态已经开启了的,但是实际使用起来还是没有生效,于是拿到这个问题后,首先就去数据库查了这条数据,发现确实如他所说,状态数据是已经更改过的。但是为什么没有生效呢?

于是再次查看了获取数据的方法,发现是优先获取的缓存,于是查询缓存里的数据,发现了问题所在,缓存里并没有将这条数据的状态更改过来,也就是缓存数据不一致问题。

继续追查状态修改的方法,发现采用的更新方式是先更新数据库,然后删除缓存。这是我们常用的双写一致性的处理方法,但也正是这样的方式出现了问题。下面我们来详细讲解

1. 先更新数据库,再删除缓存为什么有问题?

首先原来的方法,大概是这样的,将数据库更新后,再将缓存删除掉

    public R save(UserVO userVO) {

        User user = new User();
        BeanUtils.copyProperties(userVO, user);
        saveUser(user);
        redisTemplate.delete("userInfo:" + user.getUserName());
        return R.success("操作成功");
    }

同时在获取数据时,采用的是先从缓存获取,如果缓存没有,就从数据库查询,并同时存放到缓存上,这样保证了下次访问时数据能直接从缓存获取,减少了数据库压力

    public User getByUserName(String userName) {

        User user = (User) redisTemplate.opsForValue().get(userName);
        if (user != null) {

            return user;
        }
        user = this.getOne(Wrappers.<User>lambdaQuery().eq(User::getUserName, userName));
        redisTemplate.opsForValue().set("userInfo:" + userName, user);
        return user;
    }

数据库的数据已经更新成功了,说明数据库是没有报错了,那么哪个地方报错了呢?当然是redis,在执行redis的删除操作时,如果发现错误,比如因为网络问题,或者redis本身服务问题,导致没有正常执行而产生的报错,所以为了捕获这个报错,我们需要添加上数据库事务@Transactional(rollbackFor = Exception.class)

    @Transactional(rollbackFor = Exception.class)
    public R save(UserVO userVO) {

        User user = new User();
        BeanUtils.copyProperties(userVO, user);
        saveUser(user);
        redisTemplate.delete("userInfo:" + user.getUserName());
        return R.success("操作成功");
    }

但是这样你以为就结束了吗,这样的操作确实可以实现事务的回滚,但是上述的模式仅仅只是我们用到的Cache Aside模式(这里大家要了解redis缓存的四种模式),而对于另外一种同样经典的Write Through模式就不再适用于这个操作了。

2. Cache Aside模式与Write Through模式的区别

Cache Aside模式采用的是读时放缓存或者预加载缓存,写时更新数据库,删缓存,它适用于读多写少,因为缓存没有时要去数据库查数据,如果多线程场景下,同一时间打进来同样的请求,都会去访问数据库,一方面容易造成缓存击穿,一方面并不能保证数据的强一致性,比如如下场景:

两个请求同时执行:
请求A查询用户A信息,请求B更新用户A信息
请求A查询缓存没有值,于是去查询数据库,获取到值为old(还没有更新缓存)
请求B更新数据库用户A信息为new
请求B删除掉用户A信息的缓存
请求A写入缓存,值为old
至此,就导致用户A的数据缓存为旧数据了

Write Through模式采用的是读缓存,写时先更新缓存,再更新数据库,一般缓存不设置过期时间,适用于频繁查询缓存数据的场景。因为是先更新缓存,再更新数据库,且在查询操作时不做更新缓存,所以保证了数据的一致性,也防止了缓存击穿。

3. Write Through模式下的双写一致性

因为是先更新缓存,再更新数据库,那么更新方法的代码示例就变成了如下所示:

    @Transactional(rollbackFor = Exception.class)
    public R save3(UserVO userVO) {

        User user = new User();
        // 拷贝属性
        BeanUtils.copyProperties(userVO, user);
        redisTemplate.opsForValue().set(user.getUserName(), user);
        userMapper.addUser(user);
        return R.success("操作成功");
    }

但是这样的操作,肯定是有问题的,因为一旦数据库报错,@Transactional能够保证数据库回滚,但并不能保证redis的事务性,于是我们需要让redis也能保证事务

方案一: SessionCallback实现redis事务

以为redis本身就自带事务指令,所以最容易想到的就是通过事务指令来实现redis事务,结合redisTemplate实现,需要借助SessionCallback回调类,实现代码如下

   @Transactional(rollbackFor = Exception.class)
    public R save2(UserVO userVO) {

        // 本地事务+redis事务 = 双写一致性/缓存强一致性/redis.mysql事务回滚
        User user = new User();
        // 拷贝属性
        BeanUtils.copyProperties(userVO, user);

        Object execute = redisTemplate.execute(new SessionCallback<List<Boolean>>() {

            @Override
            public List<Boolean> execute(RedisOperations operations) throws DataAccessException {

                // 事务开启
                operations.multi();
                // 执行的操作,redis先操作
                operations.opsForValue().set(user.getUserName(), user);
                try {

                    saveUser(user);
                } catch (Exception e) {

                    // 事务取消
                    operations.discard();
                    e.printStackTrace();
                    return null;
                }
                // 事务的提交
                return operations.exec();
            }
        });
        return R.status(execute != null);
    }

方案二: setEnableTransactionSupport实现redis事务

这样的代码还是比较长的,书写起来略显麻烦,能不能有更简单的方法,或者说能不能让redis也适配@Transactional注解,实现事务操作。答案是当然可以的,在redisTemplate中有这样的一个方法setEnableTransactionSupport(true),它可以开启redis支持数据库事务

@Configuration
public class RedisConfig {

    /**
     * 创建RedisTemplate
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){

        // 创建对象
        RedisTemplate redisTemplate = new RedisTemplate();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置redis生成的key的序列化器,对key编码进行处理
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        // 设置redis支持数据库事务
        redisTemplate.setEnableTransactionSupport(true);
        return redisTemplate;
    }
}

开启之后,我们的更新代码就变成了如下所示,非常的简洁清爽

    @Transactional(rollbackFor = Exception.class)
    public R save3(UserVO userVO) {

        User user = new User();
        // 拷贝属性
        BeanUtils.copyProperties(userVO, user);
        redisTemplate.opsForValue().set(user.getUserName(), user);
        userMapper.addUser(user);
        return R.success("操作成功");
    }

测试

最后我们来进行一个模拟测试,我们将sql中的字段故意写成不存在的字段名

&nbsp;

请求这个接口

&nbsp;

报错字段password2不存在

&nbsp;
查看数据库中并没有添加成功

&nbsp;

缓存里同样也没有,说明我们的redis支持了数据库的事物操作

&nbsp;