Springboot整合Ehcache实现数据缓存——SpringBoot学习

本是古典何须时尚 2022-02-20 10:29 479阅读 0赞

SpringBoot 整合 Encache 实现数据的缓存，本次使用技术是基于 SpringBoot 整合 Spring JPA 进行测试。通过配置 `spring.jpa.show-sql=true` 显性的观察到是否实现了数据的缓存，从而验证是否整合成功。

### 一、POM 文件 ###

在 pom.xml 文件中添加 `spring-boot-starter-cache` 的坐标，使 SpringBoot 有支持 Encache 的基本Jar 环境。

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

### 二、创建 Ehcache 的配置文件 ###

在 `src/main/resources` 中创建文件 `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">
    	
    	
    	<defaultCache maxElementsInMemory="10000" eternal="false"
    		timeToIdleSeconds="120" timeToLiveSeconds="120"
    		maxElementsOnDisk="10000" diskExpiryThreadIntervalSeconds="120"
    		memoryStoreEvictionPolicy="LRU">
    		<persistence strategy="localTempSwap" />
    	</defaultCache>
    	
    	
    	<cache name="users"
    		maxElementsInMemory="10000" 
    		eternal="false"
    		timeToIdleSeconds="120" 
    		timeToLiveSeconds="120"
    		maxElementsOnDisk="10000" 
    		diskExpiryThreadIntervalSeconds="120"
    		memoryStoreEvictionPolicy="LRU">
    		
    		<persistence strategy="localTempSwap" />
    	</cache>
    </ehcache>

`cache` 各个属性说明：

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">属性说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>name</td> 
   <td align="left">缓存名称</td> 
  </tr> 
  <tr> 
   <td>maxElementsInMemory</td> 
   <td align="left">缓存最大个数</td> 
  </tr> 
  <tr> 
   <td>eternal</td> 
   <td align="left">对象是否永久有效，一但设置了，timeout将不起作用</td> 
  </tr> 
  <tr> 
   <td>timeToIdleSeconds</td> 
   <td align="left">设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大</td> 
  </tr> 
  <tr> 
   <td>timeToLiveSeconds</td> 
   <td align="left">设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0，也就是对象存活时间无穷大</td> 
  </tr> 
  <tr> 
   <td>overflowToDisk</td> 
   <td align="left">当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中</td> 
  </tr> 
  <tr> 
   <td>diskSpoolBufferSizeMB</td> 
   <td align="left">这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区</td> 
  </tr> 
  <tr> 
   <td>maxElementsOnDisk</td> 
   <td align="left">硬盘最大缓存个数</td> 
  </tr> 
  <tr> 
   <td>diskPersistent</td> 
   <td align="left">是否缓存虚拟机重启期数，默认false</td> 
  </tr> 
  <tr> 
   <td>diskExpiryThreadIntervalSeconds</td> 
   <td align="left">磁盘失效线程运行时间间隔，默认是120秒</td> 
  </tr> 
  <tr> 
   <td>memoryStoreEvictionPolicy</td> 
   <td align="left">当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。可设置为FIFO（先进先出）或LFU（较少使用）</td> 
  </tr> 
  <tr> 
   <td>clearOnFlush</td> 
   <td align="left">内存数量最大时是否清除</td> 
  </tr> 
 </tbody> 
</table>

### 三、配置 application.properties 文件 ###

`application.properties` 配置信息：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/mysql
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.jpa.database = MYSQL
    spring.jpa.show-sql = true
    spring.jpa.hibernate.ddl-auto = none
    spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
    spring.jpa.hibernate.naming.physical-strategy = org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

换成 `yml` 文件配置，如下：

spring:
    ### datasource Configuration      
      datasource:
        url: jdbc:mysql://localhost:3306/mysql
        driver-class-name: com.mysql.jdbc.Driver
        username: root
        password: 123456
    
    ### hibernate Configuration
      jpa:
        database: mysql
        show-sql: true
        hibernate:
          ddl-auto: none
          naming:
            implicit-strategy: org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy
            physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

### 四、修改启动类 ###

在启动类上添加注解 `@EnableCaching` 开启缓存。

package com;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cache.annotation.EnableCaching;
    
    /**
    * @Description 第一个SpringBoot 应用启动类
    * @author 欧阳
    * @since 2019年4月3日 下午6:14:39
    * @version V1.0
    */
    
    @SpringBootApplication
    @EnableCaching
    public class App {
    
    	public static void main(String[] args) {
    		
    		SpringApplication.run(App.class, args);
    	}
    
    }

### 五、创建 Dao 和 Service ###

创建 Dao 文件 `src/main/java/com/dao/UsersDao.java` 文件名 `UsersDao.java`

package com.dao;
    
    import org.springframework.data.jpa.repository.JpaRepository;
    
    import com.bean.Users;
    
    /**
    * @Description 整合spring Jpa Dao
    * @author 欧阳
    * @since 2019年4月11日 下午6:14:26
    * @version V1.0
    */
    
    public interface UsersDao extends JpaRepository<Users, String> {
    	//需要使用其他的在这里定义方法
    	
    }

创建 Service 类 `src/main/java/com/service/JpaService.java`

package com.service;
    
    import java.util.List;
    
    import com.bean.Users;
    
    /**
    * @Description 整合spring Jpa Service
    * @author 欧阳
    * @since 2019年4月11日 下午2:17:37
    * @version V1.0
    */
    
    public interface JpaService {
    	
    	/**
    	 * 添加用户
    	 * @param user
    	 */
    	public void insertUser(Users user);
    	
    	/**
    	 * 更新用户
    	 * @param user
    	 */
    	public void updateUser(Users user);
    	
    	/**
    	 * 查询用户
    	 * @param user
    	 * @return
    	 */
    	public List<Users> selectUser();
    	
    	/**
    	 * 删除用户
    	 * @param id
    	 */
    	public void deleteUser(String id);
    }

实现该 Service `src/main/java/com/service/impl/JpaServiceImpl.java`。

package com.service.impl;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import com.bean.Users;
    import com.dao.UsersDao;
    import com.service.JpaService;
    
    /**
    * @Description 整合spring Jpa Service
    * @author 欧阳
    * @since 2019年4月11日 下午6:16:09
    * @version V1.0
    */
    @Service
    public class JpaServiceImpl implements JpaService {
    
    	@Autowired
    	private UsersDao userDao;
    	
    	@Override
    	@Transactional
    	//@CacheEvict(value="users",key="'user.selectUser'") 清除缓存中以 user.selectUser 为key 的缓存对象
    	@CacheEvict(value="users", key="'user.selectUser'")
    	public void insertUser(Users user) {
    		userDao.save(user);
    	}
    
    	@Override
    	@Transactional
    	public void updateUser(Users user) {
    		userDao.save(user);
    	}
    
    	@Override
    	@Cacheable(cacheNames="users",key="'user.selectUser'")
    	public List<Users> selectUser() {
    		
    		return userDao.findAll();
    	}
    
    	@Override
    	@Transactional
    	public void deleteUser(String id) {
    		userDao.deleteById(id);
    	}
    
    }

注意：这里用到了 `@Cacheable` 和 `@CacheEvict` 注解， `@Cacheable` 注解是把方法的返回值添加到 Ehcache 中做缓存，其中 Value 属性是指定一个 Ehcache 配置文件中的缓存策略，如果么有给定 value，name 则表示使用默认的缓存策略，Key 属性给存储的值起个名称。在查询时如果有名称相同的，那么则知己从缓存中将数据返回；而 `@CacheEvict` 注解是将 Ehcache 中的缓存清除掉。  
  同时，需要检查缓存的实体类是否实现了 `Serializable` 接口来序列化，因为对于对象的缓存会用到序列化和反序列化。

### 六、编写测试 Controller ###

编写一个测试 Controller 来进行测试是否整合 Encache 成功。

package com.controller;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.Cache;
    import org.springframework.cache.Cache.ValueWrapper;
    import org.springframework.cache.CacheManager;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.bean.Users;
    import com.service.JpaService;
    
    /**
    * @Description 整合 Ehcache
    * @author 欧阳
    * @since 2019年4月13日 上午12:37:52
    * @version V1.0
    */
    
    @RestController
    public class EhcacheController {
    	
    	@Autowired
    	private JpaService jpaService;
    	
    	@Autowired
    	private CacheManager cacheManager;
    
    	@RequestMapping("/findAllUser")
    	public List<Users> findAllUser() {
    		
    		//确保第一次查询是从数据库查询的数据，所以将缓存清除
    		//使用@CacheEvict 清除缓存
    		jpaService.insertUser(new Users("13", "李四"));
    		
    		//第一次查询
    		System.out.println("---------------第一次查询----------------");
    		jpaService.selectUser();
    		
    		//第二次查询
    		System.out.println("---------------第二次查询----------------");
    		jpaService.selectUser();
    		
    		//第一次从缓存中获取查询的值
    		System.out.println("---------------第一次从缓存中取值----------------");
    		Cache cache = cacheManager.getCache("users");
    		ValueWrapper valueWrapper = cache.get("user.selectUser");
    		List<Users> result = null;
    		if(valueWrapper != null) {
    			result = (List<Users>)valueWrapper.get();
    			
    			for(Users user : result) {
    				System.out.println(user);
    			}
    		}
    		
    		
    		//使用 CacheManager 清空缓存
    		cache.clear();
    		
    		//第二次从缓存中获取查询的值
    		System.out.println("---------------第二次从缓存中取值----------------");
    		valueWrapper = cache.get("user.selectUser");
    		if(valueWrapper != null) {
    			result = (List<Users>)valueWrapper.get();
    			
    			for(Users user : result) {
    				System.out.println(user);
    			}
    		}
    		
    		//第三次查询
    		System.out.println("---------------第三次查询----------------");
    		jpaService.selectUser();
    		
    		//第三次从缓存中获取查询的值
    		System.out.println("---------------第三次从缓存中取值----------------");
    		valueWrapper = cache.get("user.selectUser");
    		if(valueWrapper != null) {
    			result = (List<Users>)valueWrapper.get();
    			
    			for(Users user : result) {
    				System.out.println(user);
    			}
    		}
    		
    		return result;
    	}
    }

### 七、测试及分析 ###

运行程序启动类，清空控制台，接着我们访问 `http://localhost:8080/findAllUser` ，紧接着控制台打印如下信息：

