EhCache使用详细介绍

转载 2012年03月31日 16:28:11

原文网址:http://www.360doc.com/content/10/1011/11/2560742_60066155.shtml

Ehcache中不仅可以用配置文件来配置缓存,而在代码中也可以实现同样的功能。
CacheManager singletonManager = CacheManager.create();
Cache memoryOnlyCache = new Cache(“testCache”, 50000, false, false, 8, 2);
Cache test = singletonManager.getCache(“testCache”);
删除只需要调用singletonManager.removeCache(“testCache”);
Shotdown CacheManager
在使用完Ehcache后,必须要shutdown缓存。Ehcache中有自己的关闭机制,不过最好在你的代码中显示调用CacheManager.getInstance().shutdown();

1.EhCache是什么
    EhCache是Hibernate的二级缓存技术之一,可以把查询出来的数据存储在内存或者磁盘,节省下次同样查询语句再次查询数据库,大幅减轻数据库压力;

2.EhCache的使用注意点
    当用Hibernate的方式修改表数据(save,update,delete等等),这时EhCache会自动把缓存中关于此表的所有缓存全部删除掉(这样能达到同步)。但对于数据经常修改的表来说,可能就失去缓存的意义了(不能减轻数据库压力);

3.EhCache使用的场合
    3.1比较少更新表数据
        EhCache一般要使用在比较少执行write操作的表(包括update,insert,delete等)[Hibernate的二级缓存也都是这样];
    3.2对并发要求不是很严格的情况
        两台机子中的缓存是不能实时同步的;

4.在项目做的实现
    4.1在工程的src目录下添加ehcache.xml文件,内容如下:
        <?xml version="1.0" encoding="UTF-8"?>
        <ehcache>    
            <diskStore path="java.io.tmpdir" />
          <defaultCache maxElementsInMemory="5"<!--缓存可以存储的总记录量-->
            eternal="false"<!--缓存是否永远不销毁-->
            overflowToDisk="true"<!--当缓存中的数据达到最大值时,是否把缓存数据写入磁盘-->
            timeToIdleSeconds="15"<!--当缓存闲置时间超过该值,则缓存自动销毁-->
                timeToLiveSeconds="120"<!--缓存创建之后,到达该缓存自动销毁-->
          />
        </ehcache>
    4.2在Hibernate.cfg.xml中的mapping标签上面加以下内容:

        <property name="show_sql">true</property>
        <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
        <property name="hibernate.cache.use_query_cache">true</property>
    4.3在要缓存的bean的hbm.xml文件中的class标签下加入以下内容:
       <cache usage="read-only" /><!--也可读写-->
    4.4创建DAO,内容如下:
        Session s = HibernateSessionFactory.getSession();
        Criteria c = s.createCriteria(Xyz.class);
        c.setCacheable(true);//这句必须要有
        System.out.println("第一次读取");
        List l = c.list();
        System.out.println(l.size());
        HibernateSessionFactory.closeSession();

        s = HibernateSessionFactory.getSession();
        c = s.createCriteria(Xyz.class);
        c.setCacheable(true);//这句必须要有
        System.out.println("第二次读取");
        l = c.list();
        System.out.println(l.size());
        HibernateSessionFactory.closeSession();
   4.5这时你会看到打印出来的信息为(表示第二次并没有去读库):
        第一次读取
        Hibernate: *******
        13
        第二次读取
        13

配置Spring+hibernate使用ehcache作为second-level cache

大量数据流动是web应用性能问题常见的原因,而缓存被广泛的用于优化数据库应用。cache被设计为通过保存从数据库里load的数据来减少应用和数据库之间的数据流动。数据库访问只有当检索的数据不在cache里可用时才必要。hibernate可以用两种不同的对象缓存:first-level cache 和 second-level cache。first-level cache和Session对象关联,而second-level cache是和Session Factory对象关联。

        缺省地,hibernate已经使用基于每个事务的first-level cache。 Hibernate用first-level cache主要是减少在一个事务内的sql查询数量。例如,如果一个对象在同一个事务内被修改多次,hibernate将只生成一个包括所有修改的 UPDATE SQL语句。为了减少数据流动,second-level cache在Session Factory级的不同事务之间保持load的对象,这些对象对整个应用可用,不只是对当前用户正在运行的查询。这样,每次查询将返回已经load在缓存里的对象,避免一个或更多潜在的数据库事务。

