`
kong0itey
  • 浏览: 304709 次
社区版块
存档分类
最新评论

ehcache缓存管理

    博客分类:
  • java
 
阅读更多

EHCache 是一个纯java的,在Hibernate2.1充当可插入的的在进程中的缓存,它具有以下缓存,最小的依赖性,全面的文特性:快速,简单,丰富的文档和测试用例。

     官方网站 http://ehcache.sourceforge.net/  


     ehcache-1.2 cacheNames 列表的取得;

     方法一:

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

     方法二:

  1. CacheManager manager =  new  CacheManager();   
  2. String[] cacheNames = manager.getCacheNames();  

     方法三:

  1. CacheManager manager1 =  new  CacheManager( 'src/config/ehcache1.' );   
  2. CacheManager manager2 =  new  CacheManager( 'src/config/ehcache2.xml' );   
  3. String[] cacheNamesForManager1 = manager1.getCacheNames();   
  4. String[] cacheNamesForManager2 = manager2.getCacheNames();  


     ehcache-1.2 管理器各种建立的方法:

     方法一:

  1. CacheManager manager =  new  CacheManager();  

     方法二:

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

     方法三:

  1. URL url = getClass().getResource( '/anotherconfigurationname.xml' );   
  2. CacheManager manager =  new  CacheManager(url);  

     方法四:

  1. InputStream fis =  new  FileInputStream( new  File( 'src/config/ehcache.xml' ).getAbsolutePath());   
  2. try  {   
  3.     CacheManager manager =  new  CacheManager(fis);   
  4. finally  {   
  5.     fis.close();   
  6. }  


     添加和删除缓存元素

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

  1. CacheManager singletonManager = CacheManager.create();   
  2. singletonManager.addCache( 'testCache' );   
  3. Cache test = singletonManager.getCache( 'testCache' );  

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

  1. CacheManager singletonManager = CacheManager.create();   
  2. Cache memoryOnlyCache =  new  Cache( 'testCache' 5000 false false 5 2 );   
  3. manager.addCache(memoryOnlyCache);   
  4. Cache test = singletonManager.getCache( 'testCache' );  


        
         Cache 属性说明:

             构造函数:
             public Cache(java.lang.String name,
                          int maxElementsInMemory,
                          boolean overflowToDisk,
                          boolean eternal,
                          long timeToLiveSeconds,
                          long timeToIdleSeconds)

             参数说明:
             name                           - 元素名字。
                 maxElementsInMemory            - 设定内存中创建对象的最大值。
                 overflowToDisk                 - 设置当内存中缓存达到 maxInMemory 限制时元素是否可写到磁盘
                                                        上。
                 eternal                        - 设置元素(译注:内存中对象)是否永久驻留。如果是,将忽略超
                                                       时限制且元素永不消亡。
                 timeToIdleSeconds              - 设置某个元素消亡前的停顿时间。
                                                       也就是在一个元素消亡之前,两次访问时间的最大时间间隔值。
                                                       这只能在元素不是永久驻留时有效(译注:如果对象永恒不灭,则
                                                       设置该属性也无用)。
                                                       如果该值是 0 就意味着元素可以停顿无穷长的时间。
                 timeToLiveSeconds              - 为元素设置消亡前的生存时间。
                                                        也就是一个元素从构建到消亡的最大时间间隔值。
                                                        这只能在元素不是永久驻留时有效。

         删除缓存元素:

  1. CacheManager singletonManager = CacheManager.create();   
  2. singletonManager.removeCache( 'test' );  


     关闭缓存管理器 CacheManager

  1. CacheManager.getInstance().shutdown();  


     对于缓存对象的操作:
         放入一个简单的对象到缓存元素;

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. Element element =  new  Element( 'key1' 'value1' );   
  3. cache.put(element);  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. Element element = cache.get( 'key1' );   
  3. Serializable value = element.getValue();  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. Element element = cache.get( 'key1' );   
  3. Object value = element.getObjectValue();  

         删除一个对象从元素;

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. Element element =  new  Element( 'key1' 'value1'   
  3. cache.remove( 'key1' );  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. cache.flush();  


     获得缓存大小:
         得到缓存的对象数量;

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. int  elementsInMemory = cache.getSize();  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. long  elementsInMemory = cache.getMemoryStoreSize();  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. long  elementsInMemory = cache.getDiskStoreSize();  

     关于缓存的读取和丢失的记录
         得到缓存读取的命中次数;

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. int  hits = cache.getHitCount();  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. int  hits = cache.getMemoryStoreHitCount();  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. int  hits = cache.getDiskStoreCount();  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. int  hits = cache.getMissCountNotFound();  

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

  1. Cache cache = manager.getCache( 'sampleCache1' );   
  2. int  hits = cache.getMissCountExpired();  

--------------------------
----------简单例子------------
--------------------------

     实战:
         XML文件格式:

  1.   maxElementsInMemory = '10000'   
  2.   eternal = 'false'   
  3.   timeToIdleSeconds = '120'   
  4.   timeToLiveSeconds = '120'   
  5.   overflowToDisk = 'true'   
  6.   diskPersistent = 'false'   
  7.   diskExpiryThreadIntervalSeconds = '120'   
  8.   memoryStoreEvictionPolicy = 'LRU'   
  9.   />   
  10.               maxElementsInMemory = '10000'   
  11. eternal = 'false'   
  12. overflowToDisk = 'true'   
  13. timeToIdleSeconds = '2'   
  14. timeToLiveSeconds = '3'   
  15. memoryStoreEvictionPolicy = 'LFU'   
  16.   />   


     源码:

  1. import  java.io.Serializable;   
  2.   
  3. import  net.sf.ehcache.Cache;   
  4. import  net.sf.ehcache.CacheManager;   
  5. import  net.sf.ehcache.Element;   
  6.   
  7. /**  
  8.  #############################################################################  
  9.  # DESCRIBE ehcache 缓存操作DEMO  
  10.  # AUTHOR    悠~游  
  11.  # DATE      2006-7-10  
  12.  # COMPANY   FLX  
  13.  # PORJECT   ehcache-demo  
  14.  #############################################################################  
  15.  */   
  16.   
  17. public   class  Demo {   
  18.       
  19.      static  CacheManager manager=  new  CacheManager();   
  20.   
  21.      /**  
  22.      *##############################################################################  
  23.      *   
  24.      * @DESCRIBE      
  25.      * @param args  
  26.      * @throws InterruptedException  
  27.      *                           
  28.      *##############################################################################  
  29.      */   
  30.      public   static   void  main(String[] args)  throws  InterruptedException {   
  31.           
  32.         String[] cacheNames = manager.getCacheNames();   
  33.         System.out.println( '读取的缓存列表为:' );   
  34.          for ( int  i= 0 ;i                     System.out.println( '-- ' +(i+ 1 )+ ' ' +cacheNames[i]);   
  35.         }   
  36.           
  37.         Cache cache = manager.getCache( 'cache1' );   
  38.         Element element =  new  Element( 'key1' 'value1' );   
  39.         cache.put(element);   
  40.           
  41.         element = cache.get( 'key1' );   
  42.         Serializable value = element.getValue();   
  43.         System.out.println( '序列化后的值为:' +value.toString());   
  44.   
  45.         element = cache.get( 'key1' );   
  46.         Object value1 = element.getObjectValue();   
  47.         System.out.println( '未序列化的值为:' +value1.toString());   
  48.           
  49.          int  elementsInMemory = cache.getSize();   
  50.         System.out.println( '得到缓存的对象数量:' +elementsInMemory);   
  51.           
  52.          long  elementsInMemory1 = cache.getMemoryStoreSize();   
  53.         System.out.println( '得到缓存对象占用内存的数量:' +elementsInMemory1);   
  54.           
  55.          long  elementsInMemory2 = cache.getDiskStoreSize();   
  56.         System.out.println( '得到缓存对对象占用磁盘的数量:' +elementsInMemory2);           
  57.           
  58.          int  hits = cache.getHitCount();   
  59.         System.out.println( '得到缓存读取的命中次数:' +hits);           
  60.           
  61.          int  hits1 = cache.getMemoryStoreHitCount();   
  62.         System.out.println( '得到内存中缓存读取的命中次数:' +hits1);           
  63.           
  64.          int  hits2 =cache.getDiskStoreHitCount();   
  65.         System.out.println( '得到磁盘中缓存读取的命中次数:' +hits2);           
  66.           
  67.          int  hits3 = cache.getMissCountNotFound();   
  68.         System.out.println( '得到缓存读取的丢失次数:' +hits3);           
  69.           
  70.          int  hits4 = cache.getMissCountExpired();   
  71.         System.out.println( '得到缓存读取的已经被销毁的对象丢失次数:' +hits4);       
  72.     }  
分享到:
评论

相关推荐

    ehcache二级缓存配置文件

    2. 在Spring配置文件中配置Ehcache缓存管理器。 3. 在需要缓存的方法或类上添加`@Cacheable`、`@CacheEvict`等注解。 4. 可选:配置缓存切面,如`@EnableCaching`。 **5. 性能优化** - 选择合适的缓存策略(LRU、...

    cache/ehcache缓存使用

    本文将详细讲解"cache/ehcache缓存使用"的相关知识点,包括缓存的基本概念、Ehcache的介绍、以及如何在Java应用中使用Ehcache进行缓存操作。 首先,我们要理解什么是缓存。缓存是一种存储技术,它临时存储常用或...

    EHCache缓存技术介绍

    【EHCache缓存技术介绍】 缓存技术是提高软件系统性能的重要手段,特别是在处理大量数据时,通过将常用数据存储在内存中,可以显著减少对硬盘或数据库的访问,从而加快数据获取速度。EHCache是一种广泛使用的开源...

    Ehcache缓存

    **Ehcache缓存** Ehcache是一种广泛使用的开源Java分布式缓存系统,它为高性能应用程序提供了内存存储和缓存解决方案。在Java世界中,尤其是在持久化框架如Hibernate的使用中,Ehcache扮演了至关重要的角色。由于...

    mybatis添加ehcache缓存支持

    为了提高性能和减少对数据库的直接访问,MyBatis 提供了缓存功能,而Ehcache 是一个广泛使用的开源Java缓存库,可以集成到MyBatis 中以实现高效的缓存管理。 在MyBatis 中添加Ehcache 缓存支持,首先需要确保项目...

    springboot整合Ehcache组件,轻量级缓存管理

    Ehcache缓存简介 1、基础简介 EhCache是一个纯Java的进程内缓存框架,具有快速、上手简单等特点,是Hibernate中默认的缓存提供方。 2、Hibernate缓存 Hibernate三级缓存机制简介: 一级缓存:基于Session级别分配...

    EHcache缓存框架

    **EHcache缓存框架** EHcache是一款开源的Java缓存框架,它被广泛应用于提高应用程序的性能和响应速度,通过存储频繁访问的数据到内存中,避免了每次请求时都进行昂贵的数据库查询。EHcache的设计目标是轻量级、高...

    Spring 与Ehcache实现基于方法的缓存

    首先,我们需要理解Spring的AOP概念,AOP允许我们定义横切关注点,如日志、事务管理或,正如在这个案例中,缓存管理。Spring通过代理模式实现了AOP,可以自动在目标方法调用前后执行特定的逻辑,这为我们实现方法...

    javaWeb中Ehcache缓存配置说明

    通过上述对Ehcache缓存配置的深入解析,我们可以看到,合理配置Ehcache不仅可以显著提升JavaWeb应用的性能,还能有效管理资源,避免不必要的系统负担。掌握这些关键配置项的含义及用法,对于优化应用、提升用户体验...

    ehcache缓存的jar包和配置文件

    - 缓存管理器(Cache Manager):它是Ehcache的核心,负责创建和管理多个缓存。 - 缓存(Cache):每个缓存都有一个唯一的名称,用于存储键值对。键必须是唯一的,而值可以是任何对象。 - 键(Key)与值(Value)...

    ehcache缓存依赖的jar

    "ehcache缓存依赖的jar"这个标题暗示我们将讨论Ehcache的核心库及其依赖关系。 Ehcache的核心JAR文件是`ehcache.jar`,它包含了Ehcache的所有核心组件和接口。这个文件提供了缓存管理、缓存配置、缓存策略(如LRU、...

    ehcache项目缓存技术

    3. **创建缓存管理器**:在代码中通过`CacheManager`初始化缓存管理器。 4. **获取和操作缓存**:使用`Cache`对象进行数据的存取,如`cache.put(key, value)`和`cache.get(key)`。 5. **监控和优化**:Ehcache提供...

    基于SpringBoot+Layui搭建的学生管理系统源码,融合shiro安全框架和Ehcache缓存框架.zip

    基于SpringBoot+Layui搭建的学生管理系统源码,融合shiro安全框架和Ehcache缓存框架.zip基于SpringBoot+Layui搭建的学生管理系统源码,融合shiro安全框架和Ehcache缓存框架.zip 【备注】 该项目是个人毕设项目,...

    Java流行ehcache缓存

    - **类层次模型**:Ehcache的缓存管理基于层次结构,每个层级都可以有自己的缓存策略。 - **缓存对象**:使用`<cache>`元素定义具体的缓存对象,如网页、数据段等。 - **缓存操作**:通过`put()`、`get()`、`...

    Spring Boot的EhCache缓存使用.docx

    默认情况下,Spring Boot的`@EnableCaching`注解会使用`ConcurrentHashMap`作为基本的缓存管理器。然而,对于生产环境,我们通常需要更强大的缓存解决方案,如EhCache。EhCache是一个开源、内存级别的缓存框架,提供...

    ehcache 缓存

    **Ehcache缓存系统详解** Ehcache是一款开源、高性能、轻量级的Java缓存框架,广泛应用于各种Java应用程序中,以提高数据访问速度并降低数据库负载。它的核心特性包括内存缓存、磁盘存储和分布式缓存,使得在大数据...

    Hibernate中二级缓存ehcache缓存案例

    一级缓存是SessionFactory级别的,它是自动管理的,每个Session内部都有一个一级缓存;而二级缓存则是SessionFactory级别的,可以跨Session共享数据,从而进一步优化性能。 **二级缓存ehcache** ehcache是...

    ehcache缓存页面.doc

    **标题解析:** "ehcache缓存页面.doc" 这个标题表明了文档内容主要关于Ehcache,一个广泛使用的Java缓存库,用于提高应用程序性能。它可能详细介绍了Ehcache如何被用来缓存页面内容,以减少数据库查询和提升响应...

    ehcache缓存入门项目

    在Spring框架中,可以利用`@Cacheable`、`@CacheEvict`和`@CacheConfig`注解实现自动缓存管理。例如: ```java @Cacheable(value = "myCache", key = "#id") public User getUser(String id) { // ... } ``` ...

    Spring+EhCache缓存实例

    **Spring+EhCache缓存实例详解** 在现代的Java企业级应用中,缓存技术扮演着至关重要的角色,它能够显著提升系统性能,减少数据库负载。Spring框架与EhCache的结合,为开发者提供了一种高效、易用的缓存解决方案。...

Global site tag (gtag.js) - Google Analytics