ehcache二级缓存
⑴ java web寮鍙戠紦瀛樻柟妗堬纴ehcache鍜宺edis鍝涓镟村ソ
浣跨敤鍦烘櫙涓崭竴镙 , 涓嶅瓨鍦ㄥ摢涓镟村ソ, 鍙浠ュ幓寮婧愪腑锲 鐪嬩笅 绾㈣柉鏁欎富鍐欑殑 :
Java涓ょ骇缂揿瓨妗嗘灦 J2Cache
J2Cache 鏄 OSChina 鐩鍓嶆ｅ湪浣跨敤镄勪袱绾х紦瀛樻嗘灦銆傜涓绾х紦瀛树娇鐢 Ehcache锛岀浜岀骇缂揿瓨浣跨敤 Redis 銆傜敱浜庡ぇ閲忕殑缂揿瓨璇诲彇浼氩艰嚧 L2 镄勭绣缁沧垚涓烘暣涓绯荤粺镄勭摱棰堬纴锲犳 L1 镄勭洰镙囨槸闄崭绠瀵 L2 镄勮诲彇娆℃暟銆傝ョ紦瀛樻嗘灦涓昏佺敤浜庨泦缇ょ幆澧冧腑銆傚崟链轰篃鍙浣跨敤锛岀敤浜庨伩鍏嶅簲鐢ㄩ吨钖瀵艰嚧镄 Ehcache 缂揿瓨鏁版嵁涓㈠け銆
⑵ hibernate怎么实现缓存
一、why（为什么要用Hibernate缓存？）
Hibernate是一个持久层框架，经常访问物理数据库。
为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。
缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。
二、what（Hibernate缓存原理是怎样的？）Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存。
1.Hibernate一级缓存又称为“Session的缓存”。
Session内置不能被卸载，Session的缓存是事务范围的缓存（Session对象的生命周期通常对应一个数据库事务或者一个应用事务）。
一级缓存中，持久化类的每个实例都具有唯一的OID。
2.Hibernate二级缓存又称为“SessionFactory的缓存”。
由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。
第二级缓存是可选的，是一个可配置的插件，默认下SessionFactory不会启用这个插件。
Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器。
什么样的数据适合存放到第二级缓存中？
1) 很少被修改的数据
2) 不是很重要的数据，允许出现偶尔并发的数据
3) 不会被并发访问的数据
4) 常量数据
不适合存放到第二级缓存的数据？
1) 经常被修改的数据
2) 绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发
3) 与其他应用共享的数据。
3.Session的延迟加载实现要解决两个问题：正常关闭连接和确保请求中访问的是同一个session。
Hibernate session就是java.sql.Connection的一层高级封装，一个session对应了一个Connection。
http请求结束后正确的关闭session（过滤器实现了session的正常关闭）；延迟加载必须保证是同一个session（session绑定在ThreadLocal）。
4.Hibernate查找对象如何应用缓存？
当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；
查不到，如果配置了二级缓存，那么从二级缓存中查；
如果都查不到，再查询数据库，把结果按照ID放入到缓存删除、更新、增加数据的时候，同时更新缓存。
5.一级缓存与二级缓存的对比图。
一级缓存
二级缓存
存放数据的形式
相互关联的持久化对象
对象的散装数据
缓存的范围
事务范围，每个事务都拥有单独的一级缓存
进程范围或集群范围，缓存被同一个进程或集群范围内所有事务共享
并发访问策略
由于每个事务都拥有单独的一级缓存不会出现并发问题，因此无须提供并发访问策略
由于多个事务会同时访问二级缓存中的相同数据，因此必须提供适当的并发访问策略，来保证特定的事务隔离级别
数据过期策略
处于一级缓存中的对象永远不会过期，除非应用程序显示清空或者清空特定对象
必须提供数据过期策略，如基于内存的缓存中对象的最大数目，允许对象处于缓存中的最长时间，以及允许对象处于缓存中的最长空闲时间
物理介质
内存
内存和硬盘，对象的散装数据首先存放到基于内存的缓存中，当内存中对象的数目达到数据过期策略的maxElementsInMemory值，就会把其余的对象写入基于硬盘的缓存中
缓存软件实现
在Hibernate的Session的实现中包含
由第三方提供，Hibernate仅提供了缓存适配器，用于把特定的缓存插件集成到Hibernate中
启用缓存的方式
只要通过Session接口来执行保存，更新，删除，加载，查询，Hibernate就会启用一级缓存，对于批量操作，如不希望启用一级缓存，直接通过JDBCAPI来执行
用户可以再单个类或类的单个集合的粒度上配置第二级缓存，如果类的实例被经常读，但很少被修改，就可以考虑使用二级缓存，只有为某个类或集合配置了二级缓存，Hibernate在运行时才会把它的实例加入到二级缓存中
用户管理缓存的方式
一级缓存的物理介质为内存，由于内存的容量有限，必须通过恰当的检索策略和检索方式来限制加载对象的数目，Session的evit（）方法可以显示的清空缓存中特定对象，但不推荐
二级缓存的物理介质可以使内存和硬盘，因此第二级缓存可以存放大容量的数据，数据
过期策略的maxElementsInMemory属性可以控制内存中的对象数目，管理二级缓存主要包括两个方面：选择需要使用第二级缓存的持久化类，设
置合适的并发访问策略；选择缓存适配器，设置合适的数据过期策略。SessionFactory的evit（）方法也可以显示的清空缓存中特定对象，但不
推荐
三、how（Hibernate的缓存机制如何应用？）
1. 一级缓存的管理:
evit(Object obj) 将指定的持久化对象从一级缓存中清除,释放对象所占用的内存资源,指定对象从持久化状态变为脱管状态,从而成为游离对象。
clear() 将一级缓存中的所有持久化对象清除,释放其占用的内存资源。
contains(Object obj) 判断指定的对象是否存在于一级缓存中。
flush() 刷新一级缓存区的内容,使之与数据库数据保持同步。
2.一级缓存应用： save()。当session对象调用save()方法保存一个对象后，该对象会被放入到session的缓存中。
get()和load()。当session对象调用get()或load()方法从数据库取出一个对象后，该对象也会被放入到session的缓存中。
使用HQL和QBC等从数据库中查询数据。
public class Client
{
public static void main(String[] args)
{
Session session = HibernateUtil.getSessionFactory().openSession();
Transaction tx = null;
try
{
/*开启一个事务*/
tx = session.beginTransaction();
/*从数据库中获取id=""的Customer对象*/
Customer customer1 = (Customer)session.get(Customer.class, "");
System.out.println("customer.getUsername is"+customer1.getUsername());
/*事务提交*/
tx.commit();
System.out.println("-------------------------------------");
/*开启一个新事务*/
tx = session.beginTransaction();
/*从数据库中获取id=""的Customer对象*/
Customer customer2 = (Customer)session.get(Customer.class, "");
System.out.println("customer2.getUsername is"+customer2.getUsername());
/*事务提交*/
tx.commit();
System.out.println("-------------------------------------");
/*比较两个get()方法获取的对象是否是同一个对象*/
System.out.println("customer1 == customer2 result is "+(customer1==customer2));
}
catch (Exception e)
{
if(tx!=null)
{
tx.rollback();
}
}
finally
{
session.close();
}
}
}
结果
Hibernate:
select
customer0_.id as id0_0_,
customer0_.username as username0_0_,
customer0_.balance as balance0_0_
from
customer customer0_
where
customer0_.id=?
customer.getUsername islisi
-------------------------------------
customer2.getUsername islisi
-------------------------------------
customer1 == customer2 result is true
输出结果中只包含了一条SELECT SQL语句，而且customer1 == customer2 result is
true说明两个取出来的对象是同一个对象。其原理是：第一次调用get()方法，
Hibernate先检索缓存中是否有该查找对象，发现没有，Hibernate发送SELECT语句到数据库中取出相应的对象，然后将该对象放入缓存
中，以便下次使用，第二次调用get()方法，Hibernate先检索缓存中是否有该查找对象，发现正好有该查找对象，就从缓存中取出来，不再去数据库
中检索。
3.二级缓存的管理：
evict(Class arg0, Serializable arg1)将某个类的指定ID的持久化对象从二级缓存中清除,释放对象所占用的资源。
sessionFactory.evict(Customer.class, new Integer(1));
evict(Class arg0) 将指定类的所有持久化对象从二级缓存中清除,释放其占用的内存资源。
sessionFactory.evict(Customer.class);
evictCollection(String arg0) 将指定类的所有持久化对象的指定集合从二级缓存中清除,释放其占用的内存资源。
sessionFactory.evictCollection("Customer.orders");
4.二级缓存的配置
常用的二级缓存插件
EHCache org.hibernate.cache.EhCacheProvider
OSCache org.hibernate.cache.OSCacheProvider
SwarmCahe org.hibernate.cache.SwarmCacheProvider
JBossCache org.hibernate.cache.TreeCacheProvider
<!-- EHCache的配置,hibernate.cfg.xml -->
<hibernate-configuration>
<session-factory>
<!-- 设置二级缓存插件EHCache的Provider类-->
<property name="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
<!-- 启动"查询缓存" -->
<property name="hibernate.cache.use_query_cache">
true
</property>
</session-factory>
</hibernate-configuration>
<!-- ehcache.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<!--
缓存到硬盘的路径
-->
<diskStore path="d:/ehcache"></diskStore>
<!--
默认设置
maxElementsInMemory : 在内存中最大缓存的对象数量。
eternal : 缓存的对象是否永远不变。
timeToIdleSeconds ：可以操作对象的时间。
timeToLiveSeconds ：缓存中对象的生命周期，时间到后查询数据会从数据库中读取。
overflowToDisk ：内存满了，是否要缓存到硬盘。
-->
<defaultCache maxElementsInMemory="200" eternal="false"
timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></defaultCache>
<!--
指定缓存的对象。
下面出现的的属性覆盖上面出现的，没出现的继承上面的。
-->
<cache name="com.suxiaolei.hibernate.pojos.Order" maxElementsInMemory="200" eternal="false"
timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></cache>
</ehcache>
<!-- *.hbm.xml -->
<?xml version="1.0" encoding='UTF-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping>
<class>
<!-- 设置该持久化类的二级缓存并发访问策略 read-only read-write nonstrict-read-write transactional-->
<cache usage="read-write"/>
</class>
</hibernate-mapping>
若存在一对多的关系，想要在在获取一方的时候将关联的多方缓存起来，需要在集合属性下添加<cache>子标签，这里需要将关联的对象的hbm文件中必须在存在<class>标签下也添加<cache>标签，不然Hibernate只会缓存OID。
<hibernate-mapping>
<class name="com.suxiaolei.hibernate.pojos.Customer" table="customer">
<!-- 主键设置 -->
<id name="id" type="string">
<column name="id"></column>
<generator class="uuid"></generator>
</id>
<!-- 属性设置 -->
<property name="username" column="username" type="string"></property>
<property name="balance" column="balance" type="integer"></property>
<set name="orders" inverse="true" cascade="all" lazy="false" fetch="join">
<cache usage="read-only"/>
<key column="customer_id" ></key>
<one-to-many class="com.suxiaolei.hibernate.pojos.Order"/>
</set>
</class>
</hibernate-mapping>
⑶ encache.index鏂囦欢璁剧疆瀛樻斁璺寰
鍦ㄧ郴缁熸牴鐩褰曟湁涓 .FineReport110 鏂囦欢澶癸纴杩欎釜鐩褰曚笅镄勬墍链夋枃浠堕兘鏄链嶅姟鍣ㄧ敓鎴愮殑銆
鍏朵腑链変釜 ./ehcache_disk_store 鏂囦欢锛岀粡甯稿崰鐢ㄩ潪甯稿ぇ镄勭┖闂达纴瀵艰嚧镙圭洰褰曞緢瀹规槗灏辨弧浜嗭纴闾ｄ箞镐庝箞淇鏀 ./ehcache_disk_store 瀛樻斁璺寰勫憿锛
1.2 瀹炵幇镐濊矾
./ehcache_disk_store 閲屾斁镄勬槸涓ょ岖被鍨嬬殑缂揿瓨鏂囦欢锛屽垎鍒鏄锛氭暟鎹搴扑簩绾х紦瀛樸佹枃浠舵湇锷″櫒镄勭紦瀛
镎崭綔镞跺苟涓嶆槸鐩存帴淇鏀 ./ehcache_disk_store 镄勮矾寰勶纴钥屾槸鍒嗗埆淇鏀硅繖涓ょ岖紦瀛樻枃浠剁殑璺寰勚
2. 镎崭綔鏂规硶
2.1 淇鏀规暟鎹搴扑簩绾х紦瀛樿矾寰
鍦ㄥ伐绋嬬洰褰 WEB-INF/config 鏂囦欢澶逛笅鍒涘缓涓涓钖崭负 ehcache.db.properties 镄勬枃浠躲
鍏朵腑璺熸暟鎹搴扑簩绾х紦瀛樿矾寰勭浉鍏崇殑閰岖疆瑙佷笅锲炬嗗嚭𨱒ョ殑閮ㄥ垎锛屽彲镙规嵁鍦烘櫙瀹为檯杩涜屼慨鏀广
鏂囦欢閰岖疆椤瑰备笅锛
# 鏁版嵁搴揺hcache閰岖疆
# 鏄钖︾佺敤浜岀骇缂揿瓨锛岄粯璁や笉绂佺敤false
disableCache=false
# 鍫嗕腑链澶х紦瀛樼┖闂达纴榛樿256M
maxBytesLocalHeap=1G
# 缂揿瓨鏄钖﹀父椹伙纴true镞秚imeToIdleSecond鍜宼imeToLiveSecond镞犳晥锛岄粯璁false
eternal=false
# 浣跨敤钖庣殑绌洪棽镞堕棿锛岄粯璁120
timeToIdleSecond=120
# 鍒涘缓钖庣殑瀛樻椿镞堕棿锛岄粯璁120
timeToLiveSecond=120
# 缂揿瓨杩囨湡绛栫暐锛屽彇鍊糒RU锛孡FU锛孎IFO锛孋LOCK锛岄粯璁LRU
memoryStoreEvictionPolicy=LRU
# 绾跨▼妫镆ョ紦瀛樿秴镞剁殑闂撮殧镞堕棿锛岄粯璁120
=120
# 鎸佷箙鍖栫被鍨嬶纴鍙栧糒OCALTEMPSWAP锛娈ISTRIBUTED锛孡OCALRESTARTABLE锛孨ONE锛岄粯璁NONE
persistenceType=LOCALTEMPSWAP
# 鎸囧畾鏁版嵁搴扑簩绾х紦瀛樿矾寰
diskStore=C:\\Users\\root\\Desktop\\tmp\\db_cache
# 鎸佷箙鍖栧悓姝ュ啓鍏ワ纴榛樿false
persistenceSynchronousWrites=false
# 姣忛殧涓娈垫椂闂存竻鐞呜繃链熺紦瀛桡纴鍗曚綅绉掞纴榛樿60
recycleCacheMemoryInterval=60
# 姣忛殧涓娈垫椂闂磀ebug杈揿嚭缂揿瓨浣跨敤𨱍呭喌锛堜粎鍦ㄨ皟璇曟椂浣跨敤锛屽悓镞舵棩蹇楃骇鍒闇瑕佽皟镊矰EBUG锛夛纴鍗曚綅绉掞纴涓0镞朵笉寮钖锛岄粯璁0
reportCacheStatusInterval=0
2.2 淇鏀规枃浠舵湇锷″櫒缂揿瓨璺寰
鍦 FineDB 镄 fine_conf_entity 琛ㄤ腑鏂板炰互涓嬩袱涓瀛楁点傛柊澧炲瓧娈垫椂璇风洿鎺ヨ繛鎺ュ埌 FineDB 鍦ㄨ〃閲屾坠锷ㄤ慨鏀癸纴涓嶆敮鎸佷娇鐢 FINE_CONF_ENTITY鍙瑙嗗寲閰岖疆鎻掍欢 閰岖疆銆
FineDB 鏁版嵁搴撶被鍨嫔拰杩炴帴鏂规硶鍙傝佹枃妗ｏ细FineDB鏁版嵁搴撶亩浠
瀛楁 鍊
ResourceCacheConfig.persistenceStrategy LOCALTEMPSWAP
ResourceCacheManagerConfig.diskStorePath diskStore=C:\\Users\\root\\Desktop\\tmp\\resource_cache
⑷ spring3.2.2+hibernate 怎么集成ehcache
spring boot集成ehcache 2.x 用于hibernate二级缓存
spring boot集成ehcache 2x 用于hibernate二级缓存
项目依赖
Ehcache简介
hibernate二级缓存配置
ehcache配置文件
ehcache事件监听
注解方式使用二级缓存
完整代码
本文将介绍如何在spring boot中集成ehcache作为hibernate的二级缓存。各个框架版本如下
spring boot：1.4.3.RELEASE
spring framework: 4.3.5.RELEASE
hibernate：5.0.1.Final（spring-boot-starter-data-jpa默认依赖）
ehcache：2.10.3
项目依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<exclusions>
<exclusion>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.10.3</version>
</dependency>
Ehcache简介
ehcache是一个纯Java的缓存框架，既可以当做一个通用缓存使用，也可以作为将其作为hibernate的二级缓存使用。缓存数据可选择如下三种存储方案
MemoryStore – On-heap memory used to hold cache elements. This tier is subject to Java garbage collection.
OffHeapStore – Provides overflow capacity to the MemoryStore. Limited in size only by available RAM. Not subject to Java garbage collection (GC). Available only with Terracotta BigMemory procts.
DiskStore – Backs up in-memory cache elements and provides overflow capacity to the other tiers.
hibernate二级缓存配置
hibernate的二级缓存支持entity和query层面的缓存，org.hibernate.cache.spi.RegionFactory各类可插拔的缓存提供商与hibernate的集成。
# 打开hibernate统计信息
spring.jpa.properties.hibernate.generate_statistics=true
# 打开二级缓存
spring.jpa.properties.hibernate.cache.use_second_level_cache=true
# 打开查询缓存
spring.jpa.properties.hibernate.cache.use_query_cache=true
# 指定缓存provider
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory
# 配置shared-cache-mode
spring.jpa.properties.javax.persistence.sharedCache.mode=ENABLE_SELECTIVE
关于hibernate缓存相关的所有配置可参考hibernate5.0官方文档#缓存
ehcache配置文件
ehcache 2.x配置文件样板参考官方网站提供的ehcache.xml。本例中使用的配置文件如下所示
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://www.ehcache.org/ehcache.xsd"
updateCheck="true" monitoring="autodetect"
dynamicConfig="true">
<diskStore path="user.dir/cache"/>
<transactionManagerLookup class="net.sf.ehcache.transaction.manager."
properties="jndiName=java:/TransactionManager" propertySeparator=";"/>
< class="com.yangyi.base.ehcache." properties=""/>
<defaultCache
maxEntriesLocalHeap="0"
eternal="false"
timeToIdleSeconds="1200"
timeToLiveSeconds="1200">
<!--<terracotta/>-->
</defaultCache>
<cache name="entityCache"
maxEntriesLocalHeap="1000"
maxEntriesLocalDisk="10000"
eternal="false"
diskSpoolBufferSizeMB="20"
timeToIdleSeconds="10"
timeToLiveSeconds="20"
memoryStoreEvictionPolicy="LFU"
transactionalMode="off">
<persistence strategy="localTempSwap"/>
<cacheEventListenerFactory class="com.yangyi.base.ehcache." />
</cache>
<cache name="org.hibernate.cache.internal.StandardQueryCache"
maxEntriesLocalHeap="5" eternal="false" timeToLiveSeconds="120">
<persistence strategy="localTempSwap" />
<cacheEventListenerFactory class="com.yangyi.base.ehcache." />
</cache>
<cache name="org.hibernate.cache.spi.UpdateTimestampsCache"
maxEntriesLocalHeap="5000" eternal="true">
<persistence strategy="localTempSwap" />
<cacheEventListenerFactory class="com.yangyi.base.ehcache." />
</cache>
</ehcache>
注解方式使用二级缓存
要使用entity cache，需要在entity上配上相应的注解方可生效。javax.persistence.Cacheable注解标记该entity使用二级缓存，org.hibernate.annotations.Cache注解指定缓存策略，以及存放到哪个缓存区域。
有关缓存策略详细信息可参考hibernate5.0官方文档#缓存
package com.yangyi.entity;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import javax.persistence.Cacheable;
import javax.persistence.Entity;
import javax.persistence.JoinTable;
@Entity
@Table(name = "users")
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "entityCache")
public class User implements Serializable {
}
最后，我们需要在spring boot应用层面打开cache功能，使用org.springframework.cache.annotation.EnableCaching注解
package com.yangyi;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
完整代码
完整代码示例见github spring-boot-ehcache2.x-hibernate-second-level-cache
⑸ 关于Hibernate二级缓存的问题
<property
name="hibernate.cache.use_second_level_cache">true</property>
<property
name="hibernate.cache.provider_class">org.hibernate.cache.ehcacheprovider</property>
前一句是打开二级缓存，后一句是启用第三方缓存产品（可改变，上面eache是hibernate官方默认的第三方缓存产品）
缓存是否实用，要看你的需求，
如果你的系统，浏览的人数比较多，但是增删的比较少，缓存的功劳非常大
如果你的系统即时性非常强，那么缓存的命中率就比较低，同时更新数据时，hibernate需要额外提供资源维护缓存与数据的一致
⑹ hibernate的延时加载与二级缓存具体怎么解释
延迟加载 意思是仅当应用系统需要访问关联的目标对象的数据时，hibernate才载入他们的值。就是只在一个对象调用他的“一对多”或“多对多”关联时的目标对象才将目标对象读取出来。 利用hibernate.initialize（），在关闭session后取得目标实体，则在使用org.hibernate包中hibernate类中静态关系hibernate.initialize（）来先载入关联目标实体，再关闭session
因为session生命周期短，所以在第一级缓存的命中率实际应用时将是很低的。因此为提高hibernate框架时应用系统总体性能，开发者要配置二级缓存。
二级缓存就是sessionfactory级别的全局缓存，分为内置缓存和外置缓存。
配置方法嘛，在hibernate.cfg.xml中加入
<property name="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
EHCache的配置文件ehcache.xml和hibernate.cfg.xml放在一起，示例
<ehcache>
<diskStore path="java.eo.tmpdir">
<defaultCache maxElementsInMemory="1000" eternal="false"
timeToIdleSeconds="120" timeToLiveSeconds="120"
overflowToDisk="true"/>
</ehcache>
虽然敲了这么多字，但是想完全弄清楚还是很困难的，毕竟书中是用专门的两章内容讲解的。建议去找本hibernate的书去看看，我手里有本《J2EE项目——hibernate框架技术》，还不错，楼主可以参考一下。
⑺ 什么是hibernate中的二级缓存
第一级别的缓存是Session级别的缓存，是属于事务范围的缓存，由Hibernate管理，一般无需进行干预。第二级别的缓存是SessionFactory级别的缓存，是属于进程范围的缓存。
二级缓存也分为了两种
内置缓存：Hibernate自带的，不可卸载，通常在Hibernate的初始化阶段，Hibernate会把映射元数据和预定义的SQL语句放置到SessionFactory的缓存中。该内置缓存是只读的。
外置缓存：通常说的二级缓存也就是外置缓存，在默认情况下SessionFactory不会启用这个缓存插件，外置缓存中的数据是数据库数据的复制，外置缓存的物理介质可以是内存或者硬盘。
hibernate二级缓存的结构
2.并发访问策略
transactional
（事务型）
仅在受管理的环境中适用
提供Repeatable Read事务隔离级别
适用经常被读，很少修改的数据
可以防止脏读和不可重复读的并发问题
缓存支持事务，发生异常的时候，缓存也能够回滚
read-write
（读写型）
提供Read Committed事务隔离级别
在非集群的环境中适用
适用经常被读，很少修改的数据
可以防止脏读
更新缓存的时候会锁定缓存中的数据
nonstrict-read-write
（非严格读写型）
适用极少被修改，偶尔允许脏读的数据（两个事务同时修改数据的情况很少见）
不保证缓存和数据库中数据的一致性
为缓存数据设置很短的过期时间，从而尽量避免脏读
不锁定缓存中的数据
read-only
（只读型）
适用从来不会被修改的数据（如参考数据）
在此模式下，如果对数据进行更新操作，会有异常
事务隔离级别低，并发性能高
在集群环境中也能完美运作
分析：通过上述表格分析如下
适合放入二级缓存中数据
很少被修改
不是很重要的数据，允许出现偶尔的并发问题
不适合放入二级缓存中的数据
经常被修改
财务数据，绝对不允许出现并发问题
与其他应用数据共享的数据
⑻ 在配置Hibernate二级缓存的时候，在ehcache.xml中 有这么一句 <diskStore path="D:\cache"/>
你的理解基本上是正确的，但还要结合overflowToDisk参数来用。
另外cache文件不需要手动创建。
下面是一些说明：
由于配置文件中只能指定maxElementsInMemory，这就会有可能存入的对象太多而超出VM的heap大小，当然你可以通过jvm参数增大heap大小，但这总还是有可能溢出。这里可以把maxElementsInMemory值设置到一个比较安全的大小，自己预先测试一下最好。如果内存仍然存不下你需要存的对象个数，那么可以开启overflowToDisk来增加可以存储的Element个数。这里要注意一下，EHCache不会自动帮助你去把内存对象写入到磁盘，当超过maxElementsInMemory程序会自动把更多的部分开始往硬盘写，但是内存的对象其实并没有清出去，这时需要手动使用Cache.flush()方法来把内存对象
重建上一次运行的缓存：这个需求肯定比较普遍，我们当然不希望一旦程序退出，整个缓存就要重建了。开启diskPersistent功能，只要使用的是CacheManager单例模式，下一次启动的时候就会调用上一次运行的缓存。比较麻烦的是写入磁盘的时间还是要自己调用Cache.flush()方法。如果仅仅考虑到程序重启的话，我建议这里把diskStore写入到一个ramfs，这样性能就更高了，但重启电脑的话就不得不重建缓存了。
⑼ 什么事Hibernate二级缓存
只需要查一次数据库，在次操作数据不用去查询了，它会首先找缓存，看看有没有，如果有就直接用，没有的时候在去查！
⑽ hibernate缓存的详细配置
很多人对二级缓存都不太了解，或者是有错误的认识，我一直想写一篇文章介绍一下hibernate的二级缓存的，今天终于忍不住了。
我的经验主要来自hibernate2.1版本，基本原理和3.0、3.1是一样的，请原谅我的顽固不化。
hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。
二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等，需要设置hibernate.cache.provider_class，我们这里用ehcache，在2.1中就是
hibernate.cache.provider_class=net.sf.hibernate.cache.EhCacheProvider
如果使用查询缓存，加上
hibernate.cache.use_query_cache=true
缓存可以简单的看成一个Map，通过key在缓存里面找value。
Class的缓存
对于一条记录，也就是一个PO来说，是根据ID来找的，缓存的key就是ID，value是POJO。无论list，load还是iterate，只要读出一个对象，都会填充缓存。但是list不会使用缓存，而iterate会先取数据库select id出来，然后一个id一个id的load，如果在缓存里面有，就从缓存取，没有的话就去数据库load。假设是读写缓存，需要设置：
<cache usage="read-write"/>
如果你使用的二级缓存实现是ehcache的话，需要配置ehcache.xml
<cache name="com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />
其中eternal表示缓存是不是永远不超时，timeToLiveSeconds是缓存中每个元素（这里也就是一个POJO）的超时时间，如果eternal="false"，超过指定的时间，这个元素就被移走了。timeToIdleSeconds是发呆时间，是可选的。当往缓存里面put的元素超过500个时，如果overflowToDisk="true"，就会把缓存中的部分数据保存在硬盘上的临时文件里面。
每个需要缓存的class都要这样配置。如果你没有配置，hibernate会在启动的时候警告你，然后使用defaultCache的配置，这样多个class会共享一个配置。
当某个ID通过hibernate修改时，hibernate会知道，于是移除缓存。
这样大家可能会想，同样的查询条件，第一次先list，第二次再iterate，就可以使用到缓存了。实际上这是很难的，因为你无法判断什么时候是第一次，而且每次查询的条件通常是不一样的，假如数据库里面有100条记录，id从1到100，第一次list的时候出了前50个id，第二次iterate的时候却查询到30至70号id，那么30-50是从缓存里面取的，51到70是从数据库取的，共发送1+20条sql。所以我一直认为iterate没有什么用，总是会有1+N的问题。
（题外话：有说法说大型查询用list会把整个结果集装入内存，很慢，而iterate只select id比较好，但是大型查询总是要分页查的，谁也不会真的把整个结果集装进来，假如一页20条的话，iterate共需要执行21条语句，list虽然选择若干字段，比iterate第一条select id语句慢一些，但只有一条语句，不装入整个结果集hibernate还会根据数据库方言做优化，比如使用mysql的limit，整体看来应该还是list快。）
如果想要对list或者iterate查询的结果缓存，就要用到查询缓存了
查询缓存
首先需要配置hibernate.cache.use_query_cache=true
如果用ehcache，配置ehcache.xml，注意hibernate3.0以后不是net.sf的包名了
<cache name="net.sf.hibernate.cache.StandardQueryCache"
maxElementsInMemory="50" eternal="false" timeToIdleSeconds="3600"
timeToLiveSeconds="7200" overflowToDisk="true"/>
<cache name="net.sf.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000" eternal="true" overflowToDisk="true"/>
然后
query.setCacheable(true);//激活查询缓存
query.setCacheRegion("myCacheRegion");//指定要使用的cacheRegion，可选
第二行指定要使用的cacheRegion是myCacheRegion，即你可以给每个查询缓存做一个单独的配置，使用setCacheRegion来做这个指定，需要在ehcache.xml里面配置它：
<cache name="myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" />
如果省略第二行，不设置cacheRegion的话，那么会使用上面提到的标准查询缓存的配置，也就是net.sf.hibernate.cache.StandardQueryCache
对于查询缓存来说，缓存的key是根据hql生成的sql，再加上参数，分页等信息（可以通过日志输出看到，不过它的输出不是很可读，最好改一下它的代码）。
比如hql：
from Cat c where c.name like ?
生成大致如下的sql：
select * from cat c where c.name like ?
参数是"tiger%"，那么查询缓存的key*大约*是这样的字符串（我是凭记忆写的，并不精确，不过看了也该明白了）：
select * from cat c where c.name like ? , parameter:tiger%
这样，保证了同样的查询、同样的参数等条件下具有一样的key。
现在说说缓存的value，如果是list方式的话，value在这里并不是整个结果集，而是查询出来的这一串ID。也就是说，不管是list方法还是iterate方法，第一次查询的时候，它们的查询方式很它们平时的方式是一样的，list执行一条sql，iterate执行1+N条，多出来的行为是它们填充了缓存。但是到同样条件第二次查询的时候，就都和iterate的行为一样了，根据缓存的key去缓存里面查到了value，value是一串id，然后在到class的缓存里面去一个一个的load出来。这样做是为了节约内存。
可以看出来，查询缓存需要打开相关类的class缓存。list和iterate方法第一次执行的时候，都是既填充查询缓存又填充class缓存的。
这里还有一个很容易被忽视的重要问题，即打开查询缓存以后，即使是list方法也可能遇到1+N的问题！相同条件第一次list的时候，因为查询缓存中找不到，不管class缓存是否存在数据，总是发送一条sql语句到数据库获取全部数据，然后填充查询缓存和class缓存。但是第二次执行的时候，问题就来了，如果你的class缓存的超时时间比较短，现在class缓存都超时了，但是查询缓存还在，那么list方法在获取id串以后，将会一个一个去数据库load！因此，class缓存的超时时间一定不能短于查询缓存设置的超时时间！如果还设置了发呆时间的话，保证class缓存的发呆时间也大于查询的缓存的生存时间。这里还有其他情况，比如class缓存被程序强制evict了，这种情况就请自己注意了。
另外，如果hql查询包含select字句，那么查询缓存里面的value就是整个结果集了。
当hibernate更新数据库的时候，它怎么知道更新哪些查询缓存呢？
hibernate在一个地方维护每个表的最后更新时间，其实也就是放在上面net.sf.hibernate.cache.UpdateTimestampsCache所指定的缓存配置里面。
当通过hibernate更新的时候，hibernate会知道这次更新影响了哪些表。然后它更新这些表的最后更新时间。每个缓存都有一个生成时间和这个缓存所查询的表，当hibernate查询一个缓存是否存在的时候，如果缓存存在，它还要取出缓存的生成时间和这个缓存所查询的表，然后去查找这些表的最后更新时间，如果有一个表在生成时间后更新过了，那么这个缓存是无效的。
可以看出，只要更新过一个表，那么凡是涉及到这个表的查询缓存就失效了，因此查询缓存的命中率可能会比较低。
Collection缓存
需要在hbm的collection里面设置
<cache usage="read-write"/>
假如class是Cat，collection叫children，那么ehcache里面配置
<cache name="com.xxx.pojo.Cat.children"
maxElementsInMemory="20" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200"
overflowToDisk="true" />
Collection的缓存和前面查询缓存的list一样，也是只保持一串id，但它不会因为这个表更新过就失效，一个collection缓存仅在这个collection里面的元素有增删时才失效。
这样有一个问题，如果你的collection是根据某个字段排序的，当其中一个元素更新了该字段时，导致顺序改变时，collection缓存里面的顺序没有做更新。
缓存策略
只读缓存（read-only）：没有什么好说的
读/写缓存（read-write）:程序可能要的更新数据
不严格的读/写缓存（nonstrict-read-write）：需要更新数据，但是两个事务更新同一条记录的可能性很小，性能比读写缓存好
事务缓存（transactional）：缓存支持事务，发生异常的时候，缓存也能够回滚，只支持jta环境，这个我没有怎么研究过
读写缓存和不严格读写缓存在实现上的区别在于，读写缓存更新缓存的时候会把缓存里面的数据换成一个锁，其他事务如果去取相应的缓存数据，发现被锁住了，然后就直接取数据库查询。
在hibernate2.1的ehcache实现中，如果锁住部分缓存的事务发生了异常，那么缓存会一直被锁住，直到60秒后超时。
不严格读写缓存不锁定缓存中的数据。
使用二级缓存的前置条件
你的hibernate程序对数据库有独占的写访问权，其他的进程更新了数据库，hibernate是不可能知道的。你操作数据库必需直接通过hibernate，如果你调用存储过程，或者自己使用jdbc更新数据库，hibernate也是不知道的。hibernate3.0的大批量更新和删除是不更新二级缓存的，但是据说3.1已经解决了这个问题。
这个限制相当的棘手，有时候hibernate做批量更新、删除很慢，但是你却不能自己写jdbc来优化，很郁闷吧。
SessionFactory也提供了移除缓存的方法，你一定要自己写一些JDBC的话，可以调用这些方法移除缓存，这些方法是：
void evict(Class persistentClass)
Evict all entries from the second-level cache.
void evict(Class persistentClass, Serializable id)
Evict an entry from the second-level cache.
void evictCollection(String roleName)
Evict all entries from the second-level cache.
void evictCollection(String roleName, Serializable id)
Evict an entry from the second-level cache.
void evictQueries()
Evict any query result sets cached in the default query cache region.
void evictQueries(String cacheRegion)
Evict any query result sets cached in the named query cache region.
不过我不建议这样做，因为这样很难维护。比如你现在用JDBC批量更新了某个表，有3个查询缓存会用到这个表，用evictQueries(String cacheRegion)移除了3个查询缓存，然后用evict(Class persistentClass)移除了class缓存，看上去好像完整了。不过哪天你添加了一个相关查询缓存，可能会忘记更新这里的移除代码。如果你的jdbc代码到处都是，在你添加一个查询缓存的时候，还知道其他什么地方也要做相应的改动吗？
----------------------------------------------------
总结：
不要想当然的以为缓存一定能提高性能，仅仅在你能够驾驭它并且条件合适的情况下才是这样的。hibernate的二级缓存限制还是比较多的，不方便用jdbc可能会大大的降低更新性能。在不了解原理的情况下乱用，可能会有1+N的问题。不当的使用还可能导致读出脏数据。
如果受不了hibernate的诸多限制，那么还是自己在应用程序的层面上做缓存吧。
在越高的层面上做缓存，效果就会越好。就好像尽管磁盘有缓存，数据库还是要实现自己的缓存，尽管数据库有缓存，咱们的应用程序还是要做缓存。因为底层的缓存它并不知道高层要用这些数据干什么，只能做的比较通用，而高层可以有针对性的实现缓存，所以在更高的级别上做缓存，效果也要好些吧。