碼上歡樂
相關內容    簡體    繁體

在Spring中快速使用EHCache注解

本文轉載自   查看原文   2012-08-10 13:06   9046    ehcache&oschache&memcached/ spring數據訪問

轉載 http://blog.csdn.net/mingshuo0615/article/details/6085248 
 

作為一名Java開發人員你一定想知道如何在Spring應用中使用新的Ehcache注解功能；是吧？ehcache-spring-annotatios是獲得Apache認證的一個開源項目；它大大簡化了在Spring應用中基於業界使用廣泛的Ehacche-2.0版本實現緩存的技術，1.1.2版本的ehcache-spring-annotations剛剛發布不久，在本文中，我將會介紹如何在一個web工程時使用ehcache-spring-annotations實現緩存機制。

 

創建一個Web工程

        在本例中，我們將會創建一個基於Spring MVC的web工程，如果您使用的IDE是Eclipse的話請確保您安裝了m2eclipse插件（譯者注：因為我們的工程基於Maven構建）；接着創建一個基於JAVA EE 5 Web應用模型的Maven工程（group id:org.codehaus.mojo.archetypes, artifact id: webapp-jee5）。

http://blog.goyello.com/wp-content/uploads/2010/07/wtp.png

上述示例在Eclipse3.6下可以很好的運行。

工程結構

首先我創建了一個簡單的web工程，項目中包含一個控制器：MessageController:

[c-sharp] view plain copy print ?
  1. @Controller  
  2. public class MessageController {  
  3.      @Autowired(required = true)  
  4.      private MessageStorage messageStorage;  
  5.      public MessageController(MessageStorage messageStorage) {  
  6.           super();  
  7.           this.messageStorage = messageStorage;  
  8.      }  
  9.      public MessageController() {  
  10.      }  
  11.      @RequestMapping(method = RequestMethod.GET, value = "/message/add")  
  12.      public ModelAndView messageForm() {  
  13.          return new ModelAndView("message-form", "command", new Message());  
  14.      }  
  15.      @RequestMapping(method = RequestMethod.POST, value = "/message/add")  
  16.      public ModelAndView addMessage(@ModelAttribute Message message) {  
  17.           messageStorage.addMessage(message);  
  18.           return getMessageById(message.getId());  
  19.      }  
  20.      @RequestMapping(method = RequestMethod.GET, value = "/message/{id}")  
  21.      public ModelAndView getMessageById(@PathVariable("id") long id) {  
  22.          Message message = messageStorage.findMessage(id);  
  23.          ModelAndView mav = new ModelAndView("message-details");  
  24.          mav.addObject("message", message);  
  25.          return mav;  
  26.      }  
  27.      @RequestMapping(method = RequestMethod.GET, value = "/message")  
  28.      public ModelAndView getAllMessages() {  
  29.      Collection<Message> messages = messageStorage.findAllMessages();  
  30.          ModelAndView mav = new ModelAndView("messages");  
  31.          mav.addObject("messages", new CollectionOfElements(messages));  
  32.          return mav;  
  33.      }  
  34. }  

 

上面的控制器依賴於一個簡單的DAO對象：MessageStorage，其實現如下：

 

  1. public interface MessageStorage {  
  2.     Message findMessage(long id);  
  3.     Collection<Message> findAllMessages();  
  4.     void addMessage(Message message);  
  5.     void setDelegate(MessageStorage storageDelegate);  
  6. }  

 

 

MessageStorage接口的唯一實現類是MemoryMessageStorage：

[c-sharp]  view plain copy print ?
  1. @Component  
  2. public class MemoryMessageStorage implements MessageStorage {  
  3.       
  4.     private Map<Long, Message> messages;  
  5.     private AtomicLong newID;  
  6.       
  7.     @PostConstruct  
  8.     public void initialize() {  
  9.         // add some messages  
  10.         addMessage(new Message("user:1", "content-1"));  
  11.         addMessage(new Message("user:2", "content-2"));  
  12.         addMessage(new Message("user:3", "content-3"));  
  13.         addMessage(new Message("user:4", "content-4"));  
  14.         addMessage(new Message("user:5", "content-5"));  
  15.     }  
  16.       
  17.     @Override  
  18.     @Cacheable(cacheName = "messageCache")  
  19.     public Message findMessage(long id) {  
  20.         //...  
  21.     }  
  22.     @Override  
  23.     @Cacheable(cacheName = "messagesCache")  
  24.     public Collection<Message> findAllMessages() {  
  25.         //...  
  26.     }  
  27.     @Override  
  28.     @TriggersRemove(cacheName = "messagesCache", when = When.AFTER_METHOD_INVOCATION, removeAll = true)  
  29.     public void addMessage(Message message) {  
  30.         //...  
  31.     }  
  32. }  
 

 

