BlogJava-Topquan's Blog-文章分类-Hibernate

Hibernate-----The first Program

topquan — Sun, 06 Aug 2006 01:05:00 GMT

一、准备工作

其实Hibernate本身是个独立的框架，它不需要任何web server或application server的支持。然而，大多数的Hibernate入门介绍都加入了很多非Hibernate的东西，比如: Tomcat, Eclipse, Log4J,Struts, XDoclet, 甚至JBoss。这容易让人产生Hibernate复杂难懂的误解，特别是打击了初学者的积极性。

在这篇文章将不涉及Eclipse, log4j, Struts, Tomcat, XDoclet，和JBoss。本文的目的是演示一下Hibernate的安装过程以及最基本的功能，从而给初学者一个低得不能再低的入门门槛。

下载文件

你需要Java SDK、 Hibernate包、Ant包、和JDBC Driver。

1、Hibernate包下载地址:
http://prdownloads.sourceforge.net/hibernate/?sort_by=date&sort=desc

2、Ant包下载地址:
http://apache.130th.net/ant/binaries/apache-ant-1.6.1-bin.zip

3、JDBC Driver要根据你用的database来定，一般database官方网站上都会有。Hibernate支持常用的database，比如 MySQL, Oracle, PostgreSQL, 和MS-SQL Server。这些数据库都有JDBC Driver:

Oracle JDBC Driver下载地址(下载前必须同意Oracle协议书)
http://otn.oracle.com/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html

MySQL JDBC Driver下载地址
http://dev.mysql.com/downloads/connector/j/3.0.html

PostgreSQL JDBC Driver下载地址
http://jdbc.postgresql.org/download.html

MS-SQL Server JDBC Driver下载地址
http://www.microsoft.com/downloads/details.aspx?FamilyID=9f1874b6-f8e1-4bd6-947c-0fc5bf05bf71&displaylang=en

4、将Hibernate包和Ant包分别解压至c:\dev\下(此目录不重要，你可以换其它任何目录)。

配置环境

1>、你需要添加一个新的环境变量: ANT_HOME，让它指向c:\dev\<你的ANT包所在目录>。并在PATH环境变量里添加%ANT_HOME%\bin。

2>、你需要添加一个新的环境变量: JAVA_HOME，让它指向你的j2sdk根目录。并在PATH环境变量里添加%JAVA_HOME%\bin。

3>、创建一个项目目录，比如c:\workspace\My1stHibernate。

在项目目录下，另外创建三个目录: src, classes, lib。

在lib目录下，创建两个目录: hibernate和db。

这样你有了如下的文件结构:

c:\workspace\My1stHibernate\
c:\workspace\My1stHibernate\src
c:\workspace\My1stHibernate\classes
c:\workspace\My1stHibernate\lib
c:\workspace\My1stHibernate\lib\hibernate
c:\workspace\My1stHibernate\lib\db

4、将c:\dev\<你的Hibernate包所在目录>\hibernate2.jar文件copy到c:\workspace\My1stHibernate\lib\hibernate下。

将c:\dev\<你的Hibernate包所在目录>\lib\下的所有文件同样copy到c:\workspace\My1stHibernate\lib\hibernate下。

将你的JDBC Driver文件(一般是一个jar文件)copy到c:\workspace\My1stHibernate\lib\db下。

二、创建数据库

1、用你最喜爱的database软件，创建一个hibernate_test的数据库。

2、在此数据库下，新建一个table名为CUSTOMER

CREATE TABLE CUSTOMER
(
    CID INTEGER NOT NULL PRIMARY KEY,
    USERNAME VARCHAR(12) NOT NULL,
    PASSWORD VARCHAR(12)
);

三、编写Java文件（POJO）

public class Customer {

    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public String getPassword() {
        return password;
    }

