这两个星期以来，我把原来用struts开发的一个测试工具改用struts+hibernate来实现，首先从心情上来，整个开发过程中始终保持愉快和平和，“原来开发可以这样愉快？”，再一点就是开发效率上高效了许多。
      现在sun又加入jdocentral.com开始着手JDO2.0，想想看等它出台以后将是一个怎样激动人心得场面，让我们拭目以待。
     
      用Hibernate来操纵持久数据非常简单，在这里一些简单的查询我会一笔带过，本文着重说明在综合查询兼有分页的时候我的一些经验，如果网友觉得我的方案还有不足的地方，也请和我讨论，我的email:plateau_t@sina.com.
     
      第一部分：Hibernate提供的查询接口或其方法（此部分不做深究，请参考hibernate手册）
     
       1。根据ID查询
    要用到Session接口的load方法。
    load(Class theClass, Serializable id)
    load(Class theClass, Serializable id, LockMode lockMode)
    load(Object object, Serializable id) 
    
       2。HQL语句进行查询
      
       2。1 利用Query接口，Query由Session里的createQuery()来产生一个查询
        1)不带参数的查询（这类比较简单）
        Query query=session.createQuery("select user from User as user");
        2)带参数的查询
        Query query=session.createQuery("select user from User as user where user.name=?");
        query.setString(0,name)//假设name为传过来的参数
        Query query=session.createQuery("select user from User as user where user.name=:name");
        query.setString("name",name)//假设name为传过来的参数
        (多个参数以此类推)
       
        利用Session接口的find查询
        find(String query)
        find(String query, Object[] values, Type[] types)
        find(String query, Object value, Type type)    均返回list  
        如:
        List list=session.find("select user from Users as user where user.name=?",name,Hibernate.STRING)
        List list=session.find("select user from Users as user where user.name=? and             user.pw=?",new Object[]{name,pw},new Type[]{Hibernate.STRING,Hibernate.STRING})
       
        {推荐使用Query的方法进行查询}  
       
      第二部分：hibernate综合查询解决方案 （此部分详细实例说明，如有不足的地方请写信给我）        
     
       大家从第一部分可以看到，带有参数的查询，必须使用到Query接口,如上边：
        Query query=session.createQuery("select users from Users as users where users.name=?");
        query.setString(0,name)//假设name为传过来的参数   
       但是在系统中如何才能写一个公用的查寻方法呢？咋一看，似乎是不可以的，因为每一次查询的参数不一样，参数的数量不一样（如下代码），那么我们如何提取共性呢？   
         Query query=session.createQuery("select users from Users as users where users.name=? and users.pw=?");
        query.setString(0,name)//假设name为传过来的参数 
        query.setString(1,pw);
      
      首先说明，我的解决方案是从Seesion接口的find方法找到出口的，如下为Session接口得find()方法之一：
        find(String query, Object[] values, Type[] types) 
      其中Object[]为存放参数值的数组，Type[]为存放参数类型的数组，他们的顺序是和query里“？” 的顺序是相同的。那么我为什么不用该find方法呢，因为如果有分页的情况，那么该方法将不适用。
    
      下面详细要说明的解决方案：
      首先我想创建三个新的对象：Paras.java（参数对象） ParasList.java（参数集合对象）HQuery.java
     （感谢我的同事camel提供注释良好的代码）
     1。Paras.java（参数对象）
    
  package com.ifreeway.homegrown.testing.waf;
  
  /**
   *
   * <p>Title:定义一个sql语句的条件参数类 </p>
   * <p>Description: 可以使用有序的参数集合传送给sql/hql语句 </p>
   * <p>Copyright: Copyright (c) 2003</p>
   * <p>Company: ifreeway</p>
   * @author camel
   * @version 1.0
   */
  
  public class Paras {
   /**
    * 参数名称
    */
   private Object pName;
   /**
    * 参数类型编码，于java.sql.types中的类型保持一致
    */
   private int typeNo;
  
   public Object getPName() {
    return pName;
   }
   public void setPName(Object pName) {
    this.pName = pName;
   }
   public int getTypeNo() {
    return typeNo;
   }
   public void setTypeNo(int typeNo) {
    this.typeNo = typeNo;
   }
  } 
 
 2。ParasList.java（参数集合对象） 
  package com.ifreeway.homegrown.testing.waf;
  
  import java.util.ArrayList;
  
  /**
   *
   * <p>Title: 参数集合类</p>
   * <p>Description: 封装sql/hql的参数到该集合类，便于处理和传递</p>
   * <p>Copyright: Copyright (c) 2003</p>
   * <p>Company: ifreeway</p>
   * @author camel
   * @version 1.0
   */
  
  public class ParaList extends ArrayList {
  
    /**
     * 在指定位置添加一个参数对象
     * @param index：参数的索引值
     * @param p：需要加入的参数对象
     */
    public  void addParas(int index,Paras p){
        super.add(index,p);
    }
  
    /**
     * 在集合的最后位置添加一个参数对象
     * @param p：需要加入的参数对象
     */
    public void addParas(Paras p){
      super.add(p);
    }
  
    /**
     * 取得指定位置的参数对象
     * @param index：参数的索引值
     * @return：参数对象
     */
    public Paras getParas(int index){
        return (Paras)super.get(index) ;
    }
    /**
     * 取得指定参数的索引
     * @param p：参数对象
     * @return：参数索引
     */
    public int indexofParas(Paras p){
       return super.indexOf(p) ;
    }
  
    /**
     * 从集合中去掉一个指定的参数对象
     * @param index：参数索引
     */
    public void removeParas(int index){
      super.remove(index) ;
    } 
  
  } 
 3。HQuery.java
  package com.ifreeway.homegrown.testing.waf;
  
  
  /**
   *
   * <p>Title: HQL的语句封装类</p>
   * <p>Description: 该对象封装HQL的查询语句，参数集合，排序参数，分组参数，单页起始地址  </p>
   * <p>Copyright: Copyright (c) 2003</p>
   * <p>Company:ifreeway </p>
   * @author camel
   * @version 1.0
   */
  
  public class HQuery {
  
    /**
     * HQL查询语句
     */
    private String queryString;
    /**
     * 参数集合对象
     */
    private ParaList paralist;
    /**
     * 排序字段
     */
    private String orderby;
    /**
     * 分组字段
     */
    private String groupby;
    /**
     * 分页起始查询地址
     */
    private int pageStartNo;
  
    /**
     * 取得一个Hibernate的Query对象
     * @return：Query对象
     */
    public String getQueryString() {
      return queryString;
    }
  
    /**
     * 设置一个HQL查询字符串
     * @param queryString：查询字符串
     *
     */
    public void setQueryString(String queryString) {
  
     this.queryString =queryString;
  
    }
  
    /**
     * 取得参数集合对象
     * @return：参数集合对象
     */
    public ParaList getParalist() {
      return paralist;
    }
  
    /**
     * 设置参数集合对象
     * @param paralist：参数集合对象
     */
    public void setParalist(ParaList paralist) {
      this.paralist = paralist;
    }
  
    /**
     * 取得排序字段
     * @return：排序字段
     */
    public String getOrderby() {
      return orderby;
    }
  
    /**
     * 设置排序字段
     * @param orderby
     */
    public void setOrderby(String orderby) {
      this.orderby = orderby;
    }
  
    /**
     * 取得分组字段
     * @return
     */
    public String getGroupby() {
      return groupby;
    }
  
    /**
     * 设置分组字段
     * @param groupby
     */
    public void setGroupby(String groupby) {
      this.groupby = groupby;
    }
  
    /**
     * 取得页起始地址
     * @return
     */
    public int getPageStartNo() {
      return pageStartNo;
    }
  
    /**
     * 设置页起始地址
     * @param pageStartNo
     */
    public void setPageStartNo(int pageStartNo) {
      this.pageStartNo = pageStartNo;
    }
  } 
  
 上面三个对象的关系是：
 
 用Paras来装载每一个查询参数
  Paras paras=new Paras();
  paras.setPName(...);
  paras.setTypeNo(...);
 然后放在ParasList中
  ParasList paraslist=new ParasList();
  paraslist.add(paras)
 最后把填充以后的ParasList集合给HQuery 
  HQuery hquery=new HQuery();
  hquery.setParalist(paraslist);
  
 先面我们写一个公用查寻方法，来实现我们的综合查询：
 
 /**
  *
  *  综合查询，首先实例化HQuery
  * @see com.ifreeway.homegrown.testing.common.waf.DBHandler#find(com.ifreeway.homegrown.testing.common.waf.HQuery)
  */
 public List find(HQuery _query) throws HibernateException {
  List itr = null;
  try {
   StringBuffer query_str = new StringBuffer(_query.getQueryString());
   //是否要排序
   if (_query.getOrderby() != null) {
    query_str.append(_query.getOrderby());
   }
   //是否要分组
   if (_query.getGroupby() != null) {
    query_str.append(_query.getGroupby());
   }
   Session session = getSession();
   Query query = session.createQuery(query_str.toString());
   if (_query.getParalist() != null) {
    List list = _query.getParalist();
    for (int i = 0; i < list.size(); i++) {
     Paras param = (Paras) list.get(i);
     switch (param.getTypeNo()) {//此处要根据参数类型的增加要增加相应的“case”
      case Types.VARCHAR :
       query.setString(i, param.getPName().toString());
       break;
      case Types.INTEGER :
       query.setInteger(
        i,
        ((Integer) param.getPName()).intValue());
       break;
      case Types.DATE :
       query.setDate(i, (java.sql.Date) param.getPName());
       break;
      case Types.DOUBLE :
       query.setDouble(
        i,
        ((Double) param.getPName()).doubleValue());
       break;
      case Types.BOOLEAN :
       query.setBoolean(
        i,
        ((Boolean) param.getPName()).booleanValue());
       break;
      case Types.CHAR :
       query.setCharacter(
        i,
        ((Character) param.getPName()).charValue());
       break;
      case Types.JAVA_OBJECT :
       query.setEntity(i, (BaseModel) param.getPName());
       break;
     }
    }
   }
   //是否存在分页，当_query.getPageStartNo()==0是不分页
   if (_query.getPageStartNo() != 0) {
    int pageno = _query.getPageStartNo();
    query.setFirstResult((pageno - 1) * Constants.RECORD_PER_PAGE);
    query.setMaxResults((pageno) * Constants.RECORD_PER_PAGE);
   }
   itr = query.list();
   closeSession();
  } catch (Exception e) {

  }
  return itr;
 } 
    
      好了一旦我们做好了上边的工作，查询对我们来说将是很容易的一件事情，而且可以达到公用，是不是省了许多力气？下面我将实例化一个例子来进一步说明：
     
      例子：
      HQuery hquery=HQuery();
      hquery.setQueryString("select users from Users as users where users.name=? and users.sex=?");
      hquery.setOrderby("order by users.age desc");
     
      //如果要分页，把当前页curpage传递给hquery
      hquery.setPageStartNo(curpage);
     
      //实例化参数，本例为两个参数
      Paras paras1=new Paras();
      paras1.setPName(name);
      paras1.setTypeNo(Types.VARCHAR);
     
      Paras paras2=new Paras();
      paras2.setPName(sex);
      paras2.setTypeNo(Types.INTEGER);
     
      ParasList paraslist=new ParasList();
      paraslist.add(paras1);
      paraslist.add(paras2);//注意顺序
     
      hquery.setParalist(paraslist);
     
      //好了，做好准备工作，调用查寻方法得到结果
      List list=find(hquery);
      
     

