Hibernate 数据查询
1 HQL 基本语法
分页查询
findEmployees(int, int)
代码如下；
/**
* 分页查询
* @param pageNo
* @param pageSize
* @return
*/
@SuppressWarnings("unchecked")
public static List<Employee> findEmployees(int pageNo, int pageSize){
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
String hql = "from Employee";
List<Employee> empls = session.createQuery(hql)
.setMaxResults(pageSize)
.setFirstResult((pageNo - 1) * pageSize)
.list();
//提交事务
session.getTransaction().commit();
//关闭Session
session.close();
return empls;
}
还有抓取连接查询
/**
* 抓取连接查询
*/
@SuppressWarnings("unchecked")
public static void testFetch(){
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
//左外抓取连接查询，一次把符合条件的部门数据查询出，同时也查询出该部门下的所有员工的数据
String hql = "FROM Dept d LEFT JOIN FETCH d.employees e "
+ " WHERE d.name LIKE '%web%'";
List<Dept> list = session.createQuery(hql).list();
//用Set来过滤重复元素
Set<Dept> depts = new HashSet<Dept>(list);
for (Dept dept : depts) {
System.out.println(dept.getName());
for(Employee empl : dept.getEmployees()){
System.out.println(" |--" + empl.getLoginName());
}
System.out.println();
}
//提交事务
session.getTransaction().commit();
//关闭Session
session.close();
}/**
* 命名查询
*/
@SuppressWarnings("unchecked")
public static void testNamedQuery(){
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
List<Dept> depts = session.getNamedQuery("findDeptsByCondition")
.setString("likeName", "%a%")
.list();
for (Dept dept : depts) {
System.out.println(dept.getId() + ","+ dept.getName());
}
//提交事务
session.getTransaction().commit();
//关闭Session
session.close();
}
/**
* 子查询
*/
@SuppressWarnings("unchecked")
public static void testSubQuery(){
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
String hql = "FROM Dept d WHERE " +
" (SELECT COUNT(e) FROM d.employees e) > 1";
List<Dept> list = session.createQuery(hql)
.list();
for (Dept dept : list) {
System.out.println(dept.getName());
}
//提交事务
session.getTransaction().commit();
//关闭Session
session.close();
}
/**
* 连接查询
*/
@SuppressWarnings("unchecked")
public static void testJoin(){
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
String hql = "FROM Dept d JOIN d.employees e "
+ " WHERE d.name LIKE :likeName";
List list = session.createQuery(hql)
.setString("likeName","%Web%")
.list();
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Object[] obj = (Object[]) iterator.next();
Dept dept= (Dept)obj[0];
Employee employee = (Employee)obj[1];
System.out.println("dept--" + dept.getName());
System.out.println("empl--" + employee.getLoginName());
}
//提交事务
session.getTransaction().commit();
//关闭Session
session.close();
}
非常多的查询策略：
hb_06_hql
Criteria Queries.
QBC: query by criteria的缩写，通过面向对象化的设计，将数据查询条件封装为一个对象。简单来讲，QBC可以看做是传统SQL的对象化表示。 QBC支持在运行时动态生成查询语句。
testDetachedCriteria()
testQBCBase()
testQBE(Employee)
三种，一种是直接写的QBC语句，一种是DetachedCriteria类来支持离线查询。所谓离线查询，就是指在一个Session范围之外创建好一个查询，然后在需要使用时，再附加到一个Session实例上来执行它。
/**
* DetachedCriteria用法
*/
@SuppressWarnings("unchecked")
public static void testDetachedCriteria(){
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
//创建好一个离线的Criteria实例
DetachedCriteria dc = DetachedCriteria.forClass(Employee.class)
.add(Restrictions.ge("salary", new Double(4000.00)))
.add(Restrictions.like("loginName", "z%"))
.addOrder(Order.desc("id"));
//在需要使用时，把这个离线的Criteria实例附加到一个Session实例上执行，再返回结果
List<Employee> list = dc.getExecutableCriteria(session)
.list();
for (Employee employee : list) {
System.out.println(employee.getLoginName() + "," + employee.getSalary());
}
//提交事务
session.getTransaction().commit();
//关闭Session
session.close();
}
还有一个Example查询，示例查询 Query By Example,根据一个给定的实例类查询来构建一个条件查询的方式，
/**
* QBE用法
*/
@SuppressWarnings("unchecked")
public static void testQBE(Employee employee){
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
//根据传入的employee实例来创建查询条件
Example example = Example.create(employee)
.excludeZeroes() //排除0值的属性
.excludeProperty("color") //排除指定的属性
.ignoreCase() //对所有的字符串类型的属性值忽略大小写比较
.enableLike(); //对所有的字符串类型的属性值使用like比较
//执行查询
List<Employee> results = session.createCriteria(Employee.class)
.add(example)
.list();
for (Employee empl : results) {
System.out.println(empl.getLoginName() + "," + empl.getSalary());
}
//提交事务
session.getTransaction().commit();
//关闭Session
session.close();
}Hibernate事务管理和并发控制
并发访问控制中，需要读取的数据是“读已提交”（代码为2，也就是事务隔离级别）
<!-- 设置数据库连接的事务隔离级别 -->
<property name="hibernate.connection.isolation">2</property>乐观并发控制和悲观并发控制
public void testTx1() {
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.getTransaction().begin();
Product prod = null;
try {
prod = (Product)session.get(Product.class, new Long(1));
System.out.println(prod.getDescription());
System.out.println("version=" + prod.getVersion());
prod.setDescription("在第一个事务中修改");
session.getTransaction().commit();
} catch (HibernateException he) {
session.getTransaction().rollback();
he.printStackTrace();
}
session.close();
// 操作完毕
System.out.println("tx1操作完成后------");
System.out.println(prod.getDescription());
System.out.println("version=" + prod.getVersion());
}
public void testTx2() {
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.getTransaction().begin();
Product prod = null;
try {
prod = (Product)session.get(Product.class, new Long(1));
System.out.println(prod.getDescription());
System.out.println("version=" + prod.getVersion());
prod.setDescription("在第二个事务中修改");
session.getTransaction().commit();
} catch (HibernateException he) {
session.getTransaction().rollback();
he.printStackTrace();
}
session.close();
// 操作完毕
System.out.println("tx2操作完成后------");
System.out.println(prod.getDescription());
System.out.println("version=" + prod.getVersion());
}Hibernate推荐！！！使用带版本化的检查方式来实现更新。字段叫private int version.
在Class.hbm.xml中，配置如下：
product这个类中，必须要有一个version字段，mapping.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 name="com.qiujy.domain.Product" table="product">
<!-- 映射对象标识符 -->
<id name="id">
<generator class="native" />
</id>
<!-- 版本号必须紧跟在id元素后面 -->
<version name="version"/>
<!-- 映射普通属性 -->
<property name="name"/>
<property name="description"/>
<property name="unitCost" />
<property name="pubTime"/>
</class>
</hibernate-mapping>乐观并发控制如上机制。
悲观并发控制如下机制。也是加一个version字段，在事务进行的时候，有一点不同。
public void testTx1() {
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.getTransaction().begin();
Product prod = null;
try {
prod = (Product)session.get(Product.class, new Long(1),LockMode.UPGRADE);
System.out.println(prod.getDescription());
prod.setDescription("在第一个事务中修改");
session.getTransaction().commit();
} catch (HibernateException he) {
session.getTransaction().rollback();
he.printStackTrace();
}
session.close();
// 操作完毕
System.out.println("tx1操作完成后------");
System.out.println(prod.getDescription());
System.out.println("version=" + prod.getVersion());
}
public void testTx2() {
//根据hibernate的默认配置文件构建一个SessoinFactory实例
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.getTransaction().begin();
Product prod = null;
try {
prod = (Product)session.get(Product.class, new Long(1),LockMode.UPGRADE);
System.out.println(prod.getDescription());
prod.setDescription("在第二个事务中修改");
session.getTransaction().commit();
} catch (HibernateException he) {
session.getTransaction().rollback();
he.printStackTrace();
}
session.close();
// 操作完毕
System.out.println("tx2操作完成后------");
System.out.println(prod.getDescription());
System.out.println("version=" + prod.getVersion());
}增加了一个改变状态！！！
http://download.youkuaiyun.com/detail/chengyangyy/9121835
Hibernate性能优化
1：延迟加载（lazy load）
主要是通过代理机制，来实现延迟加载的。它的具体过程如下：Hibernate从数据库获取某一个对象数据时，或者某一个对象的集合属性时，如果没有使用该对象的数据，则Hibernate不从数据库中真正获取数据，而是建立一个代理对象来表示这个对象，这个对象所有属性都是默认值，只有当真正用到的时候，才去数据库中取出来。
需要在hbm.xml中进行配置。
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping >
<class name="com.qiujy.domain.Account" table="account">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="loginName" column="login_name"/>
<set name="orderSet" cascade="all" order-by="id asc"
inverse="true" lazy="extra">
<key column="account_id"/>
<one-to-many class="com.qiujy.domain.Order"/>
</set>
</class>
</hibernate-mapping>账户有很多订单，用set表示，同时加入属性 lazy = “extra”.
public void testGet(){
Session session = HibernateUtil.getSession();
try{
session.beginTransaction();
//get()方法：如果在缓存中没有指定OID的实例，立即发现SQL去数据库获取数据。
Account acc = (Account)session.get(Account.class, new Long(3));
//第二 get()时，缓存中已经存在这个实例了，就把这个实例返回
// acc = (Account)session.get(Account.class, new Long(3));
// System.out.println(acc.getId());
System.out.println(acc);
//对本实体中的复杂属性，默认采用lazy
Set<Order> orderSet = acc.getOrderSet();
for (Order order : orderSet) {
System.out.println(order);
}
session.getTransaction().commit();
}catch(HibernateException he){
session.getTransaction().rollback();
he.printStackTrace();
}finally{
session.close();
}
}
public void testLoad(){
Session session = HibernateUtil.getSession();
Account acc = null;
try{
session.beginTransaction();
//get()方法：如果在缓存中没有指定OID的实例，立即发现SQL去数据库获取数据。
acc = (Account)session.load(Account.class, new Long(1));
//第二 get()时，缓存中已经存在这个实例了，就把这个实例返回
// acc = (Account)session.load(Account.class, new Long(1));
System.out.println(acc.getId());
System.out.println(acc);
//对本实体中的复杂属性，默认采用lazy
Set<Order> orderSet = acc.getOrderSet();
for (Order order : orderSet) {
System.out.println(order);
}
session.getTransaction().commit();
}catch(HibernateException he){
session.getTransaction().rollback();
he.printStackTrace();
}finally{
session.close();
}
}
//单端关联上的lazy
public void testGet2(){
Session session = HibernateUtil.getSession();
try{
session.beginTransaction();
//get()方法：如果在缓存中没有指定OID的实例，立即发现SQL去数据库获取数据。
Order ord = (Order)session.get(Order.class, new Long(10));
System.out.println(ord);
Account acc = ord.getAcc();
System.out.println(acc.getId());
System.out.println(acc);
session.getTransaction().commit();
}catch(HibernateException he){
session.getTransaction().rollback();
he.printStackTrace();
}finally{
session.close();
}
}对于大对象的延迟加载，也是这样，比如一篇文章的Article.
表结构如下所示：
需要延迟加载的属性为：content.
mapping.xml中关于content的定义如下
<property name="content" type="clob" lazy="true">
<column name="content" sql-type="longtext" />
</property>之后，需要使用类增强器对二进制Class文件进行强化处理，Hibernate3中针对应用程序中所使用的动态代理类库（cglib或者javassist）提供对应的增强工具类，可以借助Ant来定义一个任务，对需要进行强化处理。
Ant脚本build.xml文件如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<project basedir="." default="build" name="hb_09_lazy">
<!-- 指定第三方类库的存放位置 -->
<property name="lib.dir" value="./3rdlibs" />
<!-- 指定编译输出的目的地 -->
<property name="classes.dir" value="./bin" />
<!-- 指定本应用所依赖的第三类库 -->
<path id="project.classpath">
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
</fileset>
</path>
<!-- 类增强工具ant任务 -->
<target name="instrument">
<!-- 根据你的应用程序所使用的动态代理类库(cglib或javassist)来选择对应的字节码增强工具类 -->
<taskdef name="instrument"
classname="org.hibernate.tool.instrument.javassist.InstrumentTask"
classpathref="project.classpath" />
<!-- 指定要进行强化处理的类文件 -->
<instrument verbose="true">
<fileset dir="${classes.dir}/com/qiujy/domain">
<include name="Article.class" />
</fileset>
</instrument>
</target>
<!-- 默认的任务build -->
<target name="build" depends="instrument" />
</project>
可以去更多的了解Ant是干什么的。之前也了解过！！！
执行这个ant任务，就可以对指定的字节码文件Article.class进行强化处理，之后就可以针对它的大对象属性content进行延迟加载。
2：抓取策略
和延迟加载策略正好相反，是把相关的全部加载出来。通过写一条left join left语句把相关联的两个实体的数据一次性从数据库中加载下来。这样可以节省sql查询次数。
1： 单端关联，(many to one, one to one) 上的抓取策略
fetch属性有两个属性值，
一个select：默认值，当需要使用到关联对象的属性时，另外单独发送一条select语句抓取当前对象的关联对象的数据，即延迟加载。
一个join：它的策略是在同一条SELECT语句使用内连接来获得对象的数据和它的关联对象的数据，此时关联对象的延迟加载失效。
多个订单对应一个账号.
配置如下：
<?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 name="com.qiujy.domain.Order" table="orders">
<!-- 映射对象标识符 -->
<id name="id" column="id">
<generator class="native"/>
</id>
<!-- 映射普通属性 -->
<property name="orderNo"/>
<property name="createdTime"
column="created_time" type="timestamp"/>
<!-- 映射多对一关联，添加fetch属性 -->
<many-to-one name="account" column="account_id"
fetch="join" not-null="true"/>
</class>
</hibernate-mapping>
/**
* 测试单端关联的fetch策略
*/
public void testGetOrder(){
Session session = HibernateUtil.getSession();
try{
session.beginTransaction();
Order order = (Order)session.get(Order.class, new Long(2));
System.out.println(order);
Account account = order.getAccount();
System.out.println(account);
session.getTransaction().commit();
}catch(HibernateException he){
session.getTransaction().rollback();
he.printStackTrace();
}finally{
session.close();
}
}这里用法就是如此，不需要再一次查找account了。
再来看Account怎么配置。
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping >
<!-- 映射持久化类 -->
<class name="com.qiujy.domain.Account" table="account">
<!-- 映射对象标识符 -->
<id name="id" column="id">
<generator class="native"/>
</id>
<!-- 映射普通属性 -->
<property name="loginName" column="login_name"/>
<!-- 用集合来映射一对多关联，并指定fetch属性 -->
<set name="orderSet" cascade="all"
inverse="true" fetch="subselect">
<key column="account_id"/>
<one-to-many class="com.qiujy.domain.Order"/>
</set>
</class>
</hibernate-mapping>测试集合端的抓取策略
/**
* 测试集合属性端的fetch策略
*/
@SuppressWarnings("unchecked")
public void testGetAccount(){
Session session = HibernateUtil.getSession();
try{
session.beginTransaction();
List<Account> list = session.createQuery("from Account where id in(1,3,5)").list();
for(Account account : list){
System.out.println(account);
Set<Order> orderSet = account.getOrderSet();
for (Order order : orderSet) {
System.out.println(" |--" + order);
}
}
session.getTransaction().commit();
}catch(HibernateException he){
session.getTransaction().rollback();
he.printStackTrace();
}finally{
session.close();
}
}在集合属性的映射元素上，可以添加fetch属性，它有三个可选择的值
1 select，默认值，它的策略是当需要使用所关联集合的数据时，另外单独发送一个select语句抓取当前对象的关联集合，即延迟加载。
2 join 在同一条select语句使用内连接来获得对象的关联集合，此时关联集合上的lazy会失效。
3 subselect：另外发送一条查询语句（子查询语句）抓取在前面查询到的所有实体对象的关联集合。
3 缓存管理
hibernate的一级缓存在session中，需要自己定义二级缓存。
category.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 name="com.qiujy.domain.Category" table="category">
<!--
cache元素表示为本实体类启用二级缓存,它必须作为class元素的第一个子元素.它的常用属性有
1) usage: 指定并发访问策略
2) include: 指定是否对延迟加载的属性也进行缓存
all:对延迟加载的属性也进行缓存,默认值;
non-lazy:不对延迟加载的属性进行缓存。
3) region: 指定此类实例存放的缓存区域名，默认是实体类或集合的全限定名
-->
<cache usage="read-write" include="all"
region="com.qiujy.domain.Category" />
<!-- 映射对象标识符 -->
<id name="id" column="id" type="long">
<generator class="native" />
</id>
<!-- 映射普通属性 -->
<property name="name"/>
<property name="createdTime"
column="created_time" type="timestamp"/>
<!-- 映射集合属性，关联到多端的实体类
inverse属性：true表示把关联关系的维护权反转给被关联端
-->
<bag name="books" cascade="all" inverse="true">
<!-- Hibernate只会缓存对象的简单属性的值,
若要缓存集合属性,必须在集合元素中也加入<cache>子元素
而Hibernate又仅是把与当前持久对象关联的对象的OID存放到缓存中。
如果希望把整个关联的对象的数据都存入缓存,
则要在相应关联的对象的映射文件中配置<cache>元素
-->
<cache usage="read-write"/>
<!-- 用key元素指定关联的外键列 -->
<key column="category_id" />
<!-- 用one-to-many元素关联到多端的实体类 -->
<one-to-many class="com.qiujy.domain.Book" />
</bag>
</class>
</hibernate-mapping>在映射文件中通过<cache>元素来启用二级缓存，具体的属性的作用在注释中也写的很明白，接下来看，Book类的映射文件。
<?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 name="com.qiujy.domain.Book" table="book">
<!-- 用cache元素对本类的实例启用二级缓存 -->
<cache usage="read-write"/>
<!-- 映射对象标识符 -->
<id name="id" column="id" type="long">
<generator class="native" />
</id>
<!-- 映射普通属性 -->
<property name="title"/>
<property name="createdTime"
column="created_time" type="date"/>
<property name="price"/>
<!-- 映射多对一关联映射 -->
<many-to-one name="category"
column="category_id" not-null="true"/>
</class>
</hibernate-mapping>指定配置第三方缓存插件
ehcache.jar导入referenced library.
然后hbm.xml进行配置：
<!--配置缓存插件 -->
<property name="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>ehcache.xml指定各缓存区域的属性。
<ehcache>
<!-- 设置缓存数据文件的存放目录 -->
<diskStore path="c:\\ehcache\"/>
<!-- 设置默认缓存区域的属性
可设置的属性有：
name: 设置缓存的名字,它的取值为类的全限定名或类的集合的名字,必须是唯一的. 默认缓存区域不需要设置此属性.
maxElementsInMemory: 设置基于内存的缓存中可存放的元素的最大数量.
eternal: 设置该缓存是否为永久的.
true表示永不过期,此时将忽略timeToIdleSeconds和timeToLiveSeconds属性;
overflowToDisk: 设置该缓存中基于内存存放的元素数量超过上限时,是否把溢出的元素写到硬盘.
timeToIdleSeconds: 设置该缓存空闲最长时间,超过这个时间,该缓存过期.过期时,EHCache就会清除该缓存.
默认为0,表示此缓存可以无限期地处于空闲状态.
timeToLiveSeconds: 设置该缓存存活的最长时间,超过这个时间,该缓存过期.
默认为0,表示该缓存可以无限期地存在于缓存中.
diskPersistent: 默认值为false.
diskExpiryThreadIntervalSeconds: 默认值120秒.
memoryStoreEvictionPolicy: 设置基于内存的缓存中的元素到达最大数量时的清空策略.默认值LRU.
有三策略:1. FIFO(First In First Out): 先进先出.
2. LFU(Less Frequently Used): 最少被使用的.
3. LRU(Least Recently Used): 最近最少使用的.
-->
<defaultCache
maxElementsInMemory="100"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU"
/>
<!-- 设置命名的缓存区域的属性 -->
<cache name="com.qiujy.domain.Category"
maxElementsInMemory="100"
eternal="true"
overflowToDisk="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
/>
<cache name="com.qiujy.domain.Category.books"
maxElementsInMemory="5000"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
/>
<cache name="com.qiujy.domain.Book"
maxElementsInMemory="500"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
/>
<!-- 设置默认的查询缓存区域的属性 -->
<cache name="org.hibernate.cache.StandardQueryCache"
maxElementsInMemory="50"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="3600"
timeToLiveSeconds="7200"
/>
<!-- 设置时间戳缓存区域的属性 -->
<cache name="org.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="500"
eternal="true"
overflowToDisk="true"
/>
<!-- 设置自定义命名查询缓存区域的属性 -->
<cache name="myCacheRegion"
maxElementsInMemory="1000"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="3600"
timeToLiveSeconds="7200"
/>
</ehcache>
查询缓存
首先配置：
<!--启用查询缓存 -->
<property name="cache.use_query_cache">true</property>
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.qiujy.domain.Book;
/**
* 查询缓存使用示例
* @author qiujy
*/
public class QueryCacheTest{
public static void main(String[] args) {
//一定要使用同一个SessionFactory,否则没有效果???
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
test(sessionFactory);
System.out.println("*********第二次再用相同的条件过行查询************");
test2(sessionFactory);
}
@SuppressWarnings("unchecked")
public static void test(SessionFactory sessionFactory){
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
try{
session.beginTransaction();
String hql = "from Book where title like :likeTitle";
Query query = session.createQuery(hql);
//激活查询缓存
query.setCacheable(true);
//使用自定义的查询缓存区域.若不设置,则使用标准查询缓存区域.一般可以不设置
query.setCacheRegion("myCacheRegion");
List<Book> list = query.setString("likeTitle", "图书1_").list();
for (Book book : list) {
System.out.println(book);
}
//提交事务
session.getTransaction().commit();
}catch(HibernateException e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
//关闭Session
session.close();
}
}
@SuppressWarnings("unchecked")
public static void test2(SessionFactory sessionFactory){
//获取Session实例
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
try{
session.beginTransaction();
String hql = "from Book where title like :likeTitle";
Query query = session.createQuery(hql);
//激活查询缓存
query.setCacheable(true);
//使用自定义的查询缓存区域.若不设置,则使用标准查询缓存区域.一般可以不设置
query.setCacheRegion("myCacheRegion");
List<Book> list = query.setString("likeTitle", "图书2_").list();
for (Book book : list) {
System.out.println(book);
}
//提交事务
session.getTransaction().commit();
}catch(HibernateException e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
//关闭Session
session.close();
}
}
}
代码：
http://download.youkuaiyun.com/detail/chengyangyy/9122033
相关资料可以查看
hibernate查询与缓存
http://blog.youkuaiyun.com/narutobing/article/details/8934208
Hibernate 整合 Struts
扫一扫
233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
