Springboot+Mybatis集成自定义缓存Ehcache用法

时间:2022-10-18 18:21:06

Springboot+Mybatis集成自定义缓存Ehcache用法

今天小编给大家整理了springboot+mybatis集成自定义缓存ehcache用法笔记,希望对大家能有所办帮助!

一、ehcache介绍

EhCache 是一个纯Java的进程内缓存管理框架,属于开源的Java分布式缓存框架,主要用于通用缓存,Java EE和轻量级容器。

1、特点

1. 简单、快速

2. 提供多种缓存策略

3. 缓存数据可分两级:内存和磁盘

4. 缓存数据会在服务器重启的过程中重新写入磁盘

.5 可以通过RMI、可插入API等方式进行分布式缓存

6. 具有缓存和缓存管理器的侦听接口

7. 支持多缓存管理器实例,以及一个实例的多个缓存区域

8. 提供了Hibernate的缓存实现

2、应用场景

单应用或对缓存访问性能要求很高的应用

适合简单共享

适合缓存内容不大的场景,比如MyBatis自定义缓存、系统配置信息、页面缓存。

二、springboot+mybatis集成ehcache步骤

Spring Boot 的缓存机制

高速缓存抽象不提供实际存储,并且依赖于由org.springframework.cache.Cache和org.springframework.cache.CacheManager接口实现的抽象。 Spring Boot根据实现自动配置合适的CacheManager,只要缓存支持通过@EnableCaching注解启用即可。

1、添加ehcache.xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  3.     xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
  4.     <diskStore path="java.io.tmpdir" /> 
  5.  
  6.     <!-- 配置提供者 1、peerDiscovery,提供者方式,有两种方式:自动发现(automatic)、手动配置(manual) 2、rmiUrls,手动方式时提供者的地址,多个的话用|隔开 --> 
  7.     <cacheManagerPeerProviderFactory 
  8.         class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory" 
  9.         properties="peerDiscovery=manual,rmiUrls=//127.0.0.1:40002/userCache" /> 
  10.     <!-- <cacheManagerPeerProviderFactory 
  11.         class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory" 
  12.         properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1, multicastGroupPort=4446,timeToLive=255"/> 
  13.  --> 
  14.     <!-- 配置监听器 1、hostName 主机地址 2、port 端口 3、socketTimeoutMillis socket子模块的超时时间,默认是2000ms --> 
  15.     <cacheManagerPeerListenerFactory 
  16.         class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory" 
  17.         properties="hostName=127.0.0.1, port=40001, socketTimeoutMillis=2000" /> 
  18.     <!-- <cacheManagerPeerListenerFactory 
  19.          class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"/> --> 
  20.  
  21.  
  22.     <defaultCache eternal="false" maxElementsInMemory="1000" 
  23.         overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0" 
  24.         timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU" /> 
  25.  
  26.     <cache 
  27.         name="userCache" 
  28.         maxElementsInMemory="1000" 
  29.         eternal="false" 
  30.         timeToIdleSeconds="300" 
  31.         timeToLiveSeconds="300" 
  32.         overflowToDisk="false" 
  33.         memoryStoreEvictionPolicy="LRU"
  34.  
  35.  
  36.         <!-- 配置缓存事件监听器 replicateAsynchronously 操作是否异步,默认值为true. replicatePuts 添加操作是否同步到集群内的其他缓存,默认为true. 
  37.             replicateUpdates 更新操作是否同步到集群内的其他缓存,默认为true. replicateUpdatesViaCopy 更新之后的对象是否复制到集群中的其他缓存(true); 
  38.             replicateRemovals 删除操作是否同步到集群内的其他缓存,默认为true--> 
  39.         <cacheEventListenerFactory 
  40.             class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" 
  41.             properties=" 
  42.                     replicateAsynchronously=true
  43.                     replicatePuts=true
  44.                     replicateUpdates=true
  45.                     replicateUpdatesViaCopy=true
  46.                     replicateRemovals=true " /> 
  47.  
  48.  
  49.          <!-- 初始化缓存,以及自动设置 --> 
  50.         <bootstrapCacheLoaderFactory 
  51.             class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory" 
  52.             properties="bootstrapAsynchronously=true" /> 
  53.  
  54.     </cache> 
  55.  
  56. </ehcache> 

