BlogJava-konhon-随笔分类-Hibernate

应用Hibernate3的DetachedCriteria实现分页查询

konhon 优华 — Fri, 07 Apr 2006 02:37:00 GMT

Hibernate3提供了DetachedCriteria，使得我们可以在Web层构造detachedCriteria，然后调用业务层Bean，进行动态条件查询，根据这一功能，我设计了通用的抽象Bean基类和分页类支持，代码来自于Quake Wang的javaeye-core包的相应类，然后又做了很多修改。

分页支持类：

package com.javaeye.common.util;

import java.util.List;

public class PaginationSupport {

        public final static int PAGESIZE = 30;

        private int pageSize = PAGESIZE;

        private List items;

        private int totalCount;

        private int[] indexes = new int[0];

        private int startIndex = 0;

        public PaginationSupport(List items, int totalCount) {
                setPageSize(PAGESIZE);
                setTotalCount(totalCount);
                setItems(items);
                setStartIndex(0);
        }

        public PaginationSupport(List items, int totalCount, int startIndex) {
                setPageSize(PAGESIZE);
                setTotalCount(totalCount);
                setItems(items);
                setStartIndex(startIndex);
        }

        public PaginationSupport(List items, int totalCount, int pageSize, int startIndex) {
                setPageSize(pageSize);
                setTotalCount(totalCount);
                setItems(items);
                setStartIndex(startIndex);
        }

        public List getItems() {
                return items;
        }

        public void setItems(List items) {
                this.items = items;
        }

        public int getPageSize() {
                return pageSize;
        }

        public void setPageSize(int pageSize) {
                this.pageSize = pageSize;
        }

        public int getTotalCount() {
                return totalCount;
        }

        public void setTotalCount(int totalCount) {
                if (totalCount > 0) {
                        this.totalCount = totalCount;
                        int count = totalCount / pageSize;
                        if (totalCount % pageSize > 0)
                                count++;
                        indexes = new int[count];
                        for (int i = 0; i < count; i++) {
                                indexes[i] = pageSize * i;
                        }
                } else {
                        this.totalCount = 0;
                }
        }

        public int[] getIndexes() {
                return indexes;
        }

        public void setIndexes(int[] indexes) {
                this.indexes = indexes;
        }

        public int getStartIndex() {
                return startIndex;
        }

        public void setStartIndex(int startIndex) {
                if (totalCount <= 0)
                        this.startIndex = 0;
                else if (startIndex >= totalCount)
                        this.startIndex = indexes[indexes.length - 1];
                else if (startIndex < 0)
                        this.startIndex = 0;
                else {
                        this.startIndex = indexes[startIndex / pageSize];
                }
        }

        public int getNextIndex() {
                int nextIndex = getStartIndex() + pageSize;
                if (nextIndex >= totalCount)
                        return getStartIndex();
                else
                        return nextIndex;
        }

        public int getPreviousIndex() {
                int previousIndex = getStartIndex() - pageSize;
                if (previousIndex < 0)
                        return 0;
                else
                        return previousIndex;
        }

}

抽象业务类

java代码:

/**
* Created on 2005-7-12
*/
package com.javaeye.common.business;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.javaeye.common.util.PaginationSupport;

public abstract class AbstractManager extends HibernateDaoSupport {

        private boolean cacheQueries = false;

        private String queryCacheRegion;

        public void setCacheQueries(boolean cacheQueries) {
                this.cacheQueries = cacheQueries;
        }

        public void setQueryCacheRegion(String queryCacheRegion) {
                this.queryCacheRegion = queryCacheRegion;
        }

        public void save(final Object entity) {
                getHibernateTemplate().save(entity);
        }

        public void persist(final Object entity) {
                getHibernateTemplate().save(entity);
        }

        public void update(final Object entity) {
                getHibernateTemplate().update(entity);
        }

        public void delete(final Object entity) {
                getHibernateTemplate().delete(entity);
        }

