缓存的基本思想其实是以空间换时间。我们知道,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秒,耗时较多。

基于Spring的Web缓存_数据

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

多次访问未缓存页面

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

基于Spring的Web缓存_缓存_02

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

多次访问已缓存页面

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

基于Spring的Web缓存_spring_03

服务层缓存实现

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毫秒以下,根据上次实验可以发现,其效率甚至比加了数据层缓存后还要高。

基于Spring的Web缓存_缓存_04

更新缓存

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

基于Spring的Web缓存_数据_05

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

基于Spring的Web缓存_缓存_06

删除缓存

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

基于Spring的Web缓存_数据_07

页面缓存的实现

添加缓存空间

同样,第一件事情让我们添加一下缓存的空间:


<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缓存、数据层缓存、服务层缓存当中最好的。

基于Spring的Web缓存_数据_08

清空缓存后第一次访问

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

基于Spring的Web缓存_缓存_09

总结

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

从服务层缓存的实现​​@CachePut​​实现来看,在这一层需要我们配置的东西越来越多,已经有很大可能出现数据不一致的现象。而页面缓存的复杂性相对服务层缓存又高了一个层级,因此在针对缓存进行设计的时候,不仅仅考虑缓存所带来的性能提升,还要考虑到更新缓存所带来的性能损失。而且在实践当中,不是数据层缓存、服务层缓存、页面缓存越多越好,需要根据实际情况做出选择。