Ehcache 缓存组件

深碍√TFBOYSˉ_ 2022-08-22 04:44 238阅读 0赞

## Ehcache介绍 ##

ehcache是一个非常轻量级的缓存实现,ehcache 是一个纯Java的进程内缓存框架特别高效。

--------------------

## Ehcache学习使用 ##

使用ehcache最核心的一点就在于其ehcache.xml配置文件。  
ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="false"
    monitoring="autodetect" dynamicConfig="false" name="talent-default-ehcache">
    
        <diskStore path="D:/cache/ehcache.txt" />
        
        <defaultCache maxElementsInMemory="1000000" eternal="false"
            timeToIdleSeconds="1200" timeToLiveSeconds="1200" overflowToDisk="true"
            diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
            diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU" />
    
        
        
        <cache name="goodsBrand" maxElementsInMemory="200" eternal="false"
            overflowToDisk="true" diskSpoolBufferSizeMB="200" timeToIdleSeconds="7200"
            timeToLiveSeconds="7200" memoryStoreEvictionPolicy="LRU">
        </cache>
    
        
        <cache name="cityName" maxElementsInMemory="2000" eternal="false"
            overflowToDisk="true" diskSpoolBufferSizeMB="200" timeToIdleSeconds="7200"
            timeToLiveSeconds="7200" memoryStoreEvictionPolicy="LRU">
        </cache>
    </ehcache>

--------------------

#### 缓存对象清除策略: ####

1、**FIFO**:first in first out,先进先出策略(不推荐使用)  
2、**LFU**:Less Frequently Used,最少使用原则(清除最少使用的元素对象)缓存的元素有一个hit 属性,hit 值最小的将会被清出缓存。  
3、**LRU**:Least Recently Used,最近最少使用原则,缓存的元素有一个时间戳,当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

--------------------

#### 1、创建EhcacheManage对象 ####

1)使用默认配置文件(类路径下的ehcache.xml)

CacheManager manager = CacheManager.create();

2)使用指定的配置文件

CacheManager cacheManager = CacheManager.create(String configurationFileName);

3)使用输入流方式

CacheManager cacheManager = CacheManager.create(InputStream inputStream);

主要有两种方式,使用任何一种方式都可以。

--------------------

#### 2、创建Cache对象 ####

1)获得配置文件中事先已经配置好的Cache缓存对象

Cache cache=cacheManager.getCache(String name);

2)新建一个Cache并添加到CacheManager里

Cache cache=new Cache(String name,
                     int maxElementsInMemory,
                     MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
                     boolean overflowToDisk,
                     String diskStorePath,
                     boolean eternal,
                     long timeToLiveSeconds,
                     long timeToIdleSeconds,
                     boolean diskPersistent,
                     long diskExpiryThreadIntervalSeconds,
                     RegisteredEventListeners registeredEventListeners);
    
    一大推相关的配置,推荐在cache.xml配置文件里面配置Cache对象,以便缓存对象管理。

--------------------

#### 3、使用Cache缓存对象 ####

1)添加元素

cache.put(Element element);
    Element类似java中的Entry对象,可以去看看Element的源码结构。

2)获取元素

Element element=cache.get(Object key);

3)删除元素

boolean flag=cache.remove(Object key);

--------------------

### 自定义的工具类（EhCacheUtil） ###