近两天来在研究Hibernate中的one-to-one和one-to-many的问题，做了很多试验，发现实现表关系时，在hibernate-mapping中generator的class设为uuid.hex，上述的两种关系可以实现，也就是数据库的主键设为varchar（MSSQL2000），但是主键改成int型的标识却弹出“ERROR SessionImpl:2379 - Could not synchronize database state with session”和“net.sf.hibernate.HibernateException: SQL insert, update or delete failed (row not found)”异常，百思不得其解。下面贴出主键设为uuid.hex时的实现代码：

Child.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping SYSTEM "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
<hibernate-mapping>
    <class name="test.pojo.Child" table="child">
        <id name="cid" column="cid" >
            <generator class="uuid.hex"/>
        </id>
        <property name="cname" column="cname" />
        <many-to-one name="parent" column="pid" />
    </class>
</hibernate-mapping>

Child.java

package test.pojo;

public class Child {
    private String cname;
    private String pid;
    private Parent parent;
    private String cid;
    public Child() {
    }

    public String getCid() {
        return cid;
    }

    public void setCid(String cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    public Parent getParent() {
        return parent;
    }

    public void setParent(Parent parent) {
        this.parent = parent;
    }
}

Parent.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping SYSTEM "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
<hibernate-mapping>
    <class name="test.pojo.Parent" table="parent" >
        <id name="pid" column="pid" type="integer">
            <generator class="uuid.hex" />
        </id>
        <property name="pname" column="pname" />
        <set name="child" lazy="true" inverse="true" cascade="all">
            <key column="cid" />
            <one-to-many class="capinfo.negroup.test.pojo.Child"/>
        </set>
    </class>
</hibernate-mapping>

Parent.java
package test.pojo;

import java.util.HashSet;

public class Parent {
    private String pname;
    private java.util.Set child = new HashSet();
    private String pid;
    public Parent() {
    }

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public java.util.Set getChild() {
        return child;
    }