下载ehcache,hibernate3.2必须要ehcache1.2以上才能支持。可以修改log4j配置文件log4j.logger.net.sf.hibernate.cache=debug查看日志

1.在类路径上ehcache.xml:

<ehcache>

     <!-- Sets the path to the directory where cache .data files are created.

          If the path is a Java System Property it is replaced by
          its value in the running VM.

          The following properties are translated:
          user.home - User's home directory
          user.dir - User's current working directory
          java.io.tmpdir - Default temp file path -->
     <diskStore path="java.io.tmpdir"/>


     <!--Default Cache configuration. These will applied to caches programmatically created through
         the CacheManager.

         The following attributes are required:

         maxElementsInMemory             - Sets the maximum number of objects that will be created in memory
         eternal                         - Sets whether elements are eternal. If eternal,   timeouts are ignored and the
                                          element is never expired.
         overflowToDisk                  - Sets whether elements can overflow to disk when the in-memory cache
                                          has reached the maxInMemory limit.

         The following attributes are optional:
         timeToIdleSeconds               - Sets the time to idle for an element before it expires.
                                          i.e. The maximum amount of time between accesses before an element expires
                                          Is only used if the element is not eternal.
                                          Optional attribute. A value of 0 means that an Element can idle for infinity.
                                          The default value is 0.
         timeToLiveSeconds               - Sets the time to live for an element before it expires.
                                          i.e. The maximum time between creation time and when an element expires.
                                          Is only used if the element is not eternal.
                                          Optional attribute. A value of 0 means that and Element can live for infinity.
                                          The default value is 0.
         diskPersistent                  - Whether the disk store persists between restarts of the Virtual Machine.
                                          The default value is false.
         diskExpiryThreadIntervalSeconds- The number of seconds between runs of the disk expiry thread. The default value
                                          is 120 seconds.
         -->

     <defaultCache
         maxElementsInMemory="10000"
         eternal="false"
         overflowToDisk="true"
         timeToIdleSeconds="120"
         timeToLiveSeconds="120"
         diskPersistent="false"
         diskExpiryThreadIntervalSeconds="120"/>
        
     <!-- See http://ehcache.sourceforge.net/documentation/#mozTocId258426 for how to configure caching for your objects -->
</ehcache>

2.applicationContext-hibernate.xml里Hibernate SessionFactory配置:

     <!-- Hibernate SessionFactory -->
     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
         <property name="dataSource" ref="dataSource"/>
         <property name="configLocation"><value>classpath:hibernate.cfg.xml</value></property>
         <!-- The property below is commented out b/c it doesn't work when run via
              Ant in Eclipse.   It works fine for individual JUnit tests and in IDEA ??
         <property name="mappingJarLocations">
             <list><value>file:dist/appfuse-dao.jar</value></list>
         </property>
         -->
         <property name="hibernateProperties">
             <props>
                 <prop key="hibernate.dialect">@HIBERNATE-DIALECT@</prop>
                 <!--<prop key="hibernate.show_sql">true</prop>-->
                 <prop key="hibernate.max_fetch_depth">3</prop>
                 <prop key="hibernate.hibernate.use_outer_join">true</prop>
                 <prop key="hibernate.jdbc.batch_size">10</prop>
                 <prop key="hibernate.cache.use_query_cache">true</prop>
                 <prop key="hibernate.cache.use_second_level_cache">true</prop>
                 <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
                 <!--
                 <prop key="hibernate.use_sql_comments">false</prop>
                 -->
                 <!-- Create/update the database tables automatically when the JVM starts up
                 <prop key="hibernate.hbm2ddl.auto">update</prop> -->
                 <!-- Turn batching off for better error messages under PostgreSQL
                 <prop key="hibernate.jdbc.batch_size">0</prop> -->
             </props>
         </property>
         <property name="entityInterceptor">
            <ref local="auditLogInterceptor"/>
         </property>
     </bean>
