最好的Hibernate3应用实例（初学者）

http://***/forum/blogPost/list/2378.html

Hibernate是一个非常著名的的对象--关系映射工具，本文使用的是Hibernate3.6的版本。本文通过建立一个工程，来引导大家学习 hibernate，对hibernate有个认识。有些代码、概念不清楚没关系，后文会慢慢的介绍。文中也有大量的注释，附件会上传本文所有的源码。

首先建立一个Web Project，然后在WEB-INF/lib下添加相关的jar包。项目结构如下图1所示。jar包介绍如下：

 

图1

hibernate-distribution-3.6.0.Final-dist\hibernate-distribution-3.6.0.Final\lib\required 目录下相应的jar包：

• antlr-2.7.6.jar：HQL-->SQL的转换
• commons-collections-3.1.jar：Apache的集合类工具
• dom4j.jar：解析XML文档
• hibernate3.jar：hibernate核心API实现
• javassist-3.12.0.GA.jar：动态Java代码生成工具
• jta-1.1.jar：标准的Java事务处理接口
• slf4j-api-1.6.1.jar：日志管理API
• slf4j-nop-1.6.1.jar：日志管理。

一、持久化类如下：

Customer.java

1. package com.yaxing.entity;    
2.    
3. import java.util.HashSet;    
4. import java.util.Set;    
5.    
6. public class Customer {    
7.     private Long id;    
8.     private String name;    
9.     private Set<Order> orders = new HashSet<Order>();    
10.    
11.     public Long getId() {    
12.         return id;    
13.     }    
14.    
15.     public void setId(Long id) {    
16.         this.id = id;    
17.     }    
18.    
19.     public String getName() {    
20.         return name;    
21.     }    
22.    
23.     public void setName(String name) {    
24.         this.name = name;    
25.     }    
26.    
27.     public Set<Order> getOrders() {    
28.         return orders;    
29.     }    
30.    
31.     public void setOrders(Set<Order> orders) {    
32.         this.orders = orders;    
33.     }    
34.    
35. }   

Order.java

1. package com.yaxing.entity;    
2.    
3. public class Order {    
4.     private Long id;    
5.     private Customer customer;    
6.     private String orderNumber;    
7.    
8.     public Long getId() {    
9.         return id;    
10.     }    
11.    
12.     public void setId(Long id) {    
13.         this.id = id;    
14.     }    
15.    
16.     public Customer getCustomer() {    
17.         return customer;    
18.     }    
19.    
20.     public void setCustomer(Customer customer) {    
21.         this.customer = customer;    
22.     }    
23.    
24.     public String getOrderNumber() {    
25.         return orderNumber;    
26.     }    
27.    
28.     public void setOrderNumber(String orderNumber) {    
29.         this.orderNumber = orderNumber;    
30.     }    
31.    
32. } 

说明如下：这是一种典型的一对多的关联关系。即一个客户会有多个订单，而一个订单必然会属于一个客户，因此对于一个订单来说，如果其客户不存在，则此订单是没有任何意义的。这里设置的是双向的关联关系。因为可能业务中会存在大量的这样的需求：

• 查询客户的所有订单
• 根据所给的订单，查询订单所属的客户

类与类之间建立关联关系，可以很方便的从一个对象导航到另外一个对象，建立关系如下：

1.    
2. public class Order {    
3.     private Long id;    
4.     private Customer customer;    
5.          //...    
6. }   

这样就从order对象导航到了customer对象，从order对象到customer对象的导航如下：即给定了order对象，获得了与他所关联的costomer对象。

1. Customer customer = order.getCustomer();  

那么对于给定的costomer对象,如何从customer对象导航到order对象呢？因为customer对象里面包含一组order，即一个客户会存在多个订单。

因此对于给定的客户，要查询所有的订单，代码如下：

返回的是一个Set集合。

1. customer.getOrders();//返回一个set集合，用迭代器访问。  

关于集合类的操作，也不是本文的内容，读者可以参考其他文章。不清楚的，可以本文后面留言。

二、数据库和配置文件

建立的数据库如图2所示下：

图2

