Redis 緩存 + Spring 的集成示例

時間  2019-11-21
標籤 redis 緩存 spring 集成 示例 欄目 Redis 简体版
原文   原文鏈接

SpringSession和Redis實現Session跨域html

http://www.ithao123.cn/content-11111681.htmljava

 

tomcat中建立session很耗服務器內存git

原生session與session in redis對比
下面是從stackoverflow上找到的一些觀點：github

Using something like Redis for storing sessions is a great way to get more performance out of load balanced servers. Here is a case in point:web

On Amazon Web Services, the load balances have what’s called ‘sticky sessions’. What this means is that when a user first connects to your web app, e.g. when logging in to it, the load balance will choose one of your app. servers and this user will continue to be served from this server until they exit your application. This is because the sessions used by PHP, for example, will be stored on the app. server that they first start using. Now, if you use Redis on a separate server, then configure your PHP on each of your app. servers to store it’s sessions in Redis, you can turn this ‘sticky sessions’ off. This would mean that any of your servers can access the sessions and, therefore, the user be served from a different server with every request to your app. This ultimately makes for more efficient use of your load balancing set-up.redis

上面這段提到了一個優勢：在集羣環境中，使用redis能夠更靈活地實現負載均衡。spring

You want the session save handler to be fast. This is due to the fact that a PHP session will block all other concurrent requests from the same user until the first request is finished.數據庫

There are a variety of handlers you could use for PHP sessions across multiple servers: File w/ NFS, MySQL Database, Memcache, and Redis.json

The database method (using InnoDB) was the slowest in my experience followed by File w/ NFS. Locking and write contention are the main factors. Memcache and Redis provide similar performance and are by far the better alternatives since all operations are in RAM. Redis is my choice because you can enable disk persistence, and Memcache is only memory based.api

這裏提到了幾種用來存儲會話數據的方式，並把原生的session歸類的使用文件的存儲。顯然是Redis在效率上要更快些，而與memcached相比，由於有持久化，也更安全一些。

由你們的使用經驗能夠看出，說「原生的session要比使用redis來存儲session更好」的說話是沒有道理的。並且session還存在如下問題：

因爲session回收的問題，使用session還會帶來一些像登陸會話不能準時過時等問題。
在使用swoole作websocket服務器的時候，在嘗試使用session_id來獲取原生session的會話信息的時候，因爲原生session老是須要配合session_start()使用，在嘗試在處理請求session_start()的時候會報「header already sent」的問題；嘗試使用sessionHandler類的方法時，也會報告一些奇怪的問題。
所以不必守着原生session這老古董，應該積極擁抱redis存儲會話的方式。

 

《整合 spring 4(包括mvc、context、orm) + mybatis 3 示例》一文簡要介紹了最新版本的 Spring MVC、IOC、MyBatis ORM 三者的整合以及聲明式事務處理。如今咱們須要把緩存也整合進來，緩存咱們選用的是 Redis，本文將在該文示例基礎上介紹 Redis 緩存 + Spring 的集成。關於 Redis 服務器的搭建請參考博客《Redhat5.8 環境下編譯安裝 Redis 並將其註冊爲系統服務》。

1. 依賴包安裝

pom.xml 加入：

[html]  view plain  copy
 
 print?
  1. <!-- redis cache related.....start -->  
  2. <dependency>  
  3.     <groupId>org.springframework.data</groupId>  
  4.     <artifactId>spring-data-redis</artifactId>  
  5.     <version>1.6.0.RELEASE</version>  
  6. </dependency>  
  7. <dependency>  
  8.     <groupId>redis.clients</groupId>  
  9.     <artifactId>jedis</artifactId>  
  10.     <version>2.7.3</version>  
  11. </dependency>  
  12. <!-- redis cache related.....end -->  

 

2. Spring 項目集成進緩存支持

