springboot ehcache缓存使用及自定义缓存存取_ehcache为每个访问用户创建一个cache手动存取数据

添加依赖
首先在pom.xml添加必要依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>
1
2
3
4
5
6
7
8
9

添加依赖时会提示net.sf.ehcache已经集成在springboot里边，但是不加程序又提示找不到net.sf.ehcache.CacheManager的class文件。该问题需要朋友们解决一下。
开启缓存
在Spring Boot环境下，使用缓存技术只需在项目中导入相关缓存技术的依赖包，并在配置类上使用@EnableCaching开启缓存即可。
在启动类添加注解@EnableCaching

@SpringBootApplication
@EnableCaching
public class MyTestApplication  {
    private static Logger log=LoggerFactory.getLogger(MyTestApplication .class);
    public static void main(String[] args) {
        SpringApplication.run(MyTestApplication .class, args);
        log.info("服务启动成功");
    }
}
1
2
3
4
5
6
7
8
9

新建数据库表

CREATE TABLE `paraconfig` (
  `paraId` int(11) NOT NULL AUTO_INCREMENT COMMENT '参数id',
  `paraName` varchar(20) NOT NULL COMMENT '参数名称',
  `paraCode` varchar(50) NOT NULL COMMENT '参数值',
  `paraDesc` varchar(100) DEFAULT NULL COMMENT '参数描述',
  `status` enum('有效','无效') NOT NULL COMMENT '参数状态',
  PRIMARY KEY (`paraId`),
  UNIQUE KEY `paraName` (`paraName`) USING BTREE,
  KEY `paraStatus` (`status`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8
1
2
3
4
5
6
7
8
9
10

新建实体类

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Paraconfig implements Serializable{
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue
    private Integer paraid;
    private String paraname;
    private String paracode;
    private String paradesc;
    private String status;
    public Integer getParaid() {
        return paraid;
    }
    public void setParaid(Integer paraid) {
        this.paraid = paraid;
    }
    public String getParaname() {
        return paraname;
    }
    public void setParaname(String paraname) {
        this.paraname = paraname;
    }
    public String getParacode() {
        return paracode;
    }
    public void setParacode(String paracode) {
        this.paracode = paracode;
    }
    public String getParadesc() {
        return paradesc;
    }
    public void setParadesc(String paradesc) {
        this.paradesc = paradesc;
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    @Override
    public String toString() {
        return "Paraconfig [paraid=" + paraid + ", paraname=" + paraname + ", paracode=" + paracode + ", paradesc="
                + paradesc + ", status=" + status + "]";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

新建dao查询数据库接口

import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import com.xx.model.Paraconfig;
public interface IParaConfigDao extends JpaRepository<Paraconfig,Integer>{
    public Paraconfig findByParaid(Integer id);
    public Paraconfig findByParaname(String name);
    public List<Paraconfig> findByStatus(String status);
}
1
2
3
4
5
6
7
8

新建数据库操作服务及实现

import java.util.List;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import com.xx.model.Paraconfig;
public interface IParaConfigService {
    @CacheEvict(value = "SystemCache")
    public int deletePara(int id);

    @CachePut(value = "SystemCache", key = "#para.paraid") 
    public Paraconfig addPara(Paraconfig para);

    @Cacheable(value = "SystemCache", key = "#id") 
    public Paraconfig findOne(int id);

    @Cacheable(value = "SystemCache", key = "#name") 
    public Paraconfig findByName(String name);

    @Cacheable(value = "SystemCache") 
    public List<Paraconfig> findAll();

    @Cacheable(value = "SystemCache") 
    public List<Paraconfig> findByStatus(String status);

    @CachePut(value = "SystemCache", key = "#para.paraid") 
    public Paraconfig updataPara(Paraconfig para);
}

import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.xx.DatabaseSservice.paraConfig.IParaConfigService;
import com.xx.dao.IParaConfigDao;
import com.xx.model.Paraconfig;

@Service
public class ParaConfigServiceImpl implements IParaConfigService{
    private Logger log=LoggerFactory.getLogger(ParaConfigServiceImpl.class);
    @Autowired
    private IParaConfigDao dao;
    @Override
    public int deletePara(int id) {
        log.info("o==||======>删除系统参数入参ID="+id);
        int result=0;
        try{
            dao.deleteById(id);
            result=0;
        }catch(Exception e){
            e.printStackTrace();
            result=-1;
            log.info("删除系统参数异常");
        }
        return result;
    }
    @Override
    public Paraconfig addPara(Paraconfig para) {
        log.info("o==||=====>新增系统参数入参："+para.toString());
        return doExecute("addPara",null,para);
    }
    @Override
    public Paraconfig findOne(int id) {
        log.info("o==||=====>id查找系统参数入参：id="+id);
        return doExecute("findOne",String.valueOf(id),null);
    }
    @Override
    public Paraconfig findByName(String name) {
        log.info("o==||=====>name查找系统参数入参：name="+name);
        return doExecute("findByName",name,null);
    }
    @Override
    public List<Paraconfig> findAll() {
        log.info("o==||=====>查找All系统参数");
        return doExecutePage("findAll",null);
    }
    @Override
    public List<Paraconfig> findByStatus(String status) {
        log.info("o==||=====>status查找系统参数:status="+status);
        return doExecutePage("findByStatus",status);
    }
    @Override
    public Paraconfig updataPara(Paraconfig para) {
        log.info("o==||=====>更新系统参数入参："+para.toString());
        return doExecute("updataPara",null,para);
    }

    public Paraconfig doExecute(String type,String arg,Paraconfig req){
        Paraconfig resp=new Paraconfig();
        try{
            switch(type){
                case "addPara" : ;
                case "updataPara" : resp=dao.save(req);break;
                case "findOne" : resp=dao.findByParaid(Integer.valueOf(arg));break;
                case "findByName" : resp=dao.findByParaname(arg);break;
            }
        }catch(Exception e){
            e.printStackTrace();
            String Emsg = null;
            switch(type){
                case "addPara" : Emsg="新增系统参数异常";break;
                case "updataPara" : Emsg="更新系统参数异常";break;
                case "findOne" : Emsg="根据ID查找系统参数异常";break;
                case "findByName" : Emsg="根据name查找系统参数异常";break;
            }
            log.info(Emsg+e.getMessage());
        }finally{
            log.info("查找系统参数返回："+(resp==null?null:resp.toString()));
        }
        return resp;
    }

    public List<Paraconfig> doExecutePage(String type,String arg){
        List<Paraconfig> resp = null;
        try{
            switch(type){
                case "findAll" : resp=dao.findAll();break;
                case "findByStatus" : resp=dao.findByStatus(arg);break;
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            log.info("查找系统参数返回："+(resp==null?null:resp.toString()));
        }
        return resp;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

新建测试controller

@PostMapping("/testCachefindOne")
    public void testCachefindOne(){
        Paraconfig para=null;
        try{
            para=paraConfigService.findOne(1);
        }catch(Exception e){
            e.printStackTrace();
            log.info("异常:"+e.getMessage());
        }
    }
1
2
3
4
5
6
7
8
9
10

测试
使用postman请求。查看控制执行数据库操作日志。
第一次请求缓存没有则有日志打印，第二次请求缓存有数据则不会打印日志。
测试没有问题说明缓存自动存储已经没问题了，接下来就是怎么取缓存及添加自定义的缓存了。
添加ehcache配置文件

<?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">
         <diskStore path="java.io.tmpdir/Tmp_EhCache" />  
    <defaultCache  
            eternal="false"  
            maxElementsInMemory="1000"  
            overflowToDisk="false"  
            diskPersistent="false"  
            timeToIdleSeconds="0"  
            timeToLiveSeconds="100"  
            memoryStoreEvictionPolicy="LRU" />  

    <cache  
            name="SystemCache"  
            eternal="false"  
            maxElementsInMemory="100"  
            overflowToDisk="false"  
            diskPersistent="false"  
            timeToIdleSeconds="0"  
            timeToLiveSeconds="30"  
            memoryStoreEvictionPolicy="LRU" />  
</ehcache>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

配置文件详解

(1).diskStore： 为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：　　　　
user.home – 用户主目录
user.dir  – 用户当前工作目录
java.io.tmpdir – 默认临时文件路径
(2).defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
(3).cache：自定缓存策略，为自定义的缓存策略。参数解释如下：
cache元素的属性：
name：缓存名称
maxElementsInMemory：内存中最大缓存对象数
maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大
eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false
overflowToDisk：true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。
diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。
diskPersistent：是否缓存虚拟机重启期数据
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认为120秒
timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态
timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

将配置文件放在src/main/resources下（或其他路径，需要配置路径）。
新建ApplicationContextUtils实现ApplicationContextAware接口

import org.springframework.beans.BeansException;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component  
@EnableAutoConfiguration  
public class ApplicationContextUtils implements ApplicationContextAware{
     public static ApplicationContext applicationContext=null;//可写成单利模式，这里为了方便  
     @Override  
     public void setApplicationContext(ApplicationContext arg0) throws BeansException {
         applicationContext=arg0;
         System.out.println("设置ApplicationContext成功！");
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

缓存自定义存取

@PostMapping("/testCachefindOne")
    public void testCachefindOne(){
        Paraconfig para=null;
        try{
            para=paraConfigService.findOne(1);
            EhCacheCacheManager cacheCacheManager=ApplicationContextUtils.applicationContext.getBean(EhCacheCacheManager.class); 
            //获取Cache  
            Cache cache=cacheCacheManager.getCache("SystemCache");  
            cache.put("Hello-key", "Hello-value");
            System.out.println("缓存名："+cache.getName());
            System.out.println("缓存Hello-key："+cache.get("Hello-key", String.class));
            System.out.println("缓存SYSDATE："+cache.get("SYSDATE",Paraconfig.class));
        }catch(Exception e){
            e.printStackTrace();
            log.info("异常:"+e.getMessage());
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

启动测试

小结：
1.@CachePut表示缓存新添加的数据或者更新的数据到缓存中，两个参数value表示缓存的名称为SystemCache，key表示缓存的key为#id 的数据，#id为方法参数 。
2.@CacheEvict表示从缓存SystemCache中删除key为id的数据
3.@Cacheable表示添加数据到缓存中，缓存名称为SystemCache，缓存key为#para.paraid的数据。
注意： @CachePut总会执行SQL操作，其主要用在更新或插入数据时。
@Cacheable主要用在查询数据库时，缓存有则不查数据库。