mybatis使用redis做二级缓存

redis安装

springboot+mybatis搭建

maven

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
    </dependency>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

application.yml

spring:
  #DataSource
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shop?charset=utf8mb4&useSSL=false&serverTimezone=UTC
    username: root
    password: root
    #Hikari 数据源专用配置
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
#mybatis
mybatis:
  type-aliases-package: com.java.xrc.entity
  mapper-locations: classpath:mappers/*.xml

User

@Alias("user")
public class User implements Serializable {
    private Integer id;
    private String name;
    private String password;
    private String account;
	/get set ...
}

UserMapper

@Mapper
public interface UserMapper {
    Optional<User> getById(Integer id);
    Integer insert(User user);
}

UserMapper.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.java.xrc.dao.UserMapper">
    <select id="getById" parameterType="int" resultType="user">
        select id,name,password,account from user where id=#{id}
    </select>
    <insert id="insert" useGeneratedKeys="true"  keyProperty="id">
        insert into user (name,password,account) values (#{name},#{password},#{account})
    </insert>
</mapper>

使用redis做二级缓存

cache

使用mysql的二级缓存需要实现mybatis提供的cache接口

public interface Cache {
    String getId();
    void putObject(Object var1, Object var2);
    Object getObject(Object var1);
    Object removeObject(Object var1);
    void clear();
    int getSize();
    default ReadWriteLock getReadWriteLock() {
        return null;
    }
}

RedisCache

mybatis官方提供了redis做二级缓存的包，引入包

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

官方的实现类RedisCache

package org.mybatis.caches.redis;
public final class RedisCache implements Cache {
...
}

采用的默认配置JedisPoolConfig

package org.mybatis.caches.redis;
public class RedisConfig extends JedisPoolConfig {
    private String host = "localhost";
    private int port = 6379;
    private int connectionTimeout = 2000;
    private int soTimeout = 2000;
    private String password;
    private int database = 0;
	...
}

使用

在mapper.xml中使用指定实现类

<mapper namespace="com.java.xrc.dao.UserMapper">
    <cache type="org.mybatis.caches.redis.RedisCache"></cache>
</mapper>

如果官方提供的不满足业务需求，则可以自行实现cache接口，使用自定义缓存。

自定义缓存

使用spring-data-redis提供的RedisTemplate操作redis.

引入包

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.2.3.RELEASE</version>
</dependency>

自定义cache实现

/**
 * Mybatis - redis二级缓存
 */
public final class MybatisRedisCache implements Cache {
    /**
     * 读写锁
     */
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private String id;

    /**
     * 集成redisTemplate
     */
    @Autowired
    private static RedisTemplate redisTemplate;

    static {
        //初始化RedisTemplate
        JedisPoolConfig poolConfig=new JedisPoolConfig();
        poolConfig.setMaxIdle(30);
        poolConfig.setMaxTotal(50);
        poolConfig.setMaxWaitMillis(2000);
        JedisConnectionFactory connectionFactory=new JedisConnectionFactory(poolConfig);
        RedisStandaloneConfiguration rscfg=connectionFactory.getStandaloneConfiguration();
        rscfg.setHostName("127.0.0.1");
        rscfg.setPort(6379);
        RedisTemplate<Object,Object> redisTemplate1=new RedisTemplate<>();
        redisTemplate1.setConnectionFactory(connectionFactory);
        //初始实例化redisTemplate
        redisTemplate1.afterPropertiesSet();
        redisTemplate=redisTemplate1;
    }

    public MybatisRedisCache() {
    }

    public MybatisRedisCache(String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        } else {
            this.id = id;
        }
    }


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

    @Override
    public int getSize() {
        try {
            Long size = redisTemplate.opsForHash().size(this.id);
            return size.intValue();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public void putObject(final Object key, final Object value) {
        try {
            redisTemplate.opsForHash().put(this.id, key.toString(), value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public Object getObject(final Object key) {
        try {
            Object hashVal = redisTemplate.opsForHash().get(this.id, key.toString());
            return hashVal;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public Object removeObject(final Object key) {
        try {
            redisTemplate.opsForHash().delete(this.id, key.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void clear() {
        try {
            redisTemplate.delete(this.id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

    @Override
    public String toString() {
        return "MybatisRedisCache {" + this.id + "}";
    }
}

使用

<cache type="com.java.xrc.common.MybatisRedisCache" flushInterval="1000"></cache>