/**
     * EhCache工具类,主要包含取元素和插入元素。
     * @author xuyi
     *
     */
    public class EhCacheUtil {
            private static CacheManager cacheManager;
            private EhCacheUtil() {
            //私有化构造方法
            }
    
            //静态代码块,保证singleton。
            static {
            cacheManager = CacheManager.create();
            }
    
            /**
             * 根据缓存名字获得某个缓存
             * @param cacheName
             * @return
             */
            public static Cache getCache(String cacheName) {
            return cacheManager.getCache(cacheName);
            }
    
            /**
             * 根据缓存名字,元素的key值,获得缓存中对应的value值对象。
             * @param cacheName
             * @param key
             * @param isRemoveKey
             * @return
             */
            public static Object getValue(String cacheName, Object key, boolean isRemoveKey) {
            Cache cache = getCache(cacheName);
            Element e = null;
            if (isRemoveKey) {
            e = cache.get(key);
            } else {
            e = cache.getQuiet(key);
            }
            if (e == null) {
            return null;
            }
            return e.getObjectValue();
            }
    
            /**
             * 根据缓存名字,元素的key值,获得缓存中对应的value值对象。
             * @param cacheName
             * @param key
             * @return
             */
            public static Object getValue(String cacheName, Object key) {
            return getValue(cacheName, key, false);
            }
    
            /**
             * 静态的获取元素，不会产生update.
             * @param cacheName
             * @param key
             * @return
             */
            public static Element getElementByQuite(String cacheName, Object key) {
            Cache cache = getCache(cacheName);
            return cache.getQuiet(key);
            }
    
            /**
             * 动态的获取元素，会产生update.
             * @param cacheName
             * @param key
             * @return
             */
            public static Element getElementByDynic(String cacheName, Object key){
            Cache cache = getCache(cacheName);
            return cache.get(key);
            }
    
            /**
             * 向某个缓存中添加元素
             * @param cacheName
             * @param key
             * @param value
             */
            public static void put(String cacheName, Object key, Object value) {
            Element element = new Element(key, value);
            getCache(cacheName).put(element);
            }
    
            /**
             * 移除某个缓存中的元素
             * @param cacheName
             * @param key
             */
            public static void remove(String cacheName, Object key) {
            Cache cache = getCache(cacheName);
            if (cache != null) {
            cache.remove(key);
            }
            }
    
            /**
             * 判断某个缓存是否包含某个元素
             * @param cacheName
             * @param key
             * @return
             */
            public static boolean contains(String cacheName, Object key) {
            Cache cache = getCache(cacheName);
            Element e = cache.get(key);
            if (e != null) {
            return true;
            }
            return false;
            }
    
            @SuppressWarnings("unchecked")
            public static <T> List<T> getKeys(String cacheName, Class<T> t) {
            Cache cache = getCache(cacheName);
            return (List<T>) cache.getKeys();
            }
    }

--------------------

### 闲言碎语 ###

**备注:缓存这一思想在很多场景下都适用**

**ehcache和redis缓存比较**

ehcache直接在jvm虚拟机中缓存,速度快,效率高;但是缓存共享麻烦,集群分布式应用不方便。  
redis是通过socket访问到缓存服务,效率比ecache低,比数据库要快很多,处理集群和分布式缓存方便,有成熟的方案。

取数逻辑,通常先到缓存对象中去查询，如果有查询到就直接返回，如果没有查询到就到数据库里查询，将查询结果存到缓存对象中，然后将数据返回给用户对象。

--------------------

## 参考 ##

[https://en.wikipedia.org/wiki/Ehcache][https_en.wikipedia.org_wiki_Ehcache]  
[http://blog.csdn.net/jationxiaozi/article/details/8509732][http_blog.csdn.net_jationxiaozi_article_details_8509732]  
[http://blog.csdn.net/l271640625/article/details/20528573][http_blog.csdn.net_l271640625_article_details_20528573]  
[http://raychase.iteye.com/blog/1545906][http_raychase.iteye.com_blog_1545906]  
[http://www.ibm.com/developerworks/cn/java/j-jcs.html][http_www.ibm.com_developerworks_cn_java_j-jcs.html]  
[https://www.ibm.com/developerworks/cn/java/j-lo-ehcache/][https_www.ibm.com_developerworks_cn_java_j-lo-ehcache]

[https_en.wikipedia.org_wiki_Ehcache]: https://en.wikipedia.org/wiki/Ehcache
[http_blog.csdn.net_jationxiaozi_article_details_8509732]: http://blog.csdn.net/jationxiaozi/article/details/8509732
[http_blog.csdn.net_l271640625_article_details_20528573]: http://blog.csdn.net/l271640625/article/details/20528573
[http_raychase.iteye.com_blog_1545906]: http://raychase.iteye.com/blog/1545906
[http_www.ibm.com_developerworks_cn_java_j-jcs.html]: http://www.ibm.com/developerworks/cn/java/j-jcs.html
[https_www.ibm.com_developerworks_cn_java_j-lo-ehcache]: https://www.ibm.com/developerworks/cn/java/j-lo-ehcache/