    public String getUsername() {
        return username;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setUsername(String username) {
        this.username = username;
    }

}

将此类存为c:\workspace\My1stHibernate\src\Customer.java文件。

四、编写Test类

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;

public class Test {

public static void main(String[] args) {

        try {
            SessionFactory sf =
                new Configuration().configure().buildSessionFactory();
            Session session = sf.openSession();
            Transaction tx = session.beginTransaction();

            for (int i = 0; i < 200; i++) {
                Customer customer = new Customer();
                customer.setUsername("customer" + i);
                customer.setPassword("customer");
                session.save(customer);
            }

tx.commit();
session.close();

        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }
}

将此类存为c:\workspace\My1stHibernate\src\Test.java文件。

五、创建Hibernate映射文件

因为这里只有一个Class --- Customer 和一个Table --- CUSTOMER，你只需要建立一个映射文件--- Customer.hbm.xml，来对应Customer类和CUSTOMER表之间的关系。

"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

把此文件存为c:\workspace\My1stHibernate\src\Customer.hbm.xml，和Customer.java放在同一目录下。

六、编写Ant build.xml文件

你不一定要知道这个build.xml的细节，其实Ant也不是Hibernate所必须的。这里用Ant是为了简化一些任务，比如: 编译、copy、运行，等。

七、配置Hibernate描述文件

Hibernate描述文件可以是一个properties或xml 文件，其中最重要的是定义数据库的连接。我这里列出的是一个XML格式的hibernate.cfg.xml描述文件。

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

        true

            oracle.jdbc.driver.OracleDriver


            jdbc:oracle:oci8:@hibernate_test


            你的数据库用户名


            你的数据库密码