通過如下的所展示的必須的依賴配置之后我們就可以運行這個應用程序了（見下載選項獲取完整的應用程序代碼）

 

[xhtml]  view plain copy print ?
  1. <dependencies>  
  2.         <dependency>  
  3.             <groupId>javax.servlet</groupId>  
  4.             <artifactId>servlet-api</artifactId>  
  5.             <version>2.5</version>  
  6.             <scope>provided</scope>  
  7.         </dependency>  
  8.         <dependency>  
  9.             <groupId>javax.servlet.jsp</groupId>  
  10.             <artifactId>jsp-api</artifactId>  
  11.             <version>2.1</version>  
  12.             <scope>provided</scope>  
  13.         </dependency>  
  14.         <dependency>  
  15.             <groupId>junit</groupId>  
  16.             <artifactId>junit</artifactId>  
  17.             <version>4.8.1</version>  
  18.             <scope>test</scope>  
  19.         </dependency>  
  20.         <dependency>  
  21.             <groupId>org.springframework</groupId>  
  22.             <artifactId>spring-webmvc</artifactId>  
  23.             <version>3.0.3.RELEASE</version>  
  24.             <type>jar</type>  
  25.             <scope>compile</scope>  
  26.         </dependency>  
  27.         <dependency>  
  28.             <groupId>org.springframework</groupId>  
  29.             <artifactId>spring-oxm</artifactId>  
  30.             <version>3.0.3.RELEASE</version>  
  31.             <type>jar</type>  
  32.             <scope>compile</scope>  
  33.         </dependency>  
  34.         <dependency>  
  35.             <groupId>javax.servlet</groupId>  
  36.             <artifactId>jstl</artifactId>  
  37.             <version>1.2</version>  
  38.             <type>jar</type>  
  39.             <scope>compile</scope>  
  40.         </dependency>  
  41.     </dependencies>  
 

 

介紹基於Spring的web工程中使用Ehcache注解

現在該給項目增加緩存能力了，我們要為MemoryMessageStorage類提供緩存機制。首先，在POM文件中加入所需的依賴：

Spring中Ehcache的注解依賴項：

[xhtml]  view plain copy print ?
  1. <dependency>  
  2.     <groupId>com.googlecode.ehcache-spring-annotations</groupId>  
  3.     <artifactId>ehcache-spring-annotations</artifactId>  
  4.     <version>1.1.2</version>  
  5.     <type>jar</type>  
  6.     <scope>compile</scope>  
  7. </dependency>  
 

 

在寫本文的時候2.2.0版本的Ehcache也可用了，但是我們使用2.1.0版本的Ehcache，因為Ehcache Annotations for Spring 1.1.2版本是基於2.1.0版本的Ehcache的。

我還填加了SLF4J API實現的依賴(譯者注：SLF4J不是具體的日志解決方案，它只服務於各種各樣的日志系統。按照官方的說法，SLF4J是一個用於日志系統的簡單Facade，允許最終用戶在部署其應用時使用其所希望的日志系統。)：

[xhtml]  view plain copy print ?
  1. <dependency>  
  2.      <groupId>org.slf4j</groupId>  
  3.      <artifactId>slf4j-log4j12</artifactId>  
  4.      <version>1.6.1</version>  
  5.      <type>jar</type>  
  6.      <scope>compile</scope>  
  7. </dependency>  
 

 

通過上面依賴的配置，我們就可以使用Ehcache Annotations for Spring了，我們現在就如同前面所說的給MemoryMessageStorage添加注解。這里列出幾條所需達到的目標：

 

·         當調用findMessage(long)方法時用名為“messageCache”的名稱緩存結果信息。

·         當調用findAllMessages()方法時用名為“messagesCache”的名稱緩存結果信息。

·         當調用addMessage(Message)方法時清除所有“messagesCache”名稱下的緩存項。

為了達到上面所說的幾個目標，我們使用 @Cachable和@TriggersRemove兩個注解，見下面介紹：

[java]  view plain copy print ?
  1. @Component  
  2. public class MemoryMessageStorage implements MessageStorage {  
  3.     private Map<Long, Message> messages;  
  4.     private AtomicLong newID;  
  5.     public MemoryMessageStorage() {  
  6.         // ...  
  7.     }  
  8.     @Override  
  9.     @Cacheable(cacheName = "messageCache")  
  10.     public Message findMessage(long id) {  
  11.         // ...  
  12.     }  
  13.     @Override  
  14.     @Cacheable(cacheName = "messagesCache")  
  15.          public Collection<Message> findAllMessages() {  
  16.          // ...  
  17.     }  
  18.     @Override  
  19.     @TriggersRemove(cacheName = "messagesCache", when = When.AFTER_METHOD_INVOCATION, removeAll = true)  
  20.         public void addMessage(Message message) {  
  21.             // ...  
  22.     }  
  23. }  
 

 

