Spring Boot-Ehcache 3.0实现本地缓存

最新推荐文章于 2024-04-15 17:27:26 发布
最新推荐文章于 2024-04-15 17:27:26 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： Spring系列 文章标签： 缓存 spring boot java
原文链接：ramostear.com
版权

作者:: 谭朝红

原文: ramostear.com

本次内容主要介绍基于 Ehcache 3.0 来快速实现 Spring Boot 应用程序的数据缓存功能。在 Spring Boot 应用程序中，我们可以通过 Spring Caching 来快速搞定数据缓存。接下来我们将介绍如何在三步之内搞定 Spring Boot 缓存。

  1. 创建一个 Spring Boot 工程并添加 Maven 依赖

你所创建的 Spring Boot 应用程序的 maven 依赖文件至少应该是下面的样子：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ramostear</groupId>
    <artifactId>cache</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>cache</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.cache</groupId>
            <artifactId>cache-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

依赖说明：

  • spring-boot-starter-cache 为 Spring Boot 应用程序提供缓存支持

  • ehcache 提供了 Ehcache 的缓存实现

  • cache-api 提供了基于 JSR-107 的缓存规范

  1. 配置 Ehcache 缓存

现在，需要告诉 Spring Boot 去哪里找缓存配置文件，这需要在 Spring Boot 配置文件中进行设置：

spring.cache.jcache.config=classpath:ehcache.xml

然后使用 @EnableCaching 注解开启 Spring Boot 应用程序缓存功能，你可以在应用主类中进行操作：

package com.ramostear.cache;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching
public class CacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheApplication.class, args);
    }
}

接下来，需要创建一个 ehcache 的配置文件，该文件放置在类路径下，如 resources 目录下：

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.ehcache.org/v3"
        xmlns:jsr107="http://www.ehcache.org/v3/jsr107"
        xsi:schemaLocation="
            http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.0.xsd
            http://www.ehcache.org/v3/jsr107 http://www.ehcache.org/schema/ehcache-107-ext-3.0.xsd">
    <service>
        <jsr107:defaults enable-statistics="true"/>
    </service>
    <cache alias="person">
        <key-type>java.lang.Long</key-type>
        <value-type>com.ramostear.cache.entity.Person</value-type>
        <expiry>
            <ttl unit="minutes">1</ttl>
        </expiry>
        <listeners>
            <listener>
                <class>com.ramostear.cache.config.PersonCacheEventLogger</class>
                <event-firing-mode>ASYNCHRONOUS</event-firing-mode>
                <event-ordering-mode>UNORDERED</event-ordering-mode>
                <events-to-fire-on>CREATED</events-to-fire-on>
                <events-to-fire-on>UPDATED</events-to-fire-on>
                <events-to-fire-on>EXPIRED</events-to-fire-on>
                <events-to-fire-on>REMOVED</events-to-fire-on>
                <events-to-fire-on>EVICTED</events-to-fire-on>
            </listener>
        </listeners>
        <resources>
                <heap unit="entries">2000</heap>
                <offheap unit="MB">100</offheap>
        </resources>
    </cache>
</config>

最后，还需要定义个缓存事件监听器，用于记录系统操作缓存数据的情况，最快的方法是实现 CacheEventListener 接口：

package com.ramostear.cache.config;
import org.ehcache.event.CacheEvent;
import org.ehcache.event.CacheEventListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:48
 * @modify by :
 * @since:
 */
public class PersonCacheEventLogger implements CacheEventListener<Object,Object>{
    private static final Logger logger = LoggerFactory.getLogger(PersonCacheEventLogger.class);
    @Override
    public void onEvent(CacheEvent cacheEvent) {
        logger.info("person caching event {} {} {} {}",
                cacheEvent.getType(),
                cacheEvent.getKey(),
                cacheEvent.getOldValue(),
                cacheEvent.getNewValue());
    }
}
  1. 使用 @Cacheable 注解对方法进行注释

要让 Spring Boot 能够缓存我们的数据，还需要使用 @Cacheable 注解对业务方法进行注释，告诉 Spring Boot 该方法中产生的数据需要加入到缓存中：

package com.ramostear.cache.service;
import com.ramostear.cache.entity.Person;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:51
 * @modify by :
 * @since:
 */
@Service(value = "personService")
public class PersonService {
    @Cacheable(cacheNames = "person",key = "#id")
    public Person getPerson(Long id){
        Person person = new Person(id,"ramostear","ramostear@163.com");
        return person;
    }
}

通过以上三个步骤，我们就完成了 Spring Boot 的缓存功能。接下来，我们将测试一下缓存的实际情况。

  1. 缓存测试

为了测试我们的应用程序，创建一个简单的 Restful 端点，它将调用 PersonService 返回一个 Person 对象：

package com.ramostear.cache.controller;
import com.ramostear.cache.entity.Person;
import com.ramostear.cache.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:54
 * @modify by :
 * @since:
 */
