实现缓存与数据库双写一致性保障
pox文件：
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.5.RELEASE</version>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.2.2</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.2.8</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.1.43</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestone</id>
<url>https://repo.spring.io/libs-release</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-milestone</id>
<url>https://repo.spring.io/libs-release</url>
</pluginRepository>
</pluginRepositories>
Application：
import java.util.HashSet;
import java.util.Set;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.tomcat.jdbc.pool.DataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.embedded.ServletListenerRegistrationBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import com.roncoo.eshop.inventory.listener.InitListener;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
@EnableAutoConfiguration //自动载入应用程序所需的所有Bean
@SpringBootApplication //启动的类
@ComponentScan //扫描包
@MapperScan("com.roncoo.eshop.inventory.mapper")
//启动入口函数
public class Application {
//构建数据源
@Bean
@ConfigurationProperties(prefix="spring.datasource")
public DataSource dataSource() {
return new DataSource();
}
//构建MyBatis的入口类：SqlSessionFactory
@Bean
public SqlSessionFactory sqlSessionFactoryBean1() throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource());
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:/mybatis/*.xml"));
return sqlSessionFactoryBean.getObject();
}
//构建事务管理器
@Bean
public PlatformTransactionManager transactionManager() {
return new DataSourceTransactionManager(dataSource());
}
@Bean
public JedisCluster JedisClusterFactory() {
Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
jedisClusterNodes.add(new HostAndPort("192.168.31.19", 7003));
jedisClusterNodes.add(new HostAndPort("192.168.31.19", 7004));
jedisClusterNodes.add(new HostAndPort("192.168.31.227", 7006));
JedisCluster jedisCluster = new JedisCluster(jedisClusterNodes);
return jedisCluster;
}
//注册监听器 线程池+内存队列初始化
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public ServletListenerRegistrationBean servletListenerRegistrationBean(){
ServletListenerRegistrationBean servletListenerRegistrationBean=
new ServletListenerRegistrationBean();
//添加listener
servletListenerRegistrationBean.setListener(new InitListener());
return servletListenerRegistrationBean;
}
//SpringBoot 启动入口的方法
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
更新数据的时候，根据数据的唯一标识，将操作路由之后，发送到一个jvm内部的队列中
读取数据的时候，如果发现数据不在缓存中，那么将重新读取数据+更新缓存的操作，根据唯一标识路由之后，也发送同一个jvm内部的队列中
一个队列对应一个工作线程
每个工作线程串行拿到对应的操作，然后一条一条的执行
这样的话，一个数据变更的操作，先执行，删除缓存，然后再去更新数据库，但是还没完成更新
此时如果一个读请求过来，读到了空的缓存，那么可以先将缓存更新的请求发送到队列中，此时会在队列中积压，然后同步等待缓存更新完成
这里有一个优化点，一个队列中，其实多个更新缓存请求串在一起是没意义的，因此可以做过滤，如果发现队列中已经有一个更新缓存的请求了，
那么就不用再放个更新请求操作进去了，直接等待前面的更新操作请求完成即可
待那个队列对应的工作线程完成了上一个操作的数据库的修改之后，才会去执行下一个操作，也就是缓存更新的操作，此时会从数据库中读取最新的值，然后写入缓存中
如果请求还在等待时间范围内，不断轮询发现可以取到值了，那么就直接返回; 如果请求等待的时间超过一定时长，那么这一次直接从数据库中读取当前的旧值
具体实现步骤：
1、线程池+内存队列初始化
ServletContextListener里面做，listener，会跟着整个web应用的启动，就初始化，类似于线程池初始化的构建
spring boot应用，Application，搞一个listener的注册
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import com.roncoo.eshop.inventory.thread.RequestProcessorThreadPool;
//系统初始化监听器
public class InitListener implements ServletContextListener{
@Override
public void contextInitialized(ServletContextEvent sce){
// 初始化工作线程池和内存队列
RequestProcessorThreadPool.init();
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
}
}
请求接口：
public interface Request {
void process();
Integer getProductId();
boolean isForceRefresh();
}
请求队列：
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
//请求内存队列
public class RequestQueue {
//内存队列
private List<ArrayBlockingQueue<Request>> queues=
new ArrayList<ArrayBlockingQueue<Request>>();
//标示位map
private Map<Integer, Boolean> flagMap =new ConcurrentHashMap<Integer,Boolean>();
//采用线程安全的方式实现单例
//静态内部类的方法，去初始化单例
private static class Singleton{
private static RequestQueue instance;
static{
instance=new RequestQueue();
}
public static RequestQueue getInstance(){
return instance;
}
}
//jvm的机制，保证多线程并发安全
//内部类的初始化 ，一定只发生一次，不管多少个线程并发去初始化
public static RequestQueue getInstance(){
return Singleton.getInstance();
}
//添加一个内存队列
public void addQueue(ArrayBlockingQueue<Request> queue){
this.queues.add(queue);
}
//获取内存队列的数量
public int queueSize(){
return queues.size();
}
//获取内存队列
public ArrayBlockingQueue<Request> getQueue(int index){
return queues.get(index);
}
public Map<Integer, Boolean> getFlagMap(){
return flagMap;
}
}
执行请求的工作线程：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import com.roncoo.eshop.inventory.request.ProductInventoryCacheRefreshRequest;
import com.roncoo.eshop.inventory.request.ProductInventoryDBUpdateRequest;
import com.roncoo.eshop.inventory.request.Request;
import com.roncoo.eshop.inventory.request.RequestQueue;
import java.util.Map;
//执行请求的工作线程
public class RequestProcessorThread implements Callable<Boolean> {
//自己监控的内存队列
private ArrayBlockingQueue<Request> queue;
//初始化的方法
public RequestProcessorThread(ArrayBlockingQueue<Request> queue) {
this.queue = queue;
}
//请求处理封装
public Boolean call() throws Exception{
try {
while(true) {
// ArrayBlockingQueue
// Blocking就是说明，如果队列满了，或者是空的，那么都会在执行操作的时候，阻塞住
Request request=queue.take();
boolean forceRfresh=request.isForceRefresh();
//先做读请求的去重
if(!forceRfresh){
RequestQueue requestQueue=RequestQueue.getInstance();
Map<Integer,Boolean> flagMap=requestQueue.getFlagMap();
if(request instanceof ProductInventoryDBUpdateRequest){
// 如果是一个更新数据库的请求，那么就将那个productId对应的标识设置为true
flagMap.put(request.getProductId(), true);
}else if(request instanceof ProductInventoryCacheRefreshRequest){
Boolean flag=flagMap.get(request.getProductId());
//如果flag是null
if(flag==null){
flagMap.put(request.getProductId(), false);
}
// 如果是缓存刷新的请求，那么就判断，如果标识不为空，而且是true，就说明之前有一个这个商品的数据库更新请求
if(flag!=null&&flag){
flagMap.put(request.getProductId(), false);
}
// 如果是缓存刷新的请求，而且发现标识不为空，但是标识是false
// 说明前面已经有一个数据库更新请求+一个缓存刷新请求了
if(flag!=null&&!flag){
// 对于这种读请求，直接就过滤掉，不要放到后面的内存队列里面去了
return true;
}
}
}
// 执行这个request操作
request.process();
}
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
}
请求处理的线程池：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.roncoo.eshop.inventory.request.Request;
import com.roncoo.eshop.inventory.request.RequestQueue;
//请求处理线程池：单例
public class RequestProcessorThreadPool {
// 在实际项目中，你设置线程池大小是多少，每个线程监控的那个内存队列的大小是多少
// 都可以做到一个外部的配置文件中
// 直接写死了
//线程池
private ExecutorService threadPool=Executors.newFixedThreadPool(10);
//构造函数
public RequestProcessorThreadPool(){
RequestQueue requestQueue =RequestQueue.getInstance();
for(int i=0;i<10;i++){
ArrayBlockingQueue<Request> queue=new ArrayBlockingQueue<Request>(100);
requestQueue.addQueue(queue);
threadPool.submit(new RequestProcessorThread(queue));
}
}
//静态内部类的方式去初始化线程的方式
public static class Singleton{
private static RequestProcessorThreadPool instance;
static{
instance=new RequestProcessorThreadPool();
}
public static RequestProcessorThreadPool getInstance(){
return instance;
}
}
//jvm的方式去保证多线程并发安全
//内部类的初始化，一定只发生一次，不管多少个线程并发初始化
public static RequestProcessorThreadPool getInstance(){
return Singleton.getInstance();
}
//初始化的便捷方法
public static void init(){
getInstance();
}
}
请求的响应：
//请求的响应
public class Response {
public static final String SUCCESS = "success";
public static final String FAILURE = "failure";
private String status;
private String message;
public Response() {
}
public Response(String status) {
this.status = status;
}
public Response(String status, String message) {
this.status = status;
this.message = message;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
2、两种请求对象封装
import com.roncoo.eshop.inventory.model.ProductInventory;
import com.roncoo.eshop.inventory.service.ProductInventoryService;
/**
* 比如说一个商品发生了交易，那么就要修改这个商品对应的库存
* 此时就会发送请求过来，要求修改库存，那么这个可能就是所谓的data update request，数据更新请求
* cache aside pattern
* （1）删除缓存
* （2）更新数据库
* **/
//请求对象的封装，删除redis的缓存，修改数据库中的库存
public class ProductInventoryDBUpdateRequest implements Request{
// 商品库存
private ProductInventory productInventory;
//商品库存Service
private ProductInventoryService productInventoryService;
public ProductInventoryDBUpdateRequest(ProductInventory productInventory,
ProductInventoryService productInventoryService){
this.productInventory=productInventory;
this.productInventoryService=productInventoryService;
}
@Override
public void process(){
// 删除redis中的缓存
productInventoryService.removeProductInventoryCache(productInventory);
// 修改数据库中的库存
productInventoryService.updateProductInventory(productInventory);
}
//获取商品id
public Integer getProductId(){
return productInventory.getProductId();
}
@Override
public boolean isForceRefresh() {
return false;
}
}
import com.roncoo.eshop.inventory.model.ProductInventory;
import com.roncoo.eshop.inventory.service.ProductInventoryService;
//重新加载商品库存的缓存(请求对象的封装)
public class ProductInventoryCacheRefreshRequest implements Request {
//商品id
private Integer productId;
//商品库存Service
private ProductInventoryService productInventoryService;
//是否强制刷新缓存
private boolean forceRefresh;
public ProductInventoryCacheRefreshRequest(Integer productId,
ProductInventoryService productInventoryService,
boolean forceRefresh) {
this.productId=productId;
this.productInventoryService=productInventoryService;
this.forceRefresh=forceRefresh;
}
@Override
public void process() {
// 从数据库中查询最新的商品库存数量
ProductInventory productInventory = productInventoryService.findProductInventory(productId);
// 将最新的商品库存数量，刷新到redis缓存中去
productInventoryService.setProductInventoryCache(productInventory);
}
//返回商品的id
public Integer getProductId() {
return productId;
}
public boolean isForceRefresh() {
return forceRefresh;
}
}
3、请求异步执行Service封装
import java.util.concurrent.ArrayBlockingQueue;
import org.springframework.stereotype.Service;
import com.roncoo.eshop.inventory.request.Request;
import com.roncoo.eshop.inventory.request.RequestQueue;
import com.roncoo.eshop.inventory.service.RequestAsyncProcessService;
//请求异步处理的service实现
@Service("requestAsyncProcessService")
public class RequestAsyncProcessServiceImpl implements RequestAsyncProcessService{
//做请求的的路由，根据每个请求的商品id，路由到对应的内存队列中
@Override
public void process(Request request) {
try {
// 做请求的路由，根据每个请求的商品id，路由到对应的内存队列中去
ArrayBlockingQueue<Request> queue = getRoutingQueue(request.getProductId());
// 将请求放入对应的队列中，完成路由操作
queue.put(request);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取路由到的内存队列
private ArrayBlockingQueue<Request> getRoutingQueue(Integer productId){
RequestQueue requestQueue=RequestQueue.getInstance();
//获取productId的hash值
String key=String.valueOf(productId);
int h;
int hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
// 对hash值取模，将hash值路由到指定的内存队列中，比如内存队列大小8
// 用内存队列的数量对hash值取模之后，结果一定是在0~7之间
// 任何一个商品id都会被固定路由到同样的一个内存队列中去的
int index=(requestQueue.queueSize()-1)&hash;
return requestQueue.getQueue(index);
}
}
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.roncoo.eshop.inventory.dao.RedisDAO;
import com.roncoo.eshop.inventory.mapper.ProductInventoryMapper;
import com.roncoo.eshop.inventory.model.ProductInventory;
import com.roncoo.eshop.inventory.service.ProductInventoryService;
//商品库存Service实现类
@Service("productInventoryService")
public class ProductInventoryServiceImpl implements ProductInventoryService {
@Resource
private ProductInventoryMapper productInventoryMapper;
@Resource
private RedisDAO redisDAO;
@Override
public void updateProductInventory(ProductInventory productInventory) {
productInventoryMapper.updateProductInventory(productInventory);
}
@Override
public void removeProductInventoryCache(ProductInventory productInventory){
String key="product:inventory:"+productInventory.getProductId();
redisDAO.delete(key);
}
//根据商品id查询商品库存
public ProductInventory findProductInventory(Integer productId) {
return productInventoryMapper.findProductInventory(productId);
}
//设置商品库存的缓存
public void setProductInventoryCache(ProductInventory productInventory){
String key = "product:inventory:" + productInventory.getProductId();
redisDAO.set(key, String.valueOf(productInventory.getInventoryCnt()));
}
// 获取商品库存的缓存
public ProductInventory getProductInventoryCache(Integer productId){
Long inventoryCnt = 0L;
String key="product:inventory:" + productId;
String result=redisDAO.get(key);
if(result!=null&&!"".equals(result)){
try {
inventoryCnt = Long.valueOf(result);
return new ProductInventory(productId, inventoryCnt);
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
}
import com.roncoo.eshop.inventory.request.Request;
//请求异步执行的server
public interface RequestAsyncProcessService {
void process(Request request);
}
import com.roncoo.eshop.inventory.model.ProductInventory;
public interface ProductInventoryService {
/**
* 更新商品库存
* @param productInventory 商品库存
*/
void updateProductInventory(ProductInventory productInventory);
/**
* 删除Redis中的商品库存的缓存
* @param productInventory 商品库存
*/
void removeProductInventoryCache(ProductInventory productInventory);
/**
* 根据商品id查询商品库存
* @param productId 商品id
* @return 商品库存
*/
ProductInventory findProductInventory(Integer productId);
/**
* 设置商品库存的缓存
* @param productInventory 商品库存
*/
void setProductInventoryCache(ProductInventory productInventory);
/**
* 获取商品库存的缓存
* @param productId
* @return
*/
ProductInventory getProductInventoryCache(Integer productId);
}
控制器：
import com.roncoo.eshop.inventory.model.ProductInventory;
import com.roncoo.eshop.inventory.request.ProductInventoryCacheRefreshRequest;
import com.roncoo.eshop.inventory.request.ProductInventoryDBUpdateRequest;
import com.roncoo.eshop.inventory.request.Request;
import com.roncoo.eshop.inventory.service.ProductInventoryService;
import com.roncoo.eshop.inventory.service.RequestAsyncProcessService;
import com.roncoo.eshop.inventory.vo.Response;
//商品库存Controller
/*
*（1）一个更新商品库存的请求过来，然后此时会先删除redis中的缓存，然后模拟卡顿5秒钟
*（2）在这个卡顿的5秒钟内，我们发送一个商品缓存的读请求，因为此时redis中没有缓存，就会来请求将数据库中最新的数据刷新到缓存中
*（3）此时读请求会路由到同一个内存队列中，阻塞住，不会执行
*（4）等5秒钟过后，写请求完成了数据库的更新之后，读请求才会执行
*（5）读请求执行的时候，会将最新的库存从数据库中查询出来，然后更新到缓存中
* */
public class ProductInventoryController {
@Resource
private RequestAsyncProcessService requestAsyncProcessService;
@Resource
private ProductInventoryService productInventoryService;
//更新商品库存
@RequestMapping("/updateProductInventory")
@ResponseBody
public Response updateProductInventory(ProductInventory productInventory){
Response response=null;
try{
Request request=new ProductInventoryDBUpdateRequest(
productInventory, productInventoryService);
requestAsyncProcessService.process(request);
response = new Response(Response.SUCCESS);
}
catch (Exception e) {
e.printStackTrace();
response = new Response(Response.FAILURE);
}
return response;
}
//获取商品库存
@RequestMapping("/getProductInventory")
@ResponseBody
public ProductInventory getProductInventory(Integer productId){
ProductInventory productInventory = null;
try{
Request request = new ProductInventoryCacheRefreshRequest(
productId, productInventoryService, false);
requestAsyncProcessService.process(request);
requestAsyncProcessService.process(request);
// 将请求扔给service异步去处理以后，就需要while(true)一会儿，在这里hang住
// 去尝试等待前面有商品库存更新的操作，同时缓存刷新的操作，将最新的数据刷新到缓存中
long startTime = System.currentTimeMillis();
long endTime = 0L;
long waitTime = 0L;
// 等待超过200ms没有从缓存中获取到结果
while(true){
if(waitTime>200){
break;
}
// 尝试去redis中读取一次商品库存的缓存数据
productInventory =productInventoryService.getProductInventoryCache(productId);
// 如果读取到了结果，那么就返回
if(productInventory != null) {
return productInventory;
}
// 如果没有读取到结果，那么等待一段时间
else {
Thread.sleep(20);
endTime = System.currentTimeMillis();
waitTime = endTime - startTime;
}
}
// 直接尝试从数据库中读取数据
productInventory = productInventoryService.findProductInventory(productId);
if(productInventory != null) {
// 将缓存刷新一下
productInventoryService.setProductInventoryCache(productInventory);
return productInventory;
}
} catch (Exception e) {
e.printStackTrace();
}
return new ProductInventory(productId, -1L);
}
}
public interface RedisDAO {
void set(String key, String value);
String get(String key);
void delete(String key);
}
import javax.annotation.Resource;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.JedisCluster;
import com.roncoo.eshop.inventory.dao.RedisDAO;
@Repository("redisDAO")
public class RedisDAOImpl implements RedisDAO {
@Resource
private JedisCluster jedisCluster;
@Override
public void set(String key, String value) {
jedisCluster.set(key, value);
}
@Override
public String get(String key) {
return jedisCluster.get(key);
}
@Override
public void delete(String key) {
jedisCluster.del(key);
}
}
6、读请求去重优化
如果一个读请求过来，发现前面已经有一个写请求和一个读请求了，那么这个读请求就不需要压入队列中了
因为那个写请求肯定会更新数据库，然后那个读请求肯定会从数据库中读取最新数据，然后刷新到缓存中，自己只要hang一会儿就可以从缓存中读到数据了
7、空数据读请求过滤优化
可能某个数据，在数据库里面压根儿就没有，那么那个读请求是不需要放入内存队列的，而且读请求在controller那一层，直接就可以返回了，不需要等待
如果数据库里都没有，就说明，内存队列里面如果没有数据库更新的请求的话，一个读请求过来了，就可以认为是数据库里就压根儿没有数据吧
如果缓存里没数据，就两个情况，第一个是数据库里就没数据，缓存肯定也没数据; 第二个是数据库更新操作过来了，先删除了缓存，此时缓存是空的，但是数据库里是有的
但是的话呢，我们做了之前的读请求去重优化，用了一个flag map，只要前面有数据库更新操作，flag就肯定是存在的，你只不过可以根据true或false，判断你前面执行的是写请求还是读请求
但是如果flag压根儿就没有呢，就说明这个数据，无论是写请求，还是读请求，都没有过
那这个时候过来的读请求，发现flag是null，就可以认为数据库里肯定也是空的，那就不会去读取了
或者说，我们也可以认为每个商品有一个最最初始的库存，但是因为最初始的库存肯定会同步到缓存中去的，有一种特殊的情况，就是说，商品库存本来在redis中是有缓存的
但是因为redis内存满了，就给干掉了，但是此时数据库中是有值得
那么在这种情况下，可能就是之前没有任何的写请求和读请求的flag的值，此时还是需要从数据库中重新加载一次数据到缓存中的