2、配置 application.properyies

  1. #cache 配置cache  
  2.  
  3. spring.cache.cache-names=userCache  
  4. spring.cache.jcache.config=classpath:ehcache.xml 

3、springboot启动类增加注解@EnableCaching

  1. @SpringBootApplication 
  2. @ComponentScan(basePackages="com.ehcache")//扫描组件 
  3. @EnableCaching 
  4. public class EhcacheTestApplication { 
  5.  
  6.     public static void main(String[] args) { 
  7.         SpringApplication.run(EhcacheTestApplication.class, args); 
  8.     } 

4、UserInfoService.java 文件增加缓存注解

  1. @Service 
  2. public class UserInfoService { 
  3.  
  4.     @Autowired 
  5.     private UserDao userDao; 
  6.  
  7.     @CacheEvict(key="'user_'+#uid", value="userCache"
  8.     public void del(String uid) {        
  9.         userDao.del(uid); 
  10.     } 
  11.  
  12.     @CachePut(key="'user_'+#user.id", value="userCache"
  13.     public void update(User user) { 
  14.         userDao.update(user); 
  15.     } 
  16.  
  17.     @Cacheable(key="'user_'+#id",value="userCache"
  18.     public User getUserById(String id){      
  19.         return userDao.findById(id);    } 
  20.  
  21.     @CacheEvict(key="'user'",value="userCache"
  22.     public String save(User user) {         
  23.         return userDao.save(user); 
  24.     } 

5、增加测试控制器TestController.java

  1. package com.ehcache.controller; 
  2.  
  3. import java.util.ArrayList; 
  4. import java.util.HashMap; 
  5. import java.util.List; 
  6. import java.util.Map; 
  7.  
  8. import javax.servlet.http.HttpServletRequest; 
  9.  
  10. import org.springframework.beans.factory.annotation.Autowired; 
  11. import org.springframework.cache.annotation.CachePut; 
  12. import org.springframework.cache.annotation.Cacheable; 
  13. import org.springframework.web.bind.annotation.RequestMapping; 
  14. import org.springframework.web.bind.annotation.RequestMethod; 
  15. import org.springframework.web.bind.annotation.RequestParam; 
  16. import org.springframework.web.bind.annotation.ResponseBody; 
  17. import org.springframework.web.bind.annotation.RestController; 
  18.  
  19. import com.ehcache.entity.User
  20. import com.ehcache.factory.CacheManagerFactory; 
  21. import com.ehcache.factory.UserFactory; 
  22. import com.ehcache.service.UserService; 
  23. import com.google.gson.Gson; 
  24.  
  25. import net.sf.ehcache.Element; 
  26.  
  27.  
  28. @RestController 
  29. @RequestMapping("/CacheTest"
  30. public class CacheTestController { 
  31.     @Autowired 
  32.     private UserService userService; 
  33.     Gson gson = new Gson(); 
  34.     CacheManagerFactory cmf = CacheManagerFactory.getInstance(); 
  35.     @RequestMapping(value = "/test", method = RequestMethod.GET) 
  36.     public String test(HttpServletRequest request){ 
  37.         // 新增新用户 
  38.         String id = userService.save(UserFactory.createUser()); 
  39.         User user = userService.getUserById(id); 
  40.         user.setUsername("小明"); 
  41.         userService.update(user); 
  42.         // 查询该用户 
  43.         System.out.println(gson.toJson(userUser.class));       
  44.         System.out.println(); 
  45.         // 再查询该用户 
  46.         User user = userService.getUserById(uid); 
  47.         System.out.println(gson.toJson(userUser.class)); 
  48.         System.out.println(); 
  49.         // 更新该用户 
  50.         userService.update(user); 
  51.         // 更新成功后再查询该用户        System.out.println(gson.toJson(userService.getUserById(id), User.class)); 
  52.         System.out.println(); 
  53.         // 删除该用户 
  54.         userService.del(id); 
  55.         System.out.println(); 
  56.         // 删除后再查询该用户        System.out.println(gson.toJson(userService.getUserById(id), User.class)); 
  57.         return id; 
  58.     } 

个人博客网站:https://programmerblog.xyz

原文链接:https://mp.weixin.qq.com/s/nSC-7Rgx6G4PF40Z6DxNUQ