要啓用緩存支持，咱們須要建立一個新的 CacheManager bean。CacheManager 接口有不少實現，本文演示的是和 Redis 的集成，天然就是用 RedisCacheManager 了。Redis 不是應用的共享內存，它只是一個內存服務器，就像 MySql 似的，咱們須要將應用鏈接到它並使用某種「語言」進行交互，所以咱們還須要一個鏈接工廠以及一個 Spring 和 Redis 對話要用的 RedisTemplate，這些都是 Redis 緩存所必需的配置，把它們都放在自定義的 CachingConfigurerSupport 中：

[java]  view plain  copy
 
 print?
  1. /** 
  2.  * File Name：RedisCacheConfig.java 
  3.  * 
  4.  * Copyright Defonds Corporation 2015  
  5.  * All Rights Reserved 
  6.  * 
  7.  */  
  8. package com.defonds.bdp.cache.redis;  
  9.   
  10. import org.springframework.cache.CacheManager;  
  11. import org.springframework.cache.annotation.CachingConfigurerSupport;  
  12. import org.springframework.cache.annotation.EnableCaching;  
  13. import org.springframework.context.annotation.Bean;  
  14. import org.springframework.context.annotation.Configuration;  
  15. import org.springframework.data.redis.cache.RedisCacheManager;  
  16. import org.springframework.data.redis.connection.RedisConnectionFactory;  
  17. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;  
  18. import org.springframework.data.redis.core.RedisTemplate;  
  19.   
  20. /** 
  21.  *  
  22.  * Project Name：bdp  
  23.  * Type Name：RedisCacheConfig  
  24.  * Type Description： 
  25.  *  Author：Defonds 
  26.  * Create Date：2015-09-21 
  27.  *  
  28.  * @version 
  29.  *  
  30.  */  
  31. @Configuration  
  32. @EnableCaching  
  33. public class RedisCacheConfig extends CachingConfigurerSupport {  
  34.   
  35.     @Bean  
  36.     public JedisConnectionFactory redisConnectionFactory() {  
  37.         JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();  
  38.   
  39.         // Defaults  
  40.         redisConnectionFactory.setHostName("192.168.1.166");  
  41.         redisConnectionFactory.setPort(6379);  
  42.         return redisConnectionFactory;  
  43.     }  
  44.   
  45.     @Bean  
  46.     public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {  
  47.         RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();  
  48.         redisTemplate.setConnectionFactory(cf);  
  49.         return redisTemplate;  
  50.     }  
  51.   
  52.     @Bean  
  53.     public CacheManager cacheManager(RedisTemplate redisTemplate) {  
  54.         RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);  
  55.   
  56.         // Number of seconds before expiration. Defaults to unlimited (0)  
  57.         cacheManager.setDefaultExpiration(3000); // Sets the default expire time (in seconds)  
  58.         return cacheManager;  
  59.     }  
  60.       
  61. }  


固然也別忘了把這些 bean 注入 Spring，否則配置無效。在 applicationContext.xml 中加入如下：

[html]  view plain  copy
 
 print?
  1. <context:component-scan base-package="com.defonds.bdp.cache.redis" />  

 

3. 緩存某些方法的執行結果

設置好緩存配置以後咱們就可使用 @Cacheable 註解來緩存方法執行的結果了，好比根據省份名檢索城市的 provinceCities 方法和根據 city_code 檢索城市的 searchCity 方法：

[java]  view plain  copy
 
 print?
  1. // R  
  2. @Cacheable("provinceCities")  
  3. public List<City> provinceCities(String province) {  
  4.     logger.debug("province=" + province);  
  5.     return this.cityMapper.provinceCities(province);  
  6. }  
  7.   
  8. // R  
  9. @Cacheable("searchCity")  
  10. public City searchCity(String city_code){  
  11.     logger.debug("city_code=" + city_code);  
  12.     return this.cityMapper.searchCity(city_code);     
  13. }  

 

4. 緩存數據一致性保證