注意，Id都是自增numeric类型。这里的Orders表的取名问题：因为order 是关键字，作为表名的时候，会报错的，Sql Server 中对关键字作为表名字段名的处理是：使用的时候加上中括号[]，有时开发中也没注意到这点，判断错误起来也麻烦，关于这点，参见博客另外一篇文章：因使用关键字做为表名引起的Hibernate报错。

配置文件如下：Customer.hbm.xml

1. <?xml version="1.0" encoding="utf-8"?>   
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">   
4.    
5. <hibernate-mapping>   
6.     <class name="com.yaxing.entity.Customer" table="Customer">   
7.         <id name="id" type="java.lang.Long" column="Id">   
8.                 
9.             <generator class="identity"></generator>   
10.         </id>   
11.         <property name="name" column="Name" type="string"></property>   
12.         <set name="orders" cascade="all" inverse="true">   
13.             <key column="CustomerId"/><!-- 对应着外键 -->   
14.             <one-to-many class="com.yaxing.entity.Order"/>   
15.         </set>   
16.     </class>   
17. </hibernate-mapping>  

说明如下：

①<class>元素指定类和表的映射，如果没有指定table属性，则hibernate将类名做为表名。一个<class>包括一个<id>子元素和多个<property>子元素。

②<id>元素设定持久化类的OID(Object Identifier)和表的主键的映射，上述配置代码表示Customer类的id属性和Customer表的Id字段对应。

③<id>元素的<generator>子元素用于指定对象标识符生成器，它负责为OID生成唯一标识符。后文将介绍常见的对象标识符生成器的介绍。本文使用的是 native表示hibernate根据底层数据库来选择。

④<property>子元素设定类的属性和表的字段的映射,常见的属性包括

• name:指定持久化类的属性的名字
• type:指定hibernate映射类型，hibernate映射类型是在java类型和Sql类型之间的一个桥梁。比如 java.lang.String 对应 type则为string。详细情况可以参见三者之间的对应关系。如果没有为某个属性设置映射类型，hibernate会利用java的放射机制先识别出持久化类的属性的java的类型，然后自动使用与之对应的hibernate映射类型。
• column：指定与持久化类的属性映射的表的字段名，上述代码表示Customer类的name属性对应的是Customer表的Name字段。
• not-null：是否允许为空，默认为false。程序中经常碰到为空的异常，此处的配置需特别引起注意！
• <set>元素：表示Customer类的orders属性为Set集合，<one-to-many>表示orders里面存放的是一组Order对象，<key>表示数据库中Orders表通过外键CustomerId参照Customer表。<cascade>表示级联保存，默认为none，取值可以有all 、save-update 、delete、delete-orphan ，各参数具体的含义后文有介绍。

Order.hbm.xml

1. <?xml version="1.0" encoding="utf-8"?>   
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">   
4.    
5. <hibernate-mapping>   
6.     <class name="com.yaxing.entity.Order" table="Orders">   
7.         <id name="id" type="java.lang.Long" column="Id">   
8.             <generator class="identity"></generator>   
9.         </id>   
10.         <property name="orderNumber" column="OrderNumber" type="string"></property>   
11.         <many-to-one name="customer" column="CustomerId"   
12.             class="com.yaxing.entity.Customer" cascade="all" lazy="false"   
13.             not-null="true"></many-to-one>   
14.     </class>   
15. </hibernate-mapping> 

说明：<many-to-one>表示建立了customer属性和Orders表的外键CustomerId之间的映射，name为持久化类的属性的名字，column为持久化类的属性对应的表的外键CustomerId，class为持久化类的属性的类型，not-null表示是否允许为空，默认值为false.lazy是hibernate的检索策略，后文将有介绍。

三、测试代码和测试结果

CustomerAction.java