@RestController
@RequestMapping("/persons")
public class PersonController {
    @Autowired
    private PersonService personService;
    @GetMapping("/{id}")
    public ResponseEntity<Person> person(@PathVariable(value = "id") Long id){
        return new ResponseEntity<>(personService.getPerson(id), HttpStatus.OK);
    }
}

Person 是一个简单的 POJO 类：

package com.ramostear.cache.entity;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.io.Serializable;
/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:45
 * @modify by :
 * @since:
 */
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Person implements Serializable{
    private Long id;
    private String username;
    private String email;
}

以上准备工作都完成后，让我们编译并运行应用程序。项目成功启动后，使用浏览器打开：http://localhost:8080/persons/1 , 你将在浏览器页面中看到如下的信息：

{"id":1,"username":"ramostear","email":"ramostear@163.com"}

此时在观察控制台输出的日志信息：

2019-04-07 01:08:01.001  INFO 6704 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms
2019-04-07 01:08:01.054  INFO 6704 --- [e [_default_]-0] c.r.cache.config.PersonCacheEventLogger  : person caching event CREATED 1 null com.ramostear.cache.entity.Person@ba8a729

由于我们是第一次请求 API，没有任何缓存数据。因此，Ehcache 创建了一条缓存数据，可以通过 CREATED 看一了解到。

我们在 ehcache.xml 文件中将缓存过期时间设置成了 1 分钟（1），因此在一分钟之内我们刷新浏览器，不会看到有新的日志输出，一分钟之后，缓存过期，我们再次刷新浏览器，将看到如下的日志输出：

2019-04-07 01:09:28.612  INFO 6704 --- [e [_default_]-1] c.r.cache.config.PersonCacheEventLogger  : person caching event EXPIRED 1 com.ramostear.cache.entity.Person@a9f3c57 null
2019-04-07 01:09:28.612  INFO 6704 --- [e [_default_]-1] c.r.cache.config.PersonCacheEventLogger  : person caching event CREATED 1 null com.ramostear.cache.entity.Person@416900ce

第一条日志提示缓存已经过期，第二条日志提示 Ehcache 重新创建了一条缓存数据。

结束语

在本次案例中，通过简单的三个步骤，讲解了基于 Ehcache 的 Spring Boot 应用程序缓存实现。文章内容重在缓存实现的基本步骤与方法，简化了具体的业务代码，有兴趣的朋友可以自行扩展，期间遇到问题也可以随时与我联系。

