EhCache在JAVA中的应用

柔光的暖阳◎ 2022-06-16 14:21 179阅读 0赞

先看看Ehcache:（这段话是copy的）

Ehcache在java项目广泛的使用。它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案。正因为Ehcache具有健壮性（基于java开发）、被认证（具有apache 2.0  license）、充满特色（稍后会详细介绍），所以被用于大型复杂分布式web application的各个节点中。

什么特色？

1.  够快

Ehcache的发行有一段时长了，经过几年的努力和不计其数的性能测试，Ehcache终被设计于large, high concurrency systems.

2. 够简单

开发者提供的接口非常简单明了，从Ehcache的搭建到运用运行仅仅需要的是你宝贵的几分钟。其实很多开发者都不知道自己用在用Ehcache，Ehcache被广泛的运用于其他的开源项目，比如：hibernate

3.够袖珍

关于这点的特性，官方给了一个很可爱的名字small foot print ，一般Ehcache的发布版本不会到2M，V2.2.3  才 668KB。

4. 够轻量

核心程序仅仅依赖slf4j这一个包，没有之一！

5.好扩展

Ehcache提供了对大数据的内存和硬盘的存储，最近版本允许多实例、保存对象高灵活性、提供LRU、LFU、FIFO淘汰算法，基础属性支持热配置、支持的插件多

6.监听器

缓存管理器监听器 （CacheManagerListener）和 缓存监听器（CacheEvenListener）,做一些统计或数据一致性广播挺好用的。

废话不说了。直接看看怎么个用法吧：

使用ehcache之前需要把  ehcache-2.8.3.jar和 slf4j-api-1.7.7.jar 导入工程中 （jar包网上很多，自己下载就好了。版本不一定相同，我这里只是目前在用的版本）。

首先要创建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">  
    
    <diskStore path="java.io.tmpdir/ehcache"/>  
    
    
    
    <cache name="serviceCache"
    	eternal="true"  
        maxElementsInMemory="2000" 
        maxElementsOnDisk="5000"
        overflowToDisk="true" 
        diskPersistent="false"
        timeToIdleSeconds="3000" 
        timeToLiveSeconds="3000"  
        memoryStoreEvictionPolicy="LRU" /> 
    </ehcache>

然后在spring配置文件中配置：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:task="http://www.springframework.org/schema/task"
    	xmlns:cache="http://www.springframework.org/schema/cache"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
    	 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd  
         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd 
         http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.3.xsd 
         http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
    
    
    	<bean id="SpringContextUtil" class="com.im.utils.SpringContextUtil"
    		scope="singleton"></bean>
    
    	
    	<cache:annotation-driven cache-manager="ehcacheCacheManager" />
    	<bean id="ehcacheCacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
    		<property name="cacheManager" ref="ehcacheManager" />
    	</bean>
    
    	<bean id="ehcacheManager"
    		class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
    		<property name="configLocation" value="classpath:ehcache/ehcache.xml" />
    	</bean>
    
    	
    	<import resource="spring-quartz.xml" />
    
    	
    	<import resource="../dubbo/dubbo-user.xml" />
    
    	
    	<import resource="spring-redis.xml" />
    
    
    </beans>

配置非常简单，到这里基本可以正常使用EHCache了。下面给一个工具类方便使用：

package com.im.socket.utils;
    
    import net.sf.ehcache.Cache;
    import net.sf.ehcache.CacheManager;
    import net.sf.ehcache.Element;
    
    /**
     * EHCache使用工具类
     * 
     * @author kokJuis
     */
    public class EHCacheUtil {
    
        private static EHCacheUtil ehCacheUtil;
    
        private CacheManager cacheManager;
    
        private Cache cache;
    
        private EHCacheUtil() {
            cacheManager = CacheManager.create();
            this.cache = cacheManager.getCache("serviceCache");//这个名称就是配置文件里面对应的name
        }
    
        //单例模式
        public static EHCacheUtil getEHCacheUtil() {
    
            if (ehCacheUtil == null) {
                ehCacheUtil = new EHCacheUtil();
            }
            return ehCacheUtil;
        }
    
        public Cache getCache() {
            return cache;
        }
    
        public void setCache(Cache cache) {
            this.cache = cache;
        }
    
        /*
         * 通过名称从缓存中获取数据
         */
        public Object getCacheElement(String cacheKey) throws Exception {
            Element e = cache.get(cacheKey);
            if (e == null) {
                return null;
            }
            return e.getObjectValue();
        }
    
        /*
         * 将对象添加到缓存中
         */
        public void addToCache(String cacheKey, Object result) throws Exception {
            Element element = new Element(cacheKey, result);
            cache.put(element);
        }
    
        /**
         * 将对象从缓存中删除
         * 
         * @param cacheKey
         * @return
         * @author kokJuis
         * @date 2016-4-28 下午3:06:00
         * @comment
         */
        public boolean removeToCache(String cacheKey) throws Exception {
            return cache.remove(cacheKey);
        }
    
        /**
         * 获取给定Key的Write锁
         * 
         * @author kokJuis
         * @version 1.0
         * @date 2016-12-7
         * @param cacheKey
         */
        public void acquireWriteLockOnKey(String cacheKey) {
            cache.acquireWriteLockOnKey(cacheKey);
        }
    
        /**
         * 获取给定Key的Read锁
         * 
         * @author kokJuis
         * @version 1.0
         * @date 2016-12-7
         * @param cacheKey
         */
        public void acquireReadLockOnKey(String cacheKey) {
            cache.acquireReadLockOnKey(cacheKey);
        }
    
        /**
         * 释放所持有的给定Key的Read锁
         * 
         * @param key
         */
        public void releaseReadLockOnKey(String key) {
            cache.releaseReadLockOnKey(key);
        }
    
        /**
         * 释放所持有的给定Key的Write锁
         * 
         * @param key
         */
        public void releaseWriteLockOnKey(String key) {
            cache.releaseWriteLockOnKey(key);
        }
    
    }