            net.sf.hibernate.dialect.Oracle9Dialect

如果你用的不是Oracle 9i，可到C:\dev\<你的Hibernate包所在目录>\src\hibernate.properties文件里找到你的数据库，然后替换以上相对应的值。

八、开始运行

到c:\workspace\My1stHibernate下，运行ant run。如果你严格依照以上步骤，应该看到

run:
        [java] log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).
        [java] log4j:WARN Please initialize the log4j system properly.
        [java] Hibernate: insert into CUSTOMER (USERNAME, PASSWORD, CID) values (?, ?, ?)
BUILD SUCCESSFUL

到你的hibernate_test数据库看一下，在CUSTMOR表里新添了200条记录，但你没有写任何JDBC code。
以后如果你要更换数据库，只需要改变hibernate.cfg.xml描述文件里相应的值即可。

topquan 2006-08-06 09:05 发表评论

hibernate延迟加载

topquan — Fri, 04 Aug 2006 17:20:00 GMT

延迟加载的对象：
hibernate 2针对实体对象和集合
hibernate 3同时提供了属性的延迟加载功能。
其中对集合的延迟加载特性意义最为重大。

实体对象的延迟加载:
1.在hibernate配置文件中的class指定

集合类型的延迟加载：
在set中指定lazy=true
这样只有实际加载与对象相关联的集合对象的时候，再通过session从数据库中加载实际的数据集。
Hibernate.initialize方法可以强制Hibernate立即加载关联的对象集，例如：
Hibernate.initialize(user.getAddress());
集合类型的缓存：
如果为某个集合类设定了缓存，如
    name="address"
    table="t_address"
    lazy="true"
    ......
>




Hibernate对集合类型进行缓存的时候，分两部分保存。首先是这个集合中所有实体的id列表，其次才是各个实体对象。
这里制定了cache usage="read-only"只会使得Hibernate对数据索引进行缓存。也就是说只缓存了集合中的数据索引，并不包含集合中的各个实体元素。
如果指定cache usage="read-write"才会对集合中的实体进行缓存。

属性的延迟加载：
在property节点中声明lazy=true,而且还需要借助Hibernate类增强器对POJO类的二进制Class文件进行强化处理。

hibernate中的Collection
Hibernate对JDK Collention接口的独立实现：
由于传统的Java Set, Map, List实现不能满足要求，Hibernate根据这些接口提供了自己的实现。
Hibernate的实现：
无序集：Set, Bag, Map
有序集：List
Bag相当于一个允许重复元素存在的Set。
因为Hibernate是自己的Collection实现，所以如下语句会出错，
Set hset = (HashSet)user.getAddresses();
会在运行期报告一个java.lang.ClassCastException,因为实际上返回的是一个类型为org.hibernate.collention.Set的对象。
所有我们在写POJO时，必须用JDK Collection Interface(如Set, Map)，而非特定的JDK Collection实现类(如HashSet, HashMap)声明Collection型属性的原因。例如：
应该是private Set addresses;
而不是private HashSet addresses;

collection类型属性的保存过程。
例如
public class TUser implements Serializable {
private Set addresses = new HashSet();
......
}

然后创建一个TUser实例后，就可以为其添加关联的address对象：
TUser user = new TUser();
TAddress addr = new TAddress();
addr.setAddress("HongKong");
user.getAddress().add(addr);
session.save(user);
user对象在经过Hibernate处理后发生了变化，首先，由于insert操作，产生了id值，并填充到user对象的id属性，另一方面Hibernate使用了自己的collection实现对user中的HashSet型addresses属性进行了替换，并用数据对其进行了填充。

topquan 2006-08-05 01:20 发表评论

hibernate数据加载

topquan — Fri, 04 Aug 2006 17:19:00 GMT

单一数据加载：Session.get/load
均可以根据指定的实体类和id从数据库中读取记录，并返回与之对应的实体对象。
区别：
1.如果未能发现符合条件的记录，get方法返回null,而load方法会抛出一个ObjectNotFoundException。
2.Load方法可返回实体的代理类实例，而get方法永远直接返回实体类。
3.load方法可以充分利用内部缓存和二级缓存中的现有数据，而get方法仅在内部缓存中查找，如果没有发现对应的数据，将越过二级缓存，直接调用SQL完成数据读取。
数据加载的过程：
1.在一级缓存中，根据实体类型和id进行查找，如果在第一级缓存中命中，且数据状态合法，则直接返回。
2.Session会在当前"NonExists"记录中进行查找，如果在"NonExists"记录中存在同样的条件，返回null。
3.对load方法而言，如果内部缓存中没法现有效数据，查询二级缓存，命中则返回。
4.如果缓存中无有效数据，发起数据库查询操作(Select SQL)，如果经过查询未发现对应记录，将此次查询的信息在"NonExists"中加以记录，返回null.
5.根据映射配置和Select SQL查询得到的ResultSet，创建对应的数据对象。
6.将对象纳入一级缓存。
7.执行Interceptor.onLoad方法(如果有对应的Interceptor)
8.将数据纳入二级缓存
9.如果数据对象实现了LifeCycle接口，则调用数据对象的onLoad方法。
10.返回数据对象。

批量查询：Session.find/iterate
查询性能往往是系统性能表现的一个重要方面，查询机制的优劣很大程度上决定了系统的整体性能。这个领域往往也存在最大的性能调整空间。

hibernate2中Session.find()对应于3中的session.createQuery().list();
hibernate2中Session.iterate()对应于3中的session.createQuery().iterate();
find和iterate区别：
find方法通过一条Select SQL实现了查询操作，而iterate方法要执行多条Select SQL.
iterate第一次查询获取所有符合条件的记录的id，然后再根据各个id从库表中读取对应的记录，这是一个典型的N+1次的查询问题，如果符合条件记录有10000条，就需要执行10001条Select SQL，可想性能会如何的差。

那为什么要提供iterator方法，而不只是提供高效率的find方法？

原因1.与hibernate缓存机制密切相关
find方法实际上是无法利用缓存的，它对缓存只写不读。
find方法只执行一次SQL查询，它无法判断缓存中什么样的数据是符合条件的，也无法保证查询结果的完整性。而iterate方法，会首先查询所有符合条件记录的id，然后根据id去缓存中找，如果缓存中有该id，就返回，没有可以根据id再去数据库查询。
String hql = "from TUser where age > ?";
List userList = session.find(hql, new Integer(18), Hibernate.INTEGER);
Iterator it = session.iterate(hql, new Integer(18), Hibernate.INTEGER);
顺序执行，iterate方法只会执行一次SQL查询，就是查找id，然后根据id就可以从缓存中获得数据。

String hql = "from TUser where age > ?";
List userList = session.find(hql, new Integer(18), Hibernate.INTEGER);
userList = session.find(hql, new Integer(18), Hibernate.INTEGER);
缓存是不起作用的。
如果目标数据读取相对较为频繁，通过iterate这种机制，会减少性能损耗。

原因2.内存使用上的考虑
find方法将一次获得的所有记录并将其读入内存。如果数据量太大，可能会触发OutOfMemoryError，从而导致系统异常。解决方案之一就是结合iterate方法和evict方法逐条对记录进行处理，将内存消化保持在一个可以接受的范围之内。如：
String hql = "from TUser where age > ?";
Iterator it = session.iterate(hql, new Integer(18), Hibernate.INTEGER);
while(it.hasNext()) {
    TUser user = (TUser)it.next();

    //将对象从一级缓存中删除
    session.evict(user);

    //二级缓存可以设定最大缓存量,达到后自动对较老数据进行废除,但也可以通过编
    //码移除,这样有助于保持数据有效性。
    sessionFactory.evict(TUser.class, user.getID());
}

批量数据处理的缓存同步问题
1.hibernate 2:
session.delete("from TUser");
会先查询出id，然后逐个id执行 delete from T_User where id = ?;
这样造成效率低下。
为什么不直接采用一条Delete SQL？是因为ORM要自动维持其内部状态属性，必须知道用户作了什么操作。必须先从数据库中获得待删除对象，然后根据这些对象对内部缓存和二级缓存的数据进行整理，以保持内存状态与数据库的一致性。
单执行一条删除语句，删除了什么数据，只有数据库知道，ORM无法得知。下次用户从缓存中读出的数据，很可能就是被删除的数据，从而导致逻辑错误。当然，如果ORM可以根据DELETE SQL对缓存中数据进行处理，将缓存中符合条件的对象废除，然后再执行DELETE SQL
，但是这样导致缓存的管理复杂性大大增加(实际相当于实现了一个支持SQL的内存数据库)，这对于轻量级的ORM实现而言太苛刻了。
2.hibernate 3
性能提高。
但无法解决缓存同步上的问题，无法保证缓存数据的一致有效性。
Tuser user = (TUser)session.load(TUser.class, new Integer(1));

//通过Bulk delete/update 删除id=1的用户记录
Transaction tx = session.beginTransaction();
String hql = "delete TUser where id=1";
Query query = session.createQuery(hql);
query.executeUpdate();
tx.commit();

//再次尝试加载
user = (TUser)session.load(TUser.class, new Integer(1));
可以看到第二次加载是成功的。

topquan 2006-08-05 01:19 发表评论

hibernate事务处理和锁

topquan — Fri, 04 Aug 2006 17:18:00 GMT

事务处理：
Hibernate本身并不具备事务管理能力。在事务管理层，Hibernate将其委托给底层的JDBC或者JTA，以实现事务的管理与调度。

基于JDBC的事务：
无疑是最简单的实现方式，
session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
tx.commit();

基于JTA的事务管理：
hibernate默认采用JDBC Transacion。可以通过配置文件指定采用JTA作为事务管理实现。


