基于Spring的Web缓存

基于Spring的Web缓存
缓存的基本思想其实是以空间换时间。我们知道，IO的读写速度相对内存来说是非常比较慢的，通常一个web应用的瓶颈就出现在磁盘IO的读写上。那么，如果我们在内存中建立一个存储区，将数据缓存起来，当浏览器端由请求到达的时候，直接从内存中获取相应的数据，这样一来可以降低服务器的压力，二来，可以提高请求的响应速度，提升用户体验。

缓存的分类
- 数据库数据缓存
一般来说，web应用业务逻辑业务逻辑比较复杂，数据库繁多，要获取某个完整的数据，往往要多次读取数据库，或者使用极其复杂效率较低的SQL查询语句。为了提高查询的性能，将查询后的数据放到内存中进行缓存，下次查询时，直接从内存缓存直接返回，提高响应效率。
- 应用层缓存
应用层缓存主要针对某个业务方法进行缓存，有些业务对象逻辑比较复杂，，可能涉及到多次数据库读写或者其他消耗较高的操作，应用层缓存可以将复杂的业务逻辑解放出来，降低服务器压力。
- 页面缓存
除了IO外，web应用的另一大瓶颈就是页面模板的渲染。每次请求都需要从业务逻辑层获取相应的model，并将其渲染成对应的HTML。一般来说，web应用读取数据的需求比更新数据的需求大很多，大多数情况下，某个请求返回的HTML是一样的，因此直接将HTML缓存起来也是缓存的一个主流做法。
- 代理服务器缓存
代理服务器是浏览器和源服务器之间的中间服务器，浏览器先向这个中间服务器发起Web请求，经过处理后（比如权限验证，缓存匹配等），再将请求转发到源服务器。代理服务器缓存的运作原理跟浏览器的运作原理差不多，只是规模更大。可以把它理解为一个共享缓存，不只为一个用户服务，一般为大量用户提供服务，因此在减少相应时间和带宽使用方面很有效，同一个副本会被重用多次。
- CDN缓存
CDN（ Content delivery networks ）缓存，也叫网关缓存、反向代理缓存。浏览器先向CDN网关发起Web请求，网关服务器后面对应着一台或多台负载均衡源服务器，会根据它们的负载请求，动态将请求转发到合适的源服务器上。虽然这种架构负载均衡源服务器之间的缓存没法共享，但却拥有更好的处扩展性。

基于spring的缓存

spring作为一个成熟的java web 框架，自身有一套完善的缓存机制，同时，spring还未其他缓存的实现提供了扩展。接下来，让我们在一个简单的学生管理系统中尝试spring的数据库缓存、应用层缓存、页面缓存的实现。

基于spring的Web缓存

源程序简介

本节课我们来看看一个简单的学生管理系统，改系统使用了Spring+JPA+EhCache的架构对数据库进行了缓存。大家可以直接下载源码进行学习。

数据库准备

测试程序使用了mysql作为数据库，安装好mysql后，建立一个空白的数据库，例如cache。

建好数据库后，修改src/main/resources/application.properties的数据库配置
```
spring.datasource.url=jdbc:mysql://localhost/cache?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=
```
利用maven启动程序

该系统利用maven作为构建工具，如果对maven没有了解的同学可以自行了解一下，我们会利用maven进行整个项目的构建以及运行。因此需要大家下载安装maven。

安装完成后，打开命令行，进入程序所在目录，输入以下命令：
```
mvn spring-boot:run
```
打开浏览器，访问以下http://localhost:8111/blogs即可看到最初的博客列表页面

直接运行 com.tmy.App.java

如果你成功的将项目作为一个maven项目导入进eclipse，直接运行com.tmy.App.java也可以将项目启动起来。

注意，如果希望将项目导入进eclipse，需要为eclipse添加maven插件，否则会出现依赖的类找不到的问题。

页面列表