1. package com.yaxing.test;    
2.    
3. import java.util.Iterator;    
4. import java.util.List;    
5.    
6. import org.hibernate.Query;    
7. import org.hibernate.Session;    
8. import org.hibernate.Transaction;    
9.    
10. import com.yaxing.entity.Customer;    
11. import com.yaxing.util.HibernateUtil;    
12.    
13. public class CustomerAction {    
14.     private Customer customer;    
15.     private List<Customer> listCustomer;    
16.    
17.     public Customer getCustomer() {    
18.         return customer;    
19.     }    
20.    
21.     public void setCustomer(Customer customer) {    
22.         this.customer = customer;    
23.     }    
24.    
25.     public List<Customer> getListCustomer() {    
26.         return listCustomer;    
27.     }    
28.    
29.     public void setListCustomer(List<Customer> listCustomer) {    
30.         this.listCustomer = listCustomer;    
31.     }    
32.        
33.     public void addCustomer(Customer customer) {    
34.         Session s = null;    
35.         Transaction tx = null;    
36.         try {    
37.             s = HibernateUtil.getSession();    
38.             tx = s.beginTransaction();    
39.             s.save(customer);    
40.             tx.commit();    
41.         }catch(Exception e){    
42.             if(tx!=null){    
43.                 tx.rollback();    
44.             }    
45.             e.printStackTrace();    
46.         }finally{    
47.             if(s!=null){    
48.                 s.close();    
49.             }       
50.         }    
51.     }    
52.        
53.     public void deleteCustomer(Customer customer) {    
54.         Session s = null;    
55.         Transaction tx = null;    
56.         try {    
57.             s = HibernateUtil.getSession();    
58.             tx = s.beginTransaction();    
59.             s.delete(customer);    
60.             tx.commit();    
61.         }catch(Exception e){    
62.             if(tx!=null){    
63.                 tx.rollback();    
64.             }    
65.             e.printStackTrace();    
66.         }finally{    
67.             if(s!=null){    
68.                 s.close();    
69.             }       
70.         }    
71.     }    
72.        
73.     public void update(Customer customer,String name) {    
74.         Session s = null;    
75.         Transaction tx = null;    
76.         try {    
77.             s = HibernateUtil.getSession();    
78.             tx = s.beginTransaction();    
79.             customer.setName(name);    
80.             s.update(customer);    
81.             tx.commit();    
82.         }catch(Exception e){    
83.             if(tx!=null){    
84.                 tx.rollback();    
85.             }    
86.             e.printStackTrace();    
87.         }finally{    
88.             if(s!=null){    
89.                 s.close();    
90.             }       
91.         }    
92.     }    
93.        
94.     public Customer findCustomer(Long id) {    
95.         Session s = null;    
96.         Transaction tx = null;    
97.         try {    
98.             s = HibernateUtil.getSession();    
99.             tx = s.beginTransaction();    
100.             customer = (Customer) s.get(Customer.class, id);    
101.             tx.commit();    
102.         }catch(Exception e){    
103.             if(tx!=null){    
104.                 tx.rollback();    
105.             }    
106.             e.printStackTrace();    
107.         }finally{    
108.             if(s!=null){    
109.                 s.close();    
110.             }       
111.         }    
112.         return customer;    
113.     }    
114.        
115.     public List<Customer> findAll() {    
116.         Session s = null;    
117.         Transaction tx = null;    
118.         try {    
119.             s = HibernateUtil.getSession();    
120.             tx = s.beginTransaction();    
121.             Query query = s.createQuery("from Customer as a order by id asc");    
122.             listCustomer = query.list();    
123.             for(Iterator iter=listCustomer.iterator();iter.hasNext();){    
124.                 Customer customer = (Customer) iter.next();    
125.                 System.out.println("客户ID是："+customer.getId()+"客户姓名是："+customer.getName());    
126.             }       
127.             tx.commit();    
128.         }catch(Exception e){    
129.             if(tx!=null){    
130.                 tx.rollback();    
131.             }    
132.             e.printStackTrace();    
133.         }finally{    
134.             if(s!=null){    
135.                 s.close();    
136.             }       
137.         }    
138.         return listCustomer;    
139.     }    
140. } 

OrderAction.java的代码和Customer.java代码类似。

