【第22期】观点:IT 行业加班,到底有没有价值?

ehcache的配置

转载 2016年08月29日 15:44:28

转载于:http://www.16boke.com

EHCache是一款优秀的缓存框架,关于EHCache的介绍网上已经有很多了,这里分享一份EHCache在实际项目中的使用例子:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package com.avic.smartb.utils;  
  2.   
  3. /** 
  4.  *  
  5.  * @className:EHCacheConfig.java 
  6.  *  
  7.  */  
  8.   
  9. public class EHCacheConfig {  
  10.   
  11.     /** 
  12.      * 元素最大数量 
  13.      */  
  14.   
  15.     public static int MAXELEMENTSINMEMORY = 50000;  
  16.   
  17.     /** 
  18.      *  
  19.      * 是否把溢出数据持久化到硬盘 
  20.      */  
  21.   
  22.     public static boolean OVERFLOWTODISK = true;  
  23.   
  24.     /** 
  25.      *  
  26.      * 是否会死亡 
  27.      */  
  28.   
  29.     public static boolean ETERNAL = false;  
  30.   
  31.     /** 
  32.      *  
  33.      * 缓存的间歇时间 
  34.      */  
  35.   
  36.     public static int TIMETOIDLESECONDS = 600;  
  37.   
  38.     /** 
  39.      *  
  40.      * 存活时间(默认一天) 
  41.      */  
  42.   
  43.     public static int TIMETOlIVESECONDS = 86400;  
  44.   
  45.     /** 
  46.      *  
  47.      * 需要持久化到硬盘否 
  48.      */  
  49.   
  50.     public static boolean DISKPERSISTENT = false;  
  51.   
  52.     /** 
  53.      *  
  54.      * 内存存取策略 
  55.      */  
  56.   
  57.     public static String MEMORYSTOREEVICTIONPOLICY = "LFU";  
  58.   
  59. }  

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package com.avic.smartb.utils;  
  2.   
  3. import java.util.List;  
  4.   
  5. import net.sf.ehcache.Cache;  
  6. import net.sf.ehcache.CacheManager;  
  7. import net.sf.ehcache.Element;  
  8. import net.sf.ehcache.config.CacheConfiguration;  
  9.   
  10. import org.apache.commons.lang.StringUtils;  
  11.   
  12. /** 
  13.  * ehcache工具类 
  14.  */  
  15.   
  16. public class EHCacheUtil {  
  17.     private static CacheManager cacheManager = null;  
  18.     private static Cache cache = null;  
  19.   
  20.     static{  
  21.         EHCacheUtil.initCacheManager();  
  22.         EHCacheUtil.initCache("cache");  
  23.     }  
  24.     /** 
  25.      *  
  26.      * 初始化缓存管理容器 
  27.      */  
  28.     public static CacheManager initCacheManager() {  
  29.         try {  
  30.             if (cacheManager == null)  
  31.                 cacheManager = CacheManager.getInstance();  
  32.         } catch (Exception e) {  
  33.             e.printStackTrace();  
  34.         }  
  35.         return cacheManager;  
  36.     }  
  37.   
  38.     /** 
  39.      *  
  40.      * 初始化缓存管理容器 
  41.      *  
  42.      * @param path 
  43.      *            ehcache.xml存放的路徑 
  44.      */  
  45.     public static CacheManager initCacheManager(String path) {  
  46.         try {  
  47.             if (cacheManager == null) {  
  48.                 cacheManager = CacheManager.getInstance().create(path);  
  49.             }  
  50.         } catch (Exception e) {  
  51.             e.printStackTrace();  
  52.         }  
  53.         return cacheManager;  
  54.     }  
  55.   
  56.     /** 
  57.      * 初始化cache 
  58.      */  
  59.   
  60.     public static Cache initCache(String cacheName) {  
  61.         checkCacheManager();  
  62.         if (null == cacheManager.getCache(cacheName)) {  
  63.             cacheManager.addCache(cacheName);  
  64.         }  
  65.         cache = cacheManager.getCache(cacheName);  
  66.         return cache;  
  67.     }  
  68.   
  69.     /** 
  70.      *  
  71.      * 添加缓存 
  72.      *  
  73.      * @param key 
  74.      *            关键字 
  75.      * @param value 
  76.      *            值 
  77.      */  
  78.     public static void put(Object key, Object value) {  
  79.         checkCache();  
  80.         // 创建Element,然后放入Cache对象中  
  81.         Element element = new Element(key, value);  
  82.         cache.put(element);  
  83.     }  
  84.   
  85.     /** 
  86.      * 获取cache 
  87.      *  
  88.      * @param key 
  89.      *            关键字 
  90.      * @return 
  91.      */  
  92.     public static Object get(Object key) {  
  93.         checkCache();  
  94.         Element element = cache.get(key);  
  95.         if (null == element) {  
  96.             return null;  
  97.         }  
  98.         return element.getObjectValue();  
  99.     }  
  100.   
  101.     /** 
  102.      * 初始化缓存 
  103.      *  
  104.      * @param cacheName 
  105.      *            缓存名称 
  106.      * @param maxElementsInMemory 
  107.      *            元素最大数量 
  108.      * @param overflowToDisk 
  109.      *            是否持久化到硬盘 
  110.      * @param eternal 
  111.      *            是否会死亡 
  112.      * @param timeToLiveSeconds 
  113.      *            缓存存活时间 
  114.      * @param timeToIdleSeconds 
  115.      *            缓存的间隔时间 
  116.      * @return 缓存 
  117.      * @throws Exception 
  118.      */  
  119.     public static Cache initCache(String cacheName, int maxElementsInMemory, boolean overflowToDisk, boolean eternal,  
  120.             long timeToLiveSeconds, long timeToIdleSeconds) throws Exception {  
  121.         try {  
  122.             CacheManager singletonManager = CacheManager.create();  
  123.             Cache myCache = singletonManager.getCache(cacheName);  
  124.             if (myCache != null) {  
  125.                 CacheConfiguration config = cache.getCacheConfiguration();  
  126.                 config.setTimeToLiveSeconds(timeToLiveSeconds);  
  127.                 config.setMaxElementsInMemory(maxElementsInMemory);  
  128.                 config.setOverflowToDisk(overflowToDisk);  
  129.                 config.setEternal(eternal);  
  130.                 config.setTimeToIdleSeconds(timeToIdleSeconds);  
  131.             }  
  132.             if (myCache == null) {  
  133.                 Cache memoryOnlyCache = new Cache(cacheName, maxElementsInMemory, overflowToDisk, eternal, timeToLiveSeconds,  
  134.                         timeToIdleSeconds);  
  135.                 singletonManager.addCache(memoryOnlyCache);  
  136.                 myCache = singletonManager.getCache(cacheName);  
  137.             }  
  138.             return myCache;  
  139.         } catch (Exception e) {  
  140.             throw new Exception("init cache " + cacheName + " failed!!!");  
  141.         }  
  142.     }  
  143.   
  144.     /** 
  145.      * 初始化cache 
  146.      *  
  147.      * @param cacheName 
  148.      *            cache的名字 
  149.      * @param timeToLiveSeconds 
  150.      *            有效时间 
  151.      * @return cache 缓存 
  152.      * @throws Exception 
  153.      */  
  154.     public static Cache initCache(String cacheName, long timeToLiveSeconds) throws Exception {  
  155.         return EHCacheUtil.initCache(cacheName, EHCacheConfig.MAXELEMENTSINMEMORY, EHCacheConfig.OVERFLOWTODISK,  
  156.                 EHCacheConfig.ETERNAL, timeToLiveSeconds, EHCacheConfig.TIMETOIDLESECONDS);  
  157.     }  
  158.   
  159.     /** 
  160.      * 初始化Cache 
  161.      *  
  162.      * @param cacheName 
  163.      *            cache容器名 
  164.      * @return cache容器 
  165.      * @throws Exception 
  166.      */  
  167.     public static Cache initMyCache(String cacheName) throws Exception {  
  168.         return EHCacheUtil.initCache(cacheName, EHCacheConfig.TIMETOlIVESECONDS);  
  169.     }  
  170.   
  171.     /** 
  172.      * 修改缓存容器配置 
  173.      *  
  174.      * @param cacheName 
  175.      *            缓存名 
  176.      * @param timeToLiveSeconds 
  177.      *            有效时间 
  178.      * @param maxElementsInMemory 
  179.      *            最大数量 
  180.      * @throws Exception 
  181.      */  
  182.   
  183.     public static boolean modifyCache(String cacheName, long timeToLiveSeconds, int maxElementsInMemory) throws Exception {  
  184.         try {  
  185.             if (StringUtils.isNotBlank(cacheName) && timeToLiveSeconds != 0L && maxElementsInMemory != 0) {  
  186.                 CacheManager myManager = CacheManager.create();  
  187.                 Cache myCache = myManager.getCache(cacheName);  
  188.                 CacheConfiguration config = myCache.getCacheConfiguration();  
  189.                 config.setTimeToLiveSeconds(timeToLiveSeconds);  
  190.                 config.setMaxElementsInMemory(maxElementsInMemory);  
  191.                 return true;  
  192.             } else {  
  193.                 return false;  
  194.             }  
  195.         } catch (Exception e) {  
  196.             throw new Exception("modify cache " + cacheName + " failed!!!");  
  197.         }  
  198.     }  
  199.   
  200.     /** 
  201.      *  
  202.      * 向指定容器中设置值 
  203.      *  
  204.      * @param vesselName 
  205.      *            容器名 
  206.      *  
  207.      * @param key 
  208.      *            键 
  209.      *  
  210.      * @param value 
  211.      *            值 
  212.      *  
  213.      * @return 返回真 
  214.      *  
  215.      * @throws Exception 
  216.      *             异常 
  217.      */  
  218.   
  219.     public static boolean setValue(String cacheName, String key, Object value) throws Exception {  
  220.         try {  
  221.             CacheManager myManager = CacheManager.create();  
  222.             Cache myCache = myManager.getCache(cacheName);  
  223.             if (myCache == null) {  
  224.                 myCache = initCache(cacheName);  
  225.             }  
  226.             myCache.put(new Element(key, value));  
  227.             return true;  
  228.         } catch (Exception e) {  
  229.             throw new Exception("set cache " + cacheName + " failed!!!");  
  230.         }  
  231.     }  
  232.   
  233.     /** 
  234.      *  
  235.      * 向指定容器中设置值 
  236.      *  
  237.      * @param cacheName 
  238.      *            容器名 
  239.      *  
  240.      * @param key 
  241.      *            键 
  242.      *  
  243.      * @param value 
  244.      *            值 
  245.      *  
  246.      * @param timeToIdleSeconds 
  247.      *            间歇时间 
  248.      *  
  249.      * @param timeToLiveSeconds 
  250.      *            存活时间 
  251.      *  
  252.      * @return 真 
  253.      *  
  254.      * @throws Exception 
  255.      *             抛出异常 
  256.      */  
  257.   
  258.     public static boolean setValue(String cacheName, String key, Object value, Integer timeToLiveSeconds) throws Exception {  
  259.         try {  
  260.             CacheManager myManager = CacheManager.create();  
  261.             Cache myCache = myManager.getCache(cacheName);  
  262.             if (myCache == null) {  
  263.                 initCache(cacheName, timeToLiveSeconds);  
  264.                 myCache = myManager.getCache(cacheName);  
  265.             }  
  266.             myCache.put(new Element(key, value, EHCacheConfig.ETERNAL, EHCacheConfig.TIMETOIDLESECONDS, timeToLiveSeconds));  
  267.             return true;  
  268.         } catch (Exception e) {  
  269.             throw new Exception("set cache " + cacheName + " failed!!!");  
  270.         }  
  271.     }  
  272.   
  273.     /** 
  274.      *  
  275.      * 从ehcache的指定容器中取值 
  276.      *  
  277.      * @createTime 2012-4-23 
  278.      *  
  279.      * @param key 
  280.      *            键 
  281.      *  
  282.      * @return 返回Object类型的值 
  283.      *  
  284.      * @throws Exception 
  285.      *             异常 
  286.      */  
  287.   
  288.     public static Object getValue(String cacheName, String key) throws Exception {  
  289.         try {  
  290.             CacheManager myManager = CacheManager.create();  
  291.             Cache myCache = myManager.getCache(cacheName);  
  292.             if (myCache == null) {  
  293.                 myCache = initMyCache(cacheName);  
  294.             }  
  295.             return myCache.get(key).getValue();  
  296.         } catch (Exception e) {  
  297.             return null;  
  298.         }  
  299.     }  
  300.   
  301.     /** 
  302.      *  
  303.      * 删除指定的ehcache容器 
  304.      *  
  305.      * @param vesselName 
  306.      *  
  307.      * @return 真 
  308.      *  
  309.      * @throws Exception 
  310.      *             失败抛出异常 
  311.      */  
  312.   
  313.     public static boolean removeEhcache(String cacheName) throws Exception {  
  314.         try {  
  315.             CacheManager myManager = CacheManager.create();  
  316.             myManager.removeCache(cacheName);  
  317.             return true;  
  318.         } catch (Exception e) {  
  319.             throw new Exception("remove cache " + cacheName + " failed!!!");  
  320.         }  
  321.     }  
  322.   
  323.     /** 
  324.      *  
  325.      * 删除所有的EHCache容器 
  326.      *  
  327.      * @param cacheName 
  328.      *            容器名 
  329.      *  
  330.      * @return 返回真 
  331.      *  
  332.      * @throws Exception 
  333.      *             失败抛出异常 
  334.      */  
  335.   
  336.     public static boolean removeAllEhcache(String cacheName) throws Exception {  
  337.         try {  
  338.             CacheManager myManager = CacheManager.create();  
  339.             myManager.removalAll();  
  340.             return true;  
  341.         } catch (Exception e) {  
  342.             throw new Exception("remove cache " + cacheName + " failed!!!");  
  343.         }  
  344.     }  
  345.   
  346.     /** 
  347.      *  
  348.      * 删除EHCache容器中的元素 
  349.      *  
  350.      * @param cacheName 
  351.      *            容器名 
  352.      *  
  353.      * @param key 
  354.      *            键 
  355.      *  
  356.      * @return 真 
  357.      *  
  358.      * @throws Exception 
  359.      *             失败抛出异常 
  360.      */  
  361.   
  362.     public static boolean removeElment(String cacheName, String key) throws Exception {  
  363.         try {  
  364.             CacheManager myManager = CacheManager.create();  
  365.             Cache myCache = myManager.getCache(cacheName);  
  366.             myCache.remove(key);  
  367.             return true;  
  368.         } catch (Exception e) {  
  369.             throw new Exception("remove cache " + cacheName + " failed!!!");  
  370.         }  
  371.     }  
  372.   
  373.     /** 
  374.      *  
  375.      * 删除指定容器中的所有元素 
  376.      *  
  377.      * @param cacheName 
  378.      *            容器名 
  379.      *  
  380.      * @param key 
  381.      *            键 
  382.      *  
  383.      * @return 真 
  384.      *  
  385.      * @throws Exception 
  386.      *             失败抛出异常 
  387.      */  
  388.   
  389.     public static boolean removeAllElment(String cacheName, String key) throws Exception {  
  390.         try {  
  391.             CacheManager myManager = CacheManager.create();  
  392.             Cache myCache = myManager.getCache(cacheName);  
  393.             myCache.removeAll();  
  394.             return true;  
  395.         } catch (Exception e) {  
  396.             throw new Exception("remove cache " + cacheName + " failed!!!");  
  397.         }  
  398.     }  
  399.   
  400.     /** 
  401.      * 释放CacheManage 
  402.      */  
  403.   
  404.     public static void shutdown() {  
  405.         cacheManager.shutdown();  
  406.     }  
  407.   
  408.     /** 
  409.      * 移除cache 
  410.      *  
  411.      * @param cacheName 
  412.      */  
  413.   
  414.     public static void removeCache(String cacheName) {  
  415.         checkCacheManager();  
  416.         cache = cacheManager.getCache(cacheName);  
  417.         if (null != cache) {  
  418.             cacheManager.removeCache(cacheName);  
  419.         }  
  420.     }  
  421.   
  422.     /** 
  423.      * 移除cache中的key 
  424.      *  
  425.      * @param cacheName 
  426.      */  
  427.   
  428.     public static void remove(String key) {  
  429.         checkCache();  
  430.         cache.remove(key);  
  431.     }  
  432.   
  433.     /** 
  434.      * 移除所有cache 
  435.      */  
  436.   
  437.     public static void removeAllCache() {  
  438.         checkCacheManager();  
  439.         cacheManager.removalAll();  
  440.     }  
  441.   
  442.     /** 
  443.      *  
  444.      * 移除所有Element 
  445.      */  
  446.   
  447.     public static void removeAllKey() {  
  448.         checkCache();  
  449.         cache.removeAll();  
  450.     }  
  451.   
  452.     /** 
  453.      *  
  454.      * 获取所有的cache名称 
  455.      *  
  456.      * @return 
  457.      */  
  458.   
  459.     public static String[] getAllCaches() {  
  460.         checkCacheManager();  
  461.         return cacheManager.getCacheNames();  
  462.     }  
  463.   
  464.     /** 
  465.      *  
  466.      * 获取Cache所有的Keys 
  467.      *  
  468.      * @return 
  469.      */  
  470.   
  471.     public static List getKeys() {  
  472.         checkCache();  
  473.         return cache.getKeys();  
  474.     }  
  475.   
  476.     /** 
  477.      *  
  478.      * 检测cacheManager 
  479.      */  
  480.   
  481.     private static void checkCacheManager() {  
  482.         if (null == cacheManager) {  
  483.             throw new IllegalArgumentException("调用前请先初始化CacheManager值:EHCacheUtil.initCacheManager");  
  484.         }  
  485.     }  
  486.   
  487.     private static void checkCache() {  
  488.         if (null == cache) {  
  489.             throw new IllegalArgumentException("调用前请先初始化Cache值:EHCacheUtil.initCache(参数)");  
  490.         }  
  491.     }  
  492.   
  493.     public static void main(String[] arg) {  
  494.         // 初始化--必须  
  495.         EHCacheUtil.initCacheManager();  
  496.         EHCacheUtil.initCache("cache");  
  497.         EHCacheUtil.put("A""AAAAA");  
  498.         EHCacheUtil.put("B""BBBBB");  
  499.         EHCacheUtil.put("F""FFFFF");  
  500.         System.out.println(EHCacheUtil.get("F"));  
  501.         List keys = EHCacheUtil.getKeys();  
  502.         for(int i=0;i<keys.size();i++){  
  503.             System.out.println(keys.get(i));  
  504.         }  
  505.         EHCacheUtil.shutdown();  
  506.     }  
  507. }  

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.          xsi:noNamespaceSchemaLocation="ehcache.xsd"  
  4.          updateCheck="true" monitoring="autodetect"  
  5.          dynamicConfig="true">  
  6.   
  7.     <diskStore path="java.io.tmpdir"/>  
  8.   
  9.     <defaultCache  
  10.             maxEntriesLocalHeap="10000"  
  11.             eternal="true"  
  12.             timeToIdleSeconds="120"  
  13.             timeToLiveSeconds="120"  
  14.             diskSpoolBufferSizeMB="30"  
  15.             maxEntriesLocalDisk="10000000"  
  16.             diskExpiryThreadIntervalSeconds="120"  
  17.             memoryStoreEvictionPolicy="LRU">  
  18.         <persistence strategy="localTempSwap"/>  
  19.     </defaultCache>  
  20.   
  21.     <cache name="cache"  
  22.            maxEntriesLocalHeap="10000"  
  23.            maxEntriesLocalDisk="1000"  
  24.            eternal="true"  
  25.            diskSpoolBufferSizeMB="20"  
  26.            timeToIdleSeconds="300"  
  27.            timeToLiveSeconds="600"  
  28.            memoryStoreEvictionPolicy="LFU"  
  29.            transactionalMode="off">  
  30.         <persistence strategy="localTempSwap"/>  
  31.     </cache>  
  32. </ehcache>  


