spring使缓存变得容易

最新推荐文章于 2024-09-30 11:27:21 发布
最新推荐文章于 2024-09-30 11:27:21 发布
阅读量1k 收藏
点赞数
分类专栏： 缓存 文章标签： spring 缓存 class

spring3.1引入一种新的和简单的方式来缓存结果，在这篇文章中我们我们将看到在项目中怎么使用过spring 缓存来避免执行已经产生结果的重复任务。这篇文章的读者要有基本的spring和依赖注入的知识。

这篇文章被分成三部分。第一部分我们将会看一个只是能够运行的简单的例子；第二部分我们看一下在递归上是如何缓存的。最后一部分我们来看一个现实世界的例子，来看看缓存是如何被运用的；最后一部分我们同样也会看到当缓存过期是是如何清空的。

考虑下边这个类

package com.javacreed.examples.sc.part1;

import org.springframework.stereotype.Component;

@Component
public class Worker {

  public String longTask(final long id) {
    System.out.printf("Running long task for id: %d...%n", id);
    return "Long task for id " + id + " is done";
  }

  public String shortTask(final long id) {
    System.out.printf("Running short task for id: %d...%n", id);
    return "Short task for id " + id + " is done";
  }
}

这里有一个包含两个方法的简单的spring组件类。一个名为longTask()，传递一个虚构的长任务，第二个名为shortTask()，运行的快一些。这两个方法的输出仅仅取决于这两个方法的输入。因此对于相同的输入我们能得到同样的输出。这非常重要，否则的话我们不能使用缓存。

现在考虑下边这个例子

package com.javacreed.examples.sc.part1;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

  public static void main(final String[] args) {
    final String xmlFile = "META-INF/spring/app-context.xml";
    try (ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(xmlFile)) {

      final Worker worker = context.getBean(Worker.class);
      worker.longTask(1);
      worker.longTask(1);
      worker.longTask(1);
      worker.longTask(2);
      worker.longTask(2);
    }
  }
}

这里我们创建了spring环境并获取了spring中Worker的实例，然后我们调用方法longTask()五次，这将会迅速的产生下边的输出结果：

Running long task for id: 1...
Running long task for id: 1...
Running long task for id: 1...
Running long task for id: 2...
Running long task for id: 2...

注意这个方法longTask()运行了5次，每一次请求运行一次。同样要注意这个方法只接受了2各不同的输入。参数1的时候这个方法调用3次，参数为2的时候调用了2次。因为这个假的任务方法的输出仅仅取决于输入我们可以为下一次的请求缓存这个输出，而不用再次运行这个假的方法。

为了应用缓存，我们需要做下边三件事：

1、标记将要被缓存的这个方法（或者是类）

spring3.1在方法上增加了新的注释来使用缓存。

package com.javacreed.examples.sc.part1;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component
public class Worker {

  @Cacheable("task")
  public String longTask(final long id) {
    System.out.printf("Running long task for id: %d...%n", id);
    return "Long task for id " + id + " is done";
  }

  public String shortTask(final long id) {
    System.out.printf("Running short task for id: %d...%n", id);
    return "Short task for id " + id + " is done";
  }

}

通过简单的在方法上添加@Cacheable注解，有相同参数的值的请求会返回缓存的值。spring允许我们使用缓存的值而不写方法来获取这个值。注意这个注解也需要一个值，来作为缓存仓库的名字，我们一会讨论缓存仓库。

注意这个注解@Cacheable可以添加到类上，意味着这个类的所有方法都会被缓存。

2、激活spring缓存

在spring开始缓存我们的值之前，我们需要增加下边的说明：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:cache="http://www.springframework.org/schema/cache"
  xmlns:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">

  <context:annotation-config />
  <context:component-scan base-package="com.javacreed.examples.sc" />

  <!-- Enables the caching through annotations -->
<span style="color:#ff6666;">  <cache:annotation-driven />
</span>
</beans>

