使用Redis替换MyBatis的二级缓存

使用Redis替换MyBatis的二级缓存

Mybatis二级缓存的缺陷

• 服务器重启后，缓存会丢失。

• Mybatis运行在tomcat容器中，缓存在tomcat容器中。mybatis的二级缓存在集群或者分布式条件下无法共享。

MyBatis的默认缓存是由PerpetualCache类来实现的，我们可以模仿他，实现一个，以redis作为缓存的自定义缓存类；

第一步：先搭建一个SpringBoot项目

项目结构

第二步：连接数据库，并逆向生成

• 表

逆向生成mapper接口，参考：https://www.cnblogs.com/MLYR/p/14529663.html

第三步：编写Controller

package com.mlyr.controller;

import com.mlyr.mapper.EmpMapper;
import com.mlyr.pojo.Emp;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

/**
 * @Description:
 * @Author: 陌路邑人
 * @CreateTime: 2021/3/13
 * @Company:
 */
@RestController
@Slf4j
public class EmpController {
    @Resource
    private EmpMapper empMapper;

    //根据id查询
    @GetMapping("emp/{empno}")
    public Emp findById(@PathVariable Integer empno){
        Emp emp = empMapper.selectByPrimaryKey(empno);
        log.debug("EMP==="+emp);
        return emp;
    }
    //查询所有
    @GetMapping("emp")
    public  List<Emp> findAll(){
        List<Emp> empList = empMapper.selectByExample(null);
        log.debug("empList==="+empList);
        return empList;
    }
    //增加
    @PostMapping("emp")
    public  String  addEmp(Emp emp){
        int f = empMapper.insertSelective(emp);
        log.debug("添加==="+f);
        return "添加"+f;
    }
    //修改
    @PutMapping("emp")
    public  String  update(Emp emp){
        int f = empMapper.updateByPrimaryKeySelective(emp);
        log.debug("修改==="+f);
        return "修改"+f;
    }
    //删除
    @DeleteMapping("emp/{empno}")
    public  String  deleteByEmpno(@PathVariable Integer empno){
        int f = empMapper.deleteByPrimaryKey(empno);
        log.debug("删除==="+f);
        return "删除"+f;
    }
}

第四步：开启Mybatis二级缓存

application.yml

spring:
  #配置spring连接mybatis数据库
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/demo?characterEncoding=UTF-8
    username: root
    password: root
  #配置缓存
  cache:
    type: redis
#配置日志输出
logging:
  level:
    root: error
    com:
      mlyr: debug

在EmpMapper.xml中添加

<!--开启二级缓存，指定缓存为自定义的缓存类-->
<cache type="com.mlyr.tools.MyCache" />

第五步：编写自定义织入类

• 就是为了获取Spring中封装的RedisTemplate

package com.mlyr.autowird;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * @Description:
 * @Author: 陌路邑人
 * @CreateTime: 2021/3/13
 * @Company:    自定义织入类，为了获取RedisTemplate
 */
//
@Component
public class MyContextAware implements ApplicationContextAware {

    private static ApplicationContext act;
    //获取一个Spring容器对象
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        act = applicationContext;
    }
    //创建一个静态方法，按照name获取容器中的Bean对象
    public static Object getBean(String name){
        return act.getBean(name);
    }
}

第六步：实现自定义缓存类

package com.mlyr.tools;
import com.mlyr.autowird.MyContextAware;
import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.impl.PerpetualCache;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * @Description:
 * @Author: 陌路邑人
 * @CreateTime: 2021/3/13
 * @Company:
 */
//作为MyBatis的自定义缓存，不能让Spring容器托管
public class MyCache implements Cache {
    //但是又要使用RedisTemplate用来操作redis
    private RedisTemplate redisTemplate;
    private String id;
    private ReentrantReadWriteLock lock;//读写锁,每次读写前要加锁，防止脏读
    //只能通过织入类获取RedisTemplate
    public MyCache(String id) {
        this.id = id;
        this.redisTemplate = (RedisTemplate) MyContextAware.getBean("redisTemplate");
        lock = new ReentrantReadWriteLock();
    }
    //缓存标识
    @Override
    public String getId() {
        return id;
    }
    //放入缓存一次，它会调用一次clear()，清除所有的缓存
    // 将数据库中查出来的数据，放入redis数据库中
    @Override
    public void putObject(Object key, Object value) {
        try {
            lock.writeLock().lock();
            System.out.println("放入缓存===【"+key+"】【"+value+"】");
            redisTemplate.opsForHash().put(id,key,value);
             int num = 60 + new Random().nextInt(60);
            //设置过期时间，只能针对于namespace命名空间进行过期时间
            redisTemplate.expire(id,num, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }
    }
    //获取缓存中的值，根据key
    @Override
    public Object getObject(Object key) {
        try {
            lock.readLock().lock();
            System.out.println("获取缓存中的值，根据key==="+key);
            return redisTemplate.opsForHash().get(id,key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
        return null;
    }
    //删除key的缓存
    @Override
    public Object removeObject(Object key) {
        try {
            lock.writeLock().lock();
            System.out.println("删除key的缓存"+key);
            return redisTemplate.opsForHash().delete(id,key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
        return null;
    }
    //清空id下的所有缓存
    @Override
    public void clear() {
        try {
            lock.writeLock().lock();
            System.out.println("缓存大小==="+getSize());
            redisTemplate.delete(id);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
    //获取缓存的大小
    @Override
    public int getSize() {
        return new Integer(redisTemplate.opsForHash().size(id).toString());
    }
}

测试

当第一次访问所有的emp

• 
• 
• 

再次访问

• 

在进行添加一个emp时

• 
• 
• 

再次查询的时候，就会又在数据库中直接查询了

在进行删除、修改的操作时，和上面一样，都会清空缓存，防止脏读

注意点

• 当有多表联查的时候，比如上面的emp与dept，在进行查询所有的emp联查dept后，在进行修改dept数据，缓存中的emp并没有改变，这就产生了脏读！！！

解决多表之间的，另一张表改变，缓存脏读

• 首先在DeptMapper.xml中添加<cache></cache>
• 然后在EmpMapper.xml中引入dept的namespace<cache-ref namespace="com.mlyr.mapper.DeptMapper"></cache-ref>

就是相当于两个xml的缓存合在一起，一边的改变能够影响另一边的改变