        public Object load(final Class entity, final Serializable id) {
                return getHibernateTemplate().load(entity, id);
        }

        public Object get(final Class entity, final Serializable id) {
                return getHibernateTemplate().get(entity, id);
        }

        public List findAll(final Class entity) {
                return getHibernateTemplate().find("from " + entity.getName());
        }

        public List findByNamedQuery(final String namedQuery) {
                return getHibernateTemplate().findByNamedQuery(namedQuery);
        }

        public List findByNamedQuery(final String query, final Object parameter) {
                return getHibernateTemplate().findByNamedQuery(query, parameter);
        }

        public List findByNamedQuery(final String query, final Object[] parameters) {
                return getHibernateTemplate().findByNamedQuery(query, parameters);
        }

        public List find(final String query) {
                return getHibernateTemplate().find(query);
        }

        public List find(final String query, final Object parameter) {
                return getHibernateTemplate().find(query, parameter);
        }

        public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria) {
                return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, 0);
        }

        public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int startIndex) {
                return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, startIndex);
        }

        public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int pageSize,
                        final int startIndex) {
                return (PaginationSupport) getHibernateTemplate().execute(new HibernateCallback() {
                        public Object doInHibernate(Session session) throws HibernateException {
                                Criteria criteria = detachedCriteria.getExecutableCriteria(session);
                                int totalCount = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();
                                criteria.setProjection(null);
                                List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();
                                PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);
                                return ps;
                        }
                }, true);
        }

        public List findAllByCriteria(final DetachedCriteria detachedCriteria) {
                return (List) getHibernateTemplate().execute(new HibernateCallback() {
                        public Object doInHibernate(Session session) throws HibernateException {
                                Criteria criteria = detachedCriteria.getExecutableCriteria(session);
                                return criteria.list();
                        }
                }, true);
        }

        public int getCountByCriteria(final DetachedCriteria detachedCriteria) {
                Integer count = (Integer) getHibernateTemplate().execute(new HibernateCallback() {
                        public Object doInHibernate(Session session) throws HibernateException {
                                Criteria criteria = detachedCriteria.getExecutableCriteria(session);
                                return criteria.setProjection(Projections.rowCount()).uniqueResult();
                        }
                }, true);
                return count.intValue();
        }
}

用户在web层构造查询条件detachedCriteria，和可选的startIndex，调用业务bean的相应findByCriteria方法，返回一个PaginationSupport的实例ps。

ps.getItems()得到已分页好的结果集
ps.getIndexes()得到分页索引的数组
ps.getTotalCount()得到总结果数
ps.getStartIndex()当前分页索引
ps.getNextIndex()下一页索引
ps.getPreviousIndex()上一页索引

konhon 优华 2006-04-07 10:37 发表评论

Hibernate配置文件模板

konhon 优华 — Thu, 06 Apr 2006 02:45:00 GMT

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 ="Tuser" table ="T_User" >
     < id name ="id" column ="id" type ="java.lang.Integer" >
       < generator class ="native" />
     id >
     < property name ="name" column ="name" type ="java.lang.String" />



     < property name ="resume" column ="resume" type ="clob" />
   class >
hibernate-mapping >

復合主鍵

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="TUser2" table="T_User2">
    <composite-id name="userPk" class="TUserPk">
      <key-property name="firstName" column="firstname" type="java.lang.String"/>
      <key-property name="lastName" column="lastname" type="java.lang.String"/>
    composite-id>
    <property name="age" column="age" type="java.lang.Integer"/>
  class>
hibernate-mapping>

DISCRIMINATOR

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="TItem" table="T_Item">
    <id name="id" column="id">
      <generator class="native"/>
    id>
    <discriminator column="category" type="java.lang.String"/>
    <property name="manufacturer" column="manufacturer"/>
    <property name="name" column="name"/>
    <subclass name="TBook" discriminator-value="1">
      <property name="pageCount" column="pagecount"/>
    subclass>
    <subclass name="TDVD" discriminator-value="2">
      <property name="regionCode" column="regionCode"/>
    subclass>
  class>
