ehcace是现在非常流行的缓存框架，有轻量、灵活、可扩展、支持集群/分布式等优点。
在项目中，使用ehcace可以对数据进行缓存（一般使用、基于注解、基于aop），使用filter可以对页面进行缓存（SimplePageCachingFilter过滤器），与hibernate整合可以对对象进行缓存（二级缓存、查询缓存）。
简单的说使用缓存的方式主要分为数据层缓存、服务层缓存和页面缓存三种，它们一层比一层高效，实现也越来越复杂，在实际应用中最好能在尽量靠近用户的地方缓存，减少之后各层处理的压力，提高响应速度。
这篇文章先介绍hibernate的部分：二级缓存和查询缓存。
一、二级缓存
hibernate是自带一级缓存（session级别、事务级缓存）的，在一次请求中查询出的对象会被缓存，之后使用这个对象的时候会从缓存中取（不必多次访问数据库了）。
不过在这次请求处理结束、session关闭后，缓存中的数据就被清除了，第二次请求里用到的话还是需要再查一次。
如果想缓存一次还可以共享给之后的请求，就需要hibernate开启二级缓存了（sessionFactory级别、应用级缓存），它是跨session的，由sessionFactroy管理。
不过hibernate没有提供相应的二级缓存组件，需要加入额外的二级缓存包，常用的就是ehcache了，下面是hibernate集成ehcache进行二级缓存的配置方法（用一个较早的demo版本作为基础）：
1、添加jar包，修改pom.xml文件，加入：
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<version>4.2.21.Final</version>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<version>2.6.11</version>
</dependency>
2、修改spring-context-hibernate.xml，在hibernateProperties里增加3行配置：
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.hbm2ddl.auto">none</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.format_sql">false</prop>
<!-- 开启二级缓存 -->
<prop key="hibernate.cache.use_second_level_cache">true</prop>
<!-- 二级缓存的提供类 -->
<prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
<!-- 二级缓存配置文件的位置 -->
<prop key="net.sf.ehcache.configurationResourceName">ehcache-hibernate.xml</prop>
</props>
</property>
3、在"src/main/resources"代码文件夹中新建文件"ehcache-hibernate.xml"，内容为：
<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false">
<!-- Cache配置项说明
必须项
name 非默认Cache配置的名称，唯一的
maxEntriesLocalHeap 在内存中缓存的最大对象数（默认值为0，表示不限制）
maxEntriesLocalDisk 在磁盘中缓存的最大对象数（默认值为0，表示不限制）
overflowToDisk 如果对象数量超过内存中最大的数，是否将其保存到磁盘中
eternal 缓存是否永远不过期（如果为false，还需要根据timeToIdleSeconds、timeToLiveSeconds判断）
timeToIdleSeconds 对象的空闲时间（默认值为0秒，表示一直可以访问）
timeToLiveSeconds 对象的存活时间（默认值为0秒，表示一直可以访问）
1、如果仅设置了timeToLiveSeconds，则该对象的超时时间=创建时间+timeToLiveSeconds，假设为A；
2、如果没设置timeToLiveSeconds，则该对象的超时时间=max(创建时间，最近访问时间)+timeToIdleSeconds，假设为B；
3、如果两者都设置了，则取出A、B最少的值，即min(A,B)，表示只要有一个超时成立即算超时。
可选项
maxBytesLocalHeap 在内存中缓存的最大字节数（与maxEntriesLocalHeap属性不能同时指定，值可以加单位（K、M、G））
maxBytesLocalDisk 在磁盘中缓存的最大字节数（与maxEntriesLocalDisk属性不能同时指定，值可以加单位（CacheManager指定后可以加百分比）
指定后会隐式让当前cache的overflowToDisk为true）
diskExpiryThreadIntervalSeconds 清理保存在磁盘上的过期缓存项目线程的启动时间间隔（默认值为120秒）
diskSpoolBufferSizeMB 写入磁盘的缓冲区大小（默认为30MB，如果遇到OutOfMemory可以减小这个值）
clearOnFlush Cache的flush()方法调用时，是否清空MemoryStore（默认为true）
statistics 是否收集统计信息（默认为false，如果要监控缓存使用情况就开启，会影响性能）
memoryStoreEvictionPolicy 当内存中缓存的对象数或字节数达到设定的上限时，如果overflowToDisk=false，就采用淘汰策略替换对象（默认为LRU，可选FIFO、LFU）
1、FIFO（first in first out 先进先出）：淘汰最先进入的数据
2、LFU（Less Frequently Used 最少使用）：淘汰最长时间没有被访问的数据
3、LRU（Least Recently Used 最近最少使用）：淘汰一段时间内使用次数最少的数据
copyOnRead 当缓存被读出时，是否返回一份它的拷贝（默认为false）
copyOnWrite 当缓存被写入时，是否写入一份它的拷贝（默认为false）
-->
<!--默认的缓存配置（可以给每个实体类指定一个对应的缓存，如果没有匹配到该类，则使用这个默认的缓存配置）-->
<defaultCache
maxEntriesLocalHeap="10000"
maxEntriesLocalDisk="100000"
overflowToDisk="true"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
/>
<!-- <cache name="org.xs.techblog.modules.blog.entity.Daily" maxEntriesLocalHeap="1000" eternal="false" /> -->
<!-- 指定缓存存放在磁盘上的位置 -->
<diskStore path="java.io.tmpdir/demo1/ehcache/hibernate" />
</ehcache>
4、在实体类中增加1行@Cache注释
@Entity
@Table(name="test")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class testInfo {
其中CacheConcurrencyStrategy有5种并发性策略：
CacheConcurrencyStrategy.NONE 不使用缓存，默认的策略 CacheConcurrencyStrategy.READ_ONLY 只读模式，如果对数据更新了会报异常，适合不改动的数据 CacheConcurrencyStrategy.READ_WRITE 读写模式，更新缓存时会对缓存数据加锁，其他事务如果去取，发现被锁了，直接就去数据库查询 CacheConcurrencyStrategy.NONSTRICT_READ_WRITE 不严格的读写模式，更新缓存时不会加锁 CacheConcurrencyStrategy.TRANSACTIONAL 事务模式，支持回滚，当事务回滚时，缓存也能回滚
通常都是配置成只读模式的，读写模式的就具有事务隔离性了，而事务模式的事务隔离性最高。如果某些实体的数据经常修改、经常需要对缓存进行更新，性能就会变差，缓存也就失去了意义，这时就不如不用
5、增加相关方法、页面进行测试
testDao.java中增加方法：
public testInfo getInfo(String id) {
return (testInfo) sessionFactory.getCurrentSession().get(testInfo.class, id);
}
HelloController.java中增加方法：
@RequestMapping("list")
public String list(HttpServletRequest request) {
List<testInfo> list = testDao.getList();
request.setAttribute("testList", list);
return "list";
}
@RequestMapping("view/{id}")
public String view(@PathVariable("id") String id, HttpServletRequest request) {
testInfo info = testDao.getInfo(id);
request.setAttribute("testInfo", info);
return "view";
}
views中增加list.jsp、view.jsp页面：
list.jsp：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>Insert title here</title>
<%
/* 当前基础url地址 */
String path = request.getContextPath();
request.setAttribute("path", path);
%>
</head>
<body>
<c:if test="${!empty testList}">
<table border="1" width="100px">
<tr>
<th>列1</th>
<th>列2</th>
</tr>
<c:forEach items="${testList}" var="item">
<tr>
<td>${item.id}</td>
<td><a href="${path}/hello/view/${item.id}" target="_blank">${item.name}</a></td>
</tr>
</c:forEach>
</table>
</c:if>
</body>
</html>
view.jsp：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>Insert title here</title>
</head>
<body>
<table border="1" width="100px">
<tr>
<th>列1</th>
<td>${testInfo.id}</td>
</tr>
<tr>
<th>列2</th>
<td>${testInfo.name}</td>
</tr>
</table>
</body>
</html>
（需要在pom.xml中增加jstl、standard，来开启对标签的支持，这里略）
运行测试，访问"http://localhost:8080/demo1/hello/list"：
接着点击"666"，弹出"http://localhost:8080/demo1/hello/view/2"页面：
Console信息没有变化，还是：
说明二级缓存生效了，第二次请求访问对象"666"的时候，已经是从之前缓存的数据里取了，没有再访问数据库
注：二级缓存缓存的是完整的对象，所以如果查询的是对象的某个属性，就不会添加添加到缓存里
二、查询缓存
二级缓存和查询缓存都是sessionFactory级别的，它们都相当于一个map，不同的是：
二级缓存的map是<对象id, 对象实体>的集合 查询缓存的map是<sql语句, 结果集合>的集合
二级缓存适用于单个对象重复使用的情况，不能缓存集合，如果是某个hql语句的结果集合要重复使用，就需要再开启查询缓存了（一般二级缓存都是和查询缓存搭配使用）。
在一次list查询后，查询缓存会将hql转换后的sql语句作为key，然后将查询的结果作为value缓存起来，下面是配置方法：
1、修改spring-context-hibernate.xml，在hibernateProperties里增加1行配置：
<property name="hibernateProperties">
<props>
...
...
<!-- 开启查询缓存 -->
<prop key="hibernate.cache.use_query_cache">true</prop>
</props>
</property>
在use_query_cache设置为true后，ehcache将会创建两个缓存区域：默认用StandardQueryCache保存查询结果集，UpdateTimestampsCache保存查询缓存的时间戳，所以可以在ehcache-hibernate.xml中增加这两项，属于可选配置：
<cache name="net.sf.hibernate.cache.StandardQueryCache"
maxEntriesLocalHeap="10000"
maxEntriesLocalDisk="100000"
overflowToDisk="true"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
/>
<cache name="net.sf.hibernate.cache.UpdateTimestampsCache"
...
...
/>
2、在Dao层的查询条件设置"setCacheable(true)"
String hql = "from testInfo"; Query query = sessionFactory.getCurrentSession().createQuery(hql); query.setCacheable(true); //开启查询缓存 return query.list();
有一个可选设置：
query.setCacheRegion("myCacheRegion"); //单独指定缓存名称，在ehcache-hibernate.xml中配置，替代StandardQueryCache
3、运行测试，访问"http://localhost:8080/demo1/hello/list"：
Console信息：
之后这个地址重复刷新多次，Console信息中始终只有1条sql语句，说明查询缓存开启成功了
注：只有当hql查询语句完全相同、参数的值也完全相同时，查询缓存才有效，所以查询缓存的命中率是比较低的
当数据表中的任意数据发生一点修改时，整个表相关的查询缓存就失效了
（因为表数据修改后，时间戳更新，UpdateTimestampsCache里的时间戳不再是最新了，无法匹配所以缓存失效）
只有通过hibernate的hql修改数据才会刷新时间戳，如果直接使用sql或者使用其他应用程序修改数据库就无法监测到了
（因此query接口提供一个补救方法直接清除查询缓存：query.setForceCacheRefresh(true)）