Spring Boot - ehcache

迷南。 2023-10-12 22:32 18阅读 0赞

## 实体类 ##

package com.lfsun.springbootcacheehcache.entity;
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.io.Serializable;
 
 /**
 * 
 * 用户实体
 * 
 */
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class User implements Serializable {
 
 private static final long serialVersionUID = 2892248514883451461L;
 /**
 * 主键id
 */
 private Long id;
 /**
 * 姓名
 */
 private String name;
 }

## 接口以及实现类 ##

package com.lfsun.springbootcacheehcache.service;
 
 
 import com.lfsun.springbootcacheehcache.entity.User;
 
 /**
 * 
 * UserService
 * 
 */
 public interface UserService {
 
 /**
 * 保存或修改用户
 *
 * @param user 用户对象
 * @return 操作结果
 */
 User saveOrUpdate(User user);
 
 /**
 * 获取用户
 *
 * @param id key值
 * @return 返回结果
 */
 User get(Long id);
 
 /**
 * 删除
 *
 * @param id key值
 */
 void delete(Long id);
 }

package com.lfsun.springbootcacheehcache.service.impl;
 
 import com.google.common.collect.Maps;
 
 import com.lfsun.springbootcacheehcache.entity.User;
 import com.lfsun.springbootcacheehcache.service.UserService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.CachePut;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 
 import java.util.Map;
 
 /**
 * 
 * UserService
 * 
 */
 @Service
 @Slf4j
 public class UserServiceImpl implements UserService {
 
 /**
 * 模拟数据库
 */
 private static final Map<Long, User> DATABASES = Maps.newConcurrentMap();
 
 /**
 * 初始化数据
 */
 static {
 
 DATABASES.put(1L, new User(1L, "user1"));
 DATABASES.put(2L, new User(2L, "user2"));
 DATABASES.put(3L, new User(3L, "user3"));
 }
 
 /**
 * 保存或修改用户
 *
 * @param user 用户对象
 * @return 操作结果
 */
 @CachePut(value = "user", key = "#user.id")
 @Override
 public User saveOrUpdate(User user) {
 
 DATABASES.put(user.getId(), user);
 log.info("保存用户【user】= {}", user);
 return user;
 }
 
 /**
 * 获取用户
 *
 * @param id key值
 * @return 返回结果
 */
 @Cacheable(value = "user", key = "#id")
 @Override
 public User get(Long id) {
 
 // 我们假设从数据库读取
 log.info("查询用户【id】= {}", id);
 return DATABASES.get(id);
 }
 
 /**
 * 删除
 *
 * @param id key值
 */
 @CacheEvict(value = "user", key = "#id")
 @Override
 public void delete(Long id) {
 
 DATABASES.remove(id);
 log.info("删除用户【id】= {}", id);
 }
 }

## 配置文件 ##

### application.yml ###

spring:
      cache:
        type: ehcache
        ehcache:
          config: classpath:ehcache.xml
    logging:
      level:
        com.lfsun: debug

### ehcache.xml ###

<ehcache
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
 updateCheck="false">
 
 <diskStore path="D:\\JavaTest\\Logs\\base_ehcache"/>
 
 <defaultCache
 maxElementsInMemory="20000"
 eternal="false"
 timeToIdleSeconds="120"
 timeToLiveSeconds="120"
 overflowToDisk="true"
 maxElementsOnDisk="10000000"
 diskPersistent="false"
 diskExpiryThreadIntervalSeconds="120"
 memoryStoreEvictionPolicy="LRU"/>
 
 
 <cache name="user"
 maxElementsInMemory="20000"
 eternal="true"
 overflowToDisk="true"
 diskPersistent="false"
 timeToLiveSeconds="0"
 diskExpiryThreadIntervalSeconds="120"/>
 
 </ehcache>

## 测试 ##

package com.lfsun.springbootcacheehcache.service;
 
 
 import com.lfsun.springbootcacheehcache.SpringBootCacheEhcacheApplicationTests;
 import com.lfsun.springbootcacheehcache.entity.User;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 
 /**
 * 
 * ehcache缓存测试
 * 
 */
 @Slf4j
 public class UserServiceTest extends SpringBootCacheEhcacheApplicationTests {
 
 
 @Autowired
 private UserService userService;
 
 /**
 * 获取两次，查看日志验证缓存
 */
 @Test
 public void getTwice() {
 
 // 模拟查询id为1的用户
 User user1 = userService.get(1L);
 log.debug("【user1】= {}", user1);
 
 // 再次查询
 User user2 = userService.get(1L);
 log.debug("【user2】= {}", user2);
 // 查看日志，只打印一次日志，证明缓存生效
 }
 
 /**
 * 先存，再查询，查看日志验证缓存
 */
 @Test
 public void getAfterSave() {
 
 userService.saveOrUpdate(new User(4L, "user4"));
 
 User user = userService.get(4L);
 log.debug("【user】= {}", user);
 // 查看日志，只打印保存用户的日志，查询是未触发查询日志，因此缓存生效
 }
 
 /**
 * 测试删除，查看redis是否存在缓存数据
 */
 @Test
 public void deleteUser() {
 
 // 查询一次，使ehcache中存在缓存数据
 userService.get(1L);
 // 删除，查看ehcache是否存在缓存数据
 userService.delete(1L);
 }
 }

## 完整代码案例地址 ##

[Spring Boot 集成 ehcache][Spring Boot _ ehcache]

[Spring Boot _ ehcache]: https://gitee.com/lfsun666/springboot-study-2023/tree/master/spring-boot-cache-ehcache