詳解SpringBoot緩存的實例代碼(EhCache 2.x 篇)

更新時間：2017年07月24日 11:50:46 作者：陽光早已褪色

這篇文章主要介紹了詳解SpringBoot緩存的實例代碼(EhCache 2.x 篇)，具有一定的參考價值，感興趣的小伙伴們可以參考一下

本篇介紹了SpringBoot 緩存(EhCache 2.x 篇)，分享給大家，具體如下：

SpringBoot 緩存

在 spring Boot中，通過@EnableCaching注解自動化配置合適的緩存管理器（CacheManager），Spring Boot根據(jù)下面的順序去偵測緩存提供者：

Generic
JCache (JSR-107)
EhCache 2.x
Hazelcast
Infinispan
Redis
Guava
Simple

關(guān)于 Spring Boot 的緩存機制：

高速緩存抽象不提供實際存儲，并且依賴于由org.springframework.cache.Cache和org.springframework.cache.CacheManager接口實現(xiàn)的抽象。 Spring Boot根據(jù)實現(xiàn)自動配置合適的CacheManager，只要緩存支持通過@EnableCaching注釋啟用即可。

Spring Boot 配置 EhCache 2.x

官方文檔上對于注解緩存的介紹資料非常之少，往往需要我們自己去了解相應(yīng)的緩存提供者。我這里主要介紹的是 EhCache .

引入依賴

在pom.xml文件中引入以下依賴

   <!--開啟 cache 緩存-->
   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-cache</artifactId>
   </dependency>
   <!-- ehcache 緩存 -->
   <dependency>
     <groupId>net.sf.ehcache</groupId>
     <artifactId>ehcache</artifactId>
   </dependency>

引入配置文件 ehcache.xml

在resource文件夾下創(chuàng)建文件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"
     updateCheck="false">
  <defaultCache
      eternal="false"
      maxElementsInMemory="1000"
      overflowToDisk="false"
      diskPersistent="false"
      timeToIdleSeconds="0"
      timeToLiveSeconds="600"
      memoryStoreEvictionPolicy="LRU" />

  <!-- 這里的 users 緩存空間是為了下面的 demo 做準備 -->
  <cache
      name="users"
      eternal="false"
      maxElementsInMemory="100"
      overflowToDisk="false"
      diskPersistent="false"
      timeToIdleSeconds="0"
      timeToLiveSeconds="300"
      memoryStoreEvictionPolicy="LRU" />
</ehcache>

ehcache.xml 文件配置詳解

部分資料來源于網(wǎng)絡(luò)

diskStore：為緩存路徑，ehcache分為內(nèi)存和磁盤兩級，此屬性定義磁盤的緩存位置。
defaultCache：默認緩存策略，當(dāng)ehcache找不到定義的緩存時，則使用這個緩存策略。只能定義一個。
name:緩存名稱。
maxElementsInMemory:緩存最大數(shù)目
maxElementsOnDisk：硬盤最大緩存?zhèn)€數(shù)。
eternal:對象是否永久有效，一但設(shè)置了，timeout將不起作用。
overflowToDisk:是否保存到磁盤，當(dāng)系統(tǒng)當(dāng)機時
timeToIdleSeconds:設(shè)置對象在失效前的允許閑置時間（單位：秒）。僅當(dāng)eternal=false對象不是永久有效時使用，可選屬性，默認值是0，也就是可閑置時間無窮大。
timeToLiveSeconds:設(shè)置對象在失效前允許存活時間（單位：秒）。最大時間介于創(chuàng)建時間和失效時間之間。僅當(dāng)eternal=false對象不是永久有效時使用，默認是0.，也就是對象存活時間無窮大。
diskPersistent：是否緩存虛擬機重啟期數(shù)據(jù) Whether the disk store persists between restarts of the Virtual Machine. The default value is false.diskSpoolBufferSizeMB：這個參數(shù)設(shè)置DiskStore（磁盤緩存）的緩存區(qū)大小。默認是30MB。每個Cache都應(yīng)該有自己的一個緩沖區(qū)。
diskExpiryThreadIntervalSeconds：磁盤失效線程運行時間間隔，默認是120秒。
memoryStoreEvictionPolicy：當(dāng)達到maxElementsInMemory限制時，Ehcache將會根據(jù)指定的策略去清理內(nèi)存。默認策略是LRU（最近最少使用）。你可以設(shè)置為FIFO（先進先出）或是LFU（較少使用）。
clearOnFlush：內(nèi)存數(shù)量最大時是否清除。
memoryStoreEvictionPolicy:可選策略有：LRU（最近最少使用，默認策略）、FIFO（先進先出）、LFU（最少訪問次數(shù)）。

FIFO，first in first out，先進先出。

LFU， Less Frequently Used，一直以來最少被使用的。如上面所講，緩存的元素有一個hit屬性，hit值最小的將會被清出緩存。

LRU，Least Recently Used，最近最少使用的，緩存的元素有一個時間戳，當(dāng)緩存容量滿了，而又需要騰出地方來緩存新的元素的時候，那么現(xiàn)有緩存元素中時間戳離當(dāng)前時間最遠的元素將被清出緩存。

在主類加上啟動注解

在 Spring Boot 主類加上開啟緩存的注解@EnableCaching。

demo : SpringBoot + EhCache

搭建 Spring Boot 工程

我搭建了一個普通的 SpringBoot 工程，配置了 Druid+MySQL。

并在數(shù)據(jù)庫中創(chuàng)建了 users 表，各字段如下：

字段名	屬性
id	bigint
uuid	varchar
name	varchar
age	int

用戶實體類