有了这个声明，spring将会查找任何标注了cacheable的方法或者是类，并会执行必要的操作来提供缓存

3、配置需要使用的缓存仓库

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:cache="http://www.springframework.org/schema/cache"
  xmlns:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">

  <context:annotation-config />
  <context:component-scan base-package="com.javacreed.examples.sc" />

  <!-- Enables the caching through annotations -->
  <cache:annotation-driven />

  <!-- Generic cache manager based on the JDK ConcurrentMap -->
<span style="color:#ff0000;">  <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
    <property name="caches">
      <set>
        <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="task" />
      </set>
    </property>
  </bean></span>
</beans>

这个缓存仓库是被缓存对象存储的地方 ，spring支持两种仓库，一种是基于JDK的ConcurrentMap，另一种基于ehcache流行的库，也可能增加更多的库。这里我们使用的是JDK的ConcurrentMap作为我们的缓存仓库，仓库间的互相切换时很简单的。我们的对象将会在ConcurrentMap中被缓存，在这个例子中，我们增加了名为task的仓库。我们可以有多个仓库。注意这个仓库的名字和之前注释中仓库的名字是一样的。

请注意，这个JDK的ConcurrentMap类和spring3.1和spring3.2中的类是不一样的，这里我们使用的是spring3.2，在3.1中类的名字如下：

org.springframework.cache.concurrent.ConcurrentCacheFactoryBean


这是怎么工作的呢

当我们使用缓存的时候，spring将会把我们标记缓存的对象给代理。调用者不会操作对象而是操作代理。




如果我们打印spring返回的类的名字，我们会看到以下的信息

Worker class: com.javacreed.examples.sc.part1.Worker$$EnhancerByCGLIB$$4fa6f80b
注意这个不是我创建的Worker类（com.javacreed.examples.sc.part1.Worker)）。事实上，这个类是通过 spring的字节码技术生成的，我们在这里不做讨论。当我们调用Worker的任何方法的时候，我们将会调用代理的方法。这个代理有我们Worker类的实例。它将会推送任何请求给我们的对象并返回响应，如下图。如果这个方法被标记为可以缓存的，代理将会绕开这个请求而返回缓存的内容。如果这个代理没有为这个输入缓存值，它将会执行这个请求，并把响应缓存起来以备将来使用。



如果我们运行我们的main类，我们将会得到以下的输出结果

Running long task for id: 1...
Running long task for id: 2...

这里的假的方法实际上被调用两次，代理返回了其他请求的缓存结果。事实证明，使用springcache非常简单，我们需要做的就是我们之前列出来的东西。下一部分我们可以看一下怎么在递归上使用缓存。

缓存递归方法

package com.javacreed.examples.sc.part2_1;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component("fibonacci")
public class Fibonacci {

  private int executions = 0;

  public int getExecutions() {
    return executions;
  }

  public void resetExecutions() {
    this.executions = 0;
  }

  @Cacheable("fibonacci")
  public long valueAt(final long index) {
    executions++;
    if (index < 2) {
      return 1;
    }

    return valueAt(index - 1) + valueAt(index - 2);
  }

}

这个类实现了fibonacci数列并根据index返回了计算的结果。fibonacci数字使用下边的函数做递归计算fib(n) = fib(n-1) + fib(n-2)。注意这个类同样保存了方法被调用的次数。我们可以通过get方法获取这个值。这个fibonacci类实现了重置值为0的方法，方便将来的调用。

下边来执行：

package com.javacreed.examples.sc.part2_1;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

  public static void main(final String[] args) {
    final String xmlFile = "META-INF/spring/app-context.xml";
    try (ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(xmlFile)) {

      final long start = System.nanoTime();
      final Fibonacci sequence = context.getBean("fibonacci", Fibonacci.class);
      final long fibNumber = sequence.valueAt(5);
      final int executions = sequence.getExecutions();
      final long timeTaken = System.nanoTime() - start;
      System.out.printf("The 5th Fibonacci number is: %d (%,d executions in %,d NS)%n", fibNumber, executions,
          timeTaken);
    }
  }
}

