配置

ehcache.xml

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
<?xml version="1.0" encoding="UTF-8"?>
	<ehcache>
	<!-- 
	     磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
	      path:指定在硬盘上存储对象的路径
	 -->
	<diskStore path="D:\ehcache" />
	
	<!-- 
	    defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
	    maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
	    eternal:代表对象是否永不过期
	    overflowToDisk:当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中
	 -->
	<defaultCache
	  maxElementsInMemory="100"
	  eternal="true"
	  overflowToDisk="true"/>
     
    <cache 
      name="a"
      maxElementsInMemory="100"
      eternal="true"
      overflowToDisk="true"/>
        
    </ehcache>

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（最少访问次数）。

简单使用

maven引入

1
2
3
4
5
<dependency>
	<groupId>net.sf.ehcache</groupId>
	<artifactId>ehcache</artifactId>
	<version>2.10.3</version>
</dependency>

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 public static void main(String[] args) {
    // 根据ehcache.xml配置文件创建Cache管理器
    CacheManager manager=CacheManager.create("./src/main/resources/ehcache.xml");
    Cache c=manager.getCache("a"); // 获取指定Cache
    Element e=new Element("test","测试"); // 实例化一个元素
    c.put(e); // 把一个元素添加到Cache中
     
    Element e2=c.get("test"); // 根据Key获取缓存元素
    System.out.println(e2);
    System.out.println(e2.getObjectValue());
     
    c.flush(); // 刷新缓存
    manager.shutdown(); // 关闭缓存管理器
}

SpringBoot中使用

一、使用注解的方式（更简洁，代码量少）

1、引入pom依赖，springboot缓存支持和ehcache

1
2
3
4
5
6
7
8
9
10
<!-- Spring Boot 缓存-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- Ehcache -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

2、启动类添加@EnableCaching注解以及application.properties配置文件增加配置

1
2
3
4
# 配置ehcache缓存
spring.cache.type=ehcache
# 指定ehcache配置文件路径
spring.cache.ehcache.config=classpath:/ehcache.xml

3、添加ehcache.xml文件在resources文件夹下

文件内容参照上方

**4、使用注解实现缓存功能：@Cacheable（添加操作），@CachePut（修改操作），@CacheEvict（删除操作） **

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
import tk.coffeey.dao.UserDao;
import tk.coffeey.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
@Transactional//添加事务
public class UserServiceImpl implements UserService {
	private UserDao userDao;
    
    @Autowired
    public UserserviceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
 
	@Override
	@Cacheable(value="users",key = "#id")
	//value表示缓存的名称
	//key表示缓存的key，可以为空，也可以用el表达式。支持四种：#参数名(#id)，#p+参数index(#p0)，#参数的属性(user.id),#p+参数index(#p0.id)
	//condition表示缓存的条件，可以为空，也可以用el表达式，例如：condition="#user.id>0"(只缓存id大于0的)
	public User get(Long id) {
		User user=userDao.getUser(1L);
		System.out.println("1111111111111111111111111");
		return user;
	}
 
	@Override
	@CachePut(value = "users")
	//和@Cacheable差不多：唯一的区别是@Cacheable会先判断缓存元素是否存在，再决定是直接返回还是缓存，而@CachePut总是会缓存数据
	public User save(Long id) {
		User user=new User();
		System.out.println("222222");
		return user;
	}
 
	@Override
	@CacheEvict(value="users",key = "#id")
	//value表示缓存的名称
	//key表示缓存的key，可以为空，也可以用el表达式。支持四种：#参数名(#id)，#p+参数index(#p0)，#参数的属性(user.id),#p+参数index(#p0.id)
	//allEntries表示是否需要清除所有的元素，默认为false
	//beforeInvocation表示是否需要在执行此删除方法之前删除缓存
	public void delete(Long id) {
		System.out.println("33333333333");
	}
 
	//四、@Caching
	//可以通过@Caching注解组合多个注解集合在一个方法上
	//这个注解可以组合多个注解，从而实现自定义注解
 
	//自定义注解
/*	@Target({ElementType.TYPE, ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	@Cacheable(value="users")
	public @interface MyCacheable {
	}*/
}

二、普通方式（更灵活）

1、引入pom依赖，ehcache

1
2
3
4
5
<!-- Ehcache -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

2、启动类添加@EnableCaching注解，application.properties配置文件增加配置（同上）

3、添加ehcache.xml文件在resources文件夹下（同上）

4、service方法使用如下：

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
import tk.coffeey.dao.UserDao;
import tk.coffeey.entity.User;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
@Transactional//添加事务
public class UserServiceImpl2 implements UserService {
    private UserDao userDao;
    private CacheManager cacheManager;
    
    @Autowired
    public UserServiceImpl2(UserDao userDao, CacheManager cacheManager) {
        this.userDao = userDao;
        this.cacheManager = cacheManager;
    }
 
    @Override
    public User get(Long id) {
        Cache cache = cacheManager.getCache("users");
        Element element = cache.get(id);
        if(element!=null){//如果缓存中存在
            return (User)element.getObjectValue();//直接取缓存
        }else{
            User user=userDao.getUser(1L);
            //数据库查出后，存储到缓存
            Element element2 = new Element(id, user);
            cache.put(element2);
            return user;
        }
    }
 
    @Override
    public User save(Long id) {
        User user=new User();
        //直接存储缓存
        Cache cache = cacheManager.getCache("users");
        Element element2 = new Element(id, user);
        cache.put(element2);
        return user;
    }
 
    @Override
    public void delete(Long id) {
        Cache cache = cacheManager.getCache("users");
        cache.remove(id);
    }
 
}

需要注意，EhCache设置了元素过期时间，当元素过期时，EhCache并不会主动去清除缓存（内存）中的元素，当查询(get)时，EHCache才会把它从缓存中清空，如果一直未查询，则会一直存在于缓存中，可能会导致内存泄漏风险。

查阅文档博客时，有查看提及到当元素超过maxElementsInMemory（内存中最大缓存对象数）时，会清除掉过期元素，暂且有待验证。