spring boot學習(十三)SpringBoot緩存(EhCache 2.x 篇)

SpringBoot 緩存(EhCache 2.x 篇)

SpringBoot 緩存

在 Spring Boot中，通過@EnableCaching注解自動化配置合適的緩存管理器（CacheManager），Spring Boot根據下面的順序去偵測緩存提供者：
* Generic
* JCache (JSR-107)
* EhCache 2.x
* Hazelcast
* Infinispan
* Redis
* Guava
* Simple

關於 Spring Boot 的緩存機制：
高速緩存抽象不提供實際存儲，並且依賴於由org.springframework.cache.Cache和org.springframework.cache.CacheManager接口實現的抽象。 Spring Boot根據實現自動配置合適的CacheManager，只要緩存支持通過@EnableCaching注釋啟用即可。

Spring Boot 配置 EhCache 2.x

官方文檔上對於注解緩存的介紹資料非常之少，往往需要我們自己去了解相應的緩存提供者。我這里主要介紹的是 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文件夾下創建文件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 文件配置詳解：

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

FIFO，first in first out，先進先出。
LFU， Less Frequently Used，一直以來最少被使用的。如上面所講，緩存的元素有一個hit屬性，hit值最小的將會被清出緩存。
LRU，Least Recently Used，最近最少使用的，緩存的元素有一個時間戳，當緩存容量滿了，而又需要騰出地方來緩存新的元素的時候，那么現有緩存元素中時間戳離當前時間最遠的元素將被清出緩存。

在主類加上啟動注解

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

demo : SpringBoot + EhCache

搭建 Spring Boot 工程

我搭建了一個普通的 SpringBoot 工程，配置了 Druid+MySQL。
並在數據庫中創建了 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 方法
}

 

用戶數據庫操作接口

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

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;

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

    //更新用戶數據
    @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;
    }

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

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

 

Controller 類

最后我們創建一個 Controller 來訪問我們的緩存。因為我的 SpringBoot 處於 Debug 模式，會將所有的數據庫操作打印出來，這樣子緩存作用就可一目了然了。
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("用戶對象插入數據庫失敗");
        }

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

        System.out.println("====修改數據====");
        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 ，並查看控制台打印信息：

由控制台，我們可以清楚到看到，第一次查詢用戶信息時，工程將用戶信息存入緩存中；在第二次查詢時，無需訪問數據庫直接從緩存中獲取用戶信息。

個人參考項目：

個人參考項目：https://github.com/FunriLy/springboot-study/tree/master/%E6%A1%88%E4%BE%8B9