转载于:http://www.16boke.com


举报

相关文章推荐

ehcache简介及配置

一、java web开发缓存方案,ehcache和redis哪个更好Ehcache 在java项目广泛的使用。它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方...

Ehcache缓存配置

说明, 文章来自http://www.iteye.com/topic/369725 一. 简介 Cache的配置很灵活,官方提供的Cache配置方式有好几种。你可以通过声明配置、在xml中...

Ehcache配置详解及CacheManager使用

缓存配置         name:缓存名称。         maxElementsInMemory:缓存最大个数。         eternal:对象是否永久有效,一但设置了,timeou...

ehcache配置参数说明

Cache配置 以下属性是必须的 name:Cache的唯一标识名称 Sets the name of the cache. This is used to identify the c...

Ehcache配置文件的详细说明

Ehcache配置文件的详细说明     maxElementsInMemory :cache 中最多可以存放的元素的数量。如果放入cache中的元素超过这个数值,有两种情况:1、若overflow...

ehcache 配置详解

CacheManager配置 ==========================   一个ehcache.xml 相当于一个单个的CacheManager 学习下面的说明或者ehca...

EHCache概念,配置文件,使用示例

一. EHCache.xml 配置文件解析: 二. EHCache使用 三. 待研究部分       EHCache是一个非常轻量级的缓冲,是Hibernate的默认缓存。同时ehcac...

Spring MVC 4.+ 使用 Ehcache 超简单配置!!!

Firstpom.xml net.sf.ehcache ehcache-core 2.6.11 org.springframework

合理使用Ehcache

Ehcache是来sourceforge(http://ehcache.sourceforge.net/)的开源项目,是纯Java实现的简单、快速的Cache组件。可以对页面、对象、数据进行缓存,支持...

ehcache jgroup 分布式配置

ehcache
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)