说明:如果不设置“查询缓存”,那么hibernate只会缓存使用load()方法获得的单个持久化对象,如果想缓存使用findall()、 list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集的话,就需要设置 hibernate.cache.use_query_cache true 才行

3.model类里采用Xdoclet生成*.hbm.xml里的cache xml标签,即<cache usage="read-only"/>

/**
* @hibernate.class table="WF_WORKITEM_HIS"
* @hibernate.cache usage="read-write"
*
*/

4.对于"query cache",需要在程序里编码:

         getHibernateTemplate().setCacheQueries(true);
         return getHibernateTemplate().find(hql);

 

 

使用spring和hibernate配置ehcache和query cache
1、applicationContext.xml
<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
<prop key="hibernate.cache.use_query_cache">true</prop>

这两句加到hibernateProperties中
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
   <ref bean="sessionFactory" />
</property>
<property name="cacheQueries">
   <value>true</value>
</property>
</bean>

添加此bean到applicationcontext.xml中。在各个DAO的bean中,更改如下
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
改为
<property name="hibernateTemplate">
<ref bean="hibernateTemplate" />
</property>

2、ehcache.xml文件放在classes根目录即可

3、pojo与ehcache.xml的配置关系
以com.ce.ceblog.pojos.CeblogJournal为例子
在CeblogJournal.hbm.xml中配置:
<class name="CeblogJournal" table="CEBLOG_JOURNAL" lazy="false">
<cache usage="read-write" region="ehcache.xml中的name的属性值"/>
注意:这一句需要紧跟在class标签下面,其他位置无效。

Ehcache.xml文件主体如下
<defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="1" timeToLiveSeconds="1" overflowToDisk="true" />
<cache name="com.ce.ceblog.pojos.CeblogJournal" maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true" />
hbm文件查找cache方法名的策略:如果不指定hbm文件中的region="ehcache.xml中的name的属性值",则使用name名为 com.ce.ceblog.pojos.CeblogJournal的cache,如果不存在与类名匹配的cache名称,则用 defaultCache。
如果CeblogJournal包含set集合,则需要另行指定其cache
例如CeblogJournal包含ceblogReplySet集合,则需要
添加如下配置到ehcache.xml中
<cache name="com.ce.ceblog.pojos.CeblogJournal.ceblogReplySet"
maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="300"
timeToLiveSeconds="600" overflowToDisk="true" />

另,针对查询缓存的配置如下:
<cache name="org.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000"
eternal="true"
overflowToDisk="true"/>
<cache name="org.hibernate.cache.StandardQueryCache"
maxElementsInMemory="10000"
eternal="false"
timeToLiveSeconds="120"
overflowToDisk="true"/>

4、选择缓存策略依据:
<cache usage="transactional|read-write|nonstrict-read-write|read-only" />
ehcache不支持transactional,其他三种可以支持。
read- only:无需修改, 那么就可以对其进行只读 缓存,注意,在此策略下,如果直接修改数据库,即使能够看到前台显示效果,但是将对象修改至cache中会报error,cache不会发生作用。另:删 除记录会报错,因为不能在read-only模式的对象从cache中删除。
read-write:需要更新数据,那么使用读/写缓存 比较合适,前提:数据库不可以为serializable transaction isolation level(序列化事务隔离级别)
nonstrict-read-write:只偶尔需要更新数据(也就是说,两个事务同时更新同一记录的情况很不常见),也不需要十分严格的事务隔离,那么比较适合使用非严格读/写缓存策略。

5、调试时候使用log4j的log4j.logger.org.hibernate.cache=debug,更方便看到ehcache的操作过程,主要用于调试过程,实际应用发布时候,请注释掉,以免影响性能。

6、 使用ehcache,打印sql语句是正常的,因为query cache设置为true将会创建两个缓存区域:一个用于保存查询结果集 (org.hibernate.cache.StandardQueryCache);另一个则用于保存最近查询的一系列表的时间戳(org.hibernate.cache.UpdateTimestampsCache)。请注意:在查询缓存中,它并不缓存结果集中所包含的实体的确切状态;它只缓存这些实体的标识符属性的值、以及各值类型的结果。需要将打印sql语句与最近的cache内容相比较,将不同之处修改到cache中,所以查询缓存通常会和二级缓存一起使用。

 

 

 

 