hibernate-mapping>

konhon 优华 2006-04-06 10:45 发表评论

標准的Hibernate.cfg.xml文件 SQL Server

konhon 优华 — Thu, 06 Apr 2006 02:42:00 GMT

DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >

< hibernate-configuration >
   < session-factory >
     < property name ="hibernate.connection.url" >
       jdbc:Microsoft:sqlserver://192.168.10.236:1433;databaseName=Sample
     property >
     < property name ="hibernate.connection.driver_class" >
       com.microsoft.jdbc.sqlserver.SQLServerDriver
     property >
     < property name ="hibernate.connection.username" >
       sa
     property >
     < property name ="hibernate.connection.password" >
       55
     property >
     < property name ="dialect" >
       org.hibernate.dialect.SQLServerDialect
     property >
     < property name ="hibernate.show_sql" >
       true
     property >
     < property name ="hibernate.transaction.factory_class" >
       org.hibernate.transaction.JDBCTransactionFactory
     property >
     < mapping resource ="TItem.hbm.xml" />
   session-factory >
hibernate-configuration >

konhon 优华 2006-04-06 10:42 发表评论

Hibernate 的CRUD

konhon 优华 — Wed, 05 Apr 2006 01:37:00 GMT

Save
// 新增名為"Emma"的用戶記錄
Tuser user = new Tuser();
user.setName("Emma");
session.save(user);

Get
// 假設T_User表中存在ID = 1的記錄
Tuser user = (Tuser)session.get(Tuser.class, new Integer(1));

Delete
// 假設T_User表中存在ID = 1的記錄
Tuser user = (Tuser)session.get(Tuser.class, new Integer(1));
session.delete(user);

// 也可以通過HQL指定刪除條件
Session.delete(" from Tuser where id = 1");

// 通過Query接口進於基於HQL的刪除操作
Stirng hql = "delete Tuser where id = 1";
Query query = session.createQuery(hql);
query.executeUpdate();

Find
// 通過Query接口進行數據查詢
String hql="from Tuser user where user.name like ?";
Query query = session.createQuery(hql);
query.setParameter(0, "Cartier");

List list = query.list();

Iterator it = list.iterator();
while(it.hasNext()){
Tuser user = (Tuser)it.next();
System.out.println(user.getName());
}

// 通過Criteria接口進行數據查詢
Criteria criteria = session.createCriteria(Tuser.class);
criteria.add(Expression.eq("name","Cariter"));

List list = criteria.list();

Iterator it = list.iterator();
while(it.hasNext()){
Tuser user = (Tuser)it.next();
System.out.println(user.getName());
}

konhon 优华 2006-04-05 09:37 发表评论

Hibernate 通過數據產生基礎代碼之數據連接配置文件

konhon 优华 — Tue, 04 Apr 2006 07:42:00 GMT

使用MiddleGen for Hibernate工具.

配置./config/database下的mssql.xml文件

    < property name ="database.script.file"            value ="" />
    < property name ="database.driver.file"            value ="${lib.dir}/mssqlserver.jar" />
    < property name ="database.driver"                 value ="com.microsoft.jdbc.sqlserver.SQLServerDriver" />
    < property name ="database.url"                    value ="jdbc:Microsoft:sqlserver://192.168.10.236:1433;databaseName=Sample" />
    < property name ="database.userid"                 value ="sa" />
    < property name ="database.password"               value ="kidsland%55" />
    < property name ="database.schema"                 value ="dbo" />
    < property name ="database.catalog"                value ="Sample" />

    < property name ="jboss.datasource.mapping"        value ="MS SQLSERVER" />

注意: database.schema 與 database.catalog 不能為空.

konhon 优华 2006-04-04 15:42 发表评论

Hibernate : Query.list()、Query.iterator()的區別