熊崽_张
关注
专栏目录
Spring Boot整合ehcache3.0 缓存
一年e度的夏天的专栏
12-06 8499
Spring Boot结合ehcache3.0以上缓存1、题记 目前市面上大多数文章都是ehcache2.0的版本，由于ehcache3.0改动较大，原来的配置方式已经不使用了，故小小研究了一番，笔以记之。 2、 先配置Spring boot<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/P
Springboot整合集成ehcache3
caiwufei的博客
12-13 5689
1.pom.xml中添加依赖。spring-boot-starer-cache中已经有了ehcache和cache-api，可以不用再添加。 org.springframework.boot spring-boot-starter-cache <!-- org.ehcache ehcache javax.cache c
Springboot集成Ehcache3实现本地缓存
最新发布
Spirit_NKlaus的专栏
04-15 1217
如果只需要在单个应用程序中使用本地缓存，则可以选择Ehcache；它支持内存和磁盘存储，这里不以注解方式演示，通过自己实现缓存管理者灵活控制缓存的读写；5、编写缓存管理者，来控制缓存的增删改查。6、编写controller进行简单测试。3、配置ehcache.xml文件。7、分别调用接口查看日志打印。4、编写缓存策略枚举。
SpringBoot集成外部缓存库EhCache3
qq_29536773的博客
03-04 1912
Spring 从 3.1 开始引入对 Cache 的支持，并支持使用JCache（JSR-107）注解简化开发。Cache 接口下 Spring 提供了各种 xxxCache 的实现，其中就包括了EhCache。EhCache 是一个纯 Java 的进程内缓存框架，是 Hibernate 中默认的 CacheProvider，同Redis一样，EhCache 不是纯内存缓存，它支持基于内存和磁盘的二级缓存，本文所使用的EhCache3还增加了堆外缓存的支持，同时 EhCache 还原生支持集群能力。
【Java】Spring整合Ehcache管理缓存（代码案例实战）
程序猿开发日志【学习永无止境】
03-03 796
前言 Ehcache 是一个成熟的缓存框架，你可以直接使用它来管理你的缓存。 Spring 提供了对缓存功能的抽象：即允许绑定不同的缓存解决方案（如Ehcache），但本身不直接提供缓存功能的实现。它支持注解方式使用缓存，非常方便。 本文先通过Ehcache独立应用的范例来介绍它的基本使用方法，然后再介绍与Spring整合的方法。 概述 Ehcache是什么？ EhCa
hello Ehcache(Ehcache3.0)
漫长学习路
06-28 6022
Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大，最初知道它，是从Hibernate的缓存开始的。Ehcache 3.0是一个里程碑式的版本； 这个新的主要版本的Ehcache提供以下 修改缓存API,利用Java泛型和简化了交互, 全面兼容javax。 缓存API(jsr - 107), Offheap存储功能,包括Offheap只缓存, Eh
Ehcache 3.0 Documentation
chaojixiaozhu的专栏
12-29 356
Ehcache 3.0 DocumentationConfiguring Ehcache In order to start using Ehcache, you will need to configure your first CacheManager and Cache. This can be achieved through programmatic configuration or
autoload-cache-spring-boot-starter：自动加载缓存spring boot starter
01-30
4. **Spring Cache**: Spring Cache是Spring Framework的一个模块，它提供了一种抽象的方式来添加缓存支持到你的应用程序中，不局限于特定的缓存实现，如 EhCache、Redis 或 Hazelcast。`autoload-cache-spring-boot...
spring-boot整合ehcache实现缓存机制的方法
08-28
"Spring Boot 整合 EhCache 实现缓存机制的方法" Spring Boot 是一个快速的集成框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义...
Spring Boot快速集成Ehcache3.0数据缓存教程
本文档介绍了如何在Spring Boot项目中集成Ehcache 3.0实现数据缓存功能。首先，我们了解Spring Boot本身并不直接支持Ehcache，但可以通过Spring Caching框架来利用其强大的缓存管理能力。以下是详细的步骤和配置： ...
详解spring boot集成ehcache 2.x 用于hibernate二级缓存
08-30
"Spring Boot 集成 Ehcache 2.x 用于 Hibernate 二级缓存" 本篇文章主要介绍了如何在 Spring Boot 中集成 Ehcache 2.x 作为 Hibernate 的二级缓存，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 Ehcache ...
EhCache
Meiko记录
08-11 953
二： 简介 2.1、基本介绍 　　EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认CacheProvider。Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。 　　Spring 提供了对缓存功能的抽象：即允许绑定不同的缓存解决方案（如Ehcache），但本身不直接提
Spring Boot 3 整合 Spring Cache 与 Redis 缓存实战
有来技术
12-04 3850
Spring Cache是简化缓存管理的利器，通过注解实现灵活的缓存策略。整合Spring Boot和Redis，为应用性能提供了可靠支持。
springboot-cache3自定义缓存加载数据库属性配置
奋斗的小鸟专栏
05-07 1669
需求：由于项目中配置项太多，配置文件维护很不方便，将配置项放在数据库中维护，通过项目启动时将数据库配置加载到环境变量中，其他需要使用的业务直接使用引用的方式是@Value("${字段}")项目结构：pom.xml引入依赖包&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/P...
使用spring3.0的cache方案解决缓存问题
毅个混蛋的专栏
05-25 4803
缓存： 实现原理： 通过spring的缓存模块，进行spring缓存 配置缓存管理器及缓存通知，对某个service进行代理，然后配置其中需要缓存数据的方法一级需要清理缓存数据的方法 定义一个缓存key生成器，会根据当前被缓存的方法的参数生成一个key，然后把key缓存起来，并把查询的结果也缓存起来， 对应关系是这样： 类.方法--n-->key--1--查询结果 每个方法根据参数不
SpringBoot整合Ehcache3
月月鸟先森的博客
01-03 4266
前言 公司部门老项目要迁移升级java版本，需要进行缓存相关操作，原框架未支持这部分，经过调研java相关缓存方案大致分为ehcache和redis两种，redis的value最大值为500mb且超过1mb会对存取有性能影响，业务系统需要支持列表查询缓存就不可避免的涉及到大量的数据存取过滤，ehcache支持内存+磁盘缓存不用担心缓存容量问题，所以框架初步版本决定集成ehcache3，设计流程结构如下图所示 缓存配置 maven引用 <dependency>
springboot3整合ehcache3
m0_54250110的博客
04-14 1551
JCache是通过classpath上存在javax.cache.spi.CachingProvider来引导的（也就是说，classpath上存在一个符合JSR-107标准的缓存库），JCacheCacheManager由spring-boot-starter-cache "启动器 "提供。可能会出现不止一个提供者的情况，在这种情况下，必须明确指定提供者。中对于支持缓存提供者的部分示例如下，不再有一个ehcache标签指定ehcache，而是统一为jcache（java缓存通用标准）即可识别。
缓存--ehcache3的基本使用
yi_shen_zhi_nu的专栏
07-15 1448
http://www.ehcache.org/documentation/3.7/getting-started.html --cache3.7官方英文文档 怎么使用这里写的都很明白 https://www.cnblogs.com/zhao1949/p/8124325.html springboot与ehcache3整合 https://www.jianshu.com/p/0a24a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值