Redis数据缓存思路

对于数据库和服务的一致性问题经常会被讨论，目前市场上最优的解决方案为：

一、 使用中间层管理，一部解耦存储redis

其解决方式就是通过canal监听mysql的binlog日志的DML(数据的操作语句)、DDL(数据定义语言)语句来实现监听同步。

二、代码设计规避

1. 对于增删改操作的处理，统一是对于数据库操作成功后，仅仅需要对redis的缓存信息进行删除即可。即为：增删改成功后，调用redis删除key值。
2. 对于查询操作需要服务代码逻辑复杂化，这是在单个服务应用逻辑的写法。可能大家会考虑到服务部署集群怎么办，其实方案中锁的方式替换成分布式锁，但是要把读锁的那一步去掉。另一种方案是，就这么写，不用管，因为redis存储是单线程操作，数据完全不会有冲突，重复插入同一个key毫无影响，而且同时插入概率小，就算有最多也就是你有几个服务，就有几次插入而已，不会出现高并发的情况。
   学习ReadWriteLock链接
   Redis中热key的同时写
   

实例代码

redis存储操作

package com.ibm.mq.test.consumer;

import com.ibm.mq.test.dto.TestMessaging;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Consumer;

@Slf4j
@Service
public class RedisSet {
    private static ReadWriteLock lock = new ReentrantReadWriteLock();
    @Autowired
    private StringRedisTemplate redisTemplate;
    private static String key = "testValue";

    public String setRedis() {
        String resault = "";
        lock.readLock().lock();
        try {
            resault = redisTemplate.opsForValue().get(key);
            System.out.println("****开始读取Redis信息是:" + resault + " " + Thread.currentThread().getName());
            if (StringUtils.isNotBlank(resault)) {
                return resault;
            }
        } catch (Exception e) {
            log.error("报错", e);
        } finally {
            lock.readLock().unlock();
            System.out.println("****释放读锁" + Thread.currentThread().getName());
        }
        return wright();
    }


    public String wright(){
        String resault = "";
        lock.writeLock().lock();
        try {
            resault = redisTemplate.opsForValue().get(key);
            System.out.println("****--写锁进入后重新开始读取Redis信息是:" + resault + " " + Thread.currentThread().getName());
            if (StringUtils.isNotBlank(resault)) {
                System.out.println("已经有其他线程，抢到锁写好了直接退出" + Thread.currentThread().getName());
                return resault;
            }
            System.out.println("---开始写锁" + Thread.currentThread().getName());
            resault = "存储的value信息"; //开始读取数据库内容
            redisTemplate.opsForValue().set(key, resault);
        } catch (Exception e) {
            log.error("报错2", e);
        } finally {
            lock.writeLock().unlock();
            System.out.println("---释放写锁" + Thread.currentThread().getName());
        }
        return resault;
    }
}

测试redis缓存的读取操作

@Slf4j
@SpringBootTest
class SpringCloudStreamBinderIbmMqPointTestApplicationTests {
    @Autowired
    private RedisSet redisSet;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Test
    void contextLoads() {
    //保证数据库没这个数据
        redisTemplate.delete("testValue");
        //for循环创建两个线程去读取，同时两个线程重复读取
        for (int i = 0; i < 2; i++){

            Thread thread = new Thread(() -> {
                for (int j = 0; j < 3; j++) {
                    System.out.println("调用获取redis信息是" + redisSet.setRedis() + "" + Thread.currentThread().getName());
                }
            });
            thread.start();
        }
    }


}

最终效果图

分析，只有一步进行写数据库读取并存储redis的操作，并行线程不会进行重复读表写的操作。