MyBatiesPlus+Redis分布式缓存

2022-12-05 09:43:15

一、开启二级缓存

cache-enabled: true

# mybatis-plus相关配置

mybatis-plus:

  # xml扫描，多个目录用逗号或者分号分隔（告诉 Mapper 所对应的 XML 文件位置）

  mapper-locations: classpath:mapper/*.xml

  # 以下配置均有默认值,可以不设置

  global-config:

    db-config:

      #主键类型 AUTO:"数据库ID自增" INPUT:"用户输入ID",ID_WORKER:"全局唯一ID (数字类型唯一ID)", UUID:"全局唯一ID UUID";

      id-type: auto

      #字段策略 IGNORED:"忽略判断"  NOT_NULL:"非 NULL 判断")  NOT_EMPTY:"非空判断"

      field-strategy: NOT_EMPTY

      #数据库类型

      db-type: ORACLE

  configuration:

    # 是否开启自动驼峰命名规则映射:从数据库列名到Java属性驼峰命名的类似映射

    map-underscore-to-camel-case: true

    # 如果查询结果中包含空值的列，则 MyBatis 在映射的时候，不会映射这个字段

    call-setters-on-nulls: true

    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用

    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

    # 一级缓存配置 一级缓存是本地或者说局部缓存，它不能被关闭，只能配置缓存范围。SESSION 或者 STATEMENT。

    local-cache-scope: session

    # 二级缓存总开关

    cache-enabled: true

二、添加缓存注解

@EnableCaching

@SpringBootApplication

@MapperScan({"com.qiang.mybaties.plus.test.cache.dao"})

@EnableCaching

public class MybatiesPlusCacheApplication {

    public static void main(String[] args) {

        SpringApplication.run(MybatiesPlusCacheApplication.class, args);

    }

}

三、实体类实现接口

Serializable

@Data

public class Account extends Model<Account> implements Serializable{

    private Integer id;

    private Integer balance;

    private Integer freezeMoney;

    /**

     * 获取主键值

     *

     * @return 主键值

     */

    @Override

    protected Serializable pkVal() {

        return this.id;

    }

}

四、配置Redis模板

RedisConfig

@Configuration

public class RedisConfig {

    /**

     * 配置RedisTemplate

     *

     * @param factory

     * @return

     */

    @Bean

    public RedisTemplate redisTemplate(RedisConnectionFactory factory, Jackson2JsonRedisSerializer serializer) {

        RedisTemplate<Object, Object> template = new RedisTemplate<>();

        // redis连接工厂

        template.setConnectionFactory(factory);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // redis.key序列化器

        template.setKeySerializer(stringRedisSerializer);

        // redis.value序列化器

        template.setValueSerializer(serializer);

        // redis.hash.key序列化器

        template.setHashKeySerializer(stringRedisSerializer);

        // redis.hash.value序列化器

        template.setHashValueSerializer(serializer);

        // 调用其他初始化逻辑

        template.afterPropertiesSet();

        // 这里设置redis事务一致

        template.setEnableTransactionSupport(true);

        return template;

    }

    /**

     * 配置redis Json序列化器

     *

     * @return

     */

    @Bean

    public Jackson2JsonRedisSerializer redisJsonSerializer() {

        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）

        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();

        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        serializer.setObjectMapper(mapper);

        return serializer;

    }

}

五、配置Redis缓存

RedisCache

public final class RedisCache implements Cache {

    /**

     * 日志

     */

    private static final Logger logger = LogManager.getLogger(RedisCache.class);

    /**

     * 读写锁

     */

    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**

     * ID,获取缓存对象的唯一标识

     */

    private String id;

    /**

     * redisTemplate

     */

    private static RedisTemplate redisTemplate;

    public RedisCache(String id) {

        if (id == null) {

            throw new IllegalArgumentException("缓存实例需要一个id!");

        } else {

            logger.info("开启Redis缓存: id = {}", id);

            this.id = id;

        }

    }

    @Override

    public String getId() {

        return this.id;

    }

    @Override

    public int getSize() {

        try {

            if (redisTemplate == null) {

                redisTemplate = getRedisTemplate();

            }

            Long size = redisTemplate.opsForHash().size(this.id.toString());

            logger.info("Redis缓存大小: id = {}, size = {}", id, size);

            return size.intValue();

        } catch (Exception e) {

            e.printStackTrace();

        }

        return 0;

    }

    @Override

    public void putObject(final Object key, final Object value) {

        try {

            if (redisTemplate == null) {

                redisTemplate = getRedisTemplate();

            }

            logger.info("设置Redis缓存: id = {}, key = {}, value = {}", id, key, value);

            redisTemplate.opsForHash().put(this.id.toString(), key.toString(), value);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    @Override

    public Object getObject(final Object key) {

        try {

            if (redisTemplate == null) {

                redisTemplate = getRedisTemplate();

            }

            Object hashVal = redisTemplate.opsForHash().get(this.id.toString(), key.toString());

            logger.info("获取Redis缓存: id = {}, key = {}, hashVal = {}", id, key, hashVal);

            return hashVal;

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }

    @Override

    public Object removeObject(final Object key) {

        try {

            if (redisTemplate == null) {

                redisTemplate = getRedisTemplate();

            }

            redisTemplate.opsForHash().delete(this.id.toString(), key.toString());

            logger.info("移除Redis缓存: id = {}, key = {}", id, key);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

    @Override

    public void clear() {

        try {

            if (redisTemplate == null) {

                redisTemplate = getRedisTemplate();

            }

            redisTemplate.delete(this.id.toString());

            logger.info("清空Redis缓存: id = {}", id);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    @Override

    public ReadWriteLock getReadWriteLock() {

        return this.readWriteLock;

    }

    @Override

    public String toString() {

        return "RedisCache {" + this.id + "}";

    }

    /**

     * 由于启动期间注入失败，只能运行期间注入

     *

     * @return

     */

    public RedisTemplate getRedisTemplate() {

        redisTemplate = (RedisTemplate<String, Object>) SpringUtil.getBean("redisTemplate");

        return redisTemplate;

    }

}

SpringUtil

@Component

public class SpringUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        SpringUtil.applicationContext = applicationContext;

    }

    public static Object getBean(String name) {

        return applicationContext.getBean(name);

    }

    public static <T> T getBean(String name, Class<T> clazz) {

        return applicationContext.getBean(name, clazz);

    }

    public static <T> T getBean(Class<T> clazz) {

        return applicationContext.getBean(clazz);

    }

}

六、在Dao层使用

AccountDao，此时，MybatiesPlus自带的方法缓存已经生效。但是Xml文件里的方法还未生效，接着下一步

// 使用缓存

@CacheNamespace(implementation= RedisCache.class,eviction=RedisCache.class)

public interface AccountDao extends BaseMapper<Account> {

    /**

     *  查询去重的Balance

     * @return

     */

    List<Account> selectDistinctBalance();

    /**

     * 通过ID查询单条数据

     *

     * @param id 主键

     * @return 实例对象

     */

    Account queryById(Integer id);

    /**

     * 查询指定行数据

     *

     * @param offset 查询起始位置

     * @param limit  查询条数

     * @return 对象列表

     */

    List<Account> queryAllByLimit(@Param("offset") int offset, @Param("limit") int limit);

    /**

     * 通过实体作为筛选条件查询

     *

     * @param account 实例对象

     * @return 对象列表

     */

    List<Account> queryAll(Account account);

    /**

     * 新增数据

     *

     * @param account 实例对象

     * @return 影响行数

     */

    int insertOne(Account account);

    /**

     * 修改数据

     *

     * @param account 实例对象

     * @return 影响行数

     */

    int update(Account account);

    /**

     * 通过主键删除数据

     *

     * @param id 主键

     * @return 影响行数

     */

    int deleteById(Integer id);

}

七、在Xml文件使用

AccountDao.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.qiang.mybaties.plus.test.cache.dao.AccountDao">

    <resultMap id="AccountMap" type="com.qiang.mybaties.plus.test.cache.entity.Account">

        <result property="id" column="ID" jdbcType="INTEGER"/>

        <result property="balance" column="BALANCE" jdbcType="INTEGER"/>

        <result property="freezeMoney" column="FREEZE_MONEY" jdbcType="INTEGER"/>

    </resultMap>

	<!-- 使用缓存 -->

    <cache-ref namespace="com.qiang.mybaties.plus.test.cache.dao.AccountDao"/>

    <sql id="Base_Column_List">

        ID, BALANCE, FREEZE_MONEY

    </sql>

    <select id="selectDistinctBalance" resultType="com.qiang.mybaties.plus.test.cache.entity.Account">

        SELECT DISTINCT

            ( BALANCE ),

            ID,

            FREEZE_MONEY

        FROM

            ACCOUNT

    </select>

    <!--查询单个-->

    <select id="queryById" resultMap="AccountMap">

        select

          ID, BALANCE, FREEZE_MONEY

        from TEST.ACCOUNT

        where ID = #{id}

    </select>

    <!--查询指定行数据-->

    <select id="queryAllByLimit" resultMap="AccountMap">

        select

          ID, BALANCE, FREEZE_MONEY

        from TEST.ACCOUNT

        limit #{offset}, #{limit}

    </select>

    <!--通过实体作为筛选条件查询-->

    <select id="queryAll" resultMap="AccountMap">

        select

        ID, BALANCE, FREEZE_MONEY

        from TEST.ACCOUNT

        <where>

            <if test="id != null">

                and ID = #{id}

            </if>

            <if test="balance != null">

                and BALANCE = #{balance}

            </if>

            <if test="freezeMoney != null">

                and FREEZE_MONEY = #{freezeMoney}

            </if>

        </where>

    </select>

    <!--新增所有列-->

    <insert id="insertOne" keyProperty="id" useGeneratedKeys="true">

        insert into TEST.ACCOUNT(BALANCE, FREEZE_MONEY)

        values (#{balance}, #{freezeMoney})

    </insert>

    <!--通过主键修改数据-->

    <update id="update">

        update TEST.ACCOUNT

        <set>

            <if test="balance != null">

                BALANCE = #{balance},

            </if>

            <if test="freezeMoney != null">

                FREEZE_MONEY = #{freezeMoney},

            </if>

        </set>

        where ID = #{id}

    </update>

    <!--通过主键删除-->

    <delete id="deleteById">

        delete from TEST.ACCOUNT where ID = #{id}

    </delete>

</mapper>

八、验证是否成功

8.1 作用域为自带方法

测试代码

	@Test

    public void testRedisCacheCommon(){

        // 测试 mybaties-plus 中间件为redis 作用域为 mybaties自带方法 的二级缓存

        List<Account> list1 = accountService.list();

        System.out.println(list1);

        List<Account> list2 = accountService.list();

        System.out.println(list2);

    }

结果看到第二次查询使用了缓存

Redis也成功添加缓存

缓存更新

	@Test

    public void testRedisCacheCommon(){

        // 测试 mybaties-plus 中间件为redis 作用域为 mybaties自带方法 的二级缓存

        List<Account> list1 = accountService.list();

        System.out.println(list1);

        boolean b = accountService.removeById(2);

        System.out.println(b);

        List<Account> list2 = accountService.list();

        System.out.println(list2);

    }

结果看到查询了两次数据库，当缓存作用在同一个CacheNamespace时候，发生增删改操作，则缓存更新

8.2 作用域为Xml文件