spring緩存集成
1. spring為什麼要使用三級緩存解決循環依賴
首先清楚spring中bean 的載入過程：
1 解析需要spring管理的類為beanDefinition
2 通過反射實例化對象
3 反射設置屬性
4初始化，調用initMethod等。（postConstruct也是在這執行）
循環依賴的問題： a依賴b，b依賴a。
在a實例化之後會先將a放入到緩存中，然後給a設置屬性，去緩存中查到b。此時找不到就開始b的創建。b實例化之後，放入到緩存中，需要給a設置屬性，此時去緩存中查到a設置成功。然後初始化。成功後將b放入一級緩存。這個時候a在給自己屬性b設置值的時候就找到了b，然後設置b。完成屬性設置，再初始化，初始化後a放入一級緩存。
解決代理對象（如aop）循環依賴的問題。
例： a依賴b,b依賴a，同時a,b都被aop增強。
首先明確aop的實現是通過 postBeanProcess後置處理器，在初始化之後做代理操作的。
為什麼使用三級緩存原因：
1 只使用二級緩存，且二級緩存緩存的是一個不完整的bean
如果只使用二級緩存，且二級緩存緩存的是一個不完整的bean，這個時候a在設置屬性的過程中去獲取b（這個時候a還沒有被aop的後置處理器增強），創建b的過程中，b依賴a，b去緩存中拿a拿到的是沒有經過代理的a。就有問題。
2 使用二級緩存，且二級緩存是一個工廠方法的緩存
如果二級緩存是一個工廠的緩存，在從緩存中獲取的時候獲取到經過aop增強的對象。可以看到從工廠緩存中獲取的邏輯。
protected ObjectgetEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && ()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bpinstanceof ) {
ibp = () bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
a依賴b，b依賴a，c。c又依賴a。a,b，c均aop增強。
載入開始： a實例化，放入工廠緩存，設置b，b實例化，設置屬性，拿到a,此時從工廠緩存中拿到代理後的a。由於a沒載入完畢，不會放入一級緩存。這個時候b開始設置c,c實例化，設置屬性a,又去工廠緩存中拿對象a。這個時候拿到的a和b從工廠緩存不是一個對象。出現問題。
3 使用二級緩存，二級緩存緩存的是增強後的bean。這個與spring載入流程不符合。spring載入流程是：實例化，設置屬性，初始化，增強。在有循環引用的時候，之前的bean並不會增強後放入到二級緩存。
綜上1，2，3 可知二級緩存解決不了有aop的循環依賴。spring採用了三級緩存。
一級緩存 singletonObjects 緩存載入完成的bean。
二級緩存 earlySingletonObjects 緩存從三級緩存中獲取到的bean，此時裡面的bean沒有載入完畢。
三級緩存 singletonFactories 。緩存一個objectFactory工廠。
場景：a依賴b，b依賴a和c，c依賴a。並且a，b，c都aop增強。
載入過程：
a實例化，放入三級工廠緩存，設置屬性b，b實例化放入三級緩存。b設置屬性a，從三級工廠緩存中獲取代理後的對象a，同時，代理後的a放入二級緩存，然後設置屬性c，c實例化放入三級緩存，設置屬性a,此時從二級緩存中獲取到的代理後的a跟b中的a是一個對象，屬性a設置成功。c初始化，然後執行後置處理器。進行aop的增強。增強後將代理的c放入到一級緩存，同時刪除三級緩存中的c。c載入完成，b得到c，b設置c成功。b初始化，然後執行後置處理器，進行aop增強，將增強後的代理對象b放入到一級緩存。刪除三級緩存中的b。此時 a拿到b，設置屬性b成功，開始初始化，初始化後執行後置處理器。在aop的後置處理器中有一個以beanName為key，經過aop增強的代理對象為value的map earlyProxyReferences。
這個時候 後置處理器處理對象a的時候，
public (@Nullable Object bean, String beanName) {
if (bean !=null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
也就是 發現這個beanName已經被代理後就不在代理。這個時候執行後置處理器後，a還是未經代理的對象a。此時a再通過getSingleton 重新從緩存中獲取一下a。
Object earlySingletonReference = getSingleton(beanName, false);
false 表示不從三級緩存中取，只從一級，二級緩存中獲取。
這個時候能拿到二級緩存中的a。二級緩存中的a也是經過代理後的a。
然後將代理後的a放入到一級緩存中。a載入完畢。
放入一級緩存的過程 ：
addSingleton(beanName, singletonObject);
從三級工廠緩存中獲取對象：
protected ObjectgetEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && ()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bpinstanceof ) {
ibp = () bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
其中 AbstractAutoProxyCreator實現該介面。
public ObjectgetEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
return wrapIfNecessary(bean, beanName, cacheKey);
}
wrapIfNecessary（）就是真正執行代理的。
bean初始化之後執行的後置處理器：
其中AbstractAutoProxyCreator 實現了該介面。
2. spring一級緩存和二級緩存的區別是什麼
一級緩存：x0dx0a就是Session級別的緩存。一個Session做了一個查詢操作，它會把這個操作的結果放在一級緩存中。x0dx0a如果短時間內這個session（一定要同一個session）又做了同一個操作，那麼hibernate直接從一級緩存中拿，而不會再去連資料庫，取數據。x0dx0a它是內置的事務范圍的緩存，不能被卸載。x0dx0a二級緩存：x0dx0a就是SessionFactory級別的緩存。顧名思義，就是查詢的時候會把查詢結果緩存到二級緩存中。x0dx0a如果同一個sessionFactory創建的某個session執行了相同的操作，hibernate就會從二級緩存中拿結果，而不會再去連接資料庫。x0dx0a這是可選的插件式的緩存，在默認情況下，SessionFactory不會啟用這個插件。x0dx0a可以在每個類或每個集合的粒度上配置。緩存適配器用於把具體的緩存實現軟體與Hibernate集成。x0dx0a嚴格意義上說，SessionFactory緩存分為兩類：內置緩存和外置緩存。我們通常意義上說的二級緩存是指外置緩存。x0dx0a內置緩存與session級別緩存實現方式相似。前者是SessionFactory對象的一些集合屬性包含的數據，後者是指Session的一些集合屬性包含的數據x0dx0aSessionFactory的內置緩存中存放了映射元數據和預定義sql語句。x0dx0a映射元數據是映射文件中數據的拷貝；x0dx0a而預定義SQL語句是在Hibernate初始化階段根據映射元數據推導出來。x0dx0aSessionFactory的內置緩存是只讀的，應用程序不能修改緩存中的映射元數據和預定義SQL語句，因此SessionFactory不需要進行內置緩存與映射文件的同步。x0dx0aHibernate的這兩級緩存都位於持久化層，存放的都是資料庫數據的拷貝。x0dx0a緩存的兩個特性：x0dx0a緩存的范圍x0dx0a緩存的並發訪問策略x0dx0a1、緩存的范圍x0dx0a決定了緩存的生命周期以及可以被誰訪問。緩存的范圍分為三類。x0dx0a事務范圍x0dx0a進程范圍x0dx0a集群范圍x0dx0a註：x0dx0a對大多數應用來說，應該慎重地考慮是否需要使用集群范圍的緩存，因為訪問的速度不一定會比直接訪問資料庫數據的速度快多少。x0dx0a事務范圍的緩存是持久化層的第一級緩存，通常它是必需的；進程范圍或集群范圍的緩存是持久化層的第二級緩存，通常是可選的。x0dx0a2、緩存的並發訪問策略x0dx0a當多個並發的事務同時訪問持久化層的緩存的相同數據時，會引起並發問題，必須採用必要的事務隔離措施。x0dx0a在進程范圍或集群范圍的緩存，即第二級緩存，會出現並發問題。x0dx0a因此可以設定以下四種類型的並發訪問策略，每一種策略對應一種事務隔離級別。x0dx0a事務型並發訪問策略是事務隔離級別最高，只讀型的隔離級別最低。事務隔離級別越高，並發性能就越低。x0dx0aA 事務型：僅僅在受管理環境中適用。它提供了Repeatable Read事務隔離級別。x0dx0a對於經常被讀但很少修改的數據，可以採用這種隔離類型，因為它可以防止臟讀和不可重復讀這類的並發問題。x0dx0aB 讀寫型：提供了Read Committed事務隔離級別。僅僅在非集群的環境中適用。x0dx0a對於經常被讀但很少修改的數據，可以採用這種隔離類型，因為它可以防止臟讀這類的並發問題。x0dx0aC 非嚴格讀寫型：不保證緩存與資料庫中數據的一致性。x0dx0a如果存在兩個事務同時訪問緩存中相同數據的可能，必須為該數據配置一個很短的數據過期時間，從而盡量避免臟讀。x0dx0a對於極少被修改，並且允許偶爾臟讀的數據，可以採用這種並發訪問策略。x0dx0aD 只讀型：對於從來不會修改的數據，如參考數據，可以使用這種並發訪問策略。x0dx0a什麼樣的數據適合存放到第二級緩存中？x0dx0a1、很少被修改的數據x0dx0a2、不是很重要的數據，允許出現偶爾並發的數據x0dx0a3、不會被並發訪問的數據x0dx0a4、參考數據x0dx0a不適合存放到第二級緩存的數據？x0dx0a1、經常被修改的數據x0dx0a2、財務數據，絕對不允許出現並發x0dx0a3、與其他應用共享的數據。x0dx0aHibernate的二級緩存策略的一般過程如下：x0dx0a1) 條件查詢的時候，總是發出一條select * from table_name where ?. （選擇所有欄位）這樣的SQL語句查詢資料庫，一次獲得所有的數據對象。x0dx0a2) 把獲得的所有數據對象根據ID放入到第二級緩存中。x0dx0a3) 當Hibernate根據ID訪問數據對象的時候，首先從Session一級緩存中查；查不到，如果配置了二級緩存，那麼從二級緩存中查；查不到，再查詢資料庫，把結果按照ID放入到緩存。x0dx0a4) 刪除、更新、增加數據的時候，同時更新緩存。x0dx0a註：x0dx0aHibernate的二級緩存策略，是針對於ID查詢的緩存策略，對於條件查詢則毫無作用。為此，Hibernate提供了針對條件查詢的Query緩存。x0dx0aQuery緩存策略的過程如下：x0dx0a1) Hibernate首先根據這些信息組成一個Query Key，Query Key包括條件查詢的請求一般信息：SQL, SQL需要的參數，記錄范圍（起始位置rowStart，最大記錄個數maxRows)，等。x0dx0a2) Hibernate根據這個Query Key到Query緩存中查找對應的結果列表。如果存在，那麼返回這個結果列表；如果不存在，查詢資料庫，獲取結果列表，把整個結果列表根據Query Key放入到Query緩存中。x0dx0a3) Query Key中的SQL涉及到一些表名，如果這些表的任何數據發生修改、刪除、增加等操作，這些相關的Query Key都要從緩存中清空。
3. SpringBoot進階之整合Shiro實現緩存和會話管理
大家好，一直以來我都本著用最通俗的話理解核心的知識點, 我認為所有的難點都離不開 「基礎知識」 的鋪墊。目前正在出一個 SpringBoot 長期系列教程，從入門到進階, 篇幅會較多~
「大佬可以繞過 ~」
如果你是一路看過來的，很高興你能夠耐心看完。之前帶大家學了 Springboot 基礎部分，對基本的使用有了初步的認識, 接下來的幾期內容將會帶大家進階使用，會先講解基礎 中間件 的使用和一些場景的應用，或許這些技術你聽說過，沒看過也沒關系，我會帶大家一步一步的入門，耐心看完你一定會有 收獲 ~
上期帶大家學習了 Shiro 中如何進行許可權認證，本期將帶大家學習 Shiro 中如何進行 緩存和會話管理 ，最後我們將做一個在線用戶管理以及強制下線用戶的功能，同樣的，我們集成到 Springboot 中。
首先我們要明白使用緩存的原因，為啥要用它 還記得之前帶大家實現的 用戶認證 和 許可權認證 嗎，那裡我使用了 MockUser ，真實場景中是要去數據查詢的，這樣一來就會產生耗時，請求多的時候資料庫肯定忙不過來了，所以我們需要使用緩存來提高程序響應速度
緩存使用 Redis ,下面就帶大家整一下:
修改 ShiroConfig ,添加方法
這樣就可以了，大家可以把測試獲取用戶的地方改成資料庫獲取，看下 控制台 sql日誌會明顯減少，因為有一部分是從緩存拿的
這部分功能還是比較好玩的，學完可以自由發揮做一個房間功能,可以加入可以踢人,下面我們就開整
修改 ShiroConfig ,添加方法，因為我們使用的是 Redis 緩存
實現 SessionListener
最後同樣的，想要開啟需要我們注入到 Manager 中:
我們先定義一個類，用來記錄在線用戶:
那麼怎麼獲取呢？我們定義一個方法,大家實踐中可以抽到 Service 層,這里方便演示，我直接寫到控制器里
如果你看誰不爽，可以直接讓他下線，hhh~
是不是很簡單,這里就不演示了，大家自行試試
本期內容就到這里結束了，總結一下，本節主要講了 Shiro 如何進行緩存以及如何進行用戶會話管理，大家可以舉一反三，做一些小功能嘗試嘗試
下期給大家講講 Shiro 中如何整合 JWT ，這個大家應該不陌生，如果不知道啥是 JWT 也沒關系，我會帶大家一步一步入門，下期也是 Shiro 系列的終極篇，內容可能有點多，耐心看完哦。歡迎加群一起學習交流 ~
4. SpringBoot進階之緩存中間件Redis
大家好，一直以來我都本著 用最通俗的話理解核心的知識點， 我認為所有的難點都離不開 「基礎知識」 的鋪墊
「大佬可以繞過 ~」
本節給大家講講 「java的SpringBoot框架」 , 之前我們學習的都是java的基礎知識和底層提供的一些能力，我們日常工作都是在寫介面。在我們在產品開發中，一般我們都會選擇比較穩定的框架來幫我們加速開發，不會自己去造輪子，而在java眾多框架中，spring框架表現的非常好，大部分公司都會首選它作為開發框架，而至今，大部分企業都是以 springboot 來構建項目了,一個穩健的系統需要引入穩定的技術~
如果你是一路看過來的，很高興你能夠耐心看完。前幾期都是帶大家學習了 SpringBoot 的基礎使用以及集成 mybatis 開發，這也是我們寫業務的基礎，如果你還不熟悉這些，請先看完它們。接下來的幾期內容將會帶大家進階使用，會先講解基礎 中間件 的使用和一些場景的應用，或許這些技術你聽說過，沒看過也沒關系，我會帶大家一步一步的入門，耐心看完你一定會有 收獲 ,本期將會給大家講解最熱門的緩存中間件技術 Redis ,同樣的，我們集成到 Springboot 中。最近github可能會被牆，所以我把源碼放到了國內gitee上,本節我們依然使用上期的代碼
Redis 是由義大利人Salvatore Sanfilippo（網名：antirez）開發的一款內存高速緩存資料庫。全稱叫 Remote Dictionary Server（遠程數據服務） 是由 C語言 編寫的，Redis是一個 key-value 存儲系統，它支持豐富的數據類型，如： string、list、set、zset(sorted set)、hash 。
它本質上是一種鍵值對資料庫，我們之前學習的 mysql 它是持久層的關系型資料庫,而 redis 它的存儲主要存在 內存 中。我們都知道在 內存 中的數據讀取是非常快的，就好比你把一個變數存到磁碟讀取和直接放到代碼中運行，肯定是在代碼中拿到的速度快，因為運行時期，都是直接存到內存的。
給大家總結一下：
有了基本的概念之後，我們下面進行環境搭建,在學習階段，安裝 redis 很簡單,生產環境一般我們也會選擇雲產品，一切為了服務保障,雖說它只是做緩存用，但也是系統的一把 保護傘
如果你是 mac 用戶，你可以運行如下命令:
安裝完成後會提示你運行命令，運行即可。
win 用戶也很簡單，直接下載 redis 軟體，雙擊運行即可，運行之後它會有一個小方塊的圖案，和 locahost:6379 的log,說明運行成功了。初始階段沒有配置的 redis 默認 host 就是本地, port 就是 6379 , 而且是 沒有密碼 就可以訪問的。
推薦一個客戶端軟體 Redis Desktop Manager ，它是 redis 的客戶端界面軟體,方便麵我們學習的時候 清理緩存 使用,生產慎連。
我們不給大家講它的基本命令使用，它也有語法，可以通過類似命令執行,如果想學習的小夥伴，可以自行搜索。本期重點內容是在 sprinboot 中的使用,我們平時開發不可能是去命令行里敲的，都是代碼里執行，而目前市面上有很多封裝好的庫，我們可以直接調用它的方法，很方便的就可以操作它了，不用記一些繁瑣的命令,下面我們就實際操作一下:
修改 pom.xml
修改 application.yml :
redis 默認是有 16 個庫,不是 15 個啊，從 0 開始算的,我們隨便連一個
通過代碼很好理解, 首先需要引入 StringRedisTemplate ,然後需要設置一個 key ,那麼思考一下，這個 key 允許重復嗎
我們進客戶端看一下，發現 key 還是只有一個,但是值變成了新的值了，所以可以得知 key 是唯一的，我們重新設置的時候相當於刷新了它。
在 redis 中刪除緩存有兩種方式，一種是自我消亡，也就是 過期 銷毀,還有有一種是 主動 銷毀，我們先看一下，過期時間如何設置
我們設置了 10s 後過期,過完10s後發現，這個```key data``消失了。我們在看看如何主動刪除
我們可以利用 Redis 做一個計數器，實現自增功能,你可以用它做網站訪問統計
通常做法，我們會把它封裝一下，後續使用直接引入封裝好的即可，把它直接交給 Springboot容器 管理
其實這個類，你還可以繼續進一步封裝，比如約束 key 的規范，約束過期時間，約束數據類型等等，這一切也都是為了規范和後期維護，防止濫用緩存
緩存的主要場景是用於解決熱點數據問題，因為這些數據是訪問頻率比較高的，當大量的請求進來, mysql 可能壓力很大，這樣一來，數據查詢效率就很慢，用戶肯不高興等了，這樣用戶體驗很不好。所以我們一般做法，都是把這些熱點數據放到緩存里，因為緩存讀取速度很快。當有新數據的時候，我們再及時更新它，一般流程是先查詢緩存，查到了直接返回緩存數據，查不到再走資料庫，然後再刷回緩存。
但是並發足夠大的時候，還是會暴露出很多問題，比如面試常問的一些高頻問題 緩存雪崩、緩存穿透、緩存雪崩 ,這些問題後邊會給大家專門講，和如何去防範。所以總的來說，引入任何一門技術並不是萬事大吉，還需我們不斷的在實踐中積累經驗
本期到這里就結束了，總結一下，我們了解了什麼是 redis ，以及在 springboot 中如何去使用它們，很簡單，沒什麼復雜的東西。但這里想多說一點的是，緩存的設計卻是很復雜的，因為工具是死的，人是活的，我們如何正確設計，需要我們在項目中不斷的積累。
我們之前教大家查詢列表數據，都是所有數據返回，還沒有教大家如何去做分頁，下期將帶大家學習一下 mybatis 分頁插件的使用 ，下期不見不散, 關注我，不迷路~
5. spring自帶緩存機制怎麼弄
此緩存方法既適用於層，也適用於service層。
spring配置文件配置：<!--緩存配置-->
<!--啟用緩存註解功能-->
<cache:annotation-drivencache-manager="cacheManager"/>
<!--spring自己的基於java.util.concurrent.ConcurrentHashMap實現的緩存管理器（該功能是從Spring3.1開始提供）-->
<beanid="cacheManager"class="org.springframework.cache.support.SimpleCacheManager">
<propertyname="caches">
<set>
<!--此處類concurrentMapCacheFactoryBean的作用是
-->
<beanname="myCache"class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"/>
</set>
</property>
</bean>service層示例如下：@Transactional(readOnly=true)
@Cacheable(value="myCache")
publicJsonObjectgetWFK(JsonObjectparams){
OneObob=newOneOb();
try{
List<Map<String,Object>>map=LawAssistantMapper.getWFK();
ob.setOb(map);
}catch(Exceptione){
e.printStackTrace();
ob.setCode(500);
ob.setMsg("伺服器錯誤！！！");
returnnewJsonObject(Json.encode(ob));
}
ob.setCode(200);
ob.setMsg("ok");
logger.debug(Json.encode(ob));
returnnewJsonObject(Json.encode(ob));
}
由於使用的是spring自帶的緩存類，所以，僅僅需要兩步：1.在spring配置文件中聲明，2.在service層，方法代碼前增加註解，即可。
缺點：
spring自帶的緩存功能，實質上是通過java類來保存緩存的數據，這樣會佔用一定的內存消耗，並發率越高，對內存的壓力越大。
碼民直接使用的緩存類：org.springframework.cache.support.SimpleCacheManager，org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean
6. hibernate二級緩存 和 spring整合的緩存(就是用哪個Cacheable註解的)有什麼區別么
二級緩存配置（spring+hibernate）
說明：本人不建議使用查詢緩存，因為查詢緩存要求完全相同的查詢sql語句才會起作用，所說的查詢緩存是針對第二次查詢時 sql語句與第一次sql語句完全相同 那麼就可以從緩存中取數據而不去資料庫中取數據了，在不啟用查詢緩存的情況下 每次的查詢數據也會緩存到二級緩存的 只不過每次查詢都會去查詢資料庫（不包括根據ID查詢），啟用查詢緩存很麻煩 需要每次查詢時 調用Query.setCacheable(true)方法才可以，如：List<OrgiData> orgiDatas = (List<OrgiData>) s.createQuery("from OrgiData").setCacheable(true).list();
因此建議將查詢緩存設置為如下：
hibernate.cache.use_query_cache=false
還有就是最重要的一點：對於經常修改或重要的數據不宜進行緩存，因為多並發時會造成數據不同步的情況。
首先增加ehcache-1.4.1.jar和backport-util-concurrent-3.1.jar或oscache-2.1.jar
一、spring配置
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources">
<list>
<value>com/handpay/core/merchant/bean/MerchGroupBuy.hbm.xml
</value>
</list>
</property>
<property name="hibernateProperties">
<value>
hibernate.dialect=org.hibernate.dialect.SQLServerDialect
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.hbm2ddl.auto=update
hibernate.cache.use_second_level_cache=true
hibernate.cache.use_query_cache=false
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider </value>
</property>
</bean>
<!---紅色字體是二級緩存相關的設置->
二、hbm.xml文件示例
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.handpay.core.merchant.bean">
<class name="MerchGroupBuy" table="merch_group_buy">
<cache usage="read-write" region="com.handpay.core.merchant.bean.MerchGroupBuy"/>
<id name="id">
<generator class="native" />
</id>
<property name="code" />
<property name="createTime"/>
<property name="minNum"/>
<property name="status">
</property>
<property name="title"/>
<property name="typeCode"/>
<property name="updateTime"/>
</class>
</hibernate-mapping>
三、註解示例
@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
@Table(name = "alcor_t_countries", catalog = "alcorweb")
public class AlcorTCountries implements java.io.Serializable{。。。。}
四、配置文件參數詳解
ehcache.xml是ehcache的配置文件，並且存放在應用的classpath中。下面是對該XML文件中的一些元素及其屬性的相關說明：
<diskStore>元素：指定一個文件目錄，當EHCache把數據寫到硬碟上時，將把數據寫到這個文件目錄下。 下面的參數這樣解釋：
user.home – 用戶主目錄
user.dir – 用戶當前工作目錄
java.io.tmpdir – 默認臨時文件路徑
<defaultCache>元素：設定緩存的默認數據過期策略。
<cache>元素：設定具體的命名緩存的數據過期策略。
<cache>元素的屬性
name：緩存名稱。通常為緩存對象的類名（非嚴格標准）。
maxElementsInMemory：設置基於內存的緩存可存放對象的最大數目。
maxElementsOnDisk：設置基於硬碟的緩存可存放對象的最大數目。
eternal：如果為true，表示對象永遠不會過期，此時會忽略timeToIdleSeconds和timeToLiveSeconds屬性，默認為false;
timeToIdleSeconds： 設定允許對象處於空閑狀態的最長時間，以秒為單位。當對象自從最近一次被訪問後，如果處於空閑狀態的時間超過了timeToIdleSeconds屬性值，這個對象就會過期。當對象過期，EHCache將把它從緩存中清空。只有當eternal屬性為false，該屬性才有效。如果該屬性值為0，則表示對象可以無限期地處於空閑狀態。
timeToLiveSeconds：設定對象允許存在於緩存中的最長時間，以秒為單位。當對象自從被存放到緩存中後，如果處於緩存中的時間超過了 timeToLiveSeconds屬性值，這個對象就會過期。當對象過期，EHCache將把它從緩存中清除。只有當eternal屬性為false，該屬性才有效。如果該屬性值為0，則表示對象可以無限期地存在於緩存中。timeToLiveSeconds必須大於timeToIdleSeconds屬性，才有意義。
overflowToDisk：如果為true,表示當基於內存的緩存中的對象數目達到了maxElementsInMemory界限後，會把益出的對象寫到基於硬碟的緩存中。注意：如果緩存的對象要寫入到硬碟中的話，則該對象必須實現了Serializable介面才行。
memoryStoreEvictionPolicy：緩存對象清除策略。有三種：
1 FIFO ，first in first out ，這個是大家最熟的，先進先出，不多講了
2 LFU ， Less Frequently Used ，就是上面例子中使用的策略，直白一點就是講一直以來最少被使用的。如上面所講，緩存的元素有一個hit 屬性，hit 值最小的將會被清出緩存。
2 LRU ，Least Recently Used ，最近最少使用的，緩存的元素有一個時間戳，當緩存容量滿了，而又需要騰出地方來緩存新的元素的時候，那麼現有緩存元素中時間戳離當前時間最遠的元素將被清出緩存。
五 、查看 二級緩存數據
1、使用sessionFactory直接獲取
Map cacheEntries = sessionFactory().getStatistics()
.getSecondLevelCacheStatistics("cacheRegionName")
.getEntries();
其中 cacheRegionName 既是 ehcache.xml配置中的<cache 標簽的name屬性值
2、讓log4j列印緩存信息（生成環境下請注釋掉，以免影響性能）
log4j.logger.org.hibernate.cache=debug
7. spring mvc 怎麼設計緩存
用於提供如瀏覽器緩存控制、是否必須有session開啟、支持的請求方法類型（GET、POST等）等，該類主要有如下屬性：
Set<String> supportedMethods：設置支持的請求方法類型，默認支持「GET」、「POST」、「HEAD」，如果我們想支持「PUT」，則可以加入該集合「PUT」。
boolean requireSession = false：是否當前請求必須有session，如果此屬性為true，但當前請求沒有打開session將拋出HttpSessionRequiredException異常；
boolean useExpiresHeader = true：是否使用HTTP1.0協議過期響應頭：如果true則會在響應頭添加：「Expires：」；需要配合cacheSeconds使用；
boolean useCacheControlHeader = true：是否使用HTTP1.1協議的緩存控制響應頭，如果true則會在響應頭添加；需要配合cacheSeconds使用；
boolean useCacheControlNoStore = true：是否使用HTTP 1.1協議的緩存控制響應頭，如果true則會在響應頭添加；需要配合cacheSeconds使用；
private int cacheSeconds = -1：緩存過期時間，正數表示需要緩存，負數表示不做任何事情（也就是說保留上次的緩存設置），
1、cacheSeconds =0時，則將設置如下響應頭數據：
Pragma：no-cache // HTTP 1.0的不緩存響應頭
Expires：1L // useExpiresHeader=true時，HTTP 1.0
Cache-Control ：no-cache // useCacheControlHeader=true時，HTTP 1.1
Cache-Control ：no-store // useCacheControlNoStore=true時，該設置是防止Firefox緩存
2、cacheSeconds>0時，則將設置如下響應頭數據：
Expires：System.currentTimeMillis() + cacheSeconds * 1000L // useExpiresHeader=true時，HTTP 1.0
Cache-Control ：max-age=cacheSeconds // useCacheControlHeader=true時，HTTP 1.1
3、cacheSeconds<0時，則什麼都不設置，即保留上次的緩存設置。
此處簡單說一下以上響應頭的作用，緩存控制已超出本書內容：
HTTP1.0緩存控制響應頭
Pragma：no-cache：表示防止客戶端緩存，需要強制從伺服器獲取最新的數據；
Expires：HTTP1.0響應頭，本地副本緩存過期時間，如果客戶端發現緩存文件沒有過期則不發送請求，HTTP的日期時間必須是格林威治時間（GMT），如「Expires:Wed, 14 Mar 2012 09:38:32 GMT」；
HTTP1.1緩存控制響應頭
Cache-Control ：no-cache 強制客戶端每次請求獲取伺服器的最新版本，不經過本地緩存的副本驗證；
Cache-Control ：no-store 強制客戶端不保存請求的副本，該設置是防止Firefox緩存
Cache-Control：max-age=[秒] 客戶端副本緩存的最長時間，類似於HTTP1.0的Expires，只是此處是基於請求的相對時間間隔來計算，而非絕對時間。
還有相關緩存控制機制如Last-Modified（最後修改時間驗證，客戶端的上一次請求時間 在 伺服器的最後修改時間 之後，說明伺服器數據沒有發生變化 返回304狀態碼）、ETag（沒有變化時不重新下載數據，返回304）。
該抽象類默認被AbstractController和WebContentInterceptor繼承。
8. Spring本地緩存的使用方法
我們現在在用的Spring Cache，可以直接看Spring Boot提供的緩存枚舉類，有如下這些：
EhCache：一個純Java的進程內緩存框架，所以也是基於本地緩存的。(注意EhCache2.x和EhCache3.x相互不兼容)。
Redis：分布式緩存，只有Client-Server(CS)模式，Java一般使用Jedis/Luttuce來操縱。
Hazelcast：基於內存的數據網格。雖然它基於內存，但是分布式應用程序可以使用Hazelcast進行分布式緩存、同步、集群、處理、發布/訂閱消息等。
Guava：它是Google Guava工具包中的一個非常方便易用的本地化緩存實現，基於LRU（最近最少使用）演算法實現，支持多種緩存過期策略。在Spring5.X以後的版本已經將他標記為過期了。
Caffeine：是使用Java8對Guava緩存的重寫版本，在Spring5中將取代了Guava，支持多種緩存過期策略。
SIMPLE：使用ConcurrentMapCacheManager，因為不支持緩存過期時間，所以做本地緩存基本不考慮該方式。
關於分布式緩存，我們需要後面會專門討論Redis的用法，這里只看本地緩存。性能從高到低，依次是Caffeine，Guava，ConcurrentMapCacheManager，其中Caffeine在讀寫上都快了Guava近一倍。
這里我們只討論在Spring Boot裡面怎麼整合使用Caffeine和EhCache。
主要有以下幾個步驟：
1)加依賴包：
2)配置緩存：
這里有兩種方法，通過文件配置或者在配置類裡面配置，先看一下文件配置，我們可以寫一個properties文件，內容像這樣：
然後還要在主類中加上@EnableCaching註解：
另外一種更靈活的方法是在配置類中配置：
應用類：
測試類：
導入依賴包，分為2.x版本和3.x版本。
其中2.x版本做如下導入：
3.x版本做如下導入：
導包完成後，我們使用JCacheManagerFactoryBean + ehcache.xml的方式配置：
參考資料：
https://blog.csdn.net/f641385712/article/details/94982916
http://www.360doc.com/content/17/1017/20/16915_695800687.shtml
9. SpringBoot整合SpringSeesion實現Redis緩存
使用Spring Boot開發項目時我們經常需要存儲Session，因為Session中會存一些用戶信息或者登錄信息。傳統的web服務是將session存儲在內存中的，一旦服務掛了，session也就消失了，這時候我們就需要將session存儲起來，而Redis就是用來緩存seesion的一種非關系型資料庫，我們可以通過配置或者註解的方式將Spring Boot和Redis整合。而在分布式系統中又會涉及到session共享的問題，多個服務同時部署時session需要共享，Spring Session可以幫助我們實現這一功能。將Spring Session集成到Spring Boot框架中並使用Redis進行緩存是目前非常流行的解決方案，接下來就跟著我一起學習吧。
工具/材料
IntelliJ IDEA
首先我們創建一個Spring Boot 2.x的項目，在application.properties配置文件中添加Redis的配置，Spring和Redis的整合可以參考我其他的文章，此處不再詳解。我們設置服務埠server.port為8080埠用於啟動第一個服務。
接下來我們需要在pom文件中添加spring-boot-starter-data-redis和spring-session-data-redis這兩個依賴，spring-boot-starter-data-redis用於整合Spring Boot和Redis，spring-session-data-redis集成了spring-session和spring-data-redis，提供了session與redis的整合方案。
接下來我們創建一個配置類RedisSessionConfig，這個類使用@Configuration註解表明這是一個配置類。在這個類上我們同時添加註解@EnableRedisHttpSession，表示開啟Redis的Session管理。如果需要設置失效時間可以使用@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600)表示一小時後失效。若同時需要設置Redis的命名空間則使用@EnableRedisHttpSession(maxInactiveIntervalInSeconds=3600, redisNamespace="{spring.session.redis.namespace}") ，其中{spring.session.redis.namespace}表示從配置文件中讀取這個命名空間。
配置完成後我們寫一個測試類SessionController，在這個類中我們寫兩個方法，一個方法用於往session中存數據，一個用於從session中取數據，代碼如下圖所示，我們存取請求的url。啟動類非常簡單，一般都是通用的，我們創建一個名為SpringbootApplication的啟動類，使用main方法啟動。
接下來我們使用Postman分別請求上面兩個介面，先請求存數據介面，再請求取數據介面，結果如下圖所示，我們可以看到數據已從redis中取出。另外需要注意sessionId的值，這是session共享的關鍵。
為了驗證兩個服務是否共享了session，我們修改項目的配置文件，將服務埠server.port改為8090，然後再啟動服務。此時我們不必在請求存數據的介面，只需要修改請求埠號再一次請求取數據的介面即可。由下圖可以看到兩次請求的sessionId值相同，實現了session的共享。
以上我們完成了SpringBoot整合SpringSeesion實現Redis緩存的功能，在此我們還要推薦一個Redis的可視化工具RedisDesktopManager，我們可以配置Redis資料庫的連接，然後便可以非常直觀地查看到存儲到Redis中的session了，如下圖所示，session的命名空間是share，正是從配置文件中讀取到的。
特別提示
如果Redis伺服器是很多項目共用的，非常建議配置命名空間，否則同時打開多個項目的瀏覽器頁面可能會導致session錯亂的現象。