在 Spring 中使用 @EhCache 注解作为缓存

文章目录

• • 项目概况
  • 项目设置
  • [一个简单的 RESTful Web 服务](#一个简单的 RESTful Web 服务)
  • • [Spring 整合 EhCache](#Spring 整合 EhCache)
    • [第 1 步：更新依赖项以使用 EhCache Spring 注解](#第 1 步：更新依赖项以使用 EhCache Spring 注解)
    • [第 2 步：设置自定义缓存管理器](#第 2 步：设置自定义缓存管理器)
    • [第 3 步：配置 EhCache](#第 3 步：配置 EhCache)
    • [第 4 步：测试缓存](#第 4 步：测试缓存)
  • 刷新缓存
  • 总结
  • 推荐阅读文章

EhCache 是一种广泛使用的纯 Java 缓存，可以轻松地与大多数流行的 Java 框架集成，例如 Spring 和 Hibernate。

它通常被认为是 Java 应用程序最方便的选择，因为它可以轻松集成到项目中。EhCache Spring Annotations 允许无缝集成到任何 Spring 应用程序中，只需向可缓存方法添加注释即可，而无需修改方法实现。本文重点介绍如何使用 EhCache Spring Annotations 提升您的 Spring 应用程序。

EhCache 是一种广泛使用的纯 Java 缓存，可以轻松地与大多数流行的 Java 框架集成，例如 Spring 和 Hibernate。它通常被认为是 Java 应用程序最方便的选择，因为它可以轻松集成到项目中。特别：

• 只需将 JAR 包含在项目中即可。无需额外的安装步骤。
• 与应用程序在相同的进程中运行，因此速度很快。无需其他服务即可运行。

简而言之，EhCache 是任何纯 Java 应用程序的绝佳选择。

虽然 EhCache 提供了简单、丰富的 API 来以编程方式操作缓存，但本文主要关注使用 EhCache Spring Annotations 以侵入性较小的方式提升 Spring 应用程序。我们将设置一个 Spring MVC 项目，并在 Tomcat 中部署一个 RESTful Web 服务。然后，EhCache 将集成到 Web 服务中。

项目概况

我们将在示例项目的上下文中演示 EhCache Annotations。我们将设置一个托管在 Tomcat 8 服务器上的基于 Spring MVC 的 Web 服务。

我在 Eclipse 中开发了该项目，可以按照Eclipse下载的说明进行安装。

当然，这些特定平台不是 EhCache 的要求;您始终可以选择自己喜欢的 IDE 和服务器。

EhCache Spring Annotations JAR 可Spring-EhCache下载获得。正如我们所看到的，每个版本都有两个 JAR：一个有依赖项，一个没有依赖项。具有依赖项的还包括 EhCache 2 和 Spring 3，它们是 EhCache 注解工作所必需的。如果我们下载带有依赖项的那个并将其添加到我们的构建路径中，则设置起来会更容易。

EhCache Spring Annotations 也与 Spring 4 兼容，但必须单独配置。目前尚不清楚该项目是否会在不久的将来支持 EhCache 3。对于正在使用或打算使用 EhCache 3 的用户，不建议使用本文中讨论的注释方法。

最后，我们将使用 Maven 来管理所有内容。Maven 预装在大多数 Eclipse 安装中，但也可以Maven官网获取。Spring MVC 和 EhCache Spring Annotations 依赖项可以相当容易地添加，如本文后面所示。

项目设置

如果您以前从未设置过 Spring 项目，您可能还会发现 SpringMVC搭建过程提供了丰富的信息。

在本演示中，我们将使用 Maven官网maven-archetype-webapp 设置一个基本项目。整体文件结构将如下所示：

创建一个目录 src/main/java，其中包含三个包：com.toptal.blog、com.toptal.blog.cache 和 com.toptal.blog.service。我们的应用程序源将进入这些包中，如下所述。

让我们在 web.xml 中定义一个名为 "springrest" 的 Tomcat servlet：

<web-app>
   ...
   <servlet>
      <servlet-name>springrest</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
      <servlet-name>springrest</servlet-name>
      <url-pattern>/*</url-pattern>
   </servlet-mapping>
</web-app>

除非另有明确说明，否则 Spring MVC DispatcherServlet 将在目录 WEB-INF 中查找名为 {servlet-name}-servlet.xml 的 XML 配置文件。让我们创建一个名为 springrest-servlet.xml 的配置文件。要启用带有 @RequestMapping 注释的 Spring 进程控制器方法，我们只需将 <mvc：annotation-driven /> 添加到此文件中即可。此外，让我们定义 Spring 的基本包，以便通过添加 <context:component-scan base-package="com.toptal.blog" /> .springrest-servlet.xml 配置将变为：

<beans ... >
   <mvc:annotation-driven />
   <context:component-scan base-package="com.toptal.blog" />
</beans>

一个简单的 RESTful Web 服务

现在，我们的项目已正确配置，让我们实现一个简单的 "消息服务" API。在我们的基础包 project.toptal.blog 中，我们将添加 SpringRestControllerWithEhCache.java ，其中包含一个按 ID 获取消息的 GET 方法，以及一个按 ID 设置消息的 POST 方法：

@RestController  
@RequestMapping( "/" )
public class SpringRestControllerWithEhCache {
   @Autowired
   MessageService messageService;
   
   @RequestMapping( value = "/message/{id}", method = RequestMethod.GET )
   public String getMessage( @PathVariable Integer id ) {
      String message = messageService.getMessage( id );
      System.out.println( "get message ["+message+"] at "+new Date() );
      return message;
   }
   
   @RequestMapping( value = "/message/set/{id}/{message}", method = RequestMethod.POST )
   public String setMessage( @PathVariable Integer id, @PathVariable String message ) { 
      System.out.println( "set message ["+message+"] at "+new Date() );
      messageService.setMessage( id, message );
      return message;  
   }
}

我们将在 com.toptal.blog.service 中定义 MessageService 类。它将访问存储在我们的记录系统 （SOR） 中的消息。在生产应用程序中，SOR 类似于关系数据库。为简单起见，我们将使用 HashMap：

@Service
public class MessageService {
   private ConcurrentHashMap<Integer, String> messages
   = new ConcurrentHashMap<Integer, String>();
   
   public String getMessage( Integer id ) {
      System.out.println( "Getting data from SOR......" );
      return messages.get( id );
   }

   public void setMessage( Integer id, String message ){
      messages.put( id, message );
   }
}

现在，如果我们将项目导出为 WAR 并将其部署到 Tomcat 中，我们应该能够通过在 中创建 HTTP POST 请求来为 ID=1 设置一条消息，例如"test_message http://localhost:8080/EhCacheExample/message/set/1/test_message "。然后，我们应该能够通过 HTTP GET 请求的 "test_message" 返回 http://localhost:8080/EhCacheExample/message/1 。我使用 Insomnia 作为方便的 REST 客户端来进行测试。

Spring 整合 EhCache

现在让我们让 EhCache 为我们工作。只需几个快速步骤即可配置我们的项目以正确运行 EhCache。

第 1 步：更新依赖项以使用 EhCache Spring 注解

在 Maven 的 pom.xml中添加 EhCache Spring Annotations 依赖项：

<!-- ehcache -->
<dependency>
   <groupId>com.googlecode.ehcache-spring-annotations</groupId>
   <artifactId>ehcache-spring-annotations</artifactId>
   <version>1.2.0</version>
</dependency>

第 2 步：设置自定义缓存管理器

Spring 有一个内置的 EhCache 缓存管理器 org.springframework.cache.ehcache.EhCacheManagerFactoryBean 。这适用于大多数缓存情况，但我发现定义自定义缓存管理器非常有用，因为它允许我使用相同的缓存管理器以编程方式或通过注释控制缓存。本文重点介绍 annotations，但让我们继续定义一个自定义缓存管理器，以便在需要时做好准备。如果您更喜欢坚持使用 默认缓存管理器 ，您可以跳过此步骤。

我们将在 ： com.toptal.blog.cache.CustomCacheManager

public class CustomCacheManager extends net.sf.ehcache.CacheManager{

   public CustomCacheManager(){
      super();
   }

   /* Add your own cache methods here.
    * 
    * public void myCustomCacheMethod(){
    *    // your code here
    * }
    * */
}

通过更新springrest-servlet.xml来启用它，如下所示：

   ...
   <ehcache:annotation-driven cache-manager="customCacheManager" />
   <bean id="customCacheManager"
         class="com.toptal.blog.cache.CustomCacheManager"
         scope="singleton"></bean>
   ...

第 3 步：配置 EhCache

最后，在 Classpath 中创建 EhCache 配置文件ehcache.xml。默认情况下，Eclipse 将在 classpath 中包含 src/main/resources，我们将文件放在这里。此文件是 EhCache 正常运行所必需的。它定义缓存名称和每个缓存的一些属性，例如 timeToLiveSeconds：

<ehcache xmlms:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd">
   <diskStore path="cache" />
   <cache
      name="messageCache"
      maxElementsInMemory="10000"
      eternal="false"
      timeToIdleSeconds="0"
      timeToLiveSeconds="10"
      overflowToDisk="false"
      memoryStoreEvictionPolicy="LFU" />      
</ehcache>

第 4 步：测试缓存

现在，一切都设置好了，使用 EhCache 应该是一件简单而愉快的工作。我们可以简单地将 @Cacheable 添加到我们想要缓存的方法或类中。例如，我将 @Cacheable 添加到 MessageService 中的 getMessage 方法中。就是这么简单！

@Cacheable( cacheName = "messageCache" )
public String getMessage( Integer id ) {
   System.out.println( "Getting data from SOR......" );
   return messages.get( id );
}

要测试我们的缓存是否正常工作，我们可以通过在 处 http://localhost:8080/EhCacheExample/message/set/1/newMessage 发出 HTTP POST 请求来创建一条 ID=1 的消息，然后多次获取 ID=1 的消息，并向 . http://localhost:8080/EhCacheExample/message/1 如下面的控制台输出所示，Web 服务在我们第一次请求消息时要求 SOR 获取消息，但在接下来的两个请求中不请求，而是返回缓存的消息。由于我们将 timeToLiveSeconds 定义为 10，因此 Web 服务会在 10 秒后调用 SOR 再次获取消息：

set message [newMessage] at Sun Dec 06 23:55:39 MST 2015
get message [newMessage] at Sun Dec 06 23:55:42 MST 2015
Getting data from SOR......
get message [newMessage] at Sun Dec 06 23:55:47 MST 2015
get message [newMessage] at Sun Dec 06 23:55:49 MST 2015
get message [newMessage] at Sun Dec 06 23:55:54 MST 2015
Getting data from SOR......

刷新缓存

现在，我们正在享受缓存给我们带来的速度和便利，而且 EhCache 足够好，每 10 秒自行刷新一次。但是，如果我们想在 SOR 更新后立即刷新它，该怎么办？EhCache Spring Annotation 提供了@TriggersRemove，以便在调用带注释的方法时从缓存中删除指定的键。在我们的消息服务 API 中，当调用 setMessage 时，应该从缓存中删除缓存的消息。因此，下次收到 getMessage 请求时，缓存将从 SOR 中获取新记录：

@Cacheable(
   cacheName = "messageCache",
   keyGenerator = @KeyGenerator (                             // method name is not included in cache key to work with @TriggersRemove
                     name = "HashCodeCacheKeyGenerator",
                     properties = @Property( name="includeMethod", value="false" )))  
public String getMessage( Integer id ) {
   System.out.println( "Getting data from SOR......" );
   return messages.get( id );
}

@TriggersRemove(
   cacheName = "messageCache",
   keyGenerator = @KeyGenerator (
                     name = "HashCodeCacheKeyGenerator",
                     properties = @Property( name="includeMethod", value="false" )))
public void setMessage( @PartialCacheKey Integer id, String message ) {
   messages.put( id, message );
}

缓存管理器使用密钥生成器来生成缓存密钥。可在此处找到预定义的缓存密钥生成器列表。默认情况下，@KeyGenerator 使用方法名称和传入的参数来生成缓存键。但是，由于我们希望 setMessage 方法生成与 getMessage 相同的 key，并删除与该 key 关联的缓存值，因此我们必须仅使用消息 ID 作为 key，并消除生成 key 的方法名称。因此，我们将这两个方法的密钥生成器的 includeMethod 属性设置为 false。此外，由于 setMessage 有两个参数，我们在 id 参数上使用 EhCache 的 @PartialCacheKey 注解来指定它是密钥生成器唯一应该使用的参数。最后，回想一下，我们为此资源类型配置了专用缓存 messageCache，因此仅使用键的 ID 不会与其他资源类型发生冲突。

现在，如果我们对 ID=1 的消息执行多个 HTTP 请求，如下所示：

HTTP POST:  http://localhost:8080/EhCacheExample/message/set/1/newMessage1
HTTP GET:http://localhost:8080/EhCacheExample/message/1
HTTP POST: http://localhost:8080/EhCacheExample/message/set/1/newMessage2
HTTP GET:http://localhost:8080/EhCacheExample/message/1

控制台将显示：

set message [newMessage1] at Tue Dec 08 17:53:44 MST 2015
get message [newMessage1] at Tue Dec 08 17:53:47 MST 2015
Getting data from SOR......
set message [newMessage2] at Tue Dec 08 17:53:50 MST 2015
get message [newMessage2] at Tue Dec 08 17:53:53 MST 2015
Getting data from SOR......

总结

最终的项目结构如下所示：

在此示例中，我们首先创建了一个简单的 Spring MVC RESTful Web 应用程序。无需修改现有应用程序代码的哪怕一行，我们就可以使用 EhCache Spring Annotations 将 EhCache 无缝集成到应用程序中。我们已经证明 EhCache Spring Annotations 既易于安装（通过添加其 Maven 依赖项）又易于使用（通过向方法添加注释）。

推荐阅读文章

1、使用 Spring 框架构建 MVC 应用程序：初学者教程
2、有缺陷的 Java 代码：Java 开发人员最常犯的 10 大错误
3、如何理解应用 Java 多线程与并发编程？
4、Java Spring 中常用的 @PostConstruct 注解使用总结
5、线程 vs 虚拟线程：深入理解及区别
6、深度解读 JDK 8、JDK 11、JDK 17 和 JDK 21 的区别
7、10大程序员提升代码优雅度的必杀技，瞬间让你成为团队宠儿！
8、"打破重复代码的魔咒：使用 Function 接口在 Java 8 中实现优雅重构！"
9、Java 中消除 If-else 技巧总结
10、线程池的核心参数配置(仅供参考)
11【人工智能】聊聊Transformer，深度学习的一股清流(13)