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


相关文章推荐

Java 缓存之 Ehcache 配置详解

1.下载地址  下载地址: http://sourceforge.net/projects/ehcache/files/ 在线文档: http://tool.oschina.net/apidocs/a...

Ehcache 中ehcache.xml 配置详解和示例

转载地址             Mandatory Default Cache configuration. These settings will be appl...

Intellij IDEA常用配置详解

http://www.cnblogs.com/ShaYeBlog/p/4540915.html 1. IDEA内存优化  先看看你机器本身的配置而配置.  \IntelliJ IDEA ...

ehcache-terracotta代码配置

  • 2014-04-21 23:35
  • 14.03MB
  • 下载

Ehcache缓存配置

简介   Cache的配置很灵活,官方提供的Cache配置方式有好几种。你可以通过声明配置、在xml中配置、在程序里配置或者调用构造方法时传入不同的参数。   你可以将Cach...

EHCache 配置说明

  • 2009-09-29 17:34
  • 144KB
  • 下载

配置EhCache二级缓存

  • 2011-11-23 17:29
  • 91KB
  • 下载

Ehcache集群环境配置

Ehcache支持的分布式缓存支持有三种RMI,JGroups,JMS,这里介绍下MRI和JGrpups两种方式,Ehcache使用版本为 1.5.0,关于ehcache的其他信息请参考http:/...

EHCache的配置和使用说明

  • 2011-09-02 12:23
  • 46KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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