springboot+redis配置mybatis二级缓存

雨点打透心脏的1/2处 2022-01-26 01:21 413阅读 0赞

# springboot+redis配置mybatis二级缓存 #

每天多学一点点~  
闲来无事，研究一下mybatis一二级缓存  
话不多说，这就开始吧…

### 文章目录 ###

*  springboot+redis配置mybatis二级缓存
 *   *  1.mybatis一二级缓存
     *  2.sprongboot配置mybatis
     *  3.springboot配置redis
     *  4.redis集成mybatis二级缓存
     *  5.测试
     *  6.结语

## 1.mybatis一二级缓存 ##

1.  一级缓存  
    mybatis对缓存提供支持，但是在没有配置的默认情况下，它只开启一级缓存，一级缓存只是相对于同一个SqlSession而言。所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。  
    **简单来说：一级缓存就是sql语句的缓存**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70]  
    **博主列了几个一级缓存常问问道的问题。**

①、一级缓存的生命周期有多长？  
　　a、MyBatis在开启一个数据库会话时，会 创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象。Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。  
　　b、如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用。  
　　c、如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用。  
　　d、SqlSession中执行了任何一个update操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用  
②、怎么判断某两次查询是完全相同的查询？  
　　mybatis认为，对于两次查询，如果以下条件都完全一样，那么就认为它们是完全相同的两次查询。  
　　a、传入的statementId  
　　b、查询时要求的结果集中的结果范围  
　　c、 这次查询所产生的最终要传递给JDBC java.sql.Preparedstatement的Sql语句字符串（boundSql.getSql() ）  
　　d、传递给java.sql.Statement要设置的参数值

1.  二级缓存  
    MyBatis的二级缓存是Application级别的缓存，它可以提高对数据库查询的效率，以提高应用的性能。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 1]  
    SqlSessionFactory层面上的二级缓存默认是不开启的，二级缓存的开席需要进行配置，实现二级缓存的时候，MyBatis要求返回的POJO必须是可序列化的。 **也就是要求实现Serializable接口**，配置方法很简单，只需要在映射XML文件配置就可以开启缓存了，如果我们配置了二级缓存就意味着：

*  映射语句文件中的所有select语句将会被缓存。
 *  映射语句文件中的所有insert、update和delete语句会刷新缓存。
 *  缓存会使用默认的Least Recently Used（LRU，最近最少使用的）算法来收回。
 *  根据时间表，比如No Flush Interval,（CNFI没有刷新间隔），缓存不会以任何时间顺序来刷新。
 *  缓存会存储列表集合或对象(无论查询方法返回什么)的1024个引用
 *  缓存会被视为是read/write(可读/可写)的缓存，意味着对象检索不是共享的，而且可以安全的被调用者修改，不干扰其他调用者或线程所做的潜在修改。

**简单来说：二级缓存就是xml文件的namespace级别的缓存**

## 2.sprongboot配置mybatis ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 2]

#mybatis 配置
    mybatis.mapper-locations=classpath:/mapper/*
    mybatis.configuration.map-underscore-to-camel-case=true
    mybatis.configuration.call-setters-on-nulls= true
    # 开启mybatis 开启二级 缓存
    mybatis.configuration.cache-enabled=true

## 3.springboot配置redis ##

yml配置

# redis设置
    spring.redis.host=127.0.0.1
    spring.redis.port=6379
    spring.redis.database=4
    spring.redis.password=123456

配置类

@Configuration
    public class RedisConfig {
    
        /**
         *  设置redis的序列化方式
         * @param redisConnectionFactory
         * @return
         */
        @Bean
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setDefaultSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
    }

## 4.redis集成mybatis二级缓存 ##

配置redis二级缓存，**只需要实现Cache这个接口就可以**，话不多说，上代码。博主这里为了方便直接用redisTemplate；