CRUD (Create 建立，Retrieve 讀取，Update 更新，Delete 刪除) 操做中，除了 R 具有冪等性，其餘三個發生的時候均可能會形成緩存結果和數據庫不一致。爲了保證緩存數據的一致性，在進行 CUD 操做的時候咱們須要對可能影響到的緩存進行更新或者清除。

[java]  view plain  copy
 
 print?
  1. // C  
  2. @CacheEvict(value = { "provinceCities"}, allEntries = true)  
  3. public void insertCity(String city_code, String city_jb,   
  4.         String province_code, String city_name,  
  5.         String city, String province) {  
  6.     City cityBean = new City();  
  7.     cityBean.setCityCode(city_code);  
  8.     cityBean.setCityJb(city_jb);  
  9.     cityBean.setProvinceCode(province_code);  
  10.     cityBean.setCityName(city_name);  
  11.     cityBean.setCity(city);  
  12.     cityBean.setProvince(province);  
  13.     this.cityMapper.insertCity(cityBean);  
  14. }  
  15. // U  
  16. @CacheEvict(value = { "provinceCities", "searchCity" }, allEntries = true)  
  17. public int renameCity(String city_code, String city_name) {  
  18.     City city = new City();  
  19.     city.setCityCode(city_code);  
  20.     city.setCityName(city_name);  
  21.     this.cityMapper.renameCity(city);  
  22.     return 1;  
  23. }  
  24.   
  25. // D  
  26. @CacheEvict(value = { "provinceCities", "searchCity" }, allEntries = true)  
  27. public int deleteCity(String city_code) {  
  28.     this.cityMapper.deleteCity(city_code);  
  29.     return 1;  
  30. }  


業務考慮，本示例用的都是 @CacheEvict 清除緩存。若是你的 CUD 可以返回 City 實例，也可使用 @CachePut 更新緩存策略。筆者推薦能用 @CachePut 的地方就不要用 @CacheEvict，由於後者將全部相關方法的緩存都清理掉，好比上面三個方法中的任意一個被調用了的話，provinceCities 方法的全部緩存將被清除。

5. 自定義緩存數據 key 生成策略

對於使用 @Cacheable 註解的方法，每一個緩存的 key 生成策略默認使用的是參數名+參數值，好比如下方法：

[java]  view plain  copy
 
 print?
  1. @Cacheable("users")  
  2. public User findByUsername(String username)  


這個方法的緩存將保存於 key 爲 users~keys 的緩存下，對於 username 取值爲 "趙德芳" 的緩存，key 爲 "username-趙德芳"。通常狀況下沒啥問題，二般狀況如方法 key 取值相等而後參數名也同樣的時候就出問題了，如：

[java]  view plain  copy
 
 print?
  1. @Cacheable("users")  
  2. public Integer getLoginCountByUsername(String username)  


這個方法的緩存也將保存於 key 爲 users~keys 的緩存下。對於 username 取值爲 "趙德芳" 的緩存，key 也爲 "username-趙德芳"，將另一個方法的緩存覆蓋掉。
解決辦法是使用自定義緩存策略，對於同一業務(同一業務邏輯處理的方法，哪怕是集羣/分佈式系統)，生成的 key 始終一致，對於不一樣業務則不一致：

[java]  view plain  copy
 
 print?
  1. @Bean  
  2. public KeyGenerator customKeyGenerator() {  
  3.     return new KeyGenerator() {  
  4.         @Override  
  5.         public Object generate(Object o, Method method, Object... objects) {  
  6.             StringBuilder sb = new StringBuilder();  
  7.             sb.append(o.getClass().getName());  
  8.             sb.append(method.getName());  
  9.             for (Object obj : objects) {  
  10.                 sb.append(obj.toString());  
  11.             }  
  12.             return sb.toString();  
  13.         }  
  14.     };  
  15. }  


