SpringBoot配置EhCache缓存

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<dependency>
  <groupId>net.sf.ehcache</groupId>
  <artifactId>ehcache</artifactId>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

    <!-- 磁盘缓存位置 -->
    <diskStore path="java.io.tmpdir/ehcache"/>

    <!-- 默认缓存 -->
    <defaultCache
            maxEntriesLocalHeap="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxEntriesLocalDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </defaultCache>

    <!-- 自定义缓存 -->
    <cache name="department"
           maxElementsInMemory="1000"
           eternal="false"
           timeToIdleSeconds="50"
           timeToLiveSeconds="50"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"/>
</ehcache>

name：Cache 的唯一标识
maxElementsInMemory：内存中允许存储的最大的元素个数
maxElementsOnDisk：硬盘最大缓存个数，0代表无限个
clearOnFlush：内存数量最大时是否清除
eternal：缓存对象是否永久有效，如果是，超时设置将被忽略
overflowToDisk：内存不足（超过 maxElementsInMemory）时，是否启用磁盘缓存
timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大
timeToLiveSeconds：缓存数据的生存时间（TTL），也就是一个元素从构建到消亡的最大时间间隔值，这只能在元素不是永久驻留时有效，如果该值是0就意味着元素可以停顿无穷长的时间
diskPersistent：是否将缓存数据持久化到磁盘上，如果为 true，JVM 重启数据依然存在。默认值是false
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒
memoryStoreEvictionPolicy：当达到 maxElementsInMemory 限制时，Ehcache 将根据指定策略清除内存。默认为 LRU（最近最少使用），其他策略有 FIFO（先进先出），LFU（较少使用）

# 缓存类型（ehcache、redis）
spring.cache.type=ehcache

# ehcache 配置文件
spring.cache.ehcache.config=classpath:ehcache.xml

# 打印日志，查看 sql
logging.level.com.light.springboot=DEBUG

@CacheConfig(cacheNames = "department")
@Service
public class DepartmentService {

  @Autowired
  private DepartmentMapper departmentMapper;

  @CachePut(key = "#department.id")
  public Department save(Department department) {
    System.out.println("保存 id=" + department.getId() + " 的数据");
    this.departmentMapper.insert(department);
    return department;
  }

  @CachePut(key = "#department.id")
  public Department update(Department department) {
    System.out.println("修改 id=" + department.getId() + " 的数据");
    this.departmentMapper.update(department);
    return department;
  }

  @Cacheable(key = "#id")
  public Department getDepartmentById(Integer id) {
    System.out.println("获取 id=" + id + " 的数据");
    Department department = this.departmentMapper.getById(id);
    return department;
  }

  @CacheEvict(key = "#id")
  public void delete(Integer id) {
    System.out.println("删除 id=" + id + " 的数据");
    this.departmentMapper.deleteById(id);
  }
}

@Controller
@RequestMapping("department")
@ResponseBody
public class DepartmentController {

  @Autowired
  private DepartmentService departmentService;

  @RequestMapping("save")
  public Map<String,Object> save(Department department) {
    this.departmentService.save(department);

    Map<String,Object> map = new HashMap<String,Object>();
    map.put("code", "200");
    map.put("msg", "保存成功");
    return map;
  }

  @RequestMapping("get/{id}")
  public Map<String,Object> get(@PathVariable("id") Integer id) {
    Department department = this.departmentService.getDepartmentById(id);

    Map<String,Object> map = new HashMap<String,Object>();
    map.put("code", "200");
    map.put("msg", "获取成功");
    map.put("data", department);
    return map;
  }

  @RequestMapping("update")
  public Map<String,Object> update(Department department) {
    this.departmentService.update(department);

    Map<String,Object> map = new HashMap<String,Object>();
    map.put("code", "200");
    map.put("msg", "修改成功");
    return map;
  }

  @RequestMapping("delete/{id}")
  public Map<String,Object> delete(@PathVariable("id") Integer id) {
    this.departmentService.delete(id);

    Map<String,Object> map = new HashMap<String,Object>();
    map.put("code", "200");
    map.put("msg", "删除成功");
    return map;
  }
}

保存 id=2 的数据
2017-12-06 14:50:48.800 DEBUG 680 --- [nio-8081-exec-7] c.l.s.dao.DepartmentMapper.insert        : ==>  Preparing: insert into department(id,name,descr) values(?,?,?)
2017-12-06 14:50:48.801 DEBUG 680 --- [nio-8081-exec-7] c.l.s.dao.DepartmentMapper.insert        : ==> Parameters: 2(Integer), Ehcache 部门(String), Ehcache(String)
2017-12-06 14:50:48.868 DEBUG 680 --- [nio-8081-exec-7] c.l.s.dao.DepartmentMapper.insert        : <==    Updates: 1

修改 id=2 的数据
2017-12-06 14:51:16.588 DEBUG 680 --- [nio-8081-exec-8] c.l.s.dao.DepartmentMapper.update        : ==>  Preparing: update department set name = ? , descr = ? where id = ?
2017-12-06 14:51:16.589 DEBUG 680 --- [nio-8081-exec-8] c.l.s.dao.DepartmentMapper.update        : ==> Parameters: Ehcache 部门2(String), Ehcache2(String), 2(Integer)
2017-12-06 14:51:16.657 DEBUG 680 --- [nio-8081-exec-8] c.l.s.dao.DepartmentMapper.update        : <==    Updates: 1

删除 id=2 的数据
2017-12-06 14:52:07.572 DEBUG 680 --- [nio-8081-exec-1] c.l.s.dao.DepartmentMapper.deleteById    : ==>  Preparing: delete from department where id = ?
2017-12-06 14:52:07.572 DEBUG 680 --- [nio-8081-exec-1] c.l.s.dao.DepartmentMapper.deleteById    : ==> Parameters: 2(Integer)
2017-12-06 14:52:07.613 DEBUG 680 --- [nio-8081-exec-1] c.l.s.dao.DepartmentMapper.deleteById    : <==    Updates: 1

获取 id=2 的数据
2017-12-06 14:52:40.324 DEBUG 680 --- [nio-8081-exec-3] c.l.s.dao.DepartmentMapper.getById       : ==>  Preparing: select id,name,descr from department where id = ?
2017-12-06 14:52:40.325 DEBUG 680 --- [nio-8081-exec-3] c.l.s.dao.DepartmentMapper.getById       : ==> Parameters: 2(Integer)
2017-12-06 14:52:40.328 DEBUG 680 --- [nio-8081-exec-3] c.l.s.dao.DepartmentMapper.getById       : <==      Total: 0