- 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进行数据缓存。