SpringBoot中使用ehcache

1.引入依赖

<!--ehcache依赖-->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

2.创建EhCache的配置文件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"
         updateCheck="false">

    <!--
        磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
        path:指定在硬盘上存储对象的路径
        path可以配置的目录有：
        user.home（用户的家目录）
        user.dir（用户当前的工作目录）
        java.io.tmpdir（默认的临时目录）
        ehcache.disk.store.dir（ehcache的配置目录）
        绝对路径（如：d:\\ehcache）
        查看路径方法：String tmpDir = System.getProperty("java.io.tmpdir");
     -->
    <diskStore path="java.io.tmpdir" />

    <!--
        defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
        maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
        eternal:代表对象是否永不过期 (指定true则下面两项配置需为0无限期)
        timeToIdleSeconds:最大的发呆时间 /秒
        timeToLiveSeconds:最大的存活时间 /秒
        overflowToDisk:是否允许对象被写入到磁盘
        说明：下列配置自缓存建立起600秒(10分钟)有效 。
        在有效的600秒(10分钟)内，如果连续120秒(2分钟)未访问缓存，则缓存失效。
        就算有访问，也只会存活600秒。
     -->
    <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="600"
                  timeToLiveSeconds="600" overflowToDisk="true" />

    <cache name="users" maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120"
           timeToLiveSeconds="600" overflowToDisk="true" />

</ehcache>

3.application.yml中，指明缓存类型并声明Ehcache配置文件的位置

	server:
	  port: 8899
	
	spring:
	  profiles:
	    active: dev
	  cache:
	    type: ehcache
	    ehcache:
	      config: classpath:/ehcache.xml

4.SpringBoot启动类，@EnableCaching开启Spring Cache缓存功能

@EnableCaching
@SpringBootApplication
public class SpringbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
    
    @Bean  
	public EhCacheCacheManager ehCacheCacheManager(){
	   EhCacheManagerFactoryBean cacheManagerFactoryBean = new EhCacheManagerFactoryBean (); 
	   cacheManagerFactoryBean.setConfigLocation (new ClassPathResource("ehcache.xml"));
	   cacheManagerFactoryBean.setShared(true); 
	   return new EhCacheCacheManager(cacheManagerFactoryBean.getObject());
	}
}

5.使用缓存

5.1 使用注解的方式使用缓存

@Service
@Transactional     //事务，表示该类下所有的都受事务控制
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper usermapper;
    
    @Override
    @Cacheable(value="users",key="#id")
    public User selectUserById(int id) {
        User user=this.usermapper.selectUserById(id);
        return user;
    }
 
}

5.2 通过编程方式使用缓存(注解无效的情况下)

由于@Cacheable基于SpringAOP的动态代理机制，程序执行时会在代理的方法前做缓存处理，但是如果一个类（比如一个加了@Service注解的）内部方法A调用内部的@Cacheable方法B，则会直接调用方法不会进行相应的处理
解决办法:1.把A、B两个方法放进不同的Service中 2.不采用注解的方式，直接采用编程方式

@Service
@Transactional    
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper usermapper;
    
    @Override
    @Cacheable(value="users",key="#id")
    public User selectUserById(int id) {
        User user=selectUserById2(id);
        return user;
    }

	public User selectUserById2(int id) {
        User user=this.usermapper.selectUserById(id);
        return user;
    }
}

通过EhCacheUtil使用缓存

@Service
@Transactional    
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper usermapper;
    
    @Override
    public User selectUserById(int id) {
        User user=selectUserById2(id);
        return user;
    }

	public User selectUserById2(int id) {
	    if(EhCacheUtil.get("users",id) != null){
	    	User user = (User)EhCacheUtil.get("users",id);
	    	return user;
		}
        User user=this.usermapper.selectUserById(id);
        EhCacheUtil.put("users",id,user);
        return user;
    }
}

EhCacheUtil

/**
 * @ClassName：EhCacheUtil
 * @Description： <p> Ehcache工具类   </p>
*/
public class EhCacheUtil {

    /**
     * @Description: 获取缓存
     * @param cacheName 缓存名字
     * @return Cache
     */
    private static Cache getCache(String cacheName) {
        CacheManager cacheManager = CacheManager.getInstance();
        if (null == cacheManager) {
            return null;
        }
        Cache cache = cacheManager.getCache(cacheName);
        if (null == cache) {
            return null;
        }
        return cache;
    }

    /**
     * @Description:    新增缓存记录
     * @param cacheName 缓存名字
     * @param key       缓存key
     */
    public static void put(String cacheName, String key, Object value) {
        Cache cache = getCache(cacheName);
        if (null != cache) {
            Element element = new Element(key, value);
            cache.put(element);
        }
    }

    /**
     * @Description:    删除缓存记录
     * @param cacheName 缓存名字
     * @param key       缓存key
     * @return boolean  是否成功删除
     */
    public static boolean remove(String cacheName, String key) {
        Cache cache = getCache(cacheName);
        if (null == cache) {
            return false;
        }
        return cache.remove(key);
    }

    /**
     * @Description: 删除全部缓存记录
     * @param cacheName 缓存名字
     */
    public static void removeAll(String cacheName) {
        Cache cache = getCache(cacheName);
        if (null != cache) {
            //logOnRemoveAllIfPinnedCache();
            cache.removeAll();
        }
    }

    /**
     * @Description: 获取缓存记录
     * @param cacheName  缓存名字
     * @param key        缓存key
     * @return Object    缓存记录数据Object
     */
    public static Object get(String cacheName, String key) {
        Cache cache = getCache(cacheName);
        if (null == cache) {
            return null;
        }
        Element cacheElement = cache.get(key);
        if (null == cacheElement) {
            return null;
        }
        return cacheElement.getObjectValue();
    }


}