以下是程序所提供的所有页面以及相关说明：
```
http://localhost:8111/blogs //没有加缓存的博客列表页面

http://localhost:8111/blogs/dao //添加了数据层缓存

http://localhost:8111/blogs/service?test=test //添加了服务层缓存
http://localhost:8111/blogs/service/update?test=test //更新服务层缓存
http://localhost:8111/blogs/service/evict?test=test //删除服务层缓存
http://localhost:8111/blogs/service/test?test=test //删除服务层缓存的同时更新缓存

http://localhost:8111/blogs/page //添加了页面缓存
http://localhost:8111/blogs/page/update //清空页面缓存
http://localhost:8111/blogs/page/delete //清空页面缓存
```
涉及到的技术
- maven
maven是目前主流java的构建工具之一，如果对maven没有了解的同学可以自行了解一下，接下来我们会利用maven进行整个项目的构建以及运行。
- spring boot
spring boot是spring的一个子项目，其目的是spring应用的初始搭建以及开发过程，如果你想自己搭建一个基于spring的应用，强烈建议学习一下在《java web 全栈开发》这门课程，教你如何从对spring零基础到搭建好一个完整的spring web应用。这里，我们只需知道mvn spring-boot:run命令可以将系统run起来即可。
- Spring
Spring作为目前主流的java web框架，大家应该都很了解，这里不做过多介绍。
- JPA
JPA全称Java Persistence API，JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。本门课程主要讲基于spring的数据库缓存，对于JPA的内容不做过多的涉及。
- EhCache
EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点。我们的学生管理系统将利用EhCache对数据库层进行缓存。

配置EhCache

对EhCache的依赖

上一节我们讲到很多技术，这里我们主要的依赖是指对EhCache的依赖，需要在Spring项目中引入EhCache，在pom.xml中加入以下代码即可：
```
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-ehcache</artifactId>
    </dependency>
```
配置CacheManager

添加ehcache配置文件

在src/main/resources下添加文件ehcache.xml：
```
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         name="CM1"
         updateCheck="false"
         maxBytesLocalHeap="16M">

    <diskStore path="/data/app/cache/ehcache"/>

    <defaultCache
            eternal="false"
            overflowToDisk="false"
            maxElementsInMemory="10000"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="36000"
            />
</ehcache>
```
encache可以对以下参数进行配置：
- name
缓存名称
- maxElementsInMemory
内存中最大缓存对象数
- maxElementsOnDisk
硬盘中最大缓存对象数，若是0表示无穷大
- eternal
true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false
- overflowToDisk
true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。
- diskSpoolBufferSizeMB
磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。
- diskPersistent
是否缓存虚拟机重启期数据
- diskExpiryThreadIntervalSeconds
磁盘失效线程运行时间间隔，默认为120秒
- timeToIdleSeconds
设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态
- timeToLiveSeconds
设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义
- memoryStoreEvictionPolicy
当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。

添加cacheManager

首先，我们要通过@EnableCaching标注将Spring通过标注进行缓存管理的功能打开，以方便我们之后通过标注添加数据库缓存。

然后，为CacheConfiguration添加@Configuration标注，打开CacheConfiguration内@Bean的功能。

生成一个CacheManager的实例。

最后，在web app销毁的时候销毁cacheManager。
```
@Configuration
@EnableCaching
public class CacheConfiguration {
    
    private net.sf.ehcache.CacheManager cacheManager;

    @PreDestroy
    public void destroy() {
        cacheManager.shutdown();
    }

    @Bean
    public CacheManager cacheManager() {
        cacheManager = net.sf.ehcache.CacheManager.create();
        EhCacheCacheManager ehCacheManager = new EhCacheCacheManager();
        ehCacheManager.setCacheManager(cacheManager);
        return ehCacheManager;
    }

}
```
数据层缓存实现

添加ehcache设置

首先，我们需要在EhCache中设置一块区域来存放缓存，在src/main/resources/ehcache.xml中添加如下配置：
```
<cache name="com.tmy.model.User"></cache>
<cache name="com.tmy.model.Blog"></cache>
```
Hibernate的一级缓存和二级缓存

Hibernate提供了两级缓存，第一级是Session的缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。第一级缓存是必需的，hibernate会默认提供好。

第二级缓存是一个可插拔的的缓存插件，它是由SessionFactory负责管理。由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此第二级缓存是进程范围或者集群范围的缓存。这个缓存中存放的对象的松散数据第二级缓存是可选的，可以在每个类或每个集合的粒度上配置第二级缓存。