    public void setChild(java.util.Set child) {
        this.child = child;
    }

}

TestHibernate.java
package test.pojo;

public class TestHibernate {
    public TestHibernate() {
    }

    public static void main(String[] argv) {
        //先建立多的初始数据
        Child child = new Child();
        child.setCname("kerry");
        //再建立一的初始数据
        Parent parent = new Parent();
        parent.setPname("Kelphen");
        //将多的数据放入到一里
        parent.getChild().add(child);
        //再将一放到多里，这样一与多互相拥有对方
        child.setParent(parent);
        try {
            BaseDAOHibernate.saveObject(parent);
        }
        catch (DAOException daoe) {
            daoe.printStackTrace();
        }
    }
}

性能测试：
   对一个9036条记录的表进行load测试，表字段有8个，有一个字段是text型，每条记录的该字段约有1300多字节，其余都是简单字段
   软硬件：AMD XP1600+, 512M内存（测试时内存有余），winXP SP1, JDK1.4.2_06, Mysql4.1.9,InnoDB,GBK, mm.3.1.6驱动， tomcat5.0.28（启动设置最大内存256M，最小内存64M）,hibernate2.1.8, 打开二级缓存Ehcache（配置二级缓存最多10000个对象）关闭所有hibernate log信息和sql输出
  