        ......

  org.hibernate.transaction.JTATransactionFactory

锁(locking)
支持两种锁：悲观锁和乐观锁

悲观锁(Pessimistic locking)：
数据库的实现
select * from account where name='yyy' for update
通过for update子句，这条语句锁定所有符合条件的记录，在本次事务提交之前，外界无法修改这些记录。

hibernate的实现，也是基于数据库的锁机制实现：
加锁一般通过以下方法实现：
Criteria.setLockMode
Query.setLockMode
Session.lock

hibernate的加锁模式：
LockMode.NONE:无锁机制
LockMode.WRITE:hibernate在Insert和update时，会自动获取
LockMode.READ:hibernate在读取记录的时候，会自动获取
以上3种，由hibernate内部使用。

LockMode.UPGRADE:利用数据库的for update子句加锁
LockMode.UPGRADE_NOWAIT：oracle特定实现，利用oracle的for update nowait子句实现加锁。

乐观锁(Optimistic locking)：
hibernate在其数据访问引擎中内置了乐观锁实现。可以通过class描述符的optimistic-lock属性结合version描述符指定。

            name="org.hibernate.sample.TUser"
        table="t_user"
        dynamic-update="true"
        dynamic-insert="true"
        optimistic-lock="version"
    >
     ......

               column="version"
         name="version"
         type="java.lang.Integer"
      />


注意,version节点要在ID节点之后。
这里，声明了一个version属性，用于存放用户的版本信息，保存在T_User表的version字段中。

topquan 2006-08-05 01:18 发表评论

Hibernate 数据缓存

topquan — Fri, 04 Aug 2006 17:16:00 GMT

在Hibernate中，缓存将在以下情况中发挥作用：
1.通过id[主键]加载数据的时候
2.延迟加载

一级缓存：
又称内部缓存，保存了与当前session相关联的数据对象，伴随Session实例的创建而创建，消亡而消亡。因此又称此缓存为Session level cache。

一级缓存正常情况下又Hibernate自动维护，如果需要手动干预，可以通过以下方法完成。
1.Session.evict
将某个特定对象从内部缓存中清除。
2.Sessin.clear
清空内部缓存

二级缓存：
又称为SessionFactory Level Cache.
对什么样的数据使用二级缓存？
对所有数据都进行缓存是最简单的办法，也是最常用的办法。
但是某些情况下，反而会影响性能，比如电话费查询系统，如果实行缓存，内存会被几乎不可能再被重用的数据充斥，导致性能下降。
如果数据满足以下条件，可以将其纳入缓存管理：
1.数据不会被第三方应用修改。
2.data size在可以接受的范围之内
3.数据更新频率较低
4.同一数据可能会被系统频繁引用
5.非关键数据
Hibernate本身并没提供二级缓存的产品化实现(只提供了一个基于HashTable的简单缓存以供调试)，可以使用第三方缓存来实现。
默认采用EHCache作为二级缓存实现。
EHCache org.ehcache.hibernate.Provider

topquan 2006-08-05 01:16 发表评论

Hibernate Component

topquan — Fri, 04 Aug 2006 16:49:00 GMT

将实体对象中的逻辑组成称为component。在配置文件中，使用component节点对组件进行声明。

例如，一个用户有两个部分组成，姓名和联系方式。姓名和联系方式都可以作为用户的组成部分。

1.表结构如下

use sample;
DROP TABLE t_user;

CREATE TABLE t_user (
       id INT NOT NULL AUTO_INCREMENT
     , age INT
     , firstname VARCHAR(50)
     , lastname VARCHAR(50)
     , address VARCHAR(200)
     , zipcode VARCHAR(10)
     , tel VARCHAR(20)
     , PRIMARY KEY (id)
);

2.配置文件
TUser.hbm.xml

="1.0"?>
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