/**
     * @Auther: 爆裂无球    redis 作为 mybatis的二级缓存
     * @Date: 2019/5/27 14:32
     * @Description:
     */
    public class MybatisRedisCache implements Cache {
    
        private static final Logger logger = LoggerFactory.getLogger(MybatisRedisCache.class);
    
        // 读写锁
        private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    
        private static RedisTemplate redisTemplate;
    
    //    private RedisTemplate<String, Object> redisTemplate = SpringContextHolder.getBean("redisTemplate");
    
        private String id;
    
        public MybatisRedisCache(final String id) {
            if (id == null) {
                throw new IllegalArgumentException("Cache instances require an ID");
            }
            logger.info("Redis Cache id " + id);
            this.id = id;
        }
    
        @Override
        public String getId() {
            return this.id;
        }
    
        @Override
        public void putObject(Object key, Object value) {
            if (value != null) {
                // 向Redis中添加数据，有效时间是2天
                redisTemplate.opsForValue().set(key.toString(), value, 2, TimeUnit.DAYS);
            }
        }
    
        @Override
        public Object getObject(Object key) {
            try {
                if (key != null) {
                    Object obj = redisTemplate.opsForValue().get(key.toString());
                    return obj;
                }
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
            return null;
        }
    
        @Override
        public Object removeObject(Object key) {
            try {
                if (key != null) {
                    redisTemplate.delete(key.toString());
                }
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
            return null;
        }
    
        @Override
        public void clear() {
            logger.info("清空缓存");
            try {
                Set<String> keys = redisTemplate.keys("*:" + this.id + "*");
                if (!CollectionUtils.isEmpty(keys)) {
                    redisTemplate.delete(keys);
                }
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
        }
    
        @Override
        public int getSize() {
            Long size = (Long) redisTemplate.execute(new RedisCallback<Long>() {
                @Override
                public Long doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.dbSize();
                }
            });
            return size.intValue();
        }
    
        @Override
        public ReadWriteLock getReadWriteLock() {
            return this.readWriteLock;
        }
    
        public static void setRedisConnectionFactory(RedisTemplate redisTemplate) {
            MybatisRedisCache.redisTemplate = redisTemplate;
        }

在spring启动的时候，将redisTemplate注入到MybatisRedisCache类中

/**
     * @Auther: 爆裂无球   将redisTemplate注入
     * @Date: 2019/5/27 15:04
     * @Description:
     */
    @Component
    public class RedisCacheTransfer {
    
    
        @Autowired
        public void setJedisConnectionFactory(RedisTemplate redisTemplate) {
            MybatisRedisCache.setRedisConnectionFactory(redisTemplate);
        }
    
    
    
    
    }

## 5.测试 ##

1.  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.yltx.app.dao.Userdao">
        
    
        
    
        
    
        
    
        
    
        <cache type="com.yltx.app.redis.MybatisRedisCache">
            <property name="eviction" value="LRU" />
            <property name="flushInterval" value="6000000" />
            <property name="size" value="1024" />
            <property name="readOnly" value="false" />
        </cache>
    
        <resultMap id="BaseResultMap" type="com.yltx.app.bean.User" >
    
    
            <id column="id" property="id" jdbcType="VARCHAR" />
            <result column="username" property="username" jdbcType="VARCHAR" />
            <result column="sex" property="sex" jdbcType="VARCHAR" />
    
        </resultMap>
    
        <select id="getAll" resultMap="BaseResultMap" useCache="true">
            select * from user
        </select>
    
        <select id="getAll2" resultMap="BaseResultMap" useCache="true">
            select id from user
        </select>
    
    </mapper>

1.  mapper写法

/**
     * @Auther: 爆裂无球          @CacheNamespace            主要用于mybatis二级缓存，但是要注意：配置文件和接口注释是不能够配合使用的。只能通过全注解的方式或者全部通过xml配置文件的方式使用
     * @Date: 2019/4/26 10:11
     * @Description:
     */
    @CacheNamespace(implementation = MybatisRedisCache.class)
    public interface Userdao {
    
    
    
    
        @Insert("insert into user (id,username,sex) values (#{id},#{username},#{sex})")
        int insert(User user);
    
    
        @Select("   select * from user ")
        List<User> getAll();
    
        @Select("   select id from user ")
        List<String> getAll2();
    }

**注：若xml中写了cache标签，则mapper中不要加@CacheNamespace注解，不然会冲突的；两者取其一**

1.  验证  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 3]

如图，第一次查询的时候打印除了sql语句，其他四次走了缓存；Cache Hit Ratio是缓存命中率；再点一次，就全部是1了。因为此时已经在redis中产生了缓存；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 5]

此时，若在 其中插入一条修改语句(增删改)，则会**清空一次缓存**，再重新放入；目的：为了数据的一致性；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 6]

## 6.结语 ##

**世上无难事，只怕有心人，每天积累一点点，fighting！！！**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70]: /images/20220126/030642fd7b114fec993c45f51b892fe2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 1]: /images/20220126/e805bb889697419c954ba4c5eeb0a31f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 2]: /images/20220126/6bd11597e5254437ad18c04c0d1a370b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 3]: /images/20220126/e4b80e8a9fd14343a25bc55af1fbd62d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 4]: /images/20220126/28011ae2e10744bdb029ea7ad66551c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 5]: /images/20220126/d51695842f864e93a28c76fefc3ce687.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQzNzYzMw_size_16_color_FFFFFF_t_70 6]: /images/20220126/fd78604880b64d65912d9bbaaa485440.png