Ehcache使用用例(一)

Singleton创建方式

 

Ehcache1.2版本之后,都可以使用singleton(工厂创建方法)去创建一个singleton的CacheManager实例。

 

CacheManager.create();

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

 

使用默认配置创建CacheManager

 

CacheManager manager = new CacheManager();

String[] cacheNames = manager.getCacheNames();

 

使用配置文件创建指定的CacheManager

 

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

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

String[] cacheNamesForManager1 = manager1.getCacheNames();

String[] cacheNamesForManager2 = manager2.getCacheNames();

 

配置文件加载方式

 

·   CacheManager manager = new CacheManager();会在classpath路径下找ehcache.xml配置文件。

 

·   CacheManager manager = new CacheManager(“src/config.ehcache.xml”); 也可以根据相对文件路径来加载配置文件.

 

·   通过URL加载

 

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

CacheManager manager = new CacheManager(url);

 

·   通过流加载

 

InputSream fis = new FileInputStream(new File(“src/config/ehcache.xml”).getAbsolutePath());

Try {

    CacheManager manager = new CacheManager(fis);

} finally {

    Fis.close();

}

 

编码实现添加和缓存

 

Ehcache中不仅可以用配置文件来配置缓存,而在代码中也可以实现同样的功能。

 

CacheManager singletonManager = CacheManager.create();

Cache memoryOnlyCache = new Cache(“testCache”, 50000, false, false, 8, 2);

Cache test = singletonManager.getCache(“testCache”);

 

删除只需要调用singletonManager.removeCache(“testCache”);

 

Shotdown CacheManager

 

在使用完Ehcache后,必须要shutdown缓存。Ehcache中有自己的关闭机制,不过最好在你的代码中显示调用CacheManager.getInstance().shutdown();

 

 

Ehcache使用实例(二)

Cache使用

 

l          得到一个Cache引用

 

获得一个sampleCache1的引用,从官方下载ehcache.xml,在ehcache.xml中已经有配置好的缓存,大家直接使用就可以,或是做测试,如果说真正使用的时候,最后自己手动配置一个比较好。

 

Cache cache = manager.getCache(“sampleCache1”);

 

l          使用Cache

 

Put一个Element到cache中

 

Cache cache = manager.getCache(“sampleCache1”);

Element element = new Element(“key1”,”value1”);

cache.put(element);

 

update一个element时,只要在构造element时将相同的key传入,在调用cache.put(element),这是Ehcache会根据key到缓存中找到对应的element并做更新。

 

Cache cache = manager.getCache(“sampleCache1”);

Cache.put(new Element(“key1”, “value1”));

//更新element

Cache.put(new Element(“key1”, “value2”));

 

根据key取得对应element的序列化value值

 

 

Cache cache = manager.getCache(“sampleCache1”);

Element element = cache.get(“key1”);

Serializable value = element.getValue();

 

根据key取得对应element的非序列化value值

 

Cache cache = manager.getcache(“samplecache1”);

Element element = cache.get(“key1”);

Ojbect value = element.getObjectValue();

 

从cache中移除key对应的element

 

Cache cache = manager.getCache(“sampleCache”);

Element element = new Element(“key1”, “value1”);

Cache.reomve(“key1”);

l          磁盘持久化

 

SampleCache1的配置是支持磁盘持久化的。如果想要保证element即时的被输出到磁盘,可以调用cache.flush();

 

Cache cache = manager.getcache(“samplecache1”);

Cache.flush();

 

l          Cache Sizes

 

获得当前cache中的element数量。

 

Cache cache = manager.getCache(“sampleCache1”);

Int elementsInMemory = cache.getSize();

 

获得当前MemoryStore中的element数量。

 

Cache cache = manager.getCache(“sampleCache1”);

long elementsInMemory = cache.getMemoryStoreSize();

 