Spring和Ehcache的配置

注解已經加到位了，接下來我們需要配置這個項目去使它們起作用，通過Spring的配置文件就可以達到這個目的：

  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.        xmlns:oxm="http://www.springframework.org/schema/oxm"  
  6.     xmlns:mvc="http://www.springframework.org/schema/mvc"  
  7.        xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring"  
  8.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  9.        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  10.        http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-3.0.xsd  
  11.        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd  
  12.         http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd">  
  13.     <ehcache:annotation-driven />  
  14.     <ehcache:config cache-manager="cacheManager">  
  15.         <ehcache:evict-expired-elements interval="60" />  
  16.     </ehcache:config>  
  17.     <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"/>  
  18.     <!-- rest of the file omitted -->  
  19. </beans>  

 

最后要做的是添加Ehcache的配置文件，在web應用程序的/WEB-INF目錄下面創建ehcache.xml的xml文件：

[xhtml]  view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">  
  3.     <defaultCache eternal="true" maxElementsInMemory="100" overflowToDisk="false" />  
  4.     <cache name="messageCache" maxElementsInMemory="10" eternal="true" overflowToDisk="false" />  
  5.     <cache name="messagesCache" maxElementsInMemory="10" eternal="true" overflowToDisk="false" />  
  6. </ehcache>  
 

 

接下來需要配置緩存manager使它去管理Ehcache的配置，在Spring上下文的配置文件中加入cacheManager 這個Bean的配置，並需要在其中加入configLocation屬性：

[xhtml]  view plain copy print ?
  1. <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">  
  2.      <property name="configLocation"  value="/WEB-INF/ehcache.xml"/>  
  3. </bean>  
 

 

配置完畢，在Tomcat 6應用服務器上運行該應用程序(Run As – Run on server)，你會發現有日志輸出-如果DEBUG模式被允許的話你會發現類似如下的條目輸出：

[java]  view plain copy print ?
  1. DEBUG [net.sf.ehcache.Cache]: Initialised cache: messagesCache  
  2. DEBUG [net.sf.ehcache.Cache]: Initialised cache: messageCache  
 

 

在項目中做一些調試去觀察緩存機制的行為（確保DEBUG日志級別是被允許的）。方法是（去看XML的輸出，將“html”替換為“xml”）：

獲取消息列表 – http://localhost:8080/esa/message.html

通過ID獲取消息 – http://localhost:8080/esa/message/{id}.html

 添加一條信息(from) – http://localhost:8080/esa/message/add.html

如果您是第一次執行MessageController 類的getMessages()方法，您將會看到：

[java]  view plain copy print ?
  1. DEBUG [com.googlecode.ehcache.annotations.interceptor.EhCacheInterceptor]: Generated key '167334053963' for invocation: ReflectiveMethodInvocation: public abstract java.util.Collection com.goyello.esa.storage.MessageStorage.findAllMessages(); target is of class [com.goyello.esa.storage.MemoryMessageStorage]  
  2. DEBUG [com.goyello.esa.storage.MemoryMessageStorage]: == got all messages, size=5  
 

 

當第二次調用同一個方法時，上面輸出的日志的第二行就不會再出現，因為所有收集的信息都是從Cache中檢索出來的。

調用MessageController中的addMessage()方法時清除Cache中的信息很簡單，重復上面的步驟，確保cache在之前是被清空的。

單元測試

為了確保緩存機制確實起作用了，而不是只是看到日志，我們創建單元測試去進行測試。為進行這個測試我們修改了MessageStorage接口，我們在其中增加了void setDelegate(MessageStorage storageDelegate)方法；給出的示例是為了檢測我們添加的緩存機制確實起作用了；實現類的變化如下（其他所有方法類似）：

[java]  view plain copy print ?
  1. @Override  
  2. @Cacheable(cacheName = "messageCache")  
  3. public Message findMessage(long id) {  
  4.          LOG.debug("== find message by id={}", id);  
  5.          if(storageDelegate != null)  
  6.          storageDelegate.findMessage(id);  
  7.          return messages.get(id);  
  8. }  
 

 

為了使測試簡單一些我們需要使用了兩個依賴：Spring Test 和Mockito：

 

