SpringBoot使用Redis做查询集中缓存（MyBatis二级缓存采用Redis配置）

首先必须的配置：yml和pom.xml

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>

#数据库连接属性配置
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/hospital?serverTimezone=Asia/Shanghai
    username: root
    password: 614
#security配置
  jackson:
    serialization:
      indent_output: true
#Redis配置
  redis:
    host: 127.0.0.1
    port: 6379
    #Redis连接池配置
    jedis:
      pool:
        min-idle: 0
        max-idle: 8
        max-active: 8
        max-wait: -1ms
#mybatis实体类名
mybatis:
  type-aliases-package: top.yibobo.hospital.domain
  configuration:
  #到下划线的表字段自动映射成驼峰命名法
    map-underscore-to-camel-case: true
  mapper-locations: classpath:mybatis/mapper/*.xml
#设置服务器端口号/session保存时长
server:
  port: 8086
#定义日志文件路径
logging:
  file: logs/all.log
  level:
    org.springframework.security: info
    top.yibobo.hospital.mapper: debug
    top.yibobo.hospital.util: debug
#JWT配置
jwt:
  header: Authorization #请求头部属性名
  secret: mySecret #自定义口令
  expiration: 604800 #token失效时间
  route: #访问路径
      authentication:
        path: /auth
        refresh: /refresh

 
 
这个时候需要在总启动类的类上写上该注释:@EnableCaching，使用Redis缓存
然后写一个缓存类，实现MyBatis的二级缓存，就是实现org.apache.ibatis.cache.Cache类
我已经写好了，放上来吧:
最重要的类！！！

package top.yibobo.hospital.util;
import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/*
使用Redis实现MyBatis的二级缓存
 */
public class RedisCache implements Cache{
    //日志记录器定义
    private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);
    //缓存对象唯一标识
    private final String id;
    //用于事务缓存对象的读写锁
    private static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //用于将缓存对象写入Redis的模板对象
    private RedisTemplate redisTemplate;
    //缓存对象失效时间
    private static final long EXPRIRE_TIME_IN_MINUT=30;
    public RedisCache(String id){
        if (id==null){
            throw new IllegalArgumentException("缓存对象ID不能为空");
        }
        this.id = id;
    }
    @Override
    public String getId() {
        return this.id;
    }
    /*
        保存缓存对象的方法
     */
    @Override
    public void putObject(Object key, Object value) {
        try{
            RedisTemplate redisTemplate = getRedisTemplate();
            //得到值操作对象
            ValueOperations operations = redisTemplate.opsForValue();
            //通过值操作对象set缓存对象
            operations.set(key,value,EXPRIRE_TIME_IN_MINUT, TimeUnit.MINUTES);
            logger.debug("缓存对象保存成功啦！！！");
        }catch (Throwable t){
            logger.error("缓存对象保存失败"+t);
        }
    }
    /*
        获取缓存对象的方法
     */
    @Override
    public Object getObject(Object key) {
        try{
            RedisTemplate redisTemplate = getRedisTemplate();
            //得到值操作对象
            ValueOperations operations = redisTemplate.opsForValue();
            Object obj =  operations.get(key);
            logger.debug("获取缓存对象成功");
            return obj;
        }catch (Throwable t){
            logger.error("缓存对象获取失败"+t);
            return null;
        }
    }
    /*
        删除缓存对象
     */
    @Override
    public Object removeObject(Object key) {
        try{
            RedisTemplate redisTemplate = getRedisTemplate();
            redisTemplate.delete(key);
            logger.debug("删除缓存对象成功");
        }catch (Throwable t){
            logger.error("删除缓存对象失败"+t);
        }
        return null;
    }
    /*
        清空所有缓存对象
     */
    @Override
    public void clear() {
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.execute((RedisCallback)collection ->{
            collection.flushDb();
            return null;
        });
        logger.debug("清空缓存对象成功~");
    }
    @Override
    public int getSize() {
        return 0;
    }
    @Override
    public ReadWriteLock getReadWriteLock(){
        return readWriteLock;
    }
    private RedisTemplate getRedisTemplate(){
        if (redisTemplate==null){
            redisTemplate = ApplicationContextHolder.getBean("redisTemplate");
        }
        return redisTemplate;
    }
}

 
此时弄完的话，可以说是已经大功告成了！！，可是还需要指定哪个东西需要使用
有两种方式:
 
第一种、在MyBatis使用注解配置的类上面定义类注解:
@CacheNamespace(implementation = 你写的缓存类.class)
这种只会在该类下已写好注解 Sql语句的(@Select)才会采用。该类下没有定义注解Sql的是不会使用Redis缓存的。
 
第二种、在对应类的Mapper.xml文件配置
加上一句话: type属性=写你写好的缓存类（全名）
比如:
<cache type=”top.yibobo.hospital.util.RedisCache” />
这种的Redis缓存只会生效在Mapper.xml中定义好的Sql语句上。
 
 
这两种各需所需。有的方法及时性要求比较强的（比如用户登陆、密码修改），最好别用缓存