打开二级缓存

我们可以通过为entry对象添加标注的方式打开二级缓存：
```
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
```
二级缓存一共有以下5种策略：
- CacheConcurrencyStrategy.NONE
不使用缓存，默认的缓存策略
- CacheConcurrencyStrategy.READ_ONLY
只读模式，在此模式下，如果对数据进行更新操作，会有异常
- CacheConcurrencyStrategy.READ_WRITE
读写模式在更新缓存的时候会把缓存里面的数据换成一个锁，其它事务如果去取相应的缓存数据，发现被锁了，直接就去数据库查询
- CacheConcurrencyStrategy.NONSTRICT_READ_WRITE
不严格的读写模式则不会的缓存数据加锁
- CacheConcurrencyStrategy.TRANSACTIONAL
事务模式指缓存支持事务，当事务回滚时，缓存也能回滚

指定cache region factory

然后，在src/main/resources/application.properties中为cache指定一个factory：
```
spring.jpa.properties. =org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory
```
性能对比

第一次访问

第一次访问http://localhost:8111/blogs时，waiting也就是服务器响应的时间为2.82秒，耗时较多。

注意：这里消耗2.82秒的原因是：在Blog对象中添加了对成员creator添加了@ManyToOne的标注，因此，当通过JPA获取blog对象后，JPA还会请求一次SQL查询，去user表中获取user信息，将user填充进来，而为了效果更加明显，系统在添加测试数据时为每个blog都添加了不同的user，导致sql请求大大增加，处理时间也大大增加

多次访问未缓存页面

多次访问http://localhost:8111/blogs后，服务器响应时间大大减少，基本保持在700毫秒左右：

这是因为mysql实际上帮我们做了缓存的工作，因此，多次访问后，服务器响应时间会大大减少。如果大家有兴趣，可以自行搜索mysql缓存相关的内容。

多次访问已缓存页面

那么，在多次访问http://localhost:8111/blogs/dao后，访问时间基本保持在100多毫秒，比没有缓存的页面效率高了5倍左右，比第一次访问效率高了20倍以上。

服务层缓存实现

Spring缓存的相关标注

Spring 提供了一套标注来保住我们快速的实现缓存系统：
- @Cacheable 触发添加缓存的方法
- @CacheEvict 触发删除缓存的方法
- @CachePut 在不干涉方法执行的情况下更新缓存
- @Caching 组织多个缓存标注的标注
- @CacheConfig 在class的层次共享缓存的设置
接下来我们来看缓存的具体实现。

添加ehcache设置

和数据层缓存一样，需要在内存中设置一块区域来存放service的缓存，在src/main/resources/ehcache.xml中添加如下配置：
```
<cache name="com.tmy.service.allBlogs"></cache>
```
为某个方法添加缓存

首先，在BlogWithCacheService上添加@CacheConfig(cacheNames = "com.tmy.service.allBlogs")标注，表明在BlogWithCacheService中的方法的缓存都是放在com.tmy.service.allBlogs区域中。

在需要缓存的方法上添加@Cacheable标注：
```
@Cacheable(key = "#justTest")
public List<BlogWithoutCache> findAll(String justTest){
    return blogRepository.findAll();
}
```
当第一次调用该方法后，其返回值就会添加进缓存当中，当第二次调用时就能直接从缓存中获取对象了。为了测试缓存功能，我们为findAll方法添加了一个参数，这里我们将这个参数作为缓存的key。除了用参数之外，Spring还提供了其他解析方式来生成key：
- 被调用方法的名称 #root.methodName
- 被调用的方法 #root.method.name
- 被调用的目标对象 #root.target
- 被调用的对象的类名 #root.targetClass
- 被调用方法的参数 #root.args[0]
- 被调用方法所用的缓存 #root.caches[0].name
- 被调用方法的参数名 #arg
- 调用后的结果（该参数只在unless参数或者@CachePut标注中才能使用） #result
更新缓存