1. package com.yaxing.test;    
2.    
3. import java.util.Iterator;    
4. import java.util.List;    
5.    
6. import org.hibernate.Query;    
7. import org.hibernate.Session;    
8. import org.hibernate.Transaction;    
9.    
10. import com.yaxing.entity.Order;    
11. import com.yaxing.util.HibernateUtil;    
12.    
13. public class OrderAction {    
14.     private Order order;    
15.     private List<Order> listorder;    
16.    
17.     public Order getorder() {    
18.         return order;    
19.     }    
20.    
21.     public void setorder(Order order) {    
22.         this.order = order;    
23.     }    
24.    
25.     public List<Order> getListorder() {    
26.         return listorder;    
27.     }    
28.    
29.     public void setListorder(List<Order> listorder) {    
30.         this.listorder = listorder;    
31.     }    
32.    
33.     public void addorder(Order order) {    
34.         Session s = null;    
35.         Transaction tx = null;    
36.         try {    
37.             s = HibernateUtil.getSession();    
38.             tx = s.beginTransaction();    
39.             s.save(order);    
40.             tx.commit();    
41.         }catch(Exception e){    
42.             if(tx!=null){    
43.                 tx.rollback();    
44.             }    
45.             e.printStackTrace();    
46.         }finally{    
47.             if(s!=null){    
48.                 s.close();    
49.             }       
50.         }    
51.     }    
52.        
53.     public void deleteorder(Order order) {    
54.         Session s = null;    
55.         Transaction tx = null;    
56.         try {    
57.             s = HibernateUtil.getSession();    
58.             tx = s.beginTransaction();    
59.             s.delete(order);    
60.             tx.commit();    
61.         }catch(Exception e){    
62.             if(tx!=null){    
63.                 tx.rollback();    
64.             }    
65.             e.printStackTrace();    
66.         }finally{    
67.             if(s!=null){    
68.                 s.close();    
69.             }       
70.         }    
71.     }    
72.    
73.     public void update(Order order,String number) {    
74.         Session s = null;    
75.         Transaction tx = null;    
76.         try {    
77.             s = HibernateUtil.getSession();    
78.             tx = s.beginTransaction();    
79.             order.setOrderNumber(number);    
80.             s.update(order);    
81.             tx.commit();    
82.         }catch(Exception e){    
83.             if(tx!=null){    
84.                 tx.rollback();    
85.             }    
86.             e.printStackTrace();    
87.         }finally{    
88.             if(s!=null){    
89.                 s.close();    
90.             }       
91.         }    
92.     }    
93.    
94.     public Order findorder(Long id) {    
95.         Session s = null;    
96.         Transaction tx = null;    
97.         try {    
98.             s = HibernateUtil.getSession();    
99.             tx = s.beginTransaction();    
100.             order = (Order) s.get(Order.class, id);    
101.             tx.commit();    
102.         }catch(Exception e){    
103.             if(tx!=null){    
104.                 tx.rollback();    
105.             }    
106.             e.printStackTrace();    
107.         }finally{    
108.             if(s!=null){    
109.                 s.close();    
110.             }       
111.         }    
112.         return order;    
113.     }    
114.    
115.     public List<Order> findAll() {    
116.         Session s = null;    
117.         Transaction tx = null;    
118.         try {    
119.             s = HibernateUtil.getSession();    
120.             tx = s.beginTransaction();    
121.             Query query = s.createQuery("from Order as a order by id asc");    
122.             listorder = query.list();    
123.             for(Iterator iter=listorder.iterator();iter.hasNext();){    
124.                 Order order = (Order) iter.next();    
125.                 System.out.println("订单ID是："+order.getId()+"订单数目是："+order.getOrderNumber());    
126.             }       
127.             tx.commit();    
128.         }catch(Exception e){    
129.             if(tx!=null){    
130.                 tx.rollback();    
131.             }    
132.             e.printStackTrace();    
133.         }finally{    
134.             if(s!=null){    
135.                 s.close();    
136.             }       
137.         }    
138.         return listorder;    
139.     }    
140. } 

HibernateUtil.java如下：

1. package com.yaxing.hibernate.util;    
2.    
3. import org.hibernate.Session;    
4. import org.hibernate.SessionFactory;    
5. import org.hibernate.cfg.Configuration;    
6.    
7. public final class HibernateUtil {    
8.     private static SessionFactory sessionFactory;    
9.     private HibernateUtil(){    
10.             
11.     }    
12.     static {    
13.         Configuration cfg = new Configuration();    
14.         cfg.configure();    
15.         sessionFactory=cfg.buildSessionFactory();    
16.     }    
17.     public static SessionFactory getSessionFactory() {    
18.         return sessionFactory;    
19.     }    
20.     public static Session getSession(){    
21.         return sessionFactory.openSession();    
22.     }    
23.    
24. }   

测试代码如下：