2019-04-13 13:33:54.378  INFO 6464 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring FrameworkServlet 'dispatcherServlet'
    2019-04-13 13:33:54.379  INFO 6464 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization started
    2019-04-13 13:33:54.450  INFO 6464 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization completed in 71 ms
    Hibernate: select users0_.id as id1_0_0_, users0_.name as name2_0_0_ from t_user users0_ where users0_.id=?
    Hibernate: insert into t_user (name, id) values (?, ?)
    ---------------第一次查询----------------
    Hibernate: select users0_.id as id1_0_, users0_.name as name2_0_ from t_user users0_
    ---------------第二次查询----------------
    ---------------第一次从缓存中取值----------------
    Users(id=12, name=zhangsan)
    Users(id=13, name=李四)
    ---------------第二次从缓存中取值----------------
    ---------------第三次查询----------------
    Hibernate: select users0_.id as id1_0_, users0_.name as name2_0_ from t_user users0_
    ---------------第三次从缓存中取值----------------
    Users(id=12, name=zhangsan)
    Users(id=13, name=李四)

清空控制台，再次访问该 URL ，控制台打印：

Hibernate: select users0_.id as id1_0_0_, users0_.name as name2_0_0_ from t_user users0_ where users0_.id=?
    ---------------第一次查询----------------
    Hibernate: select users0_.id as id1_0_, users0_.name as name2_0_ from t_user users0_
    ---------------第二次查询----------------
    ---------------第一次从缓存中取值----------------
    Users(id=12, name=zhangsan)
    Users(id=13, name=李四)
    ---------------第二次从缓存中取值----------------
    ---------------第三次查询----------------
    Hibernate: select users0_.id as id1_0_, users0_.name as name2_0_ from t_user users0_
    ---------------第三次从缓存中取值----------------
    Users(id=12, name=zhangsan)
    Users(id=13, name=李四)