konhon 优华 — Fri, 12 Aug 2005 03:25:00 GMT

Query上有list()與iterator()方法，兩者的差別在於list()方法在讀取資料時，並不會利用到快取，而是直接再向資料庫查詢，而iterator()則將讀取到的資料寫到快取，並於讀取時再次利用。

來看看下面的程式：

Session session = sessionFactory.openSession();

Query query = session.createQuery("from User");
List users = query.list();
users = query.list();

session.close();

這個程式片段會使用兩次SQL來查詢資料庫：

Hibernate: select user0_.id as id, user0_.name as name0_, user0_.age as age0_ from user user0_
Hibernate: select user0_.id as id, user0_.name as name0_, user0_.age as age0_ from user user0_

如果在Session關閉之前，要再將所有資料在取出，可以使用iterator()方法，例如：

Session session = sessionFactory.openSession();

Query query = session.createQuery("from User");
Iterator users = query.iterate();
users = query.iterate();

session.close();

這個程式片段會使用一次SQL向資料庫查詢，第二次則直接從快取中取得資料：

Hibernate: select user0_.id as col_0_0_ from user user0_

由於使用iterator()方法時會使用到Session level快取，所以在查詢大量資料時，會耗用大量的記憶體，必要時可以使用Session的evict()或clear()方法來清除快取。

konhon 优华 2005-08-12 11:25 发表评论

Hibernate之SessionFactory与Session

konhon 优华 — Thu, 11 Aug 2005 01:14:00 GMT

Session是由SessionFactory所創建，SessionFactory是執行緒安全的（Thread-safe），您可以讓多個執行緒同時存取SessionFactory而不會有資料共用的問題，然而Session則不是設計為執行緒安全的，所以試圖讓多個執行緒共用一個 Session，將會产生因資料共用而發生混亂的問題。

在Hibernate參考手冊中的 Quickstart with Tomcat 中，示範了一個HibernateUtil，它使用了ThreadLocal類別來建立一個Session管理的輔助類，這是Hibernate的Session管理一個廣為應用的解決方案，ThreadLocal是 Thread-Specific Storage 模式的一個運作實例。

由於Thread-Specific Stroage模式可以有效隔離執行緒所使用的資料，所以避開Session的多執行緒之間的資料共用問題，以下列出Hibernate參考手冊中的HibernateUtil類：

HibernateUtil.java

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
* @author Administrator
*
* TODO To change the template for this generated type comment go to Window -
* Preferences - Java - Code Style - Code Templates
*/
public class HibernateUtil {
    private static Log log = LogFactory.getLog(HibernateUtil.class);

