mybatis整合redis實現二級緩存
mybatis集成ehcache
1. 爲何須要緩存java
拉高程序的性能web
2. 什麼樣的數據須要緩存redis
不多被修改或根本不改的數據算法
業務場景好比：耗時較高的統計分析sql、電話帳單查詢sql等spring
3. ehcache是什麼sql
Ehcache 是如今最流行的純Java開源緩存框架，配置簡單、結構清晰、功能強大數據庫
注1：本章介紹的是2.X版本，3.x的版本和2.x的版本API差別比較大apache
4. ehcache的特色api
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：單條緩存數據的組成單位
四、ssm中整合ehcache
4.一、導入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>
注意：
一、mybatis默認使用的二級緩存框架就是ehcache（org.mybatis.caches.ehcache.EhcacheCache），無縫結合
二、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 等等.
二、添加依賴
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 }
測試結果
一、單個查詢有緩存，有緩存時是不須要進入數據庫去查詢直接能夠從redis中獲取
二、單個查詢無緩存
當這裏面還有數據時則是有緩存
三、多個查詢有緩存
四、多個查詢無緩存
謝謝觀看！！！
相關文章
- 1. Mybatis整合Redis實現二級緩存
- 2. mybatis整合Redis實現二級緩存
- 3. SSM整合Redis實現二級緩存
- 4. mybatis 整合redis做爲二級緩存
- 5. SSM+redis整合(mybatis整合redis作二級緩存)
- 6. mybatis中二級緩存整合ehcache實現分佈式緩存
- 7. 整合Redis緩存實現
- 8. hibernate整合Ehcache 實現二級緩存
- 9. redis與ssm整合（用 redis 替代mybatis二級緩存）
- 10. 11. Mybatis+Redis二級緩存
- 更多相關文章...
- • Hibernate整合EHCache實現二級緩存 - Hibernate教程
- • Hibernate的二級緩存 - Hibernate教程
- • ☆基於Java Instrument的Agent實現
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 外部其他進程嵌入到qt FindWindow獲得窗口句柄 報錯無法鏈接的外部符號 [email protected] 無法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的應用-TOPK問題
- 6. 實例演示ElasticSearch索引查詢term,match,match_phase,query_string之間的區別
- 7. 數學基礎知識 集合
- 8. amazeUI 復擇框問題解決
- 9. 揹包問題理解
- 10. 算數平均-幾何平均不等式的證明,從麥克勞林到柯西
歡迎關注本站公眾號,獲取更多信息