在配置有上述 `application.properties` `ehcache.xml` 等配置文件的 SpringBoot 项目中，且配置有 `spring.jpa.show-sql = true` 的前提下，再综合 Dao 、Service 和 Controller，通过对控制台打印的信息进行分析，在第一次查询时 `Users` 的信息是从数据库中查询得到的，因为打印了 `Hibernate: select users0_.id as id1_0_, users0_.name as name2_0_ from t_user users0_`；在第二次查询时没有打印 Hibernate sql 语句，紧接着第一次从缓存中取值是有值的，所以说明第二次查询是从缓存中取的，并且缓存中的Users 有两个值：`Users(id=12, name=zhangsan) 和 Users(id=13, name=李四)` ；回到 Controller 中，在第一次从缓存中取值和第二次从缓存中取值或在第三次查询前有清除缓存的代码 `cache.clear();` ，结合控制台打印的信息，说明代码 `cache.clear();` 生效，这个可通过第三次查询得知，因为第三次查询打印了 Hibernate sql 语句，这就更加证实了 `cache.clear();` 生效了；当第三次查询完之后又从缓存中取值，并且取到了和第一次从缓存中取的值一致。综上所述，在SpringBoot 中整合Encache实现了数据的缓存。  
  再此访问该 url ，打印的信息和第一次访问一样，特别是第一次查询时还是打印了 Hibernate sql 语句，并且在第一次访问时缓存中已经存在该查询的结果值，如果没有代码 `jpaService.insertUser(new Users("13", "李四"));` 时将再次从缓存中获取，这个可以从第二次查询时得到佐证，这说明代码 `jpaService.insertUser(new Users("13", "李四"));` 运行完后清除了缓存。因此使用 `@CacheEvict` 注解也可清空缓存。

### 八、总结 ###

1.  Springboot整合Encache实现数据缓存时，可以通过注入 `CacheManager` 实现缓存内容的查询和缓存清空；
2.  可以使用 `@Cacheable` 和 `@CacheEvict` 实现缓存和缓存清空；
3.  清空缓存有两种方式，方式一通过使用 `cache.clear();`，方式二使用 `@CacheEvict` 注解在调用指定方法时清空缓存；