    ="cn.blogjava.component.TUser" table="t_user" catalog="sample">
        ="id" type="integer">
            ="id" />
            ="native" />

        ="age" type="integer">
            ="age" />

        ="name" class="cn.blogjava.component.Name">
            ="firstname" type="string">
                ="firstname" length="50" />

            ="lastname" type="string">
                ="lastname" length="50" />


        ="contact" class="cn.blogjava.component.Contact">
            ="address" type="string">
                ="address" length="200" />

            ="zipcodes" type="string">
                ="zipcode" length="10" />

            ="tel" type="string">
                ="tel" length="20" />

将TUser.hbm.xml配置文件加入到hibernate.cfg.xml中去

3.POJO类
Contact.java

package cn.blogjava.component;

import java.io.Serializable;

public class Contact implements Serializable {

    private String address;
    private String zipcodes;
    private String tel;

    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getTel() {
        return tel;
    }
    public void setTel(String tel) {
        this.tel = tel;
    }
    public String getZipcodes() {
        return zipcodes;
    }
    public void setZipcodes(String zipcodes) {
        this.zipcodes = zipcodes;
    }


}

Name.java

package cn.blogjava.component;

import java.io.Serializable;

public class Name implements Serializable {

    private String firstname;
    private String lastname;

    public String getFirstname() {
        return firstname;
    }
    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }
    public String getLastname() {
        return lastname;
    }
    public void setLastname(String lastname) {
        this.lastname = lastname;
    }


}

TUser.java

package cn.blogjava.component;

public class TUser  implements java.io.Serializable {
    private Integer id;
    private Integer age;
    private Name name;
    private Contact contact;

    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Contact getContact() {
        return contact;
    }
    public void setContact(Contact contact) {
        this.contact = contact;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Name getName() {
        return name;
    }
    public void setName(Name name) {
        this.name = name;
    }

}

4.测试类

package cn.blogjava.component;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import junit.framework.TestCase;
import junit.framework.Assert;

public class HibernateTest extends TestCase {

    Session session = null;

