Spring Boot 中使用cache缓存的方法

一、什么是缓存 cache

cache 一词最早来自于cpu设计

当cpu要读取一个数据时，首先从cpu缓存中查找，找到就立即读取并送给cpu处理；没有找到，就从速率相对较慢的内存中读取并送给cpu处理，同时把这个数据所在的数据块调入缓存中，可以使得以后对整块数据的读取都从缓存中进行，不必再调用内存。正是这样的读取机制使cpu读取缓存的命中率非常高（大多数cpu可达90%左右），也就是说cpu下一次要读取的数据90%都在cpu缓存中，只有大约10%需要从内存读取。这大大节省了cpu直接读取内存的时间，也使cpu读取数据时基本无需等待。总的来说，cpu读取数据的顺序是先缓存后内存。

再到后来，出先了硬盘缓存，然后到应用缓存，浏览器缓存，web缓存，等等！

缓存为王！！

spring cache

spring cache是spring针对spring应用，给出的一整套应用缓存解决方案。

spring cache本身并不提供缓存实现，而是通过统一的接口和代码规范，配置、注解等使你可以在spring应用中使用各种cache，而不用太关心cache的细节。通过spring cache ，你可以方便的使用

各种缓存实现，包括concurrentmap,ehcache 2.x,jcache,redis等。

spring中cache的定义

sping 中关于缓存的定义，包括在接口 org.springframework.cache.cache 中，

它主要提供了如下方法

// 根据指定key获取值
<t> t get(object key, class<t> type)
// 将指定的值，根据相应的key，保存到缓存中
void put(object key, object value);
// 根据键，回收指定的值
void evict(object key)

从定义中不难看着,cache 事实上就是一个key-value的结构，我们通过个指定的key来操作相应的value

cache manager

cache是key-value的集合，但我们在项目中，可能会存在各种业务主题的不同的cache，比如用户的cache,部门的cache等，这些cache在逻辑上是分开的。为了区分这些cache，提供了org.springframework.cache.cachemanager用来管理各种cache.该接口只包含两个方法

// 根据名字获取对应主题的缓存
cache getcache(string name);
// 获取所有主题的缓存
collection<string> getcachenames();

在该接口中，不允许对cache进行增加、删除操作，这些操作应该在各种cachemanager实现的内部完成，而不应该公开出来。

基于注解的缓存

对数据的缓存操作，理论上和业务本身的相关性不大，我们应当把对cache的读写操作从主要代码逻辑中分离出来。spring分离的方式就是基于注解的（当然像jsr-107等也是基于注解的）。

spring 提供了一系列的注解，包括@cacheable，@cacheput，@cacheevict等一系列注解来简化我们对缓存的操做，这些注解都位于org.springframework.cache.annotation包下。

二、例子

一个简单的spring boot使用spring cache的例子

我们一步一步，来构建一个基于spring boot cache的例子

新建一个spring boot 项目，引入如下依赖

<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.springframework.boot</groupid>
    <artifactid>spring-boot-starter-test</artifactid>
    <scope>test</scope>
  </dependency>
</dependencies>

其中，spring-boot-starter-cache是cache关键依赖。

修改application类，加入启用缓存的注解@enablecaching

@springbootapplication
@enablecaching
public class cachesimpleapplication {
  public static void main(string[] args) {
    springapplication.run(cachesimpleapplication.class, args);
  }
}

@enablecache注解启动了spring的缓存机制，它会使应用检测所有缓存相关的注解并开始工作，同时还会创建一个cachemanager的bean,可以被我们的应用注入使用。

新建一个restcontroller类

@restcontroller
@requestmapping("/")
public class cachecontroller {
  @autowired
  private cachetestservice cachetestservice;
  /**
   * 根据id获取信息
   * 
   * @param id
   * @return
   */
  @getmapping("{id}")
  public string test(@pathvariable("id") string id) {
    return cachetestservice.get(id);
  }
  /**
   * 删除某个id的信息
   * 
   * @param id
   * @return
   */
  @deletemapping("{id}")
  public string delete(@pathvariable("id") string id) {
    return cachetestservice.delete(id);
  }
  /**
   * 保存某个id的信息
   * 
   * @param id
   * @return
   */
  @postmapping
  public string save(@requestparam("id") string id, @requestparam("value") string value) {
    return cachetestservice.save(id, value);
  }
  /**
   * 跟新某个id的信息
   * 
   * @param id
   * @return
   */
  @putmapping("{id}")
  public string update(@pathvariable("id") string id, @requestparam("value") string value) {
    return cachetestservice.update(id, value);
  }
}