1. package com.yaxing.test;    
2.    
3. import com.yaxing.entity.Customer;    
4.    
5. public class Test {    
6.     public  static void main(String args[]){    
7.         Customer customer = new Customer();    
8.         customer.setName("51CTO");    
9.         CustomerAction ca = new CustomerAction();    
10.            
11.         ca.addCustomer(customer);    
12. }  

允许之后，打印出来的SQL语句如下：

1. Hibernate:     
2.     insert     
3.     into   
4.         Customer    
5.         (Name)     
6.     values   
7.         (?) 

接下来，我们到数据库中看看记录被插入进来了没有：

 

图3

可以看到，如图3所示，记录插入成功！

接下来我们看看查询所有的：

1.    
2.         ca.findAll();  

输出：

1. Hibernate:     
2.     select   
3.         customer0_.Id as Id1_,    
4.         customer0_.Name as Name1_     
5.     from   
6.         Customer customer0_     
7.     order by   
8.         customer0_.Id asc   
9. 客户ID是：2客户姓名是：null   
10. 客户ID是：4客户姓名是：51CTO    
11. 客户ID是：5客户姓名是：51CTO    
12. 客户ID是：6客户姓名是：51CTO    
13. 客户ID是：7客户姓名是：51CTO    
14. 客户ID是：8客户姓名是：51CTO 

接下来，我们删除刚测试的ID为8的记录，

1.    
2.         Customer customer = ca.findCustomer(8L);    
3.         ca.deleteCustomer(customer);  

运行的SQL语句如下：

1. Hibernate:     
2.     select   
3.         customer0_.Id as Id1_0_,    
4.         customer0_.Name as Name1_0_     
5.     from   
6.         Customer customer0_     
7.     where   
8.         customer0_.Id=?    
9. Hibernate:     
10.     select   
11.         orders0_.CustomerId as CustomerId1_1_,    
12.         orders0_.Id as Id1_,    
13.         orders0_.Id as Id0_0_,    
14.         orders0_.OrderNumber as OrderNum2_0_0_,    
15.         orders0_.CustomerId as CustomerId0_0_     
16.     from   
17.         Orders orders0_     
18.     where   
19.         orders0_.CustomerId=?    
20. Hibernate:     
21.     delete     
22.     from   
23.         Customer     
24.     where   
25.         Id=? 

可以查看下，Id为8的记录删除了！

最后来个级联保存的：

1.    
2.         Customer customer = new Customer();    
3.         customer.setName("google");    
4.         ca.addCustomer(customer);    
5.         Order order = new Order();    
6.         order.setOrderNumber("5箱");    
7.         order.setCustomer(customer);    
8.         oa.addorder(order);  

执行的SQL语句如下：

1. Hibernate:     
2.     insert     
3.     into   
4.         Customer    
5.         (Name)     
6.     values   
7.         (?)    
8. Hibernate:     
9.     insert     
10.     into   
11.         Orders    
12.         (OrderNumber, CustomerId)     
13.     values   
14.         (?, ?)    
15. Hibernate:     
16.     update   
17.         Customer     
18.     set   
19.         Name=?     
20.     where   
21.         Id=?   

可以查看下记录：

最后帖上hibernate的配置代码：

1. <?xml version='1.0' encoding='UTF-8'?>   
2. <!DOCTYPE hibernate-configuration PUBLIC    
3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"    
4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">   
5.    
6. <hibernate-configuration>   
7.     <session-factory>   
8.         <property name="dialect">   
9.             org.hibernate.dialect.SQLServerDialect    
10.         </property>   
11.         <property name="connection.url">   
12.             jdbc:jtds:sqlserver://server:1434/hibernateTest    
13.         </property>   
14.         <property name="connection.username">sa</property>   
15.         <property name="connection.password">711</property>   
16.         <property name="connection.driver_class">   
17.             net.sourceforge.jtds.jdbc.Driver    
18.         </property>   
19.         <property name="hibernate.show_sql">true</property>   
20.         <property name="format_sql">true</property>   
21.         <property name="myeclipse.connection.profile">jtds</property>   
22.         <mapping resource="com/yaxing/entity/Order.hbm.xml" />   
23.         <mapping resource="com/yaxing/entity/Customer.hbm.xml" />   
24.     </session-factory>   
25.    
26. </hibernate-configuration>