添加进缓存后，在update方法中添加@CachePut标注可以更新相应的缓存，同样，我们还是使用传进来的参数来更新相应的缓存：
```
@CachePut(key = "#justTest")
public List<BlogWithoutCache> updateAll(String justTest){
    BlogWithoutCache blog = new BlogWithoutCache();
    blog.setContent("这是不存在的博客");
    blog.setTitle("谨慎使用这个方法");
    return Lists.newArrayList(blog);
}
```
删除缓存

在某些情况下，我们还需要删除缓存，@CacheEvict可以干这件事情：
```
@CacheEvict(key = "#justTest")
public void evictAll(String justTest){
}
```
组织多种缓存操作

如果你想在一个方法中同时对缓存做多种操作，Spring支持使用@Caching来组织这些操作：
```
@Caching(evict = @CacheEvict(key="#justTest"), put = @CachePut(key="test"))
public List<BlogWithoutCache> testForCaching(String justTest){
    BlogWithoutCache blog = new BlogWithoutCache();
    blog.setContent("这是不存在的博客");
    blog.setTitle("谨慎使用这个方法");
    return Lists.newArrayList(blog);
}
```
性能对比

多次访问service层缓存页面

在多次访问http://localhost:8111/blogs/service?test=test后，服务器的访问时间基本保持在100毫秒以下，根据上次实验可以发现，其效率甚至比加了数据层缓存后还要高。

更新缓存

更新缓存前，访问http://localhost:8111/blogs/service?test=test页面，看下以下博客：

访问http://localhost:8111/blogs/service/update?test=test更新缓存，再次访问http://localhost:8111/blogs/service?test=test，将发现数据库没有变化，但是返回的博客列表发生了变化：

删除缓存

现在缓存对象已经被玩坏了，让我们访问http://localhost:8111/blogs/service/evict?test=test缓存的对象给删掉，再次访问http://localhost:8111/blogs/service/update?test=test，我们发现博客列表重新变为正确的列表，同时服务器响应时间变成和没有做缓存时一致：

页面缓存的实现

添加缓存空间

同样，第一件事情让我们添加一下缓存的空间：
```
<cache name="com.tmy.mapper.allBlogs"></cache>
```
PageCachingFilter

ehcache为我们提供了几个缓存页面的filter，使用这些filter实现缓存：
- SimplePageCachingFilter
最基本的页面缓存filter实现，其满足大部分页面缓存的需求，该filter只缓存页面，不会修改herder的 ETag、Last-Modified、Expires属性
- SimplePageCachingFilterWithBlankPageProblem
当response没有提交时写入缓存，否则不写缓存，该缓存可能导致空白页的错误，需要特别注意！
- SimplePageFragmentCachingFilter
专门针对那些不独立存在，只是被include到其他页面的页面缓存
- SimpleCachingHeadersPageCachingFilter
SimplePageCachingFilter的扩展，会填写herder的 ETag、Last-Modified、Expires属性，可以进一步减少浏览器的访问次数

自定义的PageCachingFilter

以上filter会在filter初始化的时候通过FilterConfig对缓存进行初始化，为了在SpringBoot中方便的通过注解去实例化这些Filter，我们将CacheName的获取做一个定制：
```
public class CustomPageCachingFilter extends SimpleCachingHeadersPageCachingFilter {
    
    private final String customCacheName;
    
    public CustomPageCachingFilter(String name){
        this.customCacheName = name;
    }
    
    @Override
    protected String getCacheName() {
        return customCacheName;
    }
    
}
```
这样，我们就能很方便的注入cacheName了。

EhCache只提供了添加缓存的Filter，但是并没有提供删除缓存的Filter，没关系，让我们来自己实现一个：
```
public class ClearPageCachingFilter implements Filter {
    
    private final CacheManager cacheManager;
    
    private final String customCacheName;
    
    public ClearPageCachingFilter(String name){
        this.customCacheName = name;
        cacheManager = CacheManager.getInstance();
        assert cacheManager != null;
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
            ServletException {
        Ehcache ehcache = cacheManager.getEhcache(customCacheName);
        ehcache.removeAll();
    }

    @Override
    public void destroy() {}
}
```
现实情况URL的设计是极其复杂的，我们在这里就简单粗暴的将所有cache直接删除，如果缓存设计的比较好，最好可以通过ehcache.remove(key);的方式对cache进行管理。

