铸键为犁

使用Redis做Mybatis的二级缓存

文章目录

前言
一、二级缓存
二、使用步骤
- 1.开启二级缓存
- 2.编写ApplicationContextHolder
- 3.编写RedisCache二级缓存工具类
- 4.在mapper.xml文件中开启全局二级缓存
- 5.配置RedisTemplate序列化工具类，实体也需要实现序列化接口
三、测试
总结

前言

本篇记录怎么使用Redis做Mybtais的缓存。

一、二级缓存

MyBatis中的缓存分为一级缓存和二级缓存

一级缓存：基于sqlSession的缓存
二级缓存：基于多个sqlSession 共享的namspace数据块

通常一个mapper 都一个namespace,所有的相关二级缓存都存在该namespace 数据块下
查询顺序：先去二级缓存，如果二级没有再去一级缓存，一级没有再去数据库
注意：在spring 配置的mybatis 中不存在一级缓存，二级缓存发生增删改，该namespace 下所有缓存数据立即清空，目的是为了避免有脏数据存在

二、使用步骤

创建项目，导入依赖和基本编码部分不再赘述

1.开启二级缓存

在配置文件yml中加入以下配置

代码如下：

    cache-enabled: true #使用缓存

2.编写ApplicationContextHolder

该类主要是为了在spring环境中获取非spring容器管理的bean

package com.lzl.secondcache;

import org.springframework.stereotype.Component;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.redis.core.RedisTemplate;
/**
 * 在spring中，只要实现或者继承xxAware接口或者类，在实例该对象时，
 * 会调用实现xxAware接口的类的方法，把参数传递
 */
/**
 * --效率，是成功的核心关键--
 * 在spring中获取非spring管理的bean对象
 * @Author lzl
 * @Date 2023/3/9 08:00
 */
@Component
public class ApplicationContextHolder implements ApplicationContextAware {

    //spring容器
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextHolder.applicationContext = applicationContext;
    }

    public static RedisTemplate getRedisTemplate(){
        return ApplicationContextHolder.applicationContext
                .getBean("redisTemplate",RedisTemplate.class);
    }
}

3.编写RedisCache二级缓存工具类

package com.lzl.secondcache;
import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;

import java.util.Set;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 数据查询顺序：二级缓存 -> 一级缓存 -> 数据库
 * 我们在mybatis中指定了二级缓存，在mybatis启动会生成Cache对象，
 * 如果在该类使用@Autowired注入RedisTemplate是无法注入的，需要使用spring注入
 */
/**
 * --效率，是成功的核心关键--
 *
 * @Author lzl
 * @Date 2023/3/9 08:02
 */

public class RedisCache implements Cache{
    //RedisTemplate对象
    private RedisTemplate redisTemplate;

    //id相当于当前sql对应的cache的命名空间 namespace="com.qf.mapper.xxxMapper"
    private String id;

    //读写锁：多线程中可以共享锁，如果大家都是读操作，提高数据的读的并发能力
    //如果有一个人进行了写操作，其他人都不能进行读写操作了
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //获取RedisTemplate对象
    public RedisTemplate getRedisTemplate(){
        //判断
        if(redisTemplate == null){
            synchronized (RedisCache.class){
                if(redisTemplate == null){
                    RedisTemplate redisTemplate = ApplicationContextHolder.getRedisTemplate();
                    //设置key使用string类型的序列化方式
                    redisTemplate.setKeySerializer(RedisSerializer.string());
                    return redisTemplate;
                }
                return this.redisTemplate;
            }

        }
        return redisTemplate;
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }

    //构造器
    public RedisCache(String id) {
        System.out.println("id："+id);
        this.id = id;
    }

    //id相当于当前sql对应的cache的命名空间
    @Override
    public String getId() {
        System.out.println("getId："+id);
        return id;
    }

    /**
     * 将结果放入缓存，当访问查询方法时调用，所以这里必须通过getRedisTemplate()方法来获取redisTemplate对象
     * @param key -> 命名空间 + sql + 参数 = 组成的字符串
     * @param value -> sql查询的结果
     */
    @Override
    public void putObject(Object key, Object value) {
        System.out.println("putObject中的key："+key);
        System.out.println("putObject中的value："+value);
        getRedisTemplate().opsForValue().set(key.toString(),value);
    }

    /**
     * 获取缓存中的数据，当访问查询方法时调用，所以这里必须通过getRedisTemplate()方法来获取redisTemplate对象
     * @param key
     * @return
     */
    @Override
    public Object getObject(Object key) {
        System.out.println("getObject："+key);
        return getRedisTemplate().opsForValue().get(key.toString());
    }

    /**
     * 从缓存中移除数据，当访问查询方法时调用，所以这里必须通过getRedisTemplate()方法来获取redisTemplate对象
     * @param key
     * @return
     */
    @Override
    public Object removeObject(Object key) {
        System.out.println("removeObject："+key);
        return getRedisTemplate().delete(key.toString());
    }

    /**
     * 清空缓存
     */
    @Override
    public void clear() {
        System.out.println("clear");
        Set keys = getRedisTemplate().keys("*" + id + "*");
        System.out.println("清空缓存keys："+keys);
        getRedisTemplate().delete(keys);
    }

    /**
     * 获取缓存数据长度
     * @return
     */
    @Override
    public int getSize() {
        Set keys = getRedisTemplate().keys("*" + id + "*");
        return keys.size();
    }

}

4.在mapper.xml文件中开启全局二级缓存

    
    
    <cache type="com.lzl.secondcache.RedisCache"/>

5.配置RedisTemplate序列化工具类，实体也需要实现序列化接口

package com.lzl.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * --效率，是成功的核心关键--
 *
 * @Author lzl
 * @Date 2023/3/9 08:05
 */
@Configuration
public class RedisConfig {

    /**
     * springboot 默认帮我们创建的RedisTemplate的key和value的序列化方式是jdk默认的方式,
     * 我们有时候手动向redis中添加的数据可能无法被查询解析出来,所以我们需要修改序列化方式
     * @param connectionFactory
     * @return
     */

    @Bean
    public RedisTemplate, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate, Object> redisTemplate = new RedisTemplate<>();
        // 配置连接工厂
        redisTemplate.setConnectionFactory(connectionFactory);

        // 使用StringRedisSerializer来序列化和反序列化Redis的key值
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // 使用Jackson2JsonRedisSerializer来序列化和反序列化Redis的value值
        Jackson2JsonRedisSerializer