故事背景

隨著硬件價格的走低，大家對硬件的依賴越來越高。甚至聽說，代碼不重要，不行就加機器唄。比如緩存的使用，通常有基于虛擬機內存、基于磁盤存儲、基于中間件(Redis內存)等方式，我們都知道，最適合的才是最好的，但實踐中，往往是動不動就直接上Redis。

那么，Redis一定是最好的選擇嗎?單不說對內存的要求，從效率和性能上來說，也未必是最優的。所以，不同的場景使用不同的緩存策略才是高手應該追求的。

這篇文章就帶大家認識除Redis之外的另一種緩存框架：EhCache。之所以要寫寫，也是因為項目中運用了此框架，同時又遇到點問題，于是決定深入研究一下。研究之后，發現還真有點意思。

EhCache簡介

EhCache是一個純Java的進程內緩存框架，具有快速、精干的特點。注意的這里的關鍵字進程，基于進程的緩存直覺告訴我們效率肯定要高一些，因為它直接在進程之內進行操作，但不同應用之間緩存的共享可能就會有問題。

EhCache是Hibernate中默認的CacheProvider，Spring Boot也對其進行了支持，Spring中提供的緩存抽象也支持對EhCache緩存框架的綁定，而且支持基于注解的方式來使用。因此，EhCache是一款被廣泛使用的基于Java的高速緩存框架，使用起來也非常方便。

EhCache提供了多種緩存策略，主要分為內存和磁盤兩級，是一款面向通用緩存、Java EE和輕量級容器的緩存框架。

EhCache的特點

簡單說一下該框架的特點：

• 簡單、快速，擁有多種緩存策略;
• 緩存數據有兩級：內存和磁盤，無需擔心容量問題;
• 緩存數據會在虛擬機重啟的過程中寫入磁盤;
• 可以通過RMI、可插入API等方式進行分布式緩存;
• 具有緩存和緩存管理器的偵聽接口;
• 支持多緩存管理器實例，以及一個實例的多個緩存區域，并提供Hibernate的緩存實現。

EhCache可以單獨使用，但通常會與Mybatis、Shiro等三方類庫結合使用。本人項目中使用EhCache就是結合Shiro來使用的。

除了優點，EhCache也還有一些缺點。比如，非常占用磁盤空間，這是因為DiskCache的算法簡單，只是對元素直接追加存儲。這樣雖然可以提高效率，但在使用頻繁的系統中，磁盤很快會滿。

另外就是不能保證數據安全，當然突然kill掉Java進程時，可能會產生沖突。EhCache解決沖突的方法是重建Cache，這對Cache數據需要保持時可能會產生影響。Cache只是簡單的加速，不能保證數據的安全。

EhCache與Redis

EhCache直接在JVM中進行緩存，速度快，效率高。與Redis相比，操作簡單、易用、高效，雖然EhCache也提供有緩存共享的方案，但對分布式集群的支持不太好，緩存共享實現麻煩。

Redis是通過Socket訪問到緩存服務，效率比EhCache低，比數據庫要快很多，處理集群和分布式緩存方便，有成熟的方案。

所以，如果是單體應用，或對緩存訪問要求很高，可考慮采用EhCache;如果是大型系統，存在緩存共享、分布式部署、緩存內容很大時，則建議采用Redis。

EhCache架構圖

看一下EhCache的架構圖，大概了解一下它由幾部分組成。

Ehcache-architecture

Cache Replication部分提供了緩存復制的機制，用于分布式環境。EhCache最初是獨立的本地緩存框架組件，在后期的發展中，結合Terracotta服務陣列模型，可以支持分布式緩存集群，主要有RMI、JGroups、JMS和Cache Server等傳播方式進行節點間通信。

In-process APIs則提供了基于JSR、JMX等標準的支持，能夠較好的兼容和移植，同時對各類對象有較完善的監控管理機制。

Network APIs則對外提供了基于RESTful API、JMS API、Cache Server等方式的支持。

在使用過程中，需要關注的核心部分便是中間的Core部分了。它包含了核心的API和概念：

