Spring Boot中使用EhCache实现缓存支持
- SpringBoot提供数据缓存功能的支持，提供了一系列的自动化配置，使我们可以非常方便的使用缓存。，相信非常多人已经用过cache了。因为数据库的IO瓶颈。一般情况下我们都会引入非常多的缓存策略，例如引入redis，引入hibernate的二级缓存等。SpringBoot在annotation的层面给我们实现了cache，得益于Spring的AOP。所有的缓存配置只是在annotation层面配置，完全没有侵入到我们的代码当中，就像我们的声明式事务一样。
- Spring定义了CacheManager和Cache接口统一不同的缓存技术。其中CacheManager是Spring提供的各种缓存技术的抽象接口。而Cache接口包含缓存的各种操作，当然我们一般情况下不会直接操作Cache接口。
Spring针对不同的缓存技术，需要实现不同的cacheManager，Spring定义了如下的cacheManger实现：
| CacheManger | 描述 |
| SimpleCacheManager | 使用简单的Collection来存储缓存，主要用于测试 |
| ConcurrentMapCacheManager | 使用ConcurrentMap作为缓存技术（默认） |
| NoOpCacheManager | 测试用 |
| EhCacheCacheManager | 使用EhCache作为缓存技术，以前在hibernate的时候经常用 |
| GuavaCacheManager | 使用google guava的GuavaCache作为缓存技术 |
| HazelcastCacheManager | 使用Hazelcast作为缓存技术 |
| JCacheCacheManager | 使用JCache标准的实现作为缓存技术，如Apache Commons JCS |
| RedisCacheManager | 使用Redis作为缓存技术 |
Cache注解详解
@CacheConfig：主要用于配置该类中会用到的一些共用的缓存配置。在这里@CacheConfig(cacheNames = "users")：配置了该数据访问对象中返回的内容将存储于名为users的缓存对象中，我们也可以不使用该注解，直接通过@Cacheable自己配置缓存集的名字来定义。
@Cacheable 在方法执行前Spring先是否有缓存数据，如果有直接返回。如果没有数据，调用方法并将方法返回值存放在缓存当中。
@Cacheable：配置了findByName函数的返回值将被加入缓存。同时在查询时，会先从缓存中获取，若不存在才再发起对数据库的访问。该注解主要有下面几个参数：
- value、cacheNames：两个等同的参数（cacheNames为Spring 4新增，作为value的别名），用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig，因此在Spring 3中原本必须有的value属性，也成为非必需项了
- key：缓存对象存储在Map集合中的key值，非必需，缺省按照函数的所有参数组合作为key值，若自己配置需使用SpEL表达式，比如：@Cacheable(key = "#p0")：使用函数第一个参数作为缓存的key值，更多关于SpEL表达式的详细内容可参考官方文档
- condition：缓存对象的条件，非必需，也需使用SpEL表达式，只有满足表达式条件的内容才会被缓存，比如：@Cacheable(key = "#p0", condition = "#p0.length() < 3")，表示只有当第一个参数的长度小于3的时候才会被缓存，若做此配置上面的AAA用户就不会被缓存，读者可自行实验尝试。
- unless：另外一个缓存条件参数，非必需，需使用SpEL表达式。它不同于condition参数的地方在于它的判断时机，该条件是在函数被调用之后才做判断的，所以它可以通过对result进行判断。
- keyGenerator：用于指定key生成器，非必需。若需要指定一个自定义的key生成器，我们需要去实现org.springframework.cache.interceptor.KeyGenerator接口，并使用该参数来指定。需要注意的是：该参数与key是互斥的
- cacheManager：用于指定使用哪个缓存管理器，非必需。只有当有多个时才需要使用
- cacheResolver：用于指定使用那个缓存解析器，非必需。需通过org.springframework.cache.interceptor.CacheResolver接口来实现自己的缓存解析器，并用该参数指定。
@CachePut：配置于函数上，能够根据参数定义条件来进行缓存，它与@Cacheable不同的是，它每次都会将方法返回值放入缓存，所以主要用于数据新增和修改操作上。它的参数与@Cacheable类似，具体功能可参考上面对@Cacheable参数的解析。
@CacheEvict：配置于函数上，通常用在删除方法上，用来从缓存中移除相应数据。除了同@Cacheable一样的参数之外，它还有下面两个参数：
- allEntries：非必需，默认为false。当为true时，会移除所有数据
- beforeInvocation：非必需，默认为false，会在调用方法之后移除数据。当为true时，会在调用方法之前移除数据。
配置缓存
- 引入缓存依赖
在pom.xml中引入cache依赖，添加如下内容：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency>
- 开启缓存
在Spring Boot主类中通过@EnableCaching注解自动化配置合适的缓存管理器（CacheManager）,开启缓存功能，如下：
@SpringBootApplication @ComponentScan(basePackages={"com.gzh.*"}) @EnableCaching public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }
- 使用注解缓存数据
在数据访问接口中，增加缓存配置注解，如：
@Mapper public interface UserMapper { @Select("SELECT * FROM T_USER WHERE id = #{id}") UserVO findById(@Param("id") int id); @Select("SELECT * FROM T_USER WHERE name = #{name,jdbcType=VARCHAR}") UserVO findByName(@Param("name") String name); @Results({ @Result(property="id",column="id"), @Result(property = "name", column = "name"), @Result(property = "age", column = "age") }) @Select("SELECT id, name, age FROM T_USER") List<UserVO> findAll(); @Insert("INSERT INTO T_USER(name, age) VALUES(#{name}, #{age})") int insert(@Param("name") String name, @Param("age") Integer age); @Update("UPDATE T_USER SET age=#{age,jdbcType=INTEGER},name=#{name,jdbcType=VARCHAR} WHERE id=#{id,jdbcType=INTEGER}") void update(UserVO userVO); @Delete("DELETE FROM T_USER WHERE id =#{id,jdbcType=INTEGER}") void delete(int id); @Delete("DELETE FROM T_USER") void deleteAll(); }
新建IUserService接口类，如下:
@CacheConfig(cacheNames="user") public interface IUserService { //有一个尤其需要注意的坑：Spring默认的SimpleKeyGenerator是不会将函数名组合进key中的,即多个方法设置@Cacheable("databaseCache")，输出的key是一样的 /** * 新增一个用户 * @param name * @param age */ @CachePut(value="user",keyGenerator="cacheKeyGenerator") void create(String name, int age); /** * 根据id删除一个用户 * @param name */ @CacheEvict(value="user",keyGenerator="cacheKeyGenerator") void deleteById(int id); /** * 删除所有信息 */ @CacheEvict(keyGenerator="cacheKeyGenerator",allEntries=true) void deleteAll(); /** * 更新用户信息 * @param userVO */ @CachePut(keyGenerator="cacheKeyGenerator",cacheNames="user") void update(UserVO userVO); /** * 获取用户列表 * @return */ @Cacheable(keyGenerator="cacheKeyGenerator") List<UserVO> findAll(); /** * 根据Id查询用户信息 * @param id * @return */ @Cacheable(keyGenerator="cacheKeyGenerator") UserVO findById(int id); /** * 根据名称查询用户信息 * @param name * @return */ @Cacheable(keyGenerator="cacheKeyGenerator") UserVO findByName(String name); }
备注：大家可以先不配置keyGenerator属性，可以指定简单key。keyGenerator属性是我后边测试所用。
UserService实现类：
@Service public class UserService implements IUserService { @Autowired private UserMapper mapper; @Override public void create(String name, int age) { mapper.insert(name, age); } @Override public void deleteById(int id) { mapper.delete(id); } @Override public void deleteAll() { mapper.deleteAll(); } @Override public List<UserVO> findAll() { List<UserVO> list = mapper.findAll(); return list; } @Override public void update(UserVO userVO) { mapper.update(userVO); } @Override public UserVO findById(int id) { UserVO userVO = mapper.findById(id); return userVO; } @Override public UserVO findByName(String name) { UserVO userVO = mapper.findByName(name); return userVO; } }
新建单元测试类：
@RunWith(SpringJUnit4ClassRunner.class) @SpringApplicationConfiguration(Application.class) public class CacheApplicationTest { private static final Logger LOG = Logger.getLogger(CacheApplicationTest.class); @Autowired private IUserService iUserService; @Autowired private CacheManager cacheManager; @Before public void setUp(){ //检查使用的Cache LOG.info("Cache Manager ===== "+cacheManager.getClass().getName()); //删除所有数据 iUserService.deleteAll(); //添加用户信息 iUserService.create("guanguan", 20); iUserService.create("lindapang", 21); iUserService.create("xiaoyan", 18); } @Test public void userAddTest(){ UserVO user = iUserService.findByName("guanguan"); LOG.info("第一次查询用户信息=="+user.toString()); user = iUserService.findByName("guanguan"); LOG.info("第二次查询用户信息=="+user.toString()); } }
执行单元测试，可以在控制台看到输入如下内容：
从日志中，我们发现spring boot开启的缓存已经生效，第一次都执行了访问数据库的操作，第二次执行缓存。
完成上边案例后，大家肯定会想，spring boot是如何实现缓存的，使用的是什么缓存，带着这个疑问，我们继续往下看。
其实常规的SpringBoot已经为我们自动配置了EhCache、Collection、Guava、ConcurrentMap等缓存，默认使用SimpleCacheConfiguration，即使用ConcurrentMapCacheManager。在Spring Boot中通过@EnableCaching注解自动化配置合适的缓存管理器（CacheManager），Spring Boot根据下面的顺序去侦测缓存提供者：
• Generic
• JCache
• EhCache
• Hazelcast
• Infinispan
• Redis
• Guava
• Simple
除了按顺序侦测外，我们也可以通过配置属性spring.cache.type来强制指定。SpringBoot的application.properties配置文件，使用spring.cache前缀的属性进行配置。
spring.cache.type=#缓存的技术类型
spring.cache.cache-names=应用程序启动创建缓存的名称
spring.cache.ehcache.config=ehcache的配置文件位置
spring.cache.infinispan.config=infinispan的配置文件位置
spring.cache.jcache.config=jcache配置文件位置
spring.cache.jcache.provider=当多个jcache实现类时，指定选择jcache的实现类
这里不适用默认的ConcurrentMapCache 而是使用 EhCache，看看如何配置来使用EhCache进行缓存管理。
配置EhCache缓存
- 添加EhCache缓存依赖
<!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache --> <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.10.4</version> </dependency>
- 创建EhCache缓存配配置文件ehcache.xml
在src/main/resources目录下创建：ehcache.xml
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"> <!-- 指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下 --> <diskStore path="java.io.tmpdir"/> <!-- 设定缓存的默认数据过期策略 --> <cache name="users" maxElementsInMemory="10000" maxEntriesLocalHeap="200M" timeToLiveSeconds="600"/> <defaultCache maxElementsInMemory="10000" eternal="false" overflowToDisk="true" timeToIdleSeconds="10" timeToLiveSeconds="120" diskPersistent="false" memoryStoreEvictionPolicy="LRU" diskExpiryThreadIntervalSeconds="120"/> <!-- maxElementsInMemory 内存中最大缓存对象数，必须的配置 --> <!-- maxEntriesLocalHeap是用来限制当前缓存在堆内存上所能保存的最大元素数量的--> <!-- eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false --> <!-- maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大 --> <!-- 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（最少访问次数）。--> </ehcache>
- 在application.properties添加如下配置
spring.cache.type=ehcache
spring.cache.ehcache.config=classpath:ehcache.xml
- 在Spring Boot启动类上添加@EnableCaching注解
至此，我们所有的配置项都基本上配置完成。回到刚才IUserService接口类，我们使用缓存注解时使用到缓存的key，这个key是用来分辨同一个缓存中的缓存数据的。key是可以自己制定的，也可以通过自定义一个KeyGenerator来进行生成。
注解上key的几种形式如下：
基本形式：
1.@Cacheable(value="cacheName", key"#id")
2.public ResultDTO method(int id);
组合形式：
1.@Cacheable(value="cacheName", key"T(String).valueOf(#name).concat('-').concat(#password))
2.public ResultDTO method(int name, String password);
对象形式：
1.@Cacheable(value="cacheName", key"#user.id)
2.public ResultDTO method(User user);
自定义Key生成器：
1.@Cacheable(value="gomeo2oCache", keyGenerator = "keyGenerator")
2.public ResultDTO method(User user);
这里我们探讨下最后一种，自定义key。key可以为任何对象，我们要考虑的只有一件事，两个key对象，如何判断他们是否相等。所以很自然的我们想到重新实现它的hashCode和equals方法即可。
自定义keyGenerator
自定义的key生成器，我们需要去实现
org.springframework.cache.interceptor.KeyGenerator接口，并使用该参数来指定。需要注意的是：该参数与key是互斥的。
CacheKeyGenerator类代码如下：
@Component("cacheKeyGenerator")
public class CacheKeyGenerator implements KeyGenerator{
@Override
public Object generate(Object target, Method method, Object... params) {
Object key=new BaseCacheKey(target,method,params);
return key.toString();
}
}
BaseCacheKey类代码如下：
public class BaseCacheKey implements Serializable { /** * */ private static final long serialVersionUID = -8517453845729052981L; private static final Logger LOG = Logger.getLogger(BaseCacheKey.class); private final Object[] params; private final int hashCode; private final String className; private final String methodName; public BaseCacheKey(Object target, Method method, Object[] elements) { this.className = target.getClass().getName(); this.methodName = getMethodName(method); this.params = new Object[elements.length]; System.arraycopy(elements, 0, this.params, 0, elements.length); this.hashCode = generatorHashCode(); } private String getMethodName(Method method) { StringBuilder builder = new StringBuilder(method.getName()); Class<?>[] types = method.getParameterTypes(); if (types.length != 0) { builder.append("("); for (Class<?> type : types) { String name = type.getName(); builder.append(name + ","); } builder.append(")"); } return builder.toString(); } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; BaseCacheKey o = (BaseCacheKey) obj; if (this.hashCode != o.hashCode()) return false; if (!Optional.ofNullable(o.className).orElse("").equals(this.className)) return false; if (!Optional.ofNullable(o.methodName).orElse("").equals(this.methodName)) return false; if (!Arrays.equals(params, o.params)) return false; return true; } @Override public final int hashCode() { return hashCode; } private int generatorHashCode() { final int prime = 31; int result = 1; result = prime * result + hashCode; result = prime * result + ((methodName == null) ? 0 : methodName.hashCode()); result = prime * result + Arrays.deepHashCode(params); result = prime * result + ((className == null) ? 0 : className.hashCode()); return result; } @Override public String toString() { LOG.info(Arrays.toString(params)); LOG.info(Arrays.deepToString(params)); return "BaseCacheKey [params=" + Arrays.deepToString(params) + ", className=" + className + ", methodName=" + methodName + "]"; } }
在IUserService接口类注解中使用keyGenerator="cacheKeyGenerator"。
测试类：
@RunWith(SpringJUnit4ClassRunner.class) @SpringApplicationConfiguration(Application.class) public class CacheApplicationTest { private static final Logger LOG = Logger.getLogger(CacheApplicationTest.class); @Autowired private IUserService iUserService; @Autowired private CacheManager cacheManager; @Before public void setUp(){ //检查使用的Cache LOG.info("Cache Manager ===== "+cacheManager.getClass().getName()); //删除所有数据 iUserService.deleteAll(); //添加用户信息 iUserService.create("guanguan", 20); iUserService.create("lindapang", 21); iUserService.create("xiaoyan", 18); } @Test public void userAddTest(){ UserVO user = iUserService.findByName("guanguan"); LOG.info("第一次查询用户信息=="+user.toString()); user = iUserService.findByName("guanguan"); LOG.info("第二次查询用户信息=="+user.toString()); } }
测试结果如下，可以看到缓存依旧生效：
Cache Manager ===== org.springframework.cache.ehcache.EhCacheCacheManager
可以观察到，此时CacheManager的实例是
org.springframework.data.redis.cache.RedisCacheManager，
在第一次查询的时候，执行了select语句；第二次查询没有执行select语句，说明是从缓存中获得了结果。
不过由于EhCache是进程内的缓存框架，在集群模式下时，各应用服务器之间的缓存都是独立的。在一些要求高一致性（任何数据变化都能及时的被查询到）的系统和应用中，就不能再使用EhCache来解决了。在Spring Boot的缓存支持中使用Redis进行数据缓存。