执行上边的代码，我们得到以下的输出结果：

The 5th Fibonacci number is: 8 (15 executions in 17,762,022 NS)

这个缓存的vauleAt方法被调用了总共15次，这看起来不对，这个vauleAt方法应该被执行6次而不是15次，其他的9次应该使用缓存的值。

哪里出错了呢

在main()方法中，我们通过spring获取Fibonacci 类的实例，继而spring把对象包装到代理中，因此在main()方法中，我们只能访问代理，但是Fibonacci 中的valuesAt方法调用它自己（递归），而不是通过代理调用valueAt()方法，而是直接使用Fibonacci类，因此代理被略过了。这就是为什么我们不在递归层面使用缓存。

 注意：如果我们调用sequence.vauleAt()方法（再一次使用相同的值），这个缓存的值将会被作为变量sequence代理的实例返回。

我们怎么解决这个问题呢

为了解决这个问题，我们需要修改Fibonacci 类，传递我们代理的一个引用。

package com.javacreed.examples.sc.part2_2;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component("fibonacci2")
public class Fibonacci {

  private int executions = 0;

  public int getExecutions() {
    return executions;
  }

  public void resetExecutions() {
    this.executions = 0;
  }

  @Cacheable("fibonacci")
  public long valueAt(final long index, final Fibonacci callback) {
    executions++;
    if (index < 2) {
      return 1;
    }

    return callback.valueAt(index - 1, callback) + callback.valueAt(index - 2, callback);
  }

}

注意我们的vauleAt()方法有两个参数而不是一个参数，有Fibonacci 类的一个实例，作为callback的引用，所以不是再调用自己的vauleAt方法而是调用callback的vauleAt方法。对于main方法我们做如下修改： 

package com.javacreed.examples.sc.part2_2;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

  public static void main(final String[] args) {
    final String xmlFile = "META-INF/spring/app-context.xml";
    try (ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(xmlFile)) {

      final long start = System.nanoTime();
      final Fibonacci sequence = context.getBean("fibonacci2", Fibonacci.class);
      final long fibNumber = sequence.valueAt(5, sequence);
      final int executions = sequence.getExecutions();
      final long timeTaken = System.nanoTime() - start;
      System.out.printf("The 5th Fibonacci number is: %d (%,d executions in %,d NS)%n", fibNumber, executions,
          timeTaken);
    }
  }
}

这个将会产生如下的输出结果：

The 5th Fibonacci number is: 8 (6 executions in 18,320,003 NS)

注意：在这个例子中，花费的时间比没有缓存的要长。这是因为缓存增加了一些附加操作，这个例子中缓存的时间减少不足以抵消增加的消耗。如果我们尝试调用更大的Fibonacci 序列，这个优势就能体现出来了。请不要尝试太大的数，因为这将会花费大量的时间去计算。

真实世界的例子

package com.javacreed.examples.sc.part3;

public class Member {

  private final int memberId;
  private final String memberName;

  public Member(final int memberId, final String memberName) {
    this.memberId = memberId;
    this.memberName = memberName;
  }

  // Getters removed for brevity

  @Override
  public String toString() {
    return String.format("[%d] %s", memberId, memberName);
  }
}

这个简单的类表示了一个只有id和name的类为了简单的表示，成员用如下的方式表示：

1,Albert Attard
2,Mary Borg
3,Tony White
4,Jane Black

下边是service的代码：

package com.javacreed.examples.sc.part3;

public interface MembersService {

  Member getMemberWithId(int id);

  void saveMember(Member member);
}

这个接口有两个方法一个用来根据id取回成员，另一个用来保存修改。下边的类向MembersService的实现发送了几个请求。注意实现是被缓存的，因此我们使用的是MembersService的代理。 