• CacheManager：緩存管理器，可以通過單例或者多例的方式創建，也是Ehcache的入口類。
• Cache：每個CacheManager可以管理多個Cache，每個Cache可以采用hash的方式管理多個Element。所有cache都實現了Ehcache接口;
• Element：單條緩存數據的組成單位，用于存放真正緩存內容的。

三者的管理可以用下圖表示：

CacheManager

緩存過期策略

在架構圖中還可以看到Memory Store LRU、Memory Store LFU、Memory Store FIFO等內存存儲算法。也就是當緩存占用空間接近臨界值時，會采用上面的淘汰策略來清理掉一部分數據。

EhCache提供了三種淘汰算法：

• FIFO：First In First Out，先進先出。判斷被存儲的時間，離目前最遠的數據優先被淘汰。
• LRU：Least Recently Used，最近最少使用。判斷最近被使用的時間，目前最遠的數據優先被淘汰。
• LFU：Least Frequently Used，最不經常使用。在一段時間內，數據被使用次數最少的，優先被淘汰。

Ehcache采用的是懶淘汰機制，每次往緩存放入數據時，都會存一個時間，在讀取時要和設置的時間做TTL比較來判斷是否過期。

EhCache實戰解析

了解了上面的基礎知識之后，來實驗一下EhCache如何使用。其中EhCache2.x和EhCache3.x的使用差距較大。

這里采用比較新的3.9.6版本，不同的版本在API的使用上會有所差異。

基于API使用EhCache

EhCache提供了基于API和xml兩種形式創建CacheManger和Cache。先來看基于API的形式：

在pom文件中引入EhCache依賴：

2. org.ehcache
3. ehcache
4. 3.9.6

創建并使用的代碼如下：

1. public class EhCacheTest {
3. @Test
4. public void test() {
5. // 1、先創建一個CacheManagerBuilder；
6. // 2、使用CacheManagerBuilder創建一個預配置（pre-configured)緩存：第一個參數為別名，第二個參數用來配置Cache；
7. // 3、build方法構建并初始化；build中true參數表示進行初始化。
8. CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
9. .withCache("preConfigured",
10. CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
11. ResourcePoolsBuilder.heap(100)).build())
12. .build(true);
14. // 取回在設定的pre-configured，對于key和value值類型，要求是類型安全的，否則將拋出ClassCastException異常。
15. Cache preConfigured = cacheManager.getCache("preConfigured", Long.class, String.class);
17. System.out.println("從緩存中獲取key為preConfigured：" + preConfigured);
19. // 根據需求，通過CacheManager創建出新的Cache。實例化和完整實例化的Cache將通過CacheManager.getCache API返回。
20. Cache myCache = cacheManager.createCache("myCache",
21. CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
22. ResourcePoolsBuilder.heap(100)).build());
23. // 使用put方法存儲數據
24. myCache.put(1L, "da one!");
25. // 使用get方法獲取數據
26. String value = myCache.get(1L);
27. System.out.println("從緩存中獲取key為1L：" + value);
28. // close方法將釋放CacheManager所管理的緩存資源
29. cacheManager.close();
30. }
31. }

上述代碼基于API的形式演示了如何創建CacheManager及Cache，并對Cache進行設置和獲取。

基于XML使用EhCache

依賴Jar包不變，在src/main/resources/目錄下創建配置文件 ehcache.xml。

2. xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
3. xmlns='http://www.ehcache.org/v3'
4. xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core.xsd">
6. "foo">
7. <key-type>java.lang.Stringkey-type>
8. java.lang.String
10. "entries">20
11. "MB">10
15. name="myDefaults">
16. <key-type>java.lang.Longkey-type>
17. java.lang.String
18. "entries">200
21. "bar" uses-template="myDefaults">
22. <key-type>java.lang.Numberkey-type>
25. "simpleCache" uses-template="myDefaults" />

3.x版本與2.x版本有所區別，在xml配置文件上非常明顯。2.x中以ehcache元素為根節點，而3.x則以config為根節點。

在上述xml中包含三部分：

