mybatis整合redis实现二级缓存
mybatis集成ehcache
1. 为什么需要缓存
拉高程序的性能
2. 什么样的数据需要缓存
很少被修改或根本不改的数据
业务场景比如:耗时较高的统计分析sql、电话账单查询sql等
3. ehcache是什么
Ehcache 是现在最流行的纯Java开源缓存框架,配置简单、结构清晰、功能强大
注1:本章介绍的是2.X版本,3.x的版本和2.x的版本API差异比较大
4. ehcache的特点
4.1 够快
Ehcache的发行有一段时长了,经过几年的努力和不计其数的性能测试,Ehcache终被设计于large, high concurrency systems.
4.2 够简单
开发者提供的接口非常简单明了,从Ehcache的搭建到运用运行仅仅需要的是你宝贵的几分钟。其实很多开发者都不知道自己用在用Ehcache,Ehcache被广泛的运用于其他的开源项目
4.3 够袖珍
关于这点的特性,官方给了一个很可爱的名字small foot print ,一般Ehcache的发布版本不会到2M,V 2.2.3 才 668KB。
4.4 够轻量
核心程序仅仅依赖slf4j这一个包,没有之一!
4.5 好扩展
Ehcache提供了对大数据的内存和硬盘的存储,最近版本允许多实例、保存对象高灵活性、提供LRU、LFU、FIFO淘汰算法,基础属性支持热配置、支持的插件多
4.6 监听器
缓存管理器监听器 (CacheManagerListener)和 缓存监听器(CacheEvenListener),做一些统计或数据一致性广播挺好用的
4.7 分布式缓存
从Ehcache 1.2开始,支持高性能的分布式缓存,兼具灵活性和扩展性
3. ehcache的使用
3.1 导入相关依赖
3.2 核心接口
CacheManager:缓存管理器
Cache:缓存对象,缓存管理器内可以放置若干cache,存放数据的实质,所有cache都实现了Ehcache接口
Element:单条缓存数据的组成单位
4、ssm中整合ehcache
4.1、导入pom依赖
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>${spring.version}</version> </dependency> <!--mybatis与ehcache整合--> <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.1.0</version> </dependency> <!--ehcache依赖--> <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.10.0</version> </dependency>
4.2 修改日志配置,因为ehcache使用了Slf4j作为日志输出
1 <!-- log4j2日志配置相关依赖 --> 2 <log4j2.version>2.9.1</log4j2.version> 3 <log4j2.disruptor.version>3.2.0</log4j2.disruptor.version> 4 <slf4j.version>1.7.13</slf4j.version> 5 6 <!-- log4j2日志相关依赖 --> 7 <!-- log配置:Log4j2 + Slf4j --> 8 <!-- slf4j核心包--> 9 <dependency> 10 <groupId>org.slf4j</groupId> 11 <artifactId>slf4j-api</artifactId> 12 <version>${slf4j.version}</version> 13 </dependency> 14 <dependency> 15 <groupId>org.slf4j</groupId> 16 <artifactId>jcl-over-slf4j</artifactId> 17 <version>${slf4j.version}</version> 18 <scope>runtime</scope> 19 </dependency> 20 21 <!--核心log4j2jar包--> 22 <dependency> 23 <groupId>org.apache.logging.log4j</groupId> 24 <artifactId>log4j-api</artifactId> 25 <version>${log4j2.version}</version> 26 </dependency> 27 <dependency> 28 <groupId>org.apache.logging.log4j</groupId> 29 <artifactId>log4j-core</artifactId> 30 <version>${log4j2.version}</version> 31 </dependency> 32 <!--用于与slf4j保持桥接--> 33 <dependency> 34 <groupId>org.apache.logging.log4j</groupId> 35 <artifactId>log4j-slf4j-impl</artifactId> 36 <version>${log4j2.version}</version> 37 </dependency> 38 <!--web工程需要包含log4j-web,非web工程不需要--> 39 <dependency> 40 <groupId>org.apache.logging.log4j</groupId> 41 <artifactId>log4j-web</artifactId> 42 <version>${log4j2.version}</version> 43 <scope>runtime</scope> 44 </dependency> 45 46 <!--需要使用log4j2的AsyncLogger需要包含disruptor--> 47 <dependency> 48 <groupId>com.lmax</groupId> 49 <artifactId>disruptor</artifactId> 50 <version>${log4j2.disruptor.version}</version> 51 </dependency>
4.3 在Resource中添加一个ehcache.xml的配置文件
1 <?xml version="1.0" encoding="UTF-8"?> 2 <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3 xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd" 4 updateCheck="false"> 5 <!--磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存--> 6 <!--path:指定在硬盘上存储对象的路径--> 7 <!--java.io.tmpdir 是默认的临时文件路径。 可以通过如下方式打印出具体的文件路径 System.out.println(System.getProperty("java.io.tmpdir"));--> 8 <diskStore path="java.io.tmpdir"/> 9 10 11 <!--defaultCache:默认的管理策略--> 12 <!--eternal:设定缓存的elements是否永远不过期。如果为true,则缓存的数据始终有效,如果为false那么还要根据timeToIdleSeconds,timeToLiveSeconds判断--> 13 <!--maxElementsInMemory:在内存中缓存的element的最大数目--> 14 <!--overflowToDisk:如果内存中数据超过内存限制,是否要缓存到磁盘上--> 15 <!--diskPersistent:是否在磁盘上持久化。指重启jvm后,数据是否有效。默认为false--> 16 <!--timeToIdleSeconds:对象空闲时间(单位:秒),指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0,表示一直可以访问--> 17 <!--timeToLiveSeconds:对象存活时间(单位:秒),指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0,表示一直可以访问--> 18 <!--memoryStoreEvictionPolicy:缓存的3 种清空策略--> 19 <!--FIFO:first in first out (先进先出)--> 20 <!--LFU:Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性,hit 值最小的将会被清出缓存--> 21 <!--LRU:Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存--> 22 <defaultCache eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false" 23 timeToIdleSeconds="0" timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU"/> 24 25 <!--name: Cache的名称,必须是唯一的(ehcache会把这个cache放到HashMap里)--> 26 <!--<cache name="stuCache" eternal="false" maxElementsInMemory="100"--> 27 <!--overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"--> 28 <!--timeToLiveSeconds="300" memoryStoreEvictionPolicy="LRU"/>--> 29 </ehcache>
4.5 mybaits的二级缓存是mapper范围级别,除了在SqlMapConfig.xml设置二级缓存的总开关,还要在具体的mapper.xml中开启二级缓存
4.5.1 开启mybatis的二级缓存
<!--设置mybaits对缓存的支持--> <property name="configurationProperties"> <props> <!-- 全局映射器启用缓存 *主要将此属性设置完成即可--> <prop key="cacheEnabled">true</prop> <!-- 查询时,关闭关联对象即时加载以提高性能 --> <prop key="lazyLoadingEnabled">false</prop> <!-- 设置关联对象加载的形态,此处为按需加载字段(加载字段由SQL指 定),不会加载关联表的所有字段,以提高性能 --> <prop key="aggressiveLazyLoading">true</prop> </props> </property>
4.5.2 在XxxMapper.xml中配置cache
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
如:
4.5.3 可以通过select标签的useCache属性打开或关闭二级缓存
<select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Long" useCache="false"></select>
注意:
1、mybatis默认使用的二级缓存框架就是ehcache(org.mybatis.caches.ehcache.EhcacheCache),无缝结合
2、Mybatis缓存开关一旦开启,可缓存单条记录,也可缓存多条,hibernate不能缓存多条。
Mapper接口上的所有方法上另外提供关闭缓存的属性
无缓存查询
有缓存查询
mybatis集成redis
1. redis常用类
1.1 Jedis
jedis就是集成了redis的一些命令操作,封装了redis的java客户端
1.2 JedisPoolConfig
Redis连接池
1.3 ShardedJedis
基于一致性哈希算法实现的分布式Redis集群客户端
实现 mybatis 的二级缓存,一般来说有如下两种方式:
1) 采用 mybatis 内置的 cache 机制。
2) 采用三方 cache 框架, 比如ehcache, oscache 等等.
2、添加依赖
redis相关依赖
<!-- redis与spring的整合依赖 --> <redis.version>2.9.0</redis.version> <redis.spring.version>1.7.1.RELEASE</redis.spring.version> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>${redis.version}</version> </dependency> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version>${redis.spring.version}</version> </dependency>
jackson依赖
1 <!-- jackson --> 2 <jackson.version>2.9.3</jackson.version> 3 4 <!-- jackson --> 5 <dependency> 6 <groupId>com.fasterxml.jackson.core</groupId> 7 <artifactId>jackson-databind</artifactId> 8 <version>${jackson.version}</version> 9 </dependency> 10 <dependency> 11 <groupId>com.fasterxml.jackson.core</groupId> 12 <artifactId>jackson-core</artifactId> 13 <version>${jackson.version}</version> 14 </dependency> 15 <dependency> 16 <groupId>com.fasterxml.jackson.core</groupId> 17 <artifactId>jackson-annotations</artifactId> 18 <version>${jackson.version}</version> 19 </dependency>
3.spring + redis 集成实现缓存功能(与mybatis无关)
3.1 添加两个redis的配置文件,并将redis.properties和applicationContext-redis.xml配置到applicationContext.xml文件中 redis.properties applicationContext-redis.xml 注1:将redis.properties导入到applicationContext.xml文件中 spring中引入第二个属性文件会出现“找不到某个配置项”错误,这是因为spring只允许有一个<context:property-placeholder/> <!--引入一个属性文件的写法--> <context:property-placeholder ignore-unresolvable="true" location="classpath:jdbc.properties" /> <!--引入两个或多个属性文件的写法--> <context:property-placeholder ignore-unresolvable="true" location="classpath:jdbc.properties,classpath:redis.properties" /> 注2:通过import标签将applicationContext-redis.xml导入到applicationContext.xml文件中 <!--导入redis配置--> <import resource="applicationContext-redis.xml"/>
在resources中创建redis.properties
1 redis.hostName=192.168.238.129 2 redis.port=6379 3 redis.password=123456 4 redis.timeout=10000 5 redis.maxIdle=300 6 redis.maxTotal=1000 7 redis.maxWaitMillis=1000 8 redis.minEvictableIdleTimeMillis=300000 9 redis.numTestsPerEvictionRun=1024 10 redis.timeBetweenEvictionRunsMillis=30000 11 redis.testOnBorrow=true 12 redis.testWhileIdle=true
创建applicationContext-redis.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:context="http://www.springframework.org/schema/context" 5 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"> 6 7 <!-- 1. 引入properties配置文件 --> 8 <!--<context:property-placeholder location="classpath:redis.properties" />--> 9 10 <!-- 2. redis连接池配置--> 11 <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"> 12 <!--最大空闲数--> 13 <property name="maxIdle" value="${redis.maxIdle}"/> 14 <!--连接池的最大数据库连接数 --> 15 <property name="maxTotal" value="${redis.maxTotal}"/> 16 <!--最大建立连接等待时间--> 17 <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/> 18 <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)--> 19 <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/> 20 <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3--> 21 <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/> 22 <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1--> 23 <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/> 24 <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个--> 25 <property name="testOnBorrow" value="${redis.testOnBorrow}"/> 26 <!--在空闲时检查有效性, 默认false --> 27 <property name="testWhileIdle" value="${redis.testWhileIdle}"/> 28 </bean> 29 30 <!-- 3. redis连接工厂 --> 31 <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" 32 destroy-method="destroy"> 33 <property name="poolConfig" ref="poolConfig"/> 34 <!--IP地址 --> 35 <property name="hostName" value="${redis.hostName}"/> 36 <!--端口号 --> 37 <property name="port" value="${redis.port}"/> 38 <!--如果Redis设置有密码 --> 39 <property name="password" value="${redis.password}"/> 40 <!--客户端超时时间单位是毫秒 --> 41 <property name="timeout" value="${redis.timeout}"/> 42 </bean> 43 44 <!-- 4. redis操作模板,使用该对象可以操作redis --> 45 <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> 46 <property name="connectionFactory" ref="connectionFactory"/> 47 <!--如果不配置Serializer,那么存储的时候缺省使用String,如果用User类型存储,那么会提示错误User can't cast to String!! --> 48 <property name="keySerializer"> 49 <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/> 50 </property> 51 <property name="valueSerializer"> 52 <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/> 53 </property> 54 <property name="hashKeySerializer"> 55 <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/> 56 </property> 57 <property name="hashValueSerializer"> 58 <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/> 59 </property> 60 <!--开启事务 --> 61 <property name="enableTransactionSupport" value="true"/> 62 </bean> 63 64 <!-- 5.使用中间类解决RedisCache.RedisTemplate的静态注入,从而使MyBatis实现第三方缓存 --> 65 <bean id="redisCacheTransfer" class="com.yuan.util.RedisCacheTransfer"> 66 <property name="redisTemplate" ref="redisTemplate"/> 67 </bean> 68 </beans>
applicationContext.xml配置
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:context="http://www.springframework.org/schema/context" 5 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"> 6 7 8 <!--多数据源导入配置--> 9 <context:property-placeholder location="classpath:jdbc.properties,classpath:redis.properties" /> 10 11 <!--整合mybatis框架--> 12 <import resource="applicationContext-mybatis.xml"></import> 13 <!--spring整合redis--> 14 <import resource="applicationContext-redis.xml"></import> 15 </beans>
将redis缓存引入到mybatis中
创建mybatis的自定义缓存类“RedisCache”,必须实现org.apache.ibatis.cache.Cache接口
1 package com.yuan.util; 2 3 4 import org.apache.ibatis.cache.Cache; 5 import org.slf4j.Logger; 6 import org.slf4j.LoggerFactory; 7 import org.springframework.beans.factory.annotation.Autowired; 8 import org.springframework.dao.DataAccessException; 9 import org.springframework.data.redis.connection.RedisConnection; 10 import org.springframework.data.redis.core.RedisCallback; 11 import org.springframework.data.redis.core.RedisTemplate; 12 import org.springframework.stereotype.Component; 13 14 import java.util.concurrent.TimeUnit; 15 import java.util.concurrent.locks.ReadWriteLock; 16 import java.util.concurrent.locks.ReentrantReadWriteLock; 17 18 public class RedisCache implements Cache //实现类 19 { 20 private static final Logger logger = LoggerFactory.getLogger(RedisCache.class); 21 22 private static RedisTemplate<String,Object> redisTemplate; 23 24 private final String id; 25 26 /** 27 * The {@code ReadWriteLock}. 28 */ 29 private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); 30 31 @Override 32 public ReadWriteLock getReadWriteLock() 33 { 34 return this.readWriteLock; 35 } 36 37 public static void setRedisTemplate(RedisTemplate redisTemplate) { 38 RedisCache.redisTemplate = redisTemplate; 39 } 40 41 public RedisCache(final String id) { 42 if (id == null) { 43 throw new IllegalArgumentException("Cache instances require an ID"); 44 } 45 logger.debug("MybatisRedisCache:id=" + id); 46 this.id = id; 47 } 48 49 @Override 50 public String getId() { 51 return this.id; 52 } 53 54 @Override 55 public void putObject(Object key, Object value) { 56 try{ 57 logger.info(">>>>>>>>>>>>>>>>>>>>>>>>putObject: key="+key+",value="+value); 58 if(null!=value) 59 redisTemplate.opsForValue().set(key.toString(),value,60, TimeUnit.SECONDS); 60 }catch (Exception e){ 61 e.printStackTrace(); 62 logger.error("redis保存数据异常!"); 63 } 64 } 65 66 @Override 67 public Object getObject(Object key) { 68 try{ 69 logger.info(">>>>>>>>>>>>>>>>>>>>>>>>getObject: key="+key); 70 if(null!=key) 71 return redisTemplate.opsForValue().get(key.toString()); 72 }catch (Exception e){ 73 e.printStackTrace(); 74 logger.error("redis获取数据异常!"); 75 } 76 return null; 77 } 78 79 @Override 80 public Object removeObject(Object key) { 81 try{ 82 if(null!=key) 83 return redisTemplate.expire(key.toString(),1,TimeUnit.DAYS); 84 }catch (Exception e){ 85 e.printStackTrace(); 86 logger.error("redis获取数据异常!"); 87 } 88 return null; 89 } 90 91 @Override 92 public void clear() { 93 Long size=redisTemplate.execute(new RedisCallback<Long>() { 94 @Override 95 public Long doInRedis(RedisConnection redisConnection) throws DataAccessException { 96 Long size = redisConnection.dbSize(); 97 //连接清除数据 98 redisConnection.flushDb(); 99 redisConnection.flushAll(); 100 return size; 101 } 102 }); 103 logger.info(">>>>>>>>>>>>>>>>>>>>>>>>clear: 清除了" + size + "个对象"); 104 } 105 106 @Override 107 public int getSize() { 108 Long size = redisTemplate.execute(new RedisCallback<Long>() { 109 @Override 110 public Long doInRedis(RedisConnection connection) 111 throws DataAccessException { 112 return connection.dbSize(); 113 } 114 }); 115 return size.intValue(); 116 } 117 }
静态注入中间类“RedisCacheTransfer”,解决RedisCache中RedisTemplate的静态注入,从而使MyBatis实现第三方缓存
package com.yuan.util; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; public class RedisCacheTransfer { @Autowired public void setRedisTemplate(RedisTemplate redisTemplate) { RedisCache.setRedisTemplate(redisTemplate); } }
测试层方法
1 /** 2 * 单个查询测试有无缓存 3 */ 4 @Test 5 public void testCacheOne() { 6 System.out.println(this.bookService.selectByPrimaryKey(22)); 7 System.out.println(this.bookService.selectByPrimaryKey(22)); 8 } 9 10 /** 11 * 多个查询测试有无缓存 12 */ 13 @Test 14 public void testCacheMany() { 15 Book book = new Book(); 16 //带条件分页查询 17 book.setBname(StringUtil.toLikeStr("圣墟")); 18 PageBean pageBean = new PageBean(); 19 //不分页 20 // pageBean.setPagination(false); 21 //根据页码分页查询 22 pageBean.setPage(2); 23 List<Book> books = bookService.listPager(book, pageBean); 24 for (Book b : books) { 25 System.out.println(b); 26 } 27 28 List<Book> books2 = bookService.listPager(book, pageBean); 29 for (Book b : books2) { 30 System.out.println(b); 31 } 32 33 }
测试结果
1、单个查询有缓存,有缓存时是不需要进入数据库去查询直接可以从redis中获取
2、单个查询无缓存
当这里面还有数据时则是有缓存
3、多个查询有缓存
4、多个查询无缓存
谢谢观看!!!