Spring Cache抽象-使用Java类注解的方式整合EhCache

最新推荐文章于 2024-07-30 16:29:43 发布
最新推荐文章于 2024-07-30 16:29:43 发布
阅读量1.4w 收藏 2
点赞数 1
分类专栏： 【Spring-Cache】 文章标签： spring cache ehcache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshangwei/article/details/78157224
版权

概述

Spring Cache抽象-之缓存注解这篇博文中我们介绍了SpringCache抽象注解的使用方式

既然这是一个抽象，我们需要一个具体的缓存存储实现。比价流行的有：基于JDK java.util.concurrent.ConcurrentMap的缓存，EhCache，Gemfire缓存，Caffeine，Guava缓存和兼容JSR-107的缓存等等。这里我们使用Ehcache来实现这个缓存。

同时，我们使用EhCacheManagerFactoryBean的configLocation属性指定Ehcache的设置。如果未明确指定，则默认为ehcache.xml。

工程结构

这里写图片描述

以及EhCache的配置文件：

这里写图片描述

pom.xml 关键的依赖

<properties>            <springframework.version>4.3.9.RELEASE</springframework.version>
 <ehcache.version>2.10.4</ehcache.version>       
</properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!-- EHCache -->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
           <version>${ehcache.version}</version>
        </dependency>
        <!-- SLF4J/Logback -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.7</version>
        </dependency>     
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd" 
    updateCheck="true"
    monitoring="autodetect" 
    dynamicConfig="true">
    <diskStore path="java.io.tmpdir" />
    <cache name="products" 
        maxEntriesLocalHeap="100"
        maxEntriesLocalDisk="1000" 
        eternal="false" 
        timeToIdleSeconds="300" 
        timeToLiveSeconds="600"
        memoryStoreEvictionPolicy="LFU" 
        transactionalMode="off">
        <persistence strategy="localTempSwap" />
    </cache>
</ehcache>

  • 我们设置一个名为’products’的缓存。

  • 最多100个products将保存在内存[堆叠]存储中，

  • 最多1000个products将被保留在DiskStore中

  • 指定的路径为“java.io.tmpdir”，它指的是默认的临时文件路径。

  • 如果product闲置超过5分钟，寿命超过10分钟，products缓存将会过期

实体类

package com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain;

import java.io.Serializable;

public class Product implements Serializable {

    private static final long serialVersionUID = 123L;
    private String name;
    private double price;

    /**
     * 
     * 
     * @Title:Product
     * 
     * @Description:构造函数
     * 
     * @param name
     * @param price
     */
    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

}

Product接口

package com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.service;

import com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product;

public interface ProductService {

    Product getByName(String name);

    Product updateProduct(Product product);

    void refreshAllProducts();
}

接口实现类 及缓存配置

package com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.service;

import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product;

/**
 * 
 * 
 * @ClassName: ProductServiceImpl
 * 
 * @Description:@Service标注的服务层
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年10月3日 下午5:22:30
 */

@Service("productService")
public class ProductServiceImpl implements ProductService {

    private static final Logger logger = Logger.getLogger(ProductServiceImpl.class);

    private static List<Product> products;

    static {
        products = getDummyProducts();
    }

    @Cacheable(cacheNames = "products", key = "#name", condition = "#name != 'HTC'", unless = "#result==null")
    @Override
    public Product getByName(String name) {
        logger.info("<!----------Entering getByName()--------------------->");
        for (Product product : products) {
            if (product.getName().equalsIgnoreCase(name)) {
                return product;
            }
        }
        return null;
    }

    @CachePut(cacheNames = "products", key = "#product.name", unless = "#result==null")
    @Override
    public Product updateProduct(Product product) {
        logger.info("<!----------Entering updateProduct()--------------------->");
        for (Product p : products) {
            if (p.getName().equalsIgnoreCase(product.getName())) {
                p.setPrice(product.getPrice());
                return p;
            }
        }
        return null;
    }

    @CacheEvict(cacheNames = "products", allEntries = true)
    @Override
    public void refreshAllProducts() {

    }

    private static List<Product> getDummyProducts() {
        products = new ArrayList<Product>();
        products.add(new Product("IPhone", 500));
        products.add(new Product("Samsung", 600));
        products.add(new Product("HTC", 800));
        return products;
    }


}