因而上述兩個方法，對於 username 取值爲 "趙德芳" 的緩存，雖然都仍是存放在 key 爲 users~keys 的緩存下，但因爲 key 分別爲 "類名-findByUsername-username-趙德芳" 和 "類名-getLoginCountByUsername-username-趙德芳"，因此也不會有問題。
這對於集羣系統、分佈式系統之間共享緩存很重要，真正實現了分佈式緩存。
筆者建議：緩存方法的 @Cacheable 最好使用方法名，避免不一樣的方法的 @Cacheable 值一致，而後再配以以上緩存策略。

6. 緩存的驗證

6.1 緩存的驗證

爲了肯定每一個緩存方法到底有沒有走緩存，咱們打開了 MyBatis 的 SQL 日誌輸出，而且爲了演示清楚，咱們還清空了測試用 Redis 數據庫。
先來驗證 provinceCities 方法緩存，Eclipse 啓動 tomcat 加載項目完畢，使用 JMeter 調用 /bdp/city/province/cities.json 接口：
使用 JMeter 調用 /bdp/city/province/cities.json 接口.png
Eclipse 控制檯輸出以下：
Eclipse 控制檯輸出以下.png
說明這一次請求沒有命中緩存，走的是 db 查詢。JMeter 再次請求，Eclipse 控制檯輸出：
Eclipse 控制檯輸出
標紅部分如下是這一次請求的 log，沒有訪問 db 的 log，緩存命中。查看本次請求的 Redis 存儲狀況：
查看本次請求的 Redis 存儲狀況.png
一樣能夠驗證 city_code 爲 1492 的 searchCity 方法的緩存是否有效：
一樣能夠驗證 city_code 爲 1492 的 searchCity 方法的緩存是否有效.png
圖中標紅部分是 searchCity 的緩存存儲狀況。

6.2 緩存一致性的驗證

先來驗證 insertCity 方法的緩存配置，JMeter 調用 /bdp/city/create.json 接口：
JMeter 調用 /bdp/city/create.json 接口.png
以後看 Redis 存儲：
以後看 Redis 存儲
能夠看出 provinceCities 方法的緩存已被清理掉，insertCity 方法的緩存奏效。
而後驗證 renameCity 方法的緩存配置，JMeter 調用 /bdp/city/rename.json 接口：
JMeter 調用 /bdp/city/rename.json 接口.png
以後再看 Redis 存儲：
以後再看 Redis 存儲.png
searchCity 方法的緩存也已被清理，renameCity 方法的緩存也奏效。

7. 注意事項

  1. 要緩存的 Java 對象必須實現 Serializable 接口，由於 Spring 會將對象先序列化再存入 Redis，好比本文中的 com.defonds.bdp.city.bean.City 類，若是不實現 Serializable 的話將會遇到相似這種錯誤：nested exception is java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type [com.defonds.bdp.city.bean.City]]。
  2. 緩存的生命週期咱們能夠配置，而後託管 Spring CacheManager，不要試圖經過 redis-cli 命令行去管理緩存。好比 provinceCities 方法的緩存，某個省份的查詢結果會被以 key-value 的形式存放在 Redis，key 就是咱們剛纔自定義生成的 key，value 是序列化後的對象，這個 key 會被放在 key 名爲 provinceCities~keys key-value 存儲中，參考下圖"provinceCities 方法在 Redis 中的緩存狀況"。能夠經過 redis-cli 使用 del 命令將 provinceCities~keys 刪除，但每一個省份的緩存卻不會被清除。
  3. CacheManager 必須設置緩存過時時間，不然緩存對象將永不過時，這樣作的緣由如上，避免一些野數據「永久保存」。此外，設置緩存過時時間也有助於資源利用最大化，由於緩存裏保留的永遠是熱點數據。
  4. 緩存適用於讀多寫少的場合，查詢時緩存命中率很低、寫操做很頻繁等場景不適宜用緩存。

provinceCities方法在Redis中的存儲.png

後記

本文完整 Eclipse 下的開發項目示例已上傳 CSDN 資源，有興趣的朋友能夠去下載下來參考：http://download.csdn.net/detail/defonds/9137505。

參考資料

http://blog.csdn.net/defonds/article/details/48716161

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程