该类调用某个service来实现实际的增删改查操作。

service 实现

接下来，我们要实现我们的service

@service
public class simplecachetestserviceimpl implements cachetestservice {
  private static final logger logger = loggerfactory.getlogger(simplecachetestserviceimpl.class);
  private final map<string, string> enties = new hashmap<>();
  public simplecachetestserviceimpl() {
    enties.put("1", "this no 1");
  }
  @autowired
  private cachemanager cachemanager;
  @override
  @cacheable(cachenames = "test")
  public string get(string id) {
    // 记录数据产生的时间，用于测试对比
    long time = new date().gettime();
    // 打印使用到的cachemanager
    logger.info("the cachemanager is" + cachemanager);
    // 当数据不是从cache里面获取时，打印日志
    logger.info("get value by id=" + id + ", the time is " + time);
    return "get value by id=" + id + ",the value is" + enties.get(id);
  }
  @override
  public string delete(string id) {
    return enties.remove(id);
  }
  @override
  public string save(string id, string value) {    
    logger.info("save value " + value + " with key " + id);
    enties.put(id, value);
    return value;
  }
  @override
  public string update(string id, string value) {
    return enties.put(id, value);
  }
}

缓存

首先在get方法上加上 @cacheable 注解，运行代码测试。

我们使用postman做测试，测试地址为 ，浏览器响应get value by id=1,the value isthis no 1，服务器控制台打印两行日志

get value by id=1,the value isthis no 1 
get value by id=1, the time is 1516004770216 

但我们再次刷新浏览器地址时，浏览器正常返回，但控制台已经不再打印了，原因是第二次调用时，spring 已经不再执行方法，而是直接获取缓存的值。 spring cache将函数的返回值以函数参数为key,缓存在了名为test的缓存中 。

这里我们使用了 @cacheable 注解，注解中的cachenames指定了这里读取的是哪个cache。这里会在cachename="test"的cache中去查找key是id的缓存对象。

删除缓存中的数据

在上面的程序中，如果我们通过delete请求删除指定值，发送delete请求到 ,这个时候，值已经从map中删除了，但我们get 请求到 的时候，仍然可以拿到值，这是因为我们在删除数据的时候，没有删除缓存中的数据，而在前面的get方法中，方法的运行结果仍然被保存着，spring不会去重新读取，而是直接读取缓存。这个时候，我们在方法前面加上注解

@override
@cacheevict(cachenames = "test")
public string delete(string id) {
  return enties.remove(id);
}

先后测试，首先调用get请求，会正确显示返回值为get value by id=1,the value is 1

然后调用delete请求。将数据从cache和map中删除，再次调用get请求，这时返回get value by id=1,the value is null，代表该值确实从缓存中删除了。

这里我们使用了 @cacheevict 注解，cachenames指定了删除哪个cache中的数据， 默认会使用方法的参数作为删除的key

更新缓存

当程序到这里时，如果我们运行post请求，请求体为 id=1&value=new1，这时控制台打印save value new value1 with key 1，代码会将值保存到map中，但我们运行get请求时，会发现返回值仍然是之前的状态。这是我们可以使用

@override
@cacheput(cachenames = "test", key = "#id")
public string save(string id, string value) {
  logger.info("save value " + value + " with key " + id);
  return enties.put(id, value);
}

重新执行代码，我们先发送delete请求，从map和和cache中删除数据。然后再发送post请求，写入数据到map中。最后再发送get请求，会发现现在可以正确的取到值了，控制台也没有打印从map中获取数据的日志。

这里用到了 @cacheput 注解，这个注解的作用是 将方法的返回值按照给定的key,写入到cachenames指定的cache中去 。

同样，我们需要再put方法上加上 @cacheput 注解，让修改也能刷新缓存中的数据。

到这里，一个简单的包含增删改查的缓存应用就完成了。

三、划重点

几个注解

• @enablecaching 启用缓存配置
• @cacheable 指定某个方法的返回值是可以缓存的。在注解属性中指定缓存规则。
• @cacheput 将方法的返回值缓存到指定的key中
• @cacheevict 删除指定的缓存数据

注意

@cacheable和@cacheput都会将方法的执行结果按指定的key放到缓存中，@cacheable在执行时，会先检测缓存中是否有数据存在，如果有，直接从缓存中读取。如果没有，执行方法，将返回值放入缓存，而@cacheput会先执行方法，然后再将执行结果写入缓存。 使用@cacheput的方法一定会执行

完整的示例代码在

总结

以上所述是小编给大家介绍的spring boot 中使用cache缓存的方法，希望对大家有所帮助