   方法1：先用 List idList = session.find("select o.id from MyClass o");找出idList然后
          list.add(session.load(MyClass.class, (Long)idList.get(i)));组成list
   方法2：直接用hibernate的session.find(from MyClass )得到list
   方法3：直接用hibernate的session.iterator(from MyClass )，然后list = new ArrayList(9100);  while(iter.hasNext()) { list.add(iter.next()); }构造list
  
   每个方法连续调用5次。（第1次调用是没有二级缓存的结果，第2次以后是有二次缓存的结果）
  
   结果如下：  
       
    结束第1次loadAll1()方法, 用时15763ms~14762ms
    结束第2次loadAll1()方法, 用时771ms~580ms
    结束第3次loadAll1()方法, 用时631ms~611ms
    结束第4次loadAll1()方法, 用时641ms~591ms
    结束第5次loadAll1()方法, 用时601ms~551ms
  
    结束第1次loadAll2()方法, 用时2965ms~3025ms
    结束第2次loadAll2()方法, 用时2854ms~2950ms 
    结束第3次loadAll2()方法, 用时2613ms~
    结束第4次loadAll2()方法, 用时2815ms~
    结束第5次loadAll2()方法, 用时2653ms~
    
    结束第1次loadAll3()方法, 用时16664ms~16514ms
    结束第2次loadAll3()方法, 用时651ms~661ms
    结束第3次loadAll3()方法, 用时621ms~591ms
    结束第4次loadAll3()方法, 用时571ms~571ms
    结束第5次loadAll3()方法, 用时641ms~631ms     

  
   分析： 方法1和方法3在访问数据库的策略是一样的，所以运行时间基本差不多。（方法3稍慢一点可能是iterator遍历再组成list用的时间较多）这两种方法第一次运行都要进行9036+1次数据库访问，所以时间最长。而第二次以后运行只需访问一次数据库，并只取出数据的id不取别的字段，因为此时所有对象都已经存在二级缓存中，剩下的是访问二级缓存组成list，所以速度最快。
  
          而方法2每次都会访问数据库load所有数据的所有字段，打开cache的log信息，可以看出第2次以后会通过二级缓存得到数据，但是由于load所有字段占用时间占了此方法较大比例的开销，所以，即使访问二级缓存，性能提高也非常微小，每次运行的时间花费几乎一样。
  
         

注意事项：
  (1)不要在机器运行较长时间后运行tomcat进行测试，特别是机器启动后频繁地开启tomcat，java程序，打开较大应用程序占用很多内存的时候。那时候测试结果一定不准。比如：我昨天晚上测试先用方法1的时间是200S，60S，后运行方法2，竟然用了8000S,200S!
  (2)设置log4j的LOG级别，不要hibernate和sql的信息。时间会减少很多。（log4j的配置文件难道有这个规矩：一行结尾不能有空格的说？？？FT！！！）
  (3)在tomcat启动时进行测试，并在测试方法前调用一个会用到hibernate的方法，让hibernate初始化先完成