User.Java

public class User {

  private long id;
  private String uuid;
  private String name;
  private Integer age;

  //省略 get、set 及 toString 方法
}

用戶數(shù)據(jù)庫操作接口

UserDao.java

@Mapper
public interface UserDao{

  void delete(String uuid);

  User update(User user);

  User findByUuid(String uuid);

  int save(@Param("user") User user);
}

用戶操作Mapper文件

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="qg.fangrui.boot.dao.UserDao">
  <!--目的：為Dao接口方法提供SQL語句-->

  <!--映射實體對象-->
  <resultMap id="UserResultMap" type="qg.fangrui.boot.model.User">
    <id property="id" column="id" />
    <result property="uuid" column="uuid" />
    <result property="name" column="name" />
    <result property="age" column="age" />
  </resultMap>


  <insert id="save">
    INSERT INTO users(name, age, uuid)
    VALUES (#{user.name}, #{user.age}, #{user.uuid})
  </insert>

  <select id="findByUuid" resultType="User">
    SELECT * FROM users WHERE uuid = #{uuid}
  </select>

  <delete id="delete">
    DELETE FROM users WHERE uuid = #{uuid}
  </delete>

</mapper>

用戶操作 service 層

一般情況下，我們在Sercive層進行對緩存的操作。先介紹 Ehcache 在 Spring 中的注解：在支持 Spring Cache 的環(huán)境下，

@Cacheable : Spring在每次執(zhí)行前都會檢查Cache中是否存在相同key的緩存元素，如果存在就不再執(zhí)行該方法，而是直接從緩存中獲取結(jié)果進行返回，否則才會執(zhí)行并將返回結(jié)果存入指定的緩存中。
@CacheEvict : 清除緩存。
@CachePut : @CachePut也可以聲明一個方法支持緩存功能。使用@CachePut標注的方法在執(zhí)行前不會去檢查緩存中是否存在之前執(zhí)行過的結(jié)果，而是每次都會執(zhí)行該方法，并將執(zhí)行結(jié)果以鍵值對的形式存入指定的緩存中。
這三個方法中都有兩個主要的屬性：value 指的是 ehcache.xml 中的緩存策略空間；key 指的是緩存的標識，同時可以用 # 來引用參數(shù)。

UserService.java

@Service
public class UserService {

  //這里的單引號不能少，否則會報錯，被識別是一個對象
  private static final String CACHE_KEY = "'user'";
  private static final String DEMO_CACHE_NAME = "users";

  @Autowired
  private UserDao userDao;

  //刪除用戶數(shù)據(jù)
  @CacheEvict(value = DEMO_CACHE_NAME,key = "'user_'+#uuid")//這是清除緩存
  public void delete(String uuid){
    userDao.delete(uuid);
  }

  //更新用戶數(shù)據(jù)
  @CachePut(value = DEMO_CACHE_NAME,key = "'user_'+#user.getUuid()")
  public User update(User user) throws CacheException{
    User user1 = userDao.findByUuid(user.getUuid());
    if (null == user1){
      throw new CacheException("Not Find");
    }
    user1.setAge(user.getAge());
    user1.setName(user.getName());
    return user1;
  }

  //查找用戶數(shù)據(jù)
  @Cacheable(value=DEMO_CACHE_NAME,key="'user_'+#uuid")
  public User findByUuid(String uuid){
    //若找不到緩存將打印出提示語句
    System.err.println("沒有走緩存！"+uuid);
    return userDao.findByUuid(uuid);
  }

  //保存用戶數(shù)據(jù)
  @CacheEvict(value=DEMO_CACHE_NAME,key=CACHE_KEY)
  public int save(User user){
    return userDao.save(user);
  }
}

Controller 類

最后我們創(chuàng)建一個 Controller 來訪問我們的緩存。因為我的 SpringBoot 處于 Debug 模式，會將所有的數(shù)據(jù)庫操作打印出來，這樣子緩存作用就可一目了然了。

EhcacheController.java

@RestController
public class EhcacheController {

  private static final Logger logger = LoggerFactory.getLogger(EhcacheController.class);

  @Autowired
  private UserService userService;

  @RequestMapping("/encache")
  public String EhcacheTest(){
    logger.debug("進行Encache緩存測試");
    System.out.println("====生成第一個用戶====");
    User user1 = new User();
    //生成第一個用戶的唯一標識符 UUID
    String u1_uuid = UUID.randomUUID().toString();
    //去掉 UUID 的 - 符號
    String uuid1 = u1_uuid.substring(0,8)+u1_uuid.substring(9,13)+u1_uuid.substring(14,18)+u1_uuid.substring(19,23)+u1_uuid.substring(24);
    user1.setName("張三");
    user1.setAge(18);
    user1.setUuid(uuid1);
    if (userService.save(user1) == 0){
      throw new JdbcException("用戶對象插入數(shù)據(jù)庫失敗");
    }

    //第一次查詢
    System.out.println(userService.findByUuid(user1.getUuid()));
    //通過緩存查詢
    System.out.println(userService.findByUuid(user1.getUuid()));

    System.out.println("====修改數(shù)據(jù)====");
    User user2 = new User();
    user2.setName("李四-update");
    user2.setAge(22);
    user2.setId(user1.getId());
    user2.setUuid(user1.getUuid());
    try {
      System.out.println(userService.update(user2));
    } catch (CacheException e){
      e.printStackTrace();
    }

    System.out.println(userService.findByUuid(user2.getUuid()));
    return "success";
  }
}

測試

啟動 SpringBoot 工程，訪問 http://localhost:8080/encache ，并查看控制臺打印信息：