获得当前DiskStore中element数量。

 

Cache cache = manager.getCache(“sampleCache1”);

long elementsInMemory = cache.getDiskStoreSize();

 

l          Cache Hits and Misses

 

所谓的hits就是缓存访问次数,而misses就是缓存中每个element的丢失次数。这些参数对优化缓存配置有很大的帮助。

 

获得缓存中请求的element被找到的次数。

 

Cache cache = manager.getCache(“sampleCache1”);

Int hits = cache.getHitCount();

 

获得请求的element在MemoryStore中被找到的次数。

 

Cache cache = manager.getCache(“sampleCache1”);

Int hits = cache.getMemoryStoreHitCount();

 

 

获得请求的element在DiskStore中被找到的次数。

 

Cache cache = manager.getCache(“sampleCache1”);

Int hits = cache.getDiskStoreHitCount();

 

获得请求的element在MemoryStore中没有被找到的次数。

 

Cache cache = manager.getCache(“sampleCache1”);

Int hits = cache.getMissCountNotFound();

 

 

获得请求的element在MemoryStore中没有被找到的次数。

 

Cache cache = manager.getCache(“sampleCache1”);

Int hits = cache.getMissCountNotFound();

 

获得缓存中失效element没有被找到的次数。

 

Cache cache = manager.getcache(“samplecache1”);

Int hits = cache.getMissCountExpired();

 

创建一个默认配置cache

 

manager.addCache(String cachename);这个方法可以说是Ehcache很灵活的体现,通常我们想要添加一个新的cache到CacheManager中时,应该调用manager.addCache(Cache cache);可以看到入参是一个Cache类型对象,而前面那段代码,Ehcache会自动使用默认配置创建一个名字为输出参数的cache供使用,是不是很方面呢。

 

使用自定义参数创建一个cache

 

Ehcache允许通过编码的方式创建一个自定义Cache,也就是调用构造方法。

 

Public Cache(String name, int maxElementsInMemory, MemoryStoreEvictionPolicy memoryStoreEvictionPolicy, Boolean overflowToDisk, Boolean eternal, long timeToLiveSeconds, long timeToIdleSeconds, Boolean isdkPersistent, long diskExpiryThreadIntervalSeconds) {}

 

以上就是Cache的构造函数。

CacheManager manager = CacheManager.create();

Cache cache = new Cache(“test”, maxElements, MemoryStoreEvictionPolicy.LFU, true, false, 60, 30, false, 0);

Manager.addCache(testCache);

 

以上代码是创建一个缓存添加到cachemanager中,缓存名字为test,内存驱逐策略是LFU,允许输出到磁盘,element不是永久有效的,element最大存活时间是60秒,element最大闲置时间30秒,不会持久化到磁盘,失效element清理线程运行时间间隔是0秒。

 

 

相关文章推荐

ehcache简介及配置

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

EhCache使用详细介绍

EhCache使用详细介绍 Ehcache中不仅可以用配置文件来配置缓存,而在代码中也可以实现同样的功能。 CacheManager singletonManager = CacheMa...

EhCache使用详细介绍

Ehcache中不仅可以用配置文件来配置缓存,而在代码中也可以实现同样的功能。 CacheManager singletonManager = CacheManager.create(); C...

Linux编辑器vi使用方法详细介绍

  • 2016年02月18日 13:41
  • 18KB
  • 下载

grep命令使用的详细介绍

1. grep简介 grep (global search regular expression(RE) and print out the line,全面搜索正则表达式并把行打印出来)...

dtree 使用详细介绍

  • 2011年09月02日 17:54
  • 4KB
  • 下载

详细介绍了IAR安装与使用

  • 2011年05月11日 14:58
  • 805KB
  • 下载

MySql模糊查询like通配符使用详细介绍

今天查线上数据问题的时候。遇到一个问题。从一个表查询like‘%type%’的时候。结果太多,不准确. 改成这种: msg_content like   '%:204,______:2%'。 转载...
  • bohu83
  • bohu83
  • 2016年07月13日 19:49
  • 322
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:EhCache使用详细介绍
举报原因:
原因补充:

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