package com.javacreed.examples.sc.part3;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

  public static void main(final String[] args) {
    final String xmlFile = "META-INF/spring/app-context.xml";
    try (ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(xmlFile)) {

      final MembersService service = context.getBean(MembersService.class);

      // Load member with id 1
      Member member = service.getMemberWithId(1);
      System.out.println(member);

      // Load member with id 1 again
      member = service.getMemberWithId(1);
      System.out.println(member);

      // Edit member with id 1
      member = new Member(1, "Joe Vella");
      service.saveMember(member);

      // Load member with id 1 after it was modified
      member = service.getMemberWithId(1);
      System.out.println(member);
    }
  }

如果我们执行上边的代码，将会输出下边结果：

Retrieving the member with id: [1] from file: C:\javacreed\spring-cache\members.txt
[1] Albert Attard
[1] Albert Attard
Retrieving the member with id: [1] from file: C:\javacreed\spring-cache\members.txt
[1] Joe Vella

这里我们使用id 1发送了两个获取请求，但是方法实际就被调用了一次，在第二次请求后，缓存的值返回了。然后我们修改相同id的值，因为member已经修改了，缓存无效，因此使用相同的id获取member，我们再次回调用方法，加载这个对象。这个值会一直被存储直到失效。

我们来看一下是怎么被实现的，这个getMemberWithId方法和我们已经看的其他方法很像，被标注了@Cacheable注解

 @Override
  @Cacheable("members")
  public Member getMemberWithId(final int id) {
    System.out.printf("Retrieving the member with id: [%d] from file: %s%n", id, dataFile.getAbsolutePath());
   // code removed for brevity
  }

这个saveMember方法需要让cache无效，为了实现这个，spring提供了另一个名叫@CacheEvict的注解 

@Override
  @CacheEvict(value = "members", allEntries = true)
  public void saveMember(final Member member) {
   // code removed for brevity
  }

 当这个方法被调用的时候，缓存仓库的名字为members的所有member都会被清空（因为注解选项allEntries = true 已经说明）。因此下次再次调用getMemberWithId()方法的时候，读取新的变量，没有这个，这个getMemberWithId()方法，还会返回之前缓存的老值。

原文：http://www.javacreed.com/caching-made-easy-with-spring/