    private static final SessionFactory sessionFactory;
    static {
        try {
            sessionFactory = new Configuration().configure()
                    .buildSessionFactory();
        } catch (Throwable ex) {
            log.error("Initial SessionFactory creation failed.", ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static final ThreadLocal session = new ThreadLocal();

    public static Session currentSession() {
        Session s = (Session) session.get();
        if (s == null) {
            s = sessionFactory.openSession();
            session.set(s);
        }
        return s;
    }

    public static void closeSession() {
        Session s = (Session) session.get();
        if (s != null)
            s.clear();
        session.set(null);
    }
}

在同一個執行緒中，Session被暫存下來了，但無須擔心資料庫連結Connection持續占用問題，Hibernate會在真正需要資料庫操作時才（從連接池中）取得Connection。

在程式中可以這麼使用HibernateUtil：

Session session = HibernateUtil.currentSession();
User user = (User) session.load(User.class, new Integer(1));
System.out.println(user.getName());
HibernateUtil.closeSession();

在Web應用程式中，可以藉助Filter來進行Session管理，在需要的時候開啟Session，並在Request結束之後關閉Session，這個部份，在 JavaWorld 技術論壇的 Wiki 上有篇在filter中關閉session 可以參考。

konhon 优华 2005-08-11 09:14 发表评论

如何学习Hibernate[轉]

konhon 优华 — Tue, 09 Aug 2005 08:14:00 GMT

http://www.javajia.com

Hibernate入门容易，掌握精通我也不敢自夸。我第一遍看Hibernate文档的时候也觉得很吃力，但不是因为Hibernate难掌握而感到吃力，是因为Hibernate文档处处都是持久层设计的经验和最佳实践。Hibernate文档准确的来说，绝大部分内容都在讲对象的持久层设计，而不是简单的Hibernate使用，使用问题查Java doc就够了。所以学习Hibernate，主要是在学习持久层的设计模式，如果你把Hibernate文档都看完了，还整天只会提那些 Hibernate的配置问题，Hibernate的类调用问题，我觉得这样的人还没有真正的入门，算是白学了。

我对Hibernate 的那些配置也不是特别纯熟，每次写hbm，都要对照文档一点点的检查；类调用参数也不太记得，写代码也要Java doc随时备查。但是我在学习Hibernate的时候即集中所有精力来理解Hibernate的运行原理，集中精力来掌握持久层设计应该把握的原则和技巧，这些才对我是最重用的东西。毫不夸张的说，学习完Hibernate，我对JDBC的编程也提高了一大截，更不要说对于J2EE架构的持久层的框架设计，基本上是了然于胸了，即使将来换了API，不用Hibernate的，改用JDO，Castor什么的，这些经验一样照用。

学习Hibernate主要不是在学习Hibernat怎么配置，用工具怎么生成hbm文件，如果你把重点放在这里，基本上等于白学了Hibernate。Hibernate的精华在于无与伦比的灵巧的对象持久层设计，这些持久层设计经验不会因为你不用Hibernate而丧失掉，我自己学习Hibernate，已经明显感觉到对持久层设计能力已经长了很多经验值了，这些经验甚至不光可以用在Java上，用在.net上也是一样。所以Hibernate配置的学习，我只是简单看看，用的时候知道到那里去查就行了，一堆复杂的生成工具我根本就看都不去看，这样算下来，掌握Hibernate的配置，可以用Hibernate来替代JDBC写程序，不过花上3天时间就足够了。我想3天时间对你来说不算很奢侈的学习代价吧。

为什么我这么强调学习Hibernate的对象持久层设计理念呢？那就看你的理想是想一辈子做一个程序员呢？还是想向更高的方向发展呢？从纯做技术的角度来说，职业发展的最高点是“系统架构师”，Bill Gates不是还叫做微软的首席系统架构师吗？System Architect职位需要的是你的学习和领悟能力，如果你不能把学习Hibernate得到的设计经验运用到其它地方，那么你是失败的，也没有资格做 System Architect。

不管JDO也好，Hibernate也好，TopLink也好，CocoBase也好，还是 Castor，还是什么Torque，OJB，软件的使用和配置方法可以各异，但本质上都是ORM，都是对JDBC的对象持久层封装，所以万变不离其宗，如果你完整的学习和掌握Hibernate花了1个月的时间，那么你再学习OJB的时间不应该超过1个星期，因为你已经把对象持久层设计都了然于胸了，你需要的只是熟悉一下OJB的API和配置罢了，至于怎么运用OJB进行持久层的开发你早就已经熟悉了。

所以当你掌握了两种以上的ORM，你应该能够不拘于使用的ORM软件的限制，设计出适合于你的项目的持久层来，这才是System Architect的水准。用金庸小说来打个比方来说吧，张无忌学太极剑，只记剑意，不记剑招，这才是真正的高手，而低手就只会去学习剑招，而不去领会剑招背后蕴含的剑意，所以一辈子都是低手，永远不能真正学会太极剑。所以周颠看到张三丰第二次演示太极剑，招式完全不同就以为是另一套东西，其实本质上都一样。学习Hibernate也不要舍本逐末的去学各种五花八门的工具，重点掌握它的对象持久层设计理念。

konhon 优华 2005-08-09 16:14 发表评论