关键配置类 ，以及加载enhance

package com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.configuration;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@EnableCaching
@Configuration
@ComponentScan(basePackages = "com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache")
public class AppConfig {

    @Bean
    public CacheManager cacheManager() {
        return new EhCacheCacheManager(ehCacheCacheManager().getObject());
    }

    @Bean
    public EhCacheManagerFactoryBean ehCacheCacheManager() {
        EhCacheManagerFactoryBean factory = new EhCacheManagerFactoryBean();
        factory.setConfigLocation(new ClassPathResource("ehcache/ehcache.xml"));
        factory.setShared(true);
        return factory;
    }
}

单元测试

package com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache;

import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

import com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.configuration.AppConfig;
import com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product;
import com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.service.ProductService;

public class SpringCacheWithEhCacheTest {

    private static final Logger logger = Logger
            .getLogger(SpringCacheWithEhCacheTest.class);

    AbstractApplicationContext context = null;

    @Before
    public void initContext() {
        context = new AnnotationConfigApplicationContext(AppConfig.class);

    }

    @Test
    public void test() {
        ProductService service = (ProductService) context
                .getBean("productService");

        logger.info("IPhone ->" + service.getByName("IPhone"));
        logger.info("IPhone ->" + service.getByName("IPhone"));
        logger.info("IPhone ->" + service.getByName("IPhone"));

        logger.info("HTC ->" + service.getByName("HTC"));
        logger.info("HTC ->" + service.getByName("HTC"));
        logger.info("HTC ->" + service.getByName("HTC"));

        Product product = new Product("IPhone", 550);
        service.updateProduct(product);

        logger.info("IPhone ->" + service.getByName("IPhone"));
        logger.info("IPhone ->" + service.getByName("IPhone"));
        logger.info("IPhone ->" + service.getByName("IPhone"));

        logger.info("Refreshing all products");

        service.refreshAllProducts();
        logger.info("IPhone [after refresh]->" + service.getByName("IPhone"));
        logger.info("IPhone [after refresh]->" + service.getByName("IPhone"));
        logger.info("IPhone [after refresh]->" + service.getByName("IPhone"));
    }

    @After
    public void releaseContext() {
        ((AbstractApplicationContext) context).close();
    }

}

输出结果分析

2017-10-03 20:54:55,026  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7bd1a567: startup date [Tue Oct 03 20:54:55 BOT 2017]; root of context hierarchy
2017-10-03 20:54:55,858  INFO [main] (EhCacheManagerFactoryBean.java:130) - Initializing EhCache CacheManager
2017-10-03 20:54:56,711  INFO [main] (ProductServiceImpl.java:40) - <!----------Entering getByName()--------------------->
2017-10-03 20:54:56,715  INFO [main] (SpringCacheWithEhCacheTest.java:32) - IPhone ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,716  INFO [main] (SpringCacheWithEhCacheTest.java:33) - IPhone ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,716  INFO [main] (SpringCacheWithEhCacheTest.java:34) - IPhone ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,717  INFO [main] (ProductServiceImpl.java:40) - <!----------Entering getByName()--------------------->
2017-10-03 20:54:56,717  INFO [main] (SpringCacheWithEhCacheTest.java:36) - HTC ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@68c06cac
2017-10-03 20:54:56,717  INFO [main] (ProductServiceImpl.java:40) - <!----------Entering getByName()--------------------->
2017-10-03 20:54:56,717  INFO [main] (SpringCacheWithEhCacheTest.java:37) - HTC ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@68c06cac
2017-10-03 20:54:56,718  INFO [main] (ProductServiceImpl.java:40) - <!----------Entering getByName()--------------------->
2017-10-03 20:54:56,718  INFO [main] (SpringCacheWithEhCacheTest.java:38) - HTC ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@68c06cac
2017-10-03 20:54:56,724  INFO [main] (ProductServiceImpl.java:52) - <!----------Entering updateProduct()--------------------->
2017-10-03 20:54:56,734  INFO [main] (SpringCacheWithEhCacheTest.java:43) - IPhone ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,735  INFO [main] (SpringCacheWithEhCacheTest.java:44) - IPhone ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,735  INFO [main] (SpringCacheWithEhCacheTest.java:45) - IPhone ->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,736  INFO [main] (SpringCacheWithEhCacheTest.java:47) - Refreshing all products
2017-10-03 20:54:56,741  INFO [main] (ProductServiceImpl.java:40) - <!----------Entering getByName()--------------------->
2017-10-03 20:54:56,741  INFO [main] (SpringCacheWithEhCacheTest.java:50) - IPhone [after refresh]->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,742  INFO [main] (SpringCacheWithEhCacheTest.java:51) - IPhone [after refresh]->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,742  INFO [main] (SpringCacheWithEhCacheTest.java:52) - IPhone [after refresh]->com.xgj.cache.springCacheAnno.CompleteDemoWithEhCache.domain.Product@1a8f392
2017-10-03 20:54:56,742  INFO [main] (AbstractApplicationContext.java:984) - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7bd1a567: startup date [Tue Oct 03 20:54:55 BOT 2017]; root of context hierarchy
2017-10-03 20:54:56,744  INFO [main] (EhCacheManagerFactoryBean.java:187) - Shutting down EhCache CacheManager