txxs
关注
专栏目录
Spring 缓存使用
congyh的专栏
04-08 5330
生效原理 抽象而不是实现Spring框架中, 缓存服务是一组抽象, 也就是一组API, 由 org.springframework.cache.Cache org.springframework.cache.CacheManager 抽象. 抽象中并不包含多线程或者多进程处理逻辑, 这些逻辑应该由缓存实现方提供. Spring data工程默认提供了一些实现, 例如ConcurrentHashMap,
SpringCache缓存初探共5页.pdf.zip
10-30
总的来说，SpringCache通过简单的注解和灵活的配置，让缓存集成变得轻松，能够有效地提升应用程序的性能。在实际项目中，根据具体的业务场景和性能需求，选择合适的缓存实现，并合理地设计缓存策略，是充分利用...
spring 基于注解的Cache支持
Code-lover's Learning Notes
07-16 2239
Spring为我们提供了几个注解来支持Spring Cache。其核心主要是@Cacheable和@CacheEvict。使用@Cacheable标记的方法在执行后Spring Cache将缓存其返回结果，而使用@CacheEvict标记的方法会在方法执行前或者执行后移除Spring Cache中的某些元素。下面我们将来详细介绍一下Spring基于注解对Cache的支持所提供的几个注解。@Cache
深入理解 Spring 的三重缓存机制
最新发布
qdsd_1898的博客
09-30 957
三重缓存是 Spring 在加载 Bean 时用来优化性能的一种设计模式，它利用了三级缓存来确保 Bean 在多线程环境下的安全初始化，避免了循环依赖问题，提升了性能。
spring中使用缓存
weixin_30565327的博客
03-28 118
一、启用对缓存的支持 　　Spring 对缓存的支持最简单的方式就是在方法上添加@Cacheable和@CacheEvict注解， 　　再添加注解之前，必须先启用spring对注解驱动的支持，基于java的配置的话，直接在某个java配置类上添加@EnableCaching。 　　如下： 1 @Configuration 2 //启用缓存 3 @EnableCaching ...
在Spring中使用缓存
qq_37771475的博客
01-10 403
相关阅读：关于缓存的进阶了解：关于缓存你需要知道的  一、启用对缓存的支持 Spring对缓存的支持有两种方式： 注解驱动的缓存（推荐使用） XML声明的缓存  1、使用注解驱动的缓存配置 使用Java配置的话，只需要在其中的一个配置类上添加@EnableCaching，这样的话就能启动注解驱动的缓存。如： package spittr.config; import org.s...
谈谈spring的缓存
程序员小董的专栏
05-12 4005
缓存到底扮演了什么角色 请移步:  http://hacpai.com/article/1376986299174 在对项目进行优化的时候,我们可以主要从以下三个方面入手: 1 缓存 2 集群 3 异步 今天,就先说说缓存。先说说spring的缓存,下一节我们再聊聊redis 说到spring的缓存,得提到三个注解。 spring的三个注解 @Cach
Spring+EhCache缓存实例
01-20
Spring的缓存抽象层使得切换缓存提供商变得简单，而无需改动大量代码。 **3. 配置Spring与EhCache** 在Spring中使用EhCache，首先需要在项目中引入EhCache的依赖，并在`pom.xml`或`build.gradle`中添加相应的依赖...
Java开发框架spring实现自定义缓存标签
09-03
总的来说，Spring通过AOP机制使得自定义缓存标签的实现变得简单而灵活。开发者可以根据自己的需求定义缓存行为，如缓存策略、缓存更新策略等，同时还能利用Spring提供的其他功能，如事务管理、安全控制等，构建高效...
浅谈SpringBoot集成Redis实现缓存处理(Spring AOP实现)
08-28
它是2014年推出的一个使Spring框架开发变得容易的框架。SpringBoot充分利用了JavaConfig的配置模式以及“约定优于配置”的理念，能够极大的简化基于SpringMVC的Web应用和REST服务开发。 三、Redis简介 Redis是一个...
在Spring体系中使用redis.spring集成redis缓存
01-07
这个模块提供了对Redis操作的高级抽象，使得在Spring应用中使用Redis变得简单。 **一、集成步骤** 1. **依赖添加**：首先，在项目中添加Spring-data-redis和Redis客户端库（如Jedis或Lettuce）的依赖。通常在Maven...
Spring 缓存
04-08
介绍spring与ehcache缓存结合，使用spring注解访问，使用guava包中的缓存，封装guava缓存，为应用程序使用。类似于自定义的方式
spring缓存机制-自定义缓存(五, 六)
06-15
扩展spring自己的缓存，使之扩展性更强，功能更强大！
Spring缓存
weixin_45734499的博客
07-14 2112
spring缓存
spring中的缓存
weixin_43802688的博客
07-09 113
1.在启动类加上@EnableCaching注解，他表示开启基于注解的缓存 2.在方法上使用注解： 1）@Cacheable 2）@CacheEvict 3）@CachePut
使用spring的简单缓存
maoyeqiu的专栏
12-09 1159
这周我的一个老朋友联系到我，因为在他的应用中有个一内存问题，问题非常简单：每一个登录用户所有的应用表单和部分的键值对增加到user session中去（包含一些图片）。那用来提高访问的速度，避免多次请求数据库和加载数据。 那种方法的问题是，每一个用户在内存中都会有一个数据的拷贝。在这个例子中，同样的数据一遍一遍的被拷贝，经过一段时间，访问量增加的时候，JVM将会耗尽内存，用户只要不点击退出按钮情
Spring Data Redis 实现数据缓存详解
这些注解可以直接应用在方法上，使得缓存管理变得简单。 - @Cacheable：标记在方法上，表示该方法的返回结果应被缓存。如果缓存中有对应键的值，就直接返回，否则执行方法并将结果存入缓存。 - @CachePut：与@...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值