[c-sharp]  view plain copy print ?
  1. <dependency>  
  2.             <groupId>org.mockito</groupId>  
  3.             <artifactId>mockito-all</artifactId>  
  4.             <version>1.8.5</version>  
  5.             <type>jar</type>  
  6.             <scope>compile</scope>  
  7. </dependency>  
  8. <dependency>  
  9.             <groupId>org.springframework</groupId>  
  10.             <artifactId>spring-test</artifactId>  
  11.             <version>3.0.3.RELEASE</version>  
  12.             <type>jar</type>  
  13.             <scope>compile</scope>  
  14. </dependency>  
 

 

測試類將依托於SpringJUnit4ClassRunner運行：

[c-sharp]  view plain copy print ?
  1. @RunWith(SpringJUnit4ClassRunner.class)  
  2. @ContextConfiguration(locations = { "/spring-context-test.xml" })  
  3. public class CachingTest {  
  4.      @Autowired  
  5.      ApplicationContext context;  
  6.      @Autowired  
  7.      CacheManager cacheManager;  
  8.      MessageStorage storage;  
  9.      MessageStorage storageDelegate;  
  10.      MessageController controller;  
  11.      @Before  
  12.      public void before() throws Exception {  
  13.          storageDelegate = Mockito.mock(MessageStorage.class);  
  14.          storage = (MessageStorage) context.getBean("messageStorage");  
  15.          storage.setDelegate(storageDelegate);  
  16.          controller = new MessageController(storage);  
  17.          cacheManager.clearAll();  
  18.      }  
  19.      @Test  
  20.      public void testCaching_MessagesCache() {  
  21.          controller.getAllMessages();  
  22.          controller.getAllMessages();  
  23.          verify(storageDelegate, times(1)).findAllMessages();  
  24.      }  
  25.      @Test  
  26.      public void testCaching_MessagesCacheRemove() {  
  27.          controller.getAllMessages();  
  28.          controller.getAllMessages();  
  29.          controller.addMessage(new Message());  
  30.          controller.getAllMessages();  
  31.          verify(storageDelegate, times(2)).findAllMessages();  
  32.          verify(storageDelegate, times(1)).addMessage(any(Message.class));  
  33.      }  
  34.      @Test  
  35.      public void testCaching_MessageCache() {  
  36.          controller.getMessageById(1);  
  37.          controller.getMessageById(1);  
  38.          controller.addMessage(new Message());  
  39.          controller.getMessageById(1);  
  40.          verify(storageDelegate, times(1)).findMessage(1);  
  41.          verify(storageDelegate, times(1)).addMessage(any(Message.class));  
  42.      }  
  43. }  
 

 

本示例是一個模擬的對象用於測試實際的MessageStorage上的調用次數。本測試Spring上下文的配置如下：

[xhtml]  view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xmlns:context="http://www.springframework.org/schema/context" xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  5.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  6.         http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd">  
  7.     <ehcache:annotation-driven />  
  8.     <ehcache:config cache-manager="cacheManager">  
  9.         <ehcache:evict-expired-elements interval="60" />  
  10.     </ehcache:config>  
  11.     <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">  
  12.         <property name="configLocation" value="classpath:ehcache-test.xml" />  
  13.     </bean>  
  14.     <bean id="messageStorage" class="com.goyello.esa.storage.MemoryMessageStorage" />  
  15. </beans>  
 

 

現在我們准備運行創建好的測試用例去驗證實際在MemoryMessageStorage上的調用。我們期待的結果是：
http://blog.goyello.com/wp-content/uploads/2010/07/test.png

總結

使用Ehcache Spring Annotations是很簡潔的，通過上述簡單的一些步驟我們試圖介紹如何在您的應用中使用緩存，我強烈建議您在您的項目中使用本工具之前先去我們的網站上去讀一下文檔，這樣您會了解一些這篇文章沒有覆蓋到的用法。

參考文獻

Ehcache Spring Annotations項目主頁– http://code.google.com/p/ehcache-spring-annotations/

Ehcache項目首頁– http://ehcache.org/

Spring 3.0參考– http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/
Mockito – http://mockito.org/
Maven2 – http://maven.apache.org/

下載並運行項目

完整的工程代碼在這兒可以下載到：demo-project

下載了文件之后，解壓縮，進入到工程所在的目錄並執行下面的命令（需要安裝maven2）

mvn clean tomcat:run

啟動您的瀏覽器去看看應用的執行情況：

http://localhost:8080/esa/message.html

http://localhost:8080/esa/message/add.html


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Spring基於注解ehCache緩存整合 ehcache整合spring注解方式 使用spring cache和ehcache spring ehcache 使用詳解 SpringBoot 緩存注解 與EhCache的使用 【Spring注解驅動開發】使用@Import注解給容器中快速導入一個組件 spring和ehcache整合，實現基於注解的緩存實現 spring中@PropertySource注解的使用 Spring中@Import注解的使用 spring中基於注解使用AOP
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM