SpringBootMyBatis自定义Redis二级缓存

SpringBootMyBatis自定义Redis二级缓存

• pom.xml导入依赖

     <!--SpringWeb Test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--文件支持-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>

        <!--MySQL & MyBatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--Junit测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--集成Redis二级缓存-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
 		<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>

• UserDefineRedisCache实现

import com.baizhi.ApplicationContextHolder;
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;

/**
 * 类的作用：
 * 版本：bj1.0
 * 作者：zyk
 * 创建时间:2020/11/9/19:08
 */
public class UserDefineRedisCache implements Cache {
    private static final Logger logger =
            LoggerFactory.getLogger(UserDefineRedisCache.class);
    //记录的是Mppper的Namespace
    private String id;
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private RedisTemplate redisTemplate = (RedisTemplate)
            ApplicationContextHolder.getBean("redisTemplate");

    public UserDefineRedisCache(String id) {
        this.id = id;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void putObject(Object key, Object value) {
        logger.debug("将查询结果缓存到Redis");
        ValueOperations opsForValue = redisTemplate.opsForValue();
        opsForValue.set(key, value, 30, TimeUnit.MINUTES);
    }

    @Override
    public Object getObject(Object key) {
        logger.debug("获取缓存结果");
        ValueOperations opsForValue = redisTemplate.opsForValue();
        return opsForValue.get(key);
    }

    @Override
    public Object removeObject(Object key) {
        logger.debug("删除Redis中的Key:" + key);
        ValueOperations opsForValue = redisTemplate.opsForValue();
        Object value = opsForValue.get(key);
        redisTemplate.delete(key);
        return value;
    }

    @Override
    public void clear() {
        logger.debug("删除所有Redis中的缓存");
        redisTemplate.execute((RedisCallback) connection -> {
            connection.flushDb();
            return null;
        });
    }

    @Override
    public int getSize() {
        return 0;
    }

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

}

ApplicationContextHolder.java 和入口类放在同级目录

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * 类的作用：
 * 版本：bj1.0
 * 作者：zyk
 * 创建时间:2020/11/9/19:14
 * 该接口为标记接口，Spring工厂在初始化的时，会自动注入applicationContext
 */
@Component
public class ApplicationContextHolder implements ApplicationContextAware {
    private static ApplicationContext applicationContex;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContex=applicationContext;
    }
    public static Object getBean(String beanName){

        return applicationContex.getBean(beanName);
    }
}

UserDAO.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.baizhi.dao.IUserDAO">
    <!-- 开启二级缓存 -->
    <cache type="com.baizhi.cache.UserDefineRedisCache">
        <property name="timeout" value="60"/>
    </cache>

    <insert id="saveUser" parameterType="User" useGeneratedKeys="true"  keyProperty="id">
        insert into t_user(name,password,sex,birthDay,photo,email)values(#{name},#{password},#{sex},#{birthDay},#{photo},#{email})
    </insert>

    <update id="updateUser" parameterType="User" >
        update t_user set name=#{name},sex=#{sex},birthDay=#{birthDay},photo=#{photo},email=#{email} where id=#{id}
    </update>

    <delete id="deleteByUserId" parameterType="int">
        delete from t_user where id=#{id}
    </delete>

    <select id="queryUserByPage" resultType="User">
        select id,name,sex,birthDay,photo ,email from t_user  <if test="column != null"> where  ${column} like '%${value}%' </if> limit ${pageSize} offset ${(pageNow-1)*pageSize}
    </select>

    <select id="queryCount" resultType="int">
        select count(*) from t_user  <if test="column != null"> where  ${column} like '%${value}%' </if>
    </select>

    <select id="queryUserById" resultType="User">
        select id,name,sex,birthDay,photo ,email from t_user where id=#{id}
    </select>
    <select id="queryUserByNameAndPassword" resultType="User">
        select id,name,sex,birthDay,photo ,email from t_user where name=#{name} and password=#{password}
    </select>

    <select id="queryCountByUserName" resultType="int">
        select count(id) from t_user where name=#{name}
    </select>

</mapper>

启动类或入口类

import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.annotation.MapperScans;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.web.client.RestTemplate;

import java.net.UnknownHostException;

@SpringBootApplication
@MapperScans(value ={
        @MapperScan(basePackages = "com.baizhi.dao")
})
public class UserModelApplication {

	public static void main(String[] args) {
		SpringApplication.run(UserModelApplication.class, args);
	}
    //SpringMVC中自带的一个Rest客户端工具，可以无缝和SpringBoot集成
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

   @Bean
    public RedisTemplate<Object, Object> redisTemplate(LettuceConnectionFactory connectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        //设置Key、value的序列化
        redisTemplate.setKeySerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

}

附录 logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender" >
        <encoder>
            <pattern>%p %c#%M %d{yyyy-MM-dd HH:mm:ss} %m%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
　　　　　　<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
　　　　　　　　　<fileNamePattern>logs/userLoginFile-%d{yyyyMMdd}.log</fileNamePattern>
　　　　　　　　　<maxHistory>30</maxHistory>
　　　　　　</rollingPolicy>
　　　　　　<encoder>
　　　　　　　　　<pattern>%p %c#%M %d{yyyy-MM-dd HH:mm:ss} %m%n</pattern>
                 <charset>UTF-8</charset>
　　　　　　</encoder>
    </appender>

    <!-- 控制台输出日志级别 -->
    <root level="ERROR">
        <appender-ref ref="STDOUT" />
    </root>

    <logger name="org.springframework.jdbc" level="DEBUG" additivity="false">
        <appender-ref ref="STDOUT" />
    </logger>
    <logger name="com.baizhi.dao" level="TRACE" additivity="false">
        <appender-ref ref="STDOUT" />
    </logger>
    <logger name="com.baizhi.cache" level="DEBUG" additivity="false">
        <appender-ref ref="STDOUT" />
    </logger>
</configuration>

application.properties

# 配置Redis链接
#主机名或ip
spring.redis.host=CentOSB 
#端口号
spring.redis.port=6379
spring.redis.timeout=5s
spring.redis.lettuce.shutdown-timeout=100ms
spring.redis.lettuce.pool.max-active=10
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.max-wait=5ms
spring.redis.lettuce.pool.min-idle=1