查看ProductServiceImpl中的 getName方法中的@Cacheable注解可知

@Cacheable(cacheNames = "products", key = "#name", condition = "#name != 'HTC'", unless = "#result==null")

HTC不缓存， 结果为空不缓存。

查看输出，第一次查询 IPhone Samsung HTC ，分别从慢速设备中加载， 当第二次第三次查询IPhone Samsung ，可以看到 并没有输出

logger.info("<!----------Entering getByName()--------------------->");

可知，其从缓存中加载。

因为不缓存HTC，所以每次查询HTC都从会执行方法，从慢速设备中查询。

当调用service.updateProduct(product); 我们使用的@CachePut注解更新缓存， 然后service.getByName(“IPhone”)，缓存没有被清空，所以依然是从缓存中获取。

随后，service.refreshAllProducts(); 将缓存全部清掉，再此查询service.getByName(“IPhone”)，然后再此查询可以看到输出了<!----------Entering getByName()--------------------->，紧接着的第二次第三次，是从缓存中获取的数据.

源码

代码已托管到Github—> https://github.com/yangshangwei/SpringMaster

小小工匠
关注
专栏目录
Spring使用Cache、整合Ehcache
Elim的博客
05-15 1万+
Spring使用Cache、整合Ehcache         从3.1开始，Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果进行返回。所
Spring 3.1 Cache Abstraction Tutorial
04-21
NULL 博文链接：https://laiahu.iteye.com/blog/1912975
I/O——Spring cache abstraction
十年梦归尘的专栏
12-09 164
Spring cache abstraction
Ehcache与Spring Cache整合详解
最新发布
weixin_53840353的博客
07-30 565
Ehcache是一个开源的Java缓存库，提供了简单易用的API，并且能够快速地存储和检索数据。Ehcache支持多种缓存类型，包括内存缓存和磁盘缓存。Spring Cache是Spring框架提供的一个模块，允许开发者通过注解的方式轻松地为方法添加缓存功能。Spring Cache支持多种缓存实现，包括Ehcache、Caffeine、Redis等。通过本文的介绍，你已经学会了如何将Ehcache与Spring Cache整合，并使用简单的注解轻松实现缓存功能。
Spring+EhCache缓存实例
awen7916的专栏
10-31 177
一、ehcahe的介绍 EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展，缓存异常处理程序，一个gzip缓存servlet过滤器，支持REST和SOAP api等特点...
Spring cache abstraction
weixin_34234823的博客
12-29 179
为什么80%的码农都做不了架构师？>>> ...
Spring Cache Abstraction
04-22 150
Spring提供了一种作用在方法上的缓存抽象，从而减少方法的执行次数。缓存抽象只是一套接口，也就是操作规范，需要具体的缓存提供者去实现。
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-cache.rar
07-11
Spring Cache 是 Spring 框架的一部分，它提供了一个抽象层，允许你在不同的缓存提供商（如 EhCache、Redis、Hazelcast 或者 Infinispan）之间进行选择。 1. **配置缓存**：在 Spring Boot 中，你可以通过 `@...
spring-boot-demo19:Spring Boot基础教程 之 使用Caching-EhCache
04-15
4. **启用缓存**：在你的Spring Boot应用中，使用`@EnableCaching`注解开启缓存功能，通常放在主配置类上。 5. **使用缓存**：现在，你可以在需要缓存的方法上添加注解。例如，使用`@Cacheable`注解： ```java @...
详解Spring整合Ehcache管理缓存
08-30
通过这种方式，Spring 将 Ehcache 整合进应用程序，使得开发者可以方便地管理和使用缓存，无需关注缓存的具体实现细节。 总结，Spring 与 Ehcache 的整合使得我们可以充分利用 Ehcache 的性能优势，同时享受 Spring...
spring整合EhCache 基于注解的方式
02-16
本例子主要讲解ehcache的配置使用。采用了java配置和xml配置两种方式。主要用于学习。 使用java配置时将SpringTestCase.java 文件中的@ContextConfiguration(locations = { "classpath:applicationContext.xml" }) 注释掉 使用xml配置时。将com.test.config 下的Java文件中@Configuration 都注释掉。
spring-cache抽象
FantasyBaby的博客
10-08 134
官方文档 8.0 Spring为不同缓存做了一层抽象 简介 从3.1版开始，Spring Framework提供了对现有Spring应用程序透明地添加缓存的支持。 与事务支持类似，缓存抽象允许一致地使用各种缓存解决方案，而对代码的影响最小。 从Spring 4.1开始，通过JSR-107注释和更多自定义选项的支持，缓存抽象得到了显着改进。 cache和buffer 从术语上看,"buffer"和"cache",可以互相被替换.但是,他们确实代表着不同的事情. 传...
ehcache整合spring注解方式
weixin_33778778的博客
11-23 116
一、简介 　　在hibernate中就是用到了ehcache 充当缓存。spring对ehcache也提供了支持，使用也比较简单，只需在spring的配置文件中将ehcache的ehcache.xml文件配置进去即可。在spring中使用ehcache有两种方式，一种是使用spring提供的封装，使用注解的方式配置在某个方法上面，第一次调用该方法的时候，将该方法执行返回的数据缓存，当再次执行的时...
Spring Cache抽象详解
不动明王1984的博客
11-07 1116
原文地址：http://jinnianshilongnian.iteye.com/blog/2001040缓存简介缓存，我的理解是：让数据更接近于使用者；工作机制是：先从缓存中读取数据，如果没有再从慢速设备上读取实际数据（数据也会存入缓存）；缓存什么：那些经常读取且不经常修改的数据/那些昂贵（CPU/IO）的且对于相同的请求有相同的计算结果的数据。如CPU--L1/L2--内存--磁盘就是一个典型...
Spring5 Cache Abstraction
stay foolish
05-26 122
Since version 3.1, the Spring Framework provides support for transparently adding caching to an existing Spring application. Similar to thetransactionsupport, the caching abstraction allows consistent use of various caching solutions with minimal impact ..
聊聊Spring Cache的缓存抽象与JSR107缓存抽象JCache，并使用API方式使用Spring Cache【享学Spring】
架构师：通透，才能写出好代码！
07-02 2368
前言 缓存(Cache)是计算机领域一个极其重要的概念，它是提高硬件（比如CPU）、软件运行效率非常有效的一个手段，它的最大特点就是：快。 缓存就是数据交换的缓冲区（称作：Cache），当某一硬件要读取数据时，会首先从缓存汇总查询数据，有则直接执行返回即可。它被运用在计算机领域的各个方面，介绍如下： 操作系统磁盘缓存 ——> 减少磁盘机械操作 Web服务器缓存——>减少应用服务器请求...
Spring文档学习--缓存（Cache Abstraction）
程高伟
03-03 6629
详细介绍了Spring对缓存的支持，配置和常用标签@Cacheable，@CachePut，@CacheEvict，@Caching，@CacheConfig，condition，unless的使用
Spring源码之缓存抽象（36. Cache Abstraction）
AnY11的专栏
02-19 416
36.1 Introduction 从3.1版本开始，Spring Framework就支持在现有Spring应用程序中透明地添加缓存。与事务支持类似，缓存抽象允许在对代码影响最小的情况下一致使用各种缓存解决方案。 从Spring 4.1开始，在JSR-107注释和更多定制选项的支持下，缓存抽象得到了显著改进。 36.2 Understanding the cache abstraction...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值