添加Filter

我们目前使用标注的方式对Filter以及Filter mapping进行管理，目前我们只缓存/blogs/page这一个页面：
```
@Configuration
@AutoConfigureAfter(CacheConfiguration.class)
public class PageCacheConfiguration {
    
    @Bean
    public FilterRegistrationBean registerBlogsPageFilter(){
        CustomPageCachingFilter customPageCachingFilter = new CustomPageCachingFilter("com.tmy.mapper.allBlogs");
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(customPageCachingFilter);
        filterRegistrationBean.setUrlPatterns(Lists.newArrayList("/blogs/page"));
        return filterRegistrationBean;
    }
    
    @Bean
    public FilterRegistrationBean registerClearBlogsPageFilter(){
        ClearPageCachingFilter clearPageCachingFilter = new ClearPageCachingFilter("com.tmy.mapper.allBlogs");
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(clearPageCachingFilter);
        filterRegistrationBean.setUrlPatterns(Lists.newArrayList("/blogs/page/update", "/blogs/page/delete"));
        return filterRegistrationBean;
    }

}
```
从以上配置可以看出，我们为/blogs/page注册了一个添加缓存的Filter，/blogs/page请求将被缓存到内存当中。同时，为/blogs/page/update以及/blogs/page/delete注册了清空缓存的Filter，当访问这两个url时，将清空所有的缓存。

性能对比

访问被缓存的页面

访问http://localhost:8111/blogs/page，刷新，我们可以看到，服务器的响应时间只需要4毫秒，是mysql缓存、数据层缓存、服务层缓存当中最好的。

清空缓存后第一次访问

我们可以将以上几种缓存结合起来一起使用，http://localhost:8111/blogs/page，该请求已经结合了以上三种缓存的实现。因此，当我们访问http://localhost:8111/blogs/page/update清空页面缓存时，再次访问http://localhost:8111/blogs/page也只需要100多毫秒，此时页面缓存没有命中，但是service层缓存命中。

总结

就实践看来，数据层缓存、服务层缓存、页面缓存一层比一层更加高效，但是由于其实现越来越复杂，需要考虑的情况也越来越多，因此，其设计也越来越复杂。

从服务层缓存的实现@CachePut实现来看，在这一层需要我们配置的东西越来越多，已经有很大可能出现数据不一致的现象。而页面缓存的复杂性相对服务层缓存又高了一个层级，因此在针对缓存进行设计的时候，不仅仅考虑缓存所带来的性能提升，还要考虑到更新缓存所带来的性能损失。而且在实践当中，不是数据层缓存、服务层缓存、页面缓存越多越好，需要根据实际情况做出选择。
相关阅读:
学习记录（1）：intellij idea 导入gradle
javac不是内部或外部命令
 robot framework测试https接口实例
 py文件变成可执行exe ，遇到的问题及解决方法
 python 实现爬虫下载网页的方法
 [Usaco2009 Open]干草堆
 【题解】[USACO17JAN]Balanced Photo G
【题解】[BalticOI 2014]friends
从恒定状态出发，求解未知状态
 Scoi 组队
原文地址：https://www.cnblogs.com/duyinqiang/p/5696474.html

基于Spring的Web缓存

缓存的分类

基于spring的缓存

基于spring的Web缓存

源程序简介

数据库准备

利用maven启动程序

直接运行 com.tmy.App.java

页面列表

涉及到的技术

配置EhCache

对EhCache的依赖

配置CacheManager

添加ehcache配置文件

添加cacheManager

数据层缓存实现

添加ehcache设置

Hibernate的一级缓存和二级缓存

打开二级缓存

指定cache region factory

性能对比

第一次访问

多次访问未缓存页面

多次访问已缓存页面

服务层缓存实现

Spring缓存的相关标注

添加ehcache设置

为某个方法添加缓存

更新缓存

删除缓存

组织多种缓存操作

性能对比

多次访问service层缓存页面

更新缓存

删除缓存

页面缓存的实现

添加缓存空间

PageCachingFilter

自定义的PageCachingFilter

添加Filter

性能对比

访问被缓存的页面

清空缓存后第一次访问

总结

直接运行 `com.tmy.App.java`