• 普通緩存cache-foo：別名為foo的緩存，緩存的Key-Value值類型均為String。如果沒有指定，默認就是Object類型。
• 緩存模板cache-template：實現一個配置抽象，以便在未來可以進行擴展;
• 基于緩存模板的cache-bar：使用了cache-template模板myDefaults，并且覆蓋了key-type類型，myDefaults的key-type是Long類型，覆蓋后成了Number類型;

cache中其他屬性及元素：

• name為名稱;
• alias為別名;
• key-type為key的類型;
• value-type為value的類型;
• heap指定堆中可創建的實體格式，其中unit="entries"，表示后面的20是實體;
• offheap表示在開始淘汰過期緩存項之前，可以分配多達10M的堆內存;
• uses-template表示使用模板的名稱;

當然，也可以通過persistence元素來配置緩存的目錄等。其他屬性的使用，大家可以慢慢探索。

基于Spring Boot使用EhCache

前面已經提到，Spring對緩存進行了支持，Spring Boot也對緩存進行了自動配置的支持。下面就基于Spring Boot來完成EhCache的集成以及使用案例演示。

在Spring Boot中引入對應的starter：

1. -- ehcache依賴-->
3. org.springframework.boot
4. spring-boot-starter-cache
7. org.ehcache
8. ehcache
9. 3.9.6

在application.properties中配置添加如下配置：

1. spring.cache.ehcache.config=ehcache.xml

在Spring Boot啟動類上添加@EnableCaching注解：

1. @EnableCaching
2. @SpringBootApplication
3. @MapperScan("com.secbro.mapper")
4. public class SpringBootMainApplication {
5. public static void main(String[] args) {
6. SpringApplication.run(SpringBootMainApplication.class, args);
7. }
8. }

創建一個用戶緩存的實體類Person：

1. @Data
2. public class Person {
4. public Person(int id,String name){
5. this.id = id;
6. this.name = name;
7. }
9. private int id;
11. private String name;
12. }

對應的Service方法實現：

1. public interface PersonService {
2. Person getById(int id);
3. }
5. @Slf4j
6. @Service("personService")
7. public class PersonServiceImpl implements PersonService {
9. @Cacheable(value = "personCache", key = "#id")
10. @Override
11. public Person getById(int id) {
12. log.info("查詢id={}的用戶", id);
13. if (id == 1) {
14. return new Person(1, "Tom");
15. } else if (id == 2) {
16. return new Person(2, "Jim");
17. }
18. return new Person(3, "Other");
19. }
20. }

通過Spring提供@Cacheable注解指定了緩存的名稱為personCache，key為id。在方法內打印日志，如果調用到方法內，則會打印。

編寫單元測試類：

1. @Slf4j
2. @SpringBootTest
3. @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
4. class PersonServiceTest {
6. @Resource
7. private PersonService personService;
9. @org.junit.jupiter.api.Order(1)
10. @Test
11. void testCache() throws InterruptedException {
12. log.info("第1次查詢id=1的數據");
13. personService.getById(1);
14. log.info("第2次查詢id=1的數據");
15. personService.getById(1);
16. Thread.sleep(3000);
17. }
18. }

兩次調用對應的方法，打印日志如下：

1. c.s.s.PersonServiceTest : 第1次查詢id=1的數據
2. c.s.s.i.PersonServiceImpl : 查詢id=1的用戶
3. c.s.s.PersonServiceTest : 第2次查詢id=1的數據

可以看到，第一進入方法內進行查詢，第二次便走了緩存。

關于Spring提供的cache注解的使用還有很多使用方法和場景，這里就不再展開了。

小結

因為工作恰好用到該技術，就鉆研并寫成文章帶大家領略了EhCache的基本知識、技術架構、使用場景、API使用以及基于Spring Boot的集成。整體而言，算是入門級別的，大家可以在此基礎上進一步學習擴展。至于EhCache對分布式的支持部分，本文并未涉及，主要原因是使用起來并沒那么好用，如果感興趣的話可自行研究。

原文鏈接：https://mp.weixin.qq.com/s/dSs94d2iiAkrOlpkQI-Jag