精华内容
下载资源
问答
  • JGroups是一个开源的纯java编写的可靠的群组通讯工具。其工作模式基于IP多播,但可以在可靠性和群组成员管理上进行扩展。其结构上设计灵活,提供了一种灵活兼容多种协议的协议栈。
  • Encache

    2010-11-01 12:08:00
    Encache   源文档 <http://wj98127.javaeye.com/blog/342397 >   EhCache一般用途如下:Hibernate缓存,DAO缓存,安全性凭证缓存(Acegi),Web缓存,应用持久化和分布式缓存。  ...

    Encache

     

    源文档 <http://wj98127.javaeye.com/blog/342397 >

     

    EhCache 一般用途如下: Hibernate 缓存, DAO 缓存,安全性凭证缓存( Acegi ), Web 缓存,应用持久化和分布式缓存。

        EhCache 在默认情况下,即在用户未提供自身配置文件ehcache.xml或ehcache-failsafe.xml时,EhCache会依据其自身Jar存档包含的ehcache-failsafe.xml文件所定制的策略来管理缓存。如果用户在classpath下提供了ehcache.xml或ehcache-failsafe.xml文件,那么EhCache将会应用这个文件。如果两个文件同时提供,那么EhCache会使用ehcache.xml文件的配置。 EhCache默认内容如下:

     

    < ehcache >

    <diskStore   path = "C:/Acegi6"   />    

    < defaultCache

                maxElementsInMemory = "10000"

                eternal = "false"

                timeToIdleSeconds = "120"

                timeToLiveSeconds = "120"

                overflowToDisk = "true"

                maxElementsOnDisk = "10000000"

                diskPersistent = "false"

                diskExpiryThreadIntervalSeconds = "120"

                memoryStoreEvictionPolicy = "LRU"

                 />

    </ ehcache >

    属性说明:

    l  diskStore :指定数据在磁盘中的存储位置。

    l  defaultCache :当借助 CacheManager.add("demoCache") 创建 Cache 时, EhCache 便会采用<defalutCache/>指定的的管理策略

    以下属性是必须的:

    l  maxElementsInMemory - 在内存中缓存的 element 的最大数目

    l  maxElementsOnDisk - 在磁盘上缓存的 element 的最大数目

    l  eternal - 设定缓存的 elements 是否永远不过期。如果为 true ,则缓存的数据始终有效,如果为 false 那么还要根据 timeToIdleSeconds timeToLiveSeconds 判断

    l  overflowToDisk - 设定当内存缓存溢出的时候是否将过期的 element 缓存到磁盘上

    以下属性是可选的:

    l  timeToIdleSeconds - 当缓存在 EhCache 中的数据前后两次访问的时间超过 timeToIdleSeconds 的属性取值时,这些数据便会删除 .

    l  timeToLiveSeconds - 缓存 element 的有效生命期

    l  diskPersistent - VM 重启的时候是否启用磁盘保存 EhCache 中的数据,默认是 false

    l  diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔,默认是 120 秒。每个 120s ,相应的线程会进行一次 EhCache 中数据的清理工作

    l  memoryStoreEvictionPolicy - 当内存缓存达到最大,有新的 element 加入的时候,   移除缓存中 element 的策略。默认是 LRU (最近最少使用),可选的有 LFU (最不常使用)和 FIFO (先进先出)

     

     

     

    使用简介

     

    源文档

    http://www.uusam.com/uu/blog/article/60.htm

    1. cacheNames 列表的取得

        方法一:

            CacheManager.create();

            String[] cacheNames = CacheManager.getInstance().getCacheNames();

        方法二:

            CacheManager manager = new CacheManager();

            String[] cacheNames = manager.getCacheNames();

        方法三:

            CacheManager manager1 = new CacheManager("src/config/ehcache1.xml");

            CacheManager manager2 = new CacheManager("src/config/ehcache2.xml");

            String[] cacheNamesForManager1 = manager1.getCacheNames();

            String[] cacheNamesForManager2 = manager2.getCacheNames();

    2.CacheManager 各种建立的方法:

        方法一:

             CacheManager manager = new CacheManager(); // 实例方式

             CacheManager singletonManager = CacheManager.create(); // 单例方式

     

        方法二:

            CacheManager manager = new CacheManager("src/config/ehcache.xml");

     

        方法三:

            URL url = getClass().getResource("/anotherconfigurationname.xml");

            CacheManager manager = new CacheManager(url);

        方法四:

            InputStream fis = new 

                      FileInputStream(newFile("src/config/ehcache.xml").getAbsolutePath());

            try {

                CacheManager manager = new CacheManager(fis);

            } finally {

                fis.close();

            }

     

     

    3. 添加和删除 Cache

            // 设置一个名为 test 的新 cache,test 属性为默认

            CacheManager singletonManager = CacheManager.create();

            singletonManager.addCache("testCache");

            Cache test = singletonManager.getCache("testCache");

            // 设置一个名为 test 的新 cache, 并定义其属性

            CacheManager singletonManager = CacheManager.create();

            Cache memoryOnlyCache = new Cache("testCache", 5000, false, false, 5, 2);

            manager.addCache (memoryOnlyCache);

            Cache test = singletonManager.getCache("testCache");

            singletonManager.removeCache ("test");

     

     4. 关闭缓存管理器 CacheManager        

            CacheManager.getInstance().shutdown();

      5. 对于缓存对象的 CRUD

            // 放入一个简单的对象到缓存元素;

            Cache cache = manager.getCache("sampleCache1");

            Element element = new Element("key1", "value1");

            cache.put (element); //Update

     

           // 得到一个序列化后的对象属性值;

            Cache cache = manager.getCache("sampleCache1");

            Element element = cache.get ("key1"); //query

            Serializable value = element.getValue();

     

            // 得到一个没有序列化后的对象属性值;

            Cache cache = manager.getCache("sampleCache1");

            Element element = cache.get("key1");

            Object value = element.getObjectValue();

     

            // 删除一个对象从元素;

            Cache cache = manager.getCache("sampleCache1");

            Element element = new Element("key1", "value1"

            cache.remove ("key1");

     

          // 对于永固性磁盘存储,立即存储到磁盘:

     

            Cache cache = manager.getCache("sampleCache1");

            cache.flush ();

     

     

    6. 获得缓存大小:

            // 得到缓存的对象数量;

            Cache cache = manager.getCache("sampleCache1");

            int elementsInMemory = cache.getSize();

     

            // 得到缓存对象占用内存的数量

            Cache cache = manager.getCache("sampleCache1");

            long elementsInMemory = cache.getMemoryStoreSize();

     

            // 得到缓存对对象占用磁盘的数量

            Cache cache = manager.getCache("sampleCache1");

            long elementsInMemory = cache.getDiskStoreSize();

     

    7. 关于缓存的读取和丢失的记录

            得到缓存读取的命中次数;

            Cache cache = manager.getCache("sampleCache1");

            int hits = cache.getHitCount();

     

            得到内存中缓存读取的命中次数;

            Cache cache = manager.getCache("sampleCache1");

            int hits = cache.getMemoryStoreHitCount();

     

            得到磁盘中缓存读取的命中次数;

            Cache cache = manager.getCache("sampleCache1");

            int hits = cache.getDiskStoreCount();

     

            得到缓存读取的丢失次数;

            Cache cache = manager.getCache("sampleCache1");

            int hits = cache.getMissCountNotFound();

     

            得到缓存读取的已经被销毁的对象丢失次数;

            Cache cache = manager.getCache("sampleCache1");

            int hits = cache.getMissCountExpired();

     

     

     

     

     

     

     

     

     

    Ehcache页面缓存的使用

     

    源文档 <http://www.javaeye.com/topic/128458 >

    关于缓存的话题,在坛子里已经有很多讨论,简单的来说,如果一个应用中80% 的时间内都在访问20% 的数据,那么,这时候就应该使用缓存了。这个和长尾理论正好相悖,其实也不是相悖,只是不同的理论使用的场景不同。在80/20 原则生效的地方,我们都应该考虑是否可以使用缓存。但即使是这样,缓存也有不同的用法,举个例子,一个网站的首页估计是被访问的次数最多的,我们可以考虑给首页做一个页面缓存,而如果在某个页面上,比如说javaeye 的java 版区只有前几个页面是访问最频繁的,(假设javaeye 是使用hibernate ,当然这只是假设,我们都知道javaeye 是使用ror 开发的)那么我们就可以考虑给java 版区的record 做二级缓存了,因为二级缓存中是按照对象的id 来保存的,所以应该来说这前面几页使用的对象会一直存在于缓存之中(如何使用hibernate 的二级缓存坛子上也有介绍)。由此可见不同的页面的缓存策略有可能有天壤之别。

    本文的目的就是上面所讲的两种情况之一,页面缓存。毫无疑问,几乎所有的网站的首页都是访问率最高的,而首页上的数据来源又是非常广泛的,大多数来自不同的对象,而且有可能来自不同的db ,所以给首页做缓存是一个不错的主意,那么主页的缓存策略是什么样子的呢,我认为应该是某个固定时间之内不变的,比如说2 分钟更新一次。那么这个缓存应该做在什么地方呢,让我们来看一下,假设您的应用的结构是page-filter-action-service-dao-db ,这个过程中的- 的地方都是可以做缓存的地方,根据页面缓存的特征,应该把页面缓存做到尽量靠近客户的地方,就是在page 和filter 之间,这样的优点就是第一个用户请求之后,页面被缓存,第二个用户再来请求的时候,走到filter 这个请求就结束了,无需再走后面的action-service-dao-db 。带来的好处是服务器压力的减低和客户段页面响应速度的加快。

     

    那么我们来看一下如何使用ehcache 做到这一点。

     

    在使用ehcache 的页面缓存之前,我们必须要了解ehcache 的几个概念,

    1 timeToIdleSeconds ,多长时间不访问该缓存,那么ehcache 就会清除该缓存。

    2 timeToLiveSeconds ,缓存的存活时间,从开始创建的时间算起。

     

    看到这里,我们知道,首页的页面缓存的存活时间,我们定的是2 分钟,那么也就是说我们的timeToLiveSeconds 应该设置为120 ,同时我们的timeToIdleSeconds 最好也设置为2 分钟,或者小于2 分钟。我们来看一下下面这个配置,这个配置片段应该放到ehcache.xml 中:

     

    < cache name = "SimplePageCachingFilter"

               maxElementsInMemory = "10"

               maxElementsOnDisk = "10"

               eternal = "false"

                overflowToDisk = "true"

               diskSpoolBufferSizeMB = "20"

               timeToIdleSeconds = "10"

               timeToLiveSeconds = "10"

               memoryStoreEvictionPolicy = "LFU"

                />

     

    SimplePageCachingFilter 是缓存的名字,maxElementsInMemory 表示内存中SimplePageCachingFilter 缓存中元素的最大数量为10 ,maxElementsOnDisk 是指持久化该缓存的元素到硬盘上的最大数量也为10 (),eternal=false 意味着该缓存会死亡。overflowToDisk=true 意思是表示当缓存中元素的数量超过限制时,就把这些元素持久化到硬盘,如果overflowToDisk 是false ,那么maxElementsOnDisk 的设置就没有什么意义了。memoryStoreEvictionPolicy=LFU 是指按照缓存的hit 值来清除,也就是说缓存满了之后,新的对象需要缓存时,将会将缓存中hit 值最小的对象清除出缓存,给新的对象腾出地方来了(文章最后有ehcache 中自带的3 种缓存清空策略的介绍)。

     

    接着我们来看一下SimplePageCachingFilter 的配置,

    < filter >

            < filter-name > indexCacheFilter filter-name >

            < filter-class >

                net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter

            filter-class >

    filter >

     

        < filter-mapping >

            < filter-name > indexCacheFilter filter-name >

            < url-pattern > *index.action url-pattern >

    filter-mapping >

    就只需要这么多步骤,我们就可以给某个页面做一个缓存的,把上面这段配置放到你的web.xml 中,那么当你打开首页的时候,你会发现,2 分钟才会有一堆sql 语句出现在控制台上。当然你也可以调成5 分钟,总之一切都在控制中。

     

    好了,缓存整个页面看上去是非常的简单,甚至都不需要写一行代码,只需要几行配置就行了,够简单吧,虽然看上去简单,但是事实上内部实现却不简单哦,有兴趣的话,大家可以看看SimplePageCachingFilter 继承体系的源代码。

     

    上面的配置针对的情况是缓存首页的全部,如果你只想缓存首页的部分内容时,你需要使用SimplePageFragmentCachingFilter 这个filter 。我们看一下如下片断:

     

    < filter >

            < filter-name > indexCacheFilter filter-name >

            < filter-class >

                net.sf.ehcache.constructs.web.filter.SimplePageFragmentCachingFilter

            filter-class >

    filter >

     

        < filter-mapping >

            < filter-name > indexCacheFilter filter-name >

            < url-pattern > */index_right.jsp url-pattern >

    filter-mapping >

     

    这个jsp 需要被jsp:include 到其他页面,这样就做到的局部页面的缓存。这一点貌似没有oscache 的tag 好用。

     

    事实上在cachefilter 中还有一个特性,就是gzip ,也就是说缓存中的元素是被压缩过的,如果客户浏览器支持压缩的话,filter 会直接返回压缩过的流,这样节省了带宽,把解压的工作交给了客户浏览器,如果客户的浏览器不支持gzip ,那么filter 会把缓存的元素拿出来解压后再返回给客户浏览器(大多数爬虫是不支持gzip 的,所以filter 也会解压后再返回流),这样做的优点是节省带宽,缺点就是增加了客户浏览器的负担(但是我觉得对当代的计算机而言,这个负担微乎其微)。

     

    好了,如果你的页面正好也需要用到页面缓存,不防可以考虑一下ehcache ,因为它实在是非常简单,而且易用。

     

    总结:ehcache 是一个非常轻量级的缓存实现,而且从1.2 之后就支持了集群,目前的最新版本是1.3 ,而且是hibernate 默认的缓存provider 。虽然本文是介绍的是ehcache 对页面缓存的支持,但是ehcache 的功能远不止如此,当然要使用好缓存,对JEE 中缓存的原理,使用范围,适用场景等等都需要有比较深刻的理解,这样才能用好缓存,用对缓存。

     

    最后复习一下ehcache 中缓存的3 种清空策略:

    1 FIFO ,first in first out ,这个是大家最熟的,先进先出,不多讲了

    2 LFU , Less Frequently Used ,就是上面例子中使用的策略,直白一点就是讲一直以来最少被使用的。如上面所讲,缓存的元素有一个hit 属性,hit 值最小的将会被清出缓存。

    2 LRU ,Least Recently Used ,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

     

     

     

     Ehcache集群环境配置

    •  
      1. <cacheManagerPeerProviderFactory  class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"   
      2. properties="peerDiscovery=manual,rmiUrls=//192.168.2.23:40001/userCache|//192.168.2.23:40001/resourceCache"  />  
      1. <cacheManagerPeerListenerFactory  class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"   
      2. properties="hostName=192.168.2.154,  port=40001,socketTimeoutMillis=2000" />  
      1. <cache  name="userCache" maxElementsInMemory="10000" eternal="true" overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0" diskPersistent="false" diskExpiryThreadIntervalSeconds="120">  
      2.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"     properties="replicateAsynchronously=true, replicatePuts=true, replicateUpdates=true,replicateUpdatesViaCopy= false, replicateRemovals= true " />  
      3. </cache>   
      1. <cacheManagerPeerProviderFactory  class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"  
      2.         properties="connect=TCP(start_port=7800):  
      3.         TCPPING(initial_hosts=192.168.2.154[7800],192.168.2.23[7800];port_range=10;timeout=3000;  
      4.         num_initial_members=3;up_thread=true;down_thread=true):  
      5.         VERIFY_SUSPECT(timeout=1500;down_thread=false;up_thread=false):  
      6.         pbcast.NAKACK(down_thread=true;up_thread=true;gc_lag=100;retransmit_timeout=3000):  
      7.         pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;shun=false;  
      8.         print_local_addr=false;down_thread=true;up_thread=true)"   
      9.         propertySeparator="::" />  
      1. <cache  name="userCache" maxElementsInMemory="10000" eternal="true"  
      2.         overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"  
      3.         diskPersistent="false" diskExpiryThreadIntervalSeconds="120">  
      4.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"  
      5.             properties="replicateAsynchronously=true, replicatePuts=true,  
      6.                 replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>  
      7. </cache>   
      1. <?xml  version="1.0" encoding="UTF-8"?>  
      2. <ehcache  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
      3.     xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">  
      4.     <diskStore path="java.io.tmpdir" />  
      5.   
      6.     <cacheManagerPeerProviderFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"  
      7.         properties="connect=TCP(start_port=7800):  
      8.         TCPPING(initial_hosts=192.168.2.154[7800],192.168.2.23[7800];port_range=10;timeout=3000;  
      9.         num_initial_members=3;up_thread=true;down_thread=true):  
      10.         VERIFY_SUSPECT(timeout=1500;down_thread=false;up_thread=false):  
      11.         pbcast.NAKACK(down_thread=true;up_thread=true;gc_lag=100;retransmit_timeout=3000):  
      12.         pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;shun=false;  
      13.         print_local_addr=false;down_thread=true;up_thread=true)"   
      14.         propertySeparator="::" />  
      15.   
      16.     <defaultCache maxElementsInMemory="10000" eternal="true"  
      17.         overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"  
      18.         diskPersistent="false" diskExpiryThreadIntervalSeconds="120">  
      19.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"  
      20.             properties="replicateAsynchronously=true, replicatePuts=true,  
      21.                 replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>  
      22.     </defaultCache>  
      23.   
      24.     <cache name="velcroCache" maxElementsInMemory="10000" eternal="true"  
      25.         overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"  
      26.         diskPersistent="false" diskExpiryThreadIntervalSeconds="120">  
      27.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"  
      28.             properties="replicateAsynchronously=true, replicatePuts=true,  
      29.                 replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>  
      30.     </cache>  
      31.     <cache name="userCache" maxElementsInMemory="10000" eternal="true"  
      32.         overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"  
      33.         diskPersistent="false" diskExpiryThreadIntervalSeconds="120">  
      34.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"  
      35.             properties="replicateAsynchronously=true, replicatePuts=true,  
      36.                 replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>  
      37.     </cache>  
      38.     <cache name="resourceCache" maxElementsInMemory="10000"  
      39.         eternal="true" overflowToDisk="true" timeToIdleSeconds="0"  
      40.         timeToLiveSeconds="0" diskPersistent="false"  
      41.         diskExpiryThreadIntervalSeconds="120">  
      42.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"  
      43.             properties="replicateAsynchronously=true, replicatePuts=true,  
      44.                 replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>  
      45.     </cache>  
      46. </ehcache>   

       

      源文档 <http://www.javaeye.com/topic/335623 >

       

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

       

      环境为两台机器 server1 ip:192.168.2.154,server2 ip:192.168.2.23

       

      1. RMI方式:

      rmi的方式配置要点(下面均是server1上的配置,server2上的只需要把ip兑换即可)

       

      a. 配置PeerProvider:

       

      Xml代码

       

      配置中通过手动方式同步sever2中的userCache和resourceCache。

       

      b. 配置CacheManagerPeerListener:

       

      Xml代码

       

        配置中 server1 监听本机 40001 端口。

       

      c. 在每一个cache中添加cacheEventListener,例子如下:

       

      Xml代码

         

      2. JGroups方式:

      ehcache 1.5.0之后版本支持的一种方式,配置起来比较简单,要点:

       

      a. 配置PeerProvider,使用tcp的方式,例子如下:

       

      Xml代码

       

       b. 为每个 cache 添加 cacheEventListener

       

      Xml代码

       

       JGroup 方式配置的两个 server 上的配置文件一样,若有多个 server ,在 initial_hosts 中将 server ip 加上即可。

      一个完整的ehcache.xml文件:

      Xml代码

    展开全文
  • encache 配置解析

    2018-09-10 16:48:56
    &lt;defaultCache&gt;指默认使用的缓存 &lt;!-- 指定一个文件目录,当EhCache把数据写到硬盘上时,将把数据写到这个文件目录下 --&... diskStore:为缓存路径,ehcache分为内存和磁盘两级,...
        <defaultCache>指默认使用的缓存
    
    <!-- 指定一个文件目录,当EhCache把数据写到硬盘上时,将把数据写到这个文件目录下 -->
        <diskStore path="java.io.tmpdir"/>
        // <cache>标签配置详解
        diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。
        defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。
        name:缓存名称。
        maxElementsInMemory:缓存最大数目
        maxElementsOnDisk:硬盘最大缓存个数。
        eternal:对象是否永久有效,一但设置了,timeout将不起作用。
        overflowToDisk:是否保存到磁盘,当系统当机时
        timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
        timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
        diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
        diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
        memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
        clearOnFlush:内存数量最大时是否清除。
        memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)
    LFU(最少访问次数)。
    //FIFO,first in first out,先进先出。 
    //LFU, Less Frequently Used,一直以来最少被使用的。如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。 
    //LRU,Least Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
    

    编程方式配置:

    Cache cache = manager.getCache("mycache"); 
    CacheConfiguration config = cache.getCacheConfiguration(); 
    config.setTimeToIdleSeconds(60); 
    config.setTimeToLiveSeconds(120); 
    config.setmaxEntriesLocalHeap(10000); 
    config.setmaxEntriesLocalDisk(1000000);

    代码示例。;

    public static void main(String[] args) {
    
            // 1. 创建缓存管理器
            CacheManager cacheManager = CacheManager.create("./src/main/resources/ehcache.xml");
    
            // 2. 获取缓存对象
            Cache cache = cacheManager.getCache("HelloWorldCache");
    
            // 3. 创建元素
            Element element = new Element("key1", "value1");
    
            // 4. 将元素添加到缓存
            cache.put(element);
    
            // 5. 获取缓存
            Element value = cache.get("key1");
            System.out.println(value);
            System.out.println(value.getObjectValue());
    
            // 6. 删除元素
            cache.remove("key1");
    
            Dog dog = new Dog(1L, "taidi", (short)2);
            Element element2 = new Element("taidi", dog);
            cache.put(element2);
            Element value2 = cache.get("taidi");
            Dog dog2 = (Dog) value2.getObjectValue();
            System.out.println(dog2);
    
            System.out.println(cache.getSize());
    
            // 7. 刷新缓存
            cache.flush();
    
            // 8. 关闭缓存管理器
            cacheManager.shutdown();
        }

     

     

     

    展开全文
  • springboot2.0、Mybatis-Plus、encache...... Typora 1、热部署: org.springframework.boot spring-boot-devtools true idea默认是没有自动编译的,我们这里需要添加修改配置.打开设置 (1)File-Settings-...
  • ENCACHE缓存简介

    2018-07-09 19:52:29
    ENCACHE缓存简介 ENCACHE缓存简介 ENCACHE缓存简介 ENCACHE缓存简介
  • encache缓存

    2017-02-06 11:33:40
    encache缓存
  • encache.jar

    2016-11-26 18:09:06
    包含encache.jar,encache.core.jar,encache.web.jar还有源码
  • Encache中的参数解释

    2017-11-09 10:32:47
    Encache中的参数解释因为项目需要,要是用到Encache来昨为缓存使用,配置文件中的各类参数如下: name="storeCache" maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="0

    Encache中的参数解释

    因为项目需要,要是用到Encache来昨为缓存使用,配置文件中的各类参数如下:

    <cache
                name="storeCache"
                maxElementsInMemory="10000"
                eternal="false"
                timeToIdleSeconds="0"
                timeToLiveSeconds="0"
                overflowToDisk="true"
                maxElementsOnDisk="10000000"
                diskPersistent="false"
                diskExpiryThreadIntervalSeconds="120"
                memoryStoreEvictionPolicy="LRU"
        />

    各参数与其对应的解释如下:

    参数解释
    nameCache的唯一标识
    maxElementsInMemory内存中最大缓存对象数
    maxElementsOnDisk磁盘中最大缓存对象数,若是0表示无穷大
    eternalElement是否永久有效,一但设置了,timeout将不起作用
    overflowToDisk配置此属性,当内存中Element数量达到maxElementsInMemory时,Ehcache将会Element写到磁盘中
    timeToIdleSeconds设置Element在失效前的允许闲置时间。仅当element不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大
    timeToLiveSeconds设置Element在失效前允许存活时间。最大时间介于创建时间和失效时间之间。仅当element不是永久有效时使用,默认是0.,也就是element存活时间无穷大
    diskPersistent是否缓存虚拟机重启期数据
    diskExpiryThreadIntervalSeconds磁盘失效线程运行时间间隔,默认是120秒
    diskSpoolBufferSizeMB这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
    memoryStoreEvictionPolicy当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)

    Encache工具类如下

    public class EhcacheUtil {
    
        private static final String path = "/ehcache.xml";
    
        private URL url;
    
        private CacheManager manager;
    
        private static EhcacheUtil ehCache;
    
        private EhcacheUtil(String path) {
            url = getClass().getResource(path);
            manager = CacheManager.create(url);
        }
    
        public static EhcacheUtil getInstance() {
            if (ehCache== null) {
                ehCache= new EhcacheUtil(path);
            }
            return ehCache;
        }
    
        public void put(String cacheName, String key, Object value) {
            Cache cache = manager.getCache(cacheName);
            if (cache==null){
                cache=new Cache(cacheName, 1, false, false, 0, 0);
                manager.addCache(cache);
            }
            Element element = new Element(key, value);
            cache.put(element);
        }
    
        public Object get(String cacheName, String key) {
            Cache cache = manager.getCache(cacheName);
            Element element = cache.get(key);
            return element == null ? null : element.getObjectValue();
        }
    
        public Cache get(String cacheName) {
            Cache cache = manager.getCache(cacheName);
            if (cache==null){
                cache=new Cache(cacheName, 1, false, false, 0, 0);
                manager.addCache(cache);
            }
            return manager.getCache(cacheName);
        }
    
        public void remove(String cacheName, String key) {
            Cache cache = manager.getCache(cacheName);
            cache.remove(key);
        }
    展开全文
  • 使用Encache进行缓存存取的工具类,java中使用,配置好配置文件就可以使用
  • Encache 简介

    2014-06-03 21:30:06
    1. EHCache 的特点,是一个纯Java ,过程中(也可以理解成插入式)缓存实现,单独安装Ehcache ,需把ehcache-X.X.jar 和相关类库方到classpath中。如项目已安装了Hibernate ,则不需要做什么。...
    转自: http://sishuok.com/forum/posts/list/315.html
    

    1. EHCache 的特点,是一个纯Java ,过程中(也可以理解成插入式)缓存实现,单独安装Ehcache ,需把ehcache-X.X.jar 和相关类库方到classpath中。如项目已安装了Hibernate ,则不需要做什么。。直接可以使用Ehcache

    Cache 存储方式 :内存或磁盘

    2. 单独使用 EHCache

    使用CacheManager 创建并管理Cache
    1.创建CacheManager有4种方式:


    A:使用默认配置文件创建

    CacheManager manager = CacheManager.create(); 



    B:使用指定配置文件创建
    CacheManager manager = CacheManager.create("src/config/ehcache.xml");  



    C:从classpath中找寻配置文件并创建




    URL url = getClass().getResource("/anothername.xml");
    CacheManager manager = CacheManager.create(url);



    D:通过输入流创建



    InputStream fis = new FileInputStream(new File("src/config/ehcache.xml").getAbsolutePath());
    try {
    manager = CacheManager.create(fis);
    } finally {
    fis.close();
    }




    卸载CacheManager ,关闭Cache

    manager.shutdown();  





    使用Caches

    取得配置文件中预先 定义的sampleCache1设置,通过CacheManager生成一个Cache




    Cache cache = manager.getCache("sampleCache1"); 




    设置一个名为test 的新cache,test属性为默认

    CacheManager manager = CacheManager.create();   
    manager.addCache("test");




    设置一个名为test 的新cache,并定义其属性



    java代码: 查看复制到剪贴板打印
    CacheManager manager = CacheManager.create();   
    Cache cache = new Cache("test", 1, true, false, 5, 2);
    manager.addCache(cache);



    往cache中加入元素

    Element element = new Element("key1", "value1");
    cache.put(new Element(element);




    从cache中取得元素

    Element element = cache.get("key1");





    所以大概步骤为:
    第一步:生成CacheManager对象
    第二步:生成Cache对象
    第三步:向Cache对象里添加由key,value组成的键值对的Element元素

    具体一个Test.java程序:

    package test;   

    import net.sf.ehcache.Cache;
    import net.sf.ehcache.CacheManager;
    import net.sf.ehcache.Element;
    /**
    * 第一步:生成CacheManager对象
    * 第二步:生成Cache对象
    * 第三步:向Cache对象里添加由key,value组成的键值对的Element元素
    * @author mahaibo
    *
    */
    public class Test {

    public static void main(String[] args) {
    //指定ehcache.xml的位置
    String fileName="E:\\1008\\workspace\\ehcachetest\\ehcache.xml";
    CacheManager manager = new CacheManager(fileName);
    //取出所有的cacheName
    String names[] = manager.getCacheNames();
    for(int i=0;i<names.length;i++){
    System.out.println(names[i]);
    }
    //根据cacheName生成一个Cache对象
    //第一种方式:
    Cache cache=manager.getCache(names[0]);

    //第二种方式,ehcache里必须有defaultCache存在,"test"可以换成任何值
    // Cache cache = new Cache("test", 1, true, false, 5, 2);
    // manager.addCache(cache);

    //向Cache对象里添加Element元素,Element元素有key,value键值对组成
    cache.put(new Element("key1","values1"));
    Element element = cache.get("key1");

    System.out.println(element.getValue());
    Object obj = element.getObjectValue();
    System.out.println((String)obj);
    manager.shutdown();


    }


    }
    展开全文
  • 在网上找了很久的jar包,要不就是少这个,要不就是少那个,这次一次性收集全
  • encache缓存网页

    2016-11-27 11:46:05
    这是关于encache缓存页面的简单介绍,不对其进行深究。
  • apache shiro 与 encache

    2018-11-05 14:44:19
    这里可以使用encache缓存权限数据,注入对象后就不用再管了。   使用ehcache缓存权限数据 ehcache是专门缓存插件,可以缓存Java对象,提高系统性能。 ehcache提供的jar包: 第一步:在pom.xml文件...
  • springmvc和encache集成

    2017-11-20 17:11:00
    虽然目前已经出了 ehcache3.x 了,但是,结合我搜索到的资料,我依旧只能先采用 ehcache2.x 来使用了 首先,在pom 中引入jar &lt;dependency&gt; &lt;groupId&gt;net.sf.ehcache&.../artif...
  • 具体来说,EnCache主要的特性如下。 快速。 简单。 多种缓存策略。 缓存数据有内存和磁盘两级,无须担心容量问题。 缓存数据会在虚拟机重启的过程中写入磁盘。 可以通过rmi、可插入API等方式进行分布式缓存。 ...
  • shiro集成encache

    2015-03-03 11:10:00
    针对多频次或者几乎不变的大数量的数据,我们可以通过缓存来实现,具体的比如说权限认证,这个,每次操作都需要权限认证,所以,这里添加encache注解。具体的认证过程是: 1,用户第一次访问用户权限信息,调用...
  • encache 1 1 1 3 1 5 jar包

    2014-09-17 21:30:20
    压缩包里有encache-1.1.jar encache-1.3.jar encache-1.5.jar三个jar包
  • encache学习教程

    2016-03-30 10:45:00
    http://www.cnblogs.com/hoojo/archive/2012/07/12/2587556.html 转载于:https://www.cnblogs.com/dongqiSilent/p/5336190.html
  • 缓存之encache

    2015-12-23 09:33:37
    encache的使用: http://sishuok.com/forum/posts/list/315.html Hibernate缓存: http://sishuok.com/forum/posts/list/275.html#394
  • Encache配置

    2020-06-23 21:03:40
    缓存的配置,可以将Cache的配置从代码中剥离出来,通过encache.xml文件的形式配置。 这样做有一下几个好处: 1、在同一个地方配置所有的Cache,这样很容易管理Cache的内存和磁盘消耗。 2、发布时可更改Cache配置。 ...
  • 包含Redis,memcache,encache的NoSQL入门
  • 里面有两个xsd文件,springmodules-ehcache和springmodules-cache.xsd。需求:因为有时候在你在xml中用某个标签时,提示错误,有时候就是少了xsd的引入
  • SprongBoot访问EnCache

    2021-11-04 17:25:29
    EhCache是常用的缓存框架 可以通过配置文件ehcache.xml生成EhCache-CacheManager Spring Boot配置文件内容如下 spring: datasource: url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&...
  • encache整合spring应用实例

    千次阅读 2013-02-21 17:47:55
    缓存热点数据是提高访问效率的重要手段之一,下面我用encache演示下如何做service层的数据缓存 先写个方法拦截器,当然要先继承MethodInterceptor,encache的标识key我是将参数序列成json字符   可能强制部分会影响...
  • http://www.blogjava.net/libin2722/articles/406569.html
  • 同Caffeine和Guava Cache相比,Encache的功能更加丰富,扩展性更强: 支持多种缓存淘汰算法,包括LRU、LFU和FIFO 缓存支持堆内存储、堆外存储、磁盘存储(支持持久化)三种 支持多种集群方案,解决数据共享问题 ...
  • JVM缓存encache在JVM缓存中有一个经常使用的缓存框架,就是encache,所以这里对encache进行一些介绍,本文是基于版本3.8来介绍一些新特性。encache主要由三个组件组成CacheManager、Cache和CacheConfiguration。单台...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,218
精华内容 487
关键字:

encache