Mybatis整合Redis实现二级缓存

mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存

开启mybatis的二级缓存

<!--设置mybaits对缓存的支持-->     <property name="configurationProperties">         <props>             <!-- 全局映射器启用缓存 *主要将此属性设置完成即可-->             <prop key="cacheEnabled">true</prop>             <!-- 查询时，关闭关联对象即时加载以提高性能 -->             <prop key="lazyLoadingEnabled">false</prop>             <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->             <prop key="aggressiveLazyLoading">true</prop>         </props>     </property>

测试，产生了两条sql语句，说明缓存没有生效

因为我们还需要在BookMapper.xml中添加二级缓存核心类

再次测试，只产生一条sql语句，说明使用了缓存

当查询两次，如果控制台产生两条查询语句，说明mybatis不能同时缓存多条数据。

如果只产生一条查询语句，说明mybatis默认缓存多条数据

测试

（框架的缓存策略）

说明mybatis二级缓存开启，默认既可以缓存单条，也可以缓存多条数据

也可以通过mapper.xml中的userCache属性控制是否使用缓存

测试

此时表示多条数据的缓存已经关闭

小结

对于访问多的查询请求且用户对查询结果实时性要求不高，此时可采用mybatis二级缓存技术降低数据库访问量，提高访问速度

实现方法如下：通过设置刷新间隔时间，由mybatis每隔一段时间自动清空缓存，根据数据变化频率设置缓存刷新间隔flushInterval，比如设置为30分钟、60分钟、24小时等，根据需求而定

mybatis整合redis

---

稍微大型项目都会使用redis缓存

步骤与ehcache缓存几乎一致

1.配置pom依赖

<redis.version>2.9.0</redis.version>

<redis.spring.version>1.7.1.RELEASE</redis.spring.version>

redis.clients

jedis

${redis.version}

org.springframework.data

spring-data-redis

${redis.spring.version}

redis存储数据需要借助序列化器，序列化器的数据存储又要依赖于json的依赖jar包，因此还要导入json的相关依赖

<!-- jackson -->     <jackson.version>2.9.3</jackson.version> <!-- jackson -->     <dependency>       <groupId>com.fasterxml.jackson.core</groupId>       <artifactId>jackson-databind</artifactId>       <version>${jackson.version}</version>     </dependency>     <dependency>       <groupId>com.fasterxml.jackson.core</groupId>       <artifactId>jackson-core</artifactId>       <version>${jackson.version}</version>     </dependency>     <dependency>       <groupId>com.fasterxml.jackson.core</groupId>       <artifactId>jackson-annotations</artifactId>       <version>${jackson.version}</version>     </dependency>

2.建立redis.properties

redis.hostName=192.168.95.110虚拟机ip

redis.port=6379

redis.password=root123密码

redis.timeout=10000

redis.maxIdle=300

redis.maxTotal=1000

redis.maxWaitMillis=1000

redis.minEvictableIdleTimeMillis=300000

redis.numTestsPerEvictionRun=1024

redis.timeBetweenEvictionRunsMillis=30000

redis.testOnBorrow=true

redis.testWhileIdle=true

3.建立applicationContext-redis.xml文件放

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=“http://www.springframework.org/schema/context”

xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd”>

<bean id=“connectionFactory” class=“org.springframework.data.redis.connection.jedis.JedisConnectionFactory”

destroy-method=“destroy”>

4.建立类RedisCache实现Cache 接口

package com.javaxl.ssm.util;

import org.apache.ibatis.cache.Cache;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.dao.DataAccessException;

import org.springframework.data.redis.connection.RedisConnection;

import org.springframework.data.redis.core.RedisCallback;

import org.springframework.data.redis.core.RedisTemplate;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.ReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class RedisCache implements Cache //实现类

{

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

private static RedisTemplate<String,Object> redisTemplate;

private final String id;

/**

* The {@code ReadWriteLock}.

*/

private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

@Override

public ReadWriteLock getReadWriteLock()

{

return this.readWriteLock;

}

public static void setRedisTemplate(RedisTemplate redisTemplate) {

RedisCache.redisTemplate = redisTemplate;

}

public RedisCache(final String id) {

if (id == null) {

throw new IllegalArgumentException(“Cache instances require an ID”);

}

logger.debug(“MybatisRedisCache:id=” + id);

this.id = id;

}

@Override

public String getId() {

return this.id;

}

@Override

public void putObject(Object key, Object value) {

try{

logger.info(“>>>>>>>>>>>>>>>>>>>>>>>>putObject: key=”+key+“,value=”+value);

if(null!=value)

redisTemplate.opsForValue().set(key.toString(),value,60, TimeUnit.SECONDS);

}catch (Exception e){

e.printStackTrace();

logger.error(“redis保存数据异常！”);

}

}

@Override

public Object getObject(Object key) {

try{

logger.info(“>>>>>>>>>>>>>>>>>>>>>>>>getObject: key=”+key);

if(null!=key)

return redisTemplate.opsForValue().get(key.toString());

}catch (Exception e){

e.printStackTrace();

logger.error(“redis获取数据异常！”);

}

return null;

}

@Override

public Object removeObject(Object key) {

try{

if(null!=key)

return redisTemplate.expire(key.toString(),1,TimeUnit.DAYS);

}catch (Exception e){

e.printStackTrace();

logger.error(“redis获取数据异常！”);

}

return null;

}

@Override

public void clear() {

Long size=redisTemplate.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {

Long size = redisConnection.dbSize();

//连接清除数据

redisConnection.flushDb();

redisConnection.flushAll();

return size;

}

});

logger.info(“>>>>>>>>>>>>>>>>>>>>>>>>clear: 清除了” + size + “个对象”);

}

@Override