    protected void setUp(){
        try {
            Configuration config = new Configuration().configure();
            SessionFactory sessionFactory = config.buildSessionFactory();
            session = sessionFactory.openSession();
//            delete();
        } catch (HibernateException e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

    protected void tearDown() {
        try {
            session.close();
        } catch (HibernateException e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

    public void delete(){
        Transaction tran = null;
        String hql = " delete TUser";
        try {
            tran = session.beginTransaction();
            Query query = session.createQuery(hql);
            int ret = query.executeUpdate();
            System.out.println("Delete records => " + ret);
            tran.commit();
        } catch (HibernateException e) {
            // TODO: handle exception
            e.printStackTrace();
            Assert.fail(e.getMessage());
            if(tran != null) {
                try {
                    tran.rollback();
                } catch(HibernateException e2) {
                    e2.printStackTrace();
                }
            }
        }
    }

    public void testInsert(){
        Transaction tran = null;
        try {
            System.out.println("session is " + session);
            tran = session.beginTransaction();

            //user1
            TUser user = new TUser();
            user.setAge(25);
            Name name = new Name();
            name.setFirstname("yu");
            name.setLastname("yy");
            user.setName(name);
            Contact contact = new Contact();
            contact.setAddress("dalian");
            contact.setTel("42689334");
            contact.setZipcodes("116023");
            user.setContact(contact);

            session.save(user);

            //user2
            TUser user2 = new TUser();
            user2.setAge(26);
            Name name2 = new Name();
            name2.setFirstname("bai");
            name2.setLastname("yf");
            user2.setName(name2);
            Contact contact2 = new Contact();
            contact2.setAddress("beijing");
            contact2.setTel("12345678");
            contact2.setZipcodes("100010");
            user2.setContact(contact2);

            session.save(user2);

            session.flush();
            tran.commit();
            Assert.assertEquals(user.getId().intValue() > 0, true);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            Assert.fail(e.getMessage());
            if(tran != null) {
                try {
                    tran.rollback();
                } catch(HibernateException e2) {
                    e2.printStackTrace();
                }
            }
        }
    }

    public void testSelect(){
        String hql = " from TUser where age=25 ";
        try {
            List userList = session.createQuery(hql).list();
            TUser user = (TUser)userList.get(0);
            Contact contact = user.getContact();
            Assert.assertEquals(contact.getAddress(), "dalian");
            Assert.assertEquals(user.getName().getFirstname(), "yu");
        } catch (HibernateException e) {
            // TODO: handle exception
            e.printStackTrace();
            Assert.fail(e.getMessage());
        }
    }
}

topquan 2006-08-05 00:49 发表评论

使用Hibernate Tool执行Hql语句

topquan — Fri, 04 Aug 2006 16:47:00 GMT

1.首先，打开Hibernate Configurations视图。

2.在视图中的配置上，点击右键，编辑配置，配置如下

3.在配置上，点击右键，选择HQL Scratchpad，打开HQL语句编辑窗口

4.可以通过Hibernate Dynamic Query Translator，查看最终执行的SQL语句。

5.可以通过Query Parameters来设置查询参数

6.可以通过Hibernate Query Result来查看查询结果

7.结合property视图，看得更清楚

topquan 2006-08-05 00:47 发表评论

Hibernate一对多数据关联

topquan — Fri, 04 Aug 2006 16:44:00 GMT

摘要: 一对多数据关联一.单向一对多数据关联一个用户有多个地址，在用户类TUser中包含地址类TAddress集合。1.数据模型2.表定义sql use sample;DROP TABLE T_Address;DROP TABLE T_User;CREATE TABLE T_User ( &... 阅读全文

topquan 2006-08-05 00:44 发表评论

Hibernate一对一数据关联(二)

topquan — Fri, 04 Aug 2006 16:42:00 GMT

摘要: 唯一外键关联一.单向一对一关联1.数据模型如下图所示：2.数据表sql DROP TABLE T_User;DROP TABLE T_Group;CREATE TABLE T_Group ( id INT NOT N... 阅读全文

topquan 2006-08-05 00:42 发表评论

Hibernate一对一数据关联(一)

topquan — Fri, 04 Aug 2006 16:41:00 GMT

对于ORM而言，一个重要的特性就是对实体之间关联关系的管理。数据关联是ORM一个重要的特征，但往往也是导致性能低下的原因，在开发中要特别注意这一点。

一对一关联有两种类型：主键关联和唯一外键关联

一.主键关联：
一对一主键关联形式，即两张关联表通过主键形成一对一映射关系。
例如，一个中国公民只能有一份护照。

1.数据模型如下

2.表定义sql

DROP TABLE T_User;
DROP TABLE T_Passport;

CREATE TABLE T_Passport (
       id INT NOT NULL
     , serial VARCHAR ( 30 )
     , expiry INT
     , PRIMARY KEY (id)
);

CREATE TABLE T_User (
       id INT NOT NULL AUTO_INCREMENT
     , name VARCHAR ( 50 )
     , age INT
     , PRIMARY KEY (id)
     , INDEX (id)
     , CONSTRAINT FK_T_User_1 FOREIGN KEY (id)
                   REFERENCES T_Passport (id)
);

3.POJO类
TUser.java

package cn.blogjava.start;

public class TUser   implements java.io.Serializable {
     // Fields
      private Integer id;
      private Integer age;
      private String name;
      private TPassport passport;

     // Constructors

     public Integer getAge() {
         return age;
    }

     public void setAge(Integer age) {
         this .age = age;
    }

     public TPassport getPassport() {
         return passport;
    }

     public void setPassport(TPassport passport) {
         this .passport = passport;
    }

     /** default constructor */
     public TUser() {
    }

     /** constructor with id */
     public TUser(Integer id) {
         this .id = id;
    }
     // Property accessors

     public Integer getId() {
         return this .id;
    }

     public void setId(Integer id) {
         this .id = id;
    }

     public String getName() {
         return this .name;
    }

     public void setName(String name) {
         this .name = name;
    }

}

TPassport.java

package cn.blogjava.start;

import java.io.Serializable;

public class TPassport implements Serializable {
     private Integer id;
     private String serial;
     private Integer expiry;
     private TUser user;

     public Integer getExpiry() {
         return expiry;
    }
     public void setExpiry(Integer expiry) {
         this .expiry = expiry;
    }
     public Integer getId() {
         return id;
    }
     public void setId(Integer id) {
         this .id = id;
    }
     public String getSerial() {
         return serial;
    }
     public void setSerial(String serial) {
         this .serial = serial;
    }
     public TUser getUser() {
         return user;
    }
     public void setUser(TUser user) {
         this .user = user;
    }

}

3.配置文件
TUser.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 ="cn.blogjava.start.TUser" table ="T_User" catalog ="sample" >
         < id name ="id" type ="integer" >
             < column name ="id" />
             < generator class ="native" />
         id >
         < property name ="name" type ="string" >
             < column name ="name" length ="100" not-null ="true" />
         property >
         < property name ="age" type ="java.lang.Integer" column ="age" />
         < one-to-one name ="passport"
                    class ="cn.blogjava.start.TPassport"
                    cascade ="all"
                    outer-join ="true"
          />
     class >
hibernate-mapping >

TPassport.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 ="cn.blogjava.start.TPassport" table ="T_Passport" catalog ="sample" >
         < id name ="id" type ="integer" column ="id" >
             < generator class ="foreign" >
                 < param name ="property" > user param >
             generator >
         id >
         < property name ="serial" type ="string" column ="serial" />
         < property name ="expiry" type ="java.lang.Integer" column ="expiry" />

         < one-to-one name ="user"
                    class ="cn.blogjava.start.TUser"
                    constrained ="true"
          />
     class >
hibernate-mapping >

4.测试代码

package cn.blogjava.start;

import java.util.List;

import junit.framework.Assert;
import junit.framework.TestCase;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class HibernateTest extends TestCase {

    Session session = null ;
     protected void setUp() {
         try {

            Configuration config = new Configuration().configure();
            SessionFactory sessionFactory = config.buildSessionFactory();
            session = sessionFactory.openSession();

        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }

     protected void tearDown() {
         try {
            session.close();
        } catch (HibernateException e) {
           e.printStackTrace();
        }
    }

     public void testInsert() {
        Transaction tran = null ;
         try {

            TUser user = new TUser();
            user.setName( " byf " );
            user.setAge( new Integer( 26 ));

            TPassport passport = new TPassport();
            passport.setSerial( " PCN123456 " );
            passport.setExpiry( new Integer( 20081010 ));

             // 设置相互关联
            user.setPassport(passport);
            passport.setUser(user);

            tran = session.beginTransaction();
            session.save(user);
            session.flush();
            tran.commit();
            Assert.assertEquals(user.getId().intValue() > 0 , true );
        } catch (HibernateException e) {
            e.printStackTrace();
            Assert.fail(e.getMessage());
             if (tran != null ) {
                 try {
                    tran.rollback();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

     /**
     * 对象读取测试(Select方法)
      */
     public void testSelect(){
        String hql = " from TUser where name='byf' " ;
         try {
            List userList = session.createQuery(hql).list();
            TUser user = (TUser)userList.get( 0 );
            System.out.println( " user name is " + user.getName());
            System.out.println( " passport serial NO. is " + user.getPassport().getSerial());
            Assert.assertEquals(user.getName(), " byf " );
        } catch (Exception e) {
            e.printStackTrace();
            Assert.fail(e.getMessage());
        }
    }
}

topquan 2006-08-05 00:41 发表评论

HQL 语言基本用法

topquan — Fri, 04 Aug 2006 16:32:00 GMT

HQL

例如对于TUser类

1.实体查询
String hql = " from TUser";

执行这条语句会返回TUser以及TUser子类的纪录。

hql = "from java.lang.Object"
会返回数据库中所有库表的纪录。

where 语句
hql = "from TUser as user where user.name='yyy'";

其中，as可以省略也一样
hql = "from TUser user where user.name='yyy'";

where子句中，我们可以通过比较运算符设定条件，如：
=, <>, >, <, >=, <=, between, not between, in, not in, is, like等。

2.属性查询
List list = session.createQuery("select user.name, user.age from TUser as user").list();

还可以在HQL中动态构造对象实例的方法，将数据封装。
List list = session.createQuery("select new TUser(user.name, user.age) from TUser as user").list();
Iterator it = list.iterator();
while(it.hasNext() ) {
     TUser user = (TUser)it.next();
     System.out.println(user.getName());
}
但是要注意这里的TUser对象只是对name和age属性的封装，其他状态均未赋值，所以不能用它来进行更新操作。

也可以在HQL的Select子句中使用统计函数
"select count(*) ,min(user.age) from TUser as user"

也可以使用distinct关键字来删除重复纪录。
select distinct user.name from TUser as user;

3.实体的更新与删除
hibernate 2中需要先查询出实体，设置属性后再保存。

hibernate 3中，提供了更灵活的方式(bulk delete/update)
更新：
    Query query = session.createQuery("update TUser set age=18 where id=1");
    query.executeUpdate();
删除：
    session.createQuery("delete TUser where age>=18");
    query.executeUpdate();

4.分组与排序
Order by子句：
    from TUser user order by user.name, user.age desc
Group by子句和Having子句
    "select count(user), user.age from TUser user group by user.age having count(user)>10"

5.参数邦定
通过顺序占位符?来填充参数：
1)hibernate 2 中通过session.find方法来填充
     session.find("from TUser user where user.name=?", "Erica", Hibernate.STRING);
多个参数的情况：
       Object[] args = new Object[] {"Erica", new Integer(20)};
       Type[] types = new Type{Hibernate.STRING, Hibernate.INTEGER};
       session.find("from TUser user where user.name=? and user.age=?", args, types);

2)通过Query接口进行参数填充：
        Query query = session.createQuery("from TUser user where user.name=? and user.age>?");
        query.setString(0,"Erica");
        query.setInteger(1, 20);

通过引用占位符来填充参数：
        String hql = "from TUser where name=:name";
        Query query = session.createQuery(hql);
        query.setParameter("name","Erica");

甚至可以将查询条件封装为一个JavaBean
class UserQuery {
    private String name;
    private Integer age;
    //getter and setter
}
String hql = "from TUser where name=:name and age=:age";
Query query = session.createQuery(hql);
UserQuery uq = new UserQuery();
uq.setName("Erica");
uq.setAge(new Integer(20));

query.setProperties(uq); //会调用里面的getter?
query.iterate();

6.联合查询
也可以使用 inner join,left outer join, right out join, full join
排列组合：form TUser, TAddress

topquan 2006-08-05 00:32 发表评论

利用Hibernate开发Blog实例分析

topquan — Mon, 08 May 2006 07:39:00 GMT

摘要: 开发工具采用 MYECLIPS3.6 ，首先是建立项目，导入 STRUTS+HIBERNATE 包，然后配置 SRC 跟目录下的 Hibernate.cfg.xml. 我采用的是 MYSQL数据库，所以配置如下：　　　　　　