Hibernate3.6应用实例详解

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.  * 顾客类  
7.  * */ 
8. public class Customer {  
9.     private Long id;  
10.     private String name;  
11.     private Set<Order> orders = new HashSet<Order>();  
12.  
13.     public Long getId() {  
14.         return id;  
15.     }  
16.  
17.     public void setId(Long id) {  
18.         this.id = id;  
19.     }  
20.  
21.     public String getName() {  
22.         return name;  
23.     }  
24.  
25.     public void setName(String name) {  
26.         this.name = name;  
27.     }  
28.  
29.     public Set<Order> getOrders() {  
30.         return orders;  
31.     }  
32.  
33.     public void setOrders(Set<Order> orders) {  
34.         this.orders = orders;  
35.     }  
36.  
37. }  

Order.java

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

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

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

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

1. /**  
2.  * 订单类  
3.  * */ 
4. public class Order {  
5.     private Long id;  
6.     private Customer customer;  
7.          //...  
8. }  

这样就从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.      * 添加客户  
34.      * */ 
35.     public void addCustomer(Customer customer) {  
36.         Session s = null;  
37.         Transaction tx = null;  
38.         try {  
39.             s = HibernateUtil.getSession();  
40.             tx = s.beginTransaction();  
41.             s.save(customer);  
42.             tx.commit();  
43.         }catch(Exception e){  
44.             if(tx!=null){  
45.                 tx.rollback();  
46.             }  
47.             e.printStackTrace();  
48.         }finally{  
49.             if(s!=null){  
50.                 s.close();  
51.             }     
52.         }  
53.     }  
54.     /**  
55.      * 删除客户  
56.      * */ 
57.     public void deleteCustomer(Customer customer) {  
58.         Session s = null;  
59.         Transaction tx = null;  
60.         try {  
61.             s = HibernateUtil.getSession();  
62.             tx = s.beginTransaction();  
63.             s.delete(customer);  
64.             tx.commit();  
65.         }catch(Exception e){  
66.             if(tx!=null){  
67.                 tx.rollback();  
68.             }  
69.             e.printStackTrace();  
70.         }finally{  
71.             if(s!=null){  
72.                 s.close();  
73.             }     
74.         }  
75.     }  
76.     /**  
77.      * 更新客户  
78.      * */ 
79.     public void update(Customer customer,String name) {  
80.         Session s = null;  
81.         Transaction tx = null;  
82.         try {  
83.             s = HibernateUtil.getSession();  
84.             tx = s.beginTransaction();  
85.             customer.setName(name);  
86.             s.update(customer);  
87.             tx.commit();  
88.         }catch(Exception e){  
89.             if(tx!=null){  
90.                 tx.rollback();  
91.             }  
92.             e.printStackTrace();  
93.         }finally{  
94.             if(s!=null){  
95.                 s.close();  
96.             }     
97.         }  
98.     }  
99.     /**  
100.      * 查询客户  
101.      * */ 
102.     public Customer findCustomer(Long id) {  
103.         Session s = null;  
104.         Transaction tx = null;  
105.         try {  
106.             s = HibernateUtil.getSession();  
107.             tx = s.beginTransaction();  
108.             customer = (Customer) s.get(Customer.class, id);  
109.             tx.commit();  
110.         }catch(Exception e){  
111.             if(tx!=null){  
112.                 tx.rollback();  
113.             }  
114.             e.printStackTrace();  
115.         }finally{  
116.             if(s!=null){  
117.                 s.close();  
118.             }     
119.         }  
120.         return customer;  
121.     }  
122.     /**  
123.      * 查找所有的客户  
124.      * */ 
125.     public List<Customer> findAll() {  
126.         Session s = null;  
127.         Transaction tx = null;  
128.         try {  
129.             s = HibernateUtil.getSession();  
130.             tx = s.beginTransaction();  
131.             Query query = s.createQuery("from Customer as a order by id asc");  
132.             listCustomer = query.list();  
133.             for(Iterator iter=listCustomer.iterator();iter.hasNext();){  
134.                 Customer customer = (Customer) iter.next();  
135.                 System.out.println("客户ID是："+customer.getId()+"客户姓名是："+customer.getName());  
136.             }     
137.             tx.commit();  
138.         }catch(Exception e){  
139.             if(tx!=null){  
140.                 tx.rollback();  
141.             }  
142.             e.printStackTrace();  
143.         }finally{  
144.             if(s!=null){  
145.                 s.close();  
146.             }     
147.         }  
148.         return listCustomer;  
149.     }  
150. }  

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.      * 删除用户  
54.      * */ 
55.     public void deleteorder(Order order) {  
56.         Session s = null;  
57.         Transaction tx = null;  
58.         try {  
59.             s = HibernateUtil.getSession();  
60.             tx = s.beginTransaction();  
61.             s.delete(order);  
62.             tx.commit();  
63.         }catch(Exception e){  
64.             if(tx!=null){  
65.                 tx.rollback();  
66.             }  
67.             e.printStackTrace();  
68.         }finally{  
69.             if(s!=null){  
70.                 s.close();  
71.             }     
72.         }  
73.     }  
74.  
75.     public void update(Order order,String number) {  
76.         Session s = null;  
77.         Transaction tx = null;  
78.         try {  
79.             s = HibernateUtil.getSession();  
80.             tx = s.beginTransaction();  
81.             order.setOrderNumber(number);  
82.             s.update(order);  
83.             tx.commit();  
84.         }catch(Exception e){  
85.             if(tx!=null){  
86.                 tx.rollback();  
87.             }  
88.             e.printStackTrace();  
89.         }finally{  
90.             if(s!=null){  
91.                 s.close();  
92.             }     
93.         }  
94.     }  
95.  
96.     public Order findorder(Long id) {  
97.         Session s = null;  
98.         Transaction tx = null;  
99.         try {  
100.             s = HibernateUtil.getSession();  
101.             tx = s.beginTransaction();  
102.             order = (Order) s.get(Order.class, id);  
103.             tx.commit();  
104.         }catch(Exception e){  
105.             if(tx!=null){  
106.                 tx.rollback();  
107.             }  
108.             e.printStackTrace();  
109.         }finally{  
110.             if(s!=null){  
111.                 s.close();  
112.             }     
113.         }  
114.         return order;  
115.     }  
116.  
117.     public List<Order> findAll() {  
118.         Session s = null;  
119.         Transaction tx = null;  
120.         try {  
121.             s = HibernateUtil.getSession();  
122.             tx = s.beginTransaction();  
123.             Query query = s.createQuery("from Order as a order by id asc");  
124.             listorder = query.list();  
125.             for(Iterator iter=listorder.iterator();iter.hasNext();){  
126.                 Order order = (Order) iter.next();  
127.                 System.out.println("订单ID是："+order.getId()+"订单数目是："+order.getOrderNumber());  
128.             }     
129.             tx.commit();  
130.         }catch(Exception e){  
131.             if(tx!=null){  
132.                 tx.rollback();  
133.             }  
134.             e.printStackTrace();  
135.         }finally{  
136.             if(s!=null){  
137.                 s.close();  
138.             }     
139.         }  
140.         return listorder;  
141.     }  
142. }  

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.          * 添加对象  
12.          * */ 
13.         ca.addCustomer(customer);  
14. } 

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

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

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

 

图3

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

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

 

1. /**  
2.          * 查询所有  
3.          * */ 
4.         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.          * 删除指定对象  
3.          * */ 
4.         Customer customer = ca.findCustomer(8L);  
5.         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.          * 保存订单  
3.          * 级联保存  
4.          * */ 
5.         Customer customer = new Customer();  
6.         customer.setName("google");  
7.         ca.addCustomer(customer);  
8.         Order order = new Order();  
9.         order.setOrderNumber("5箱");  
10.         order.setCustomer(customer);  
11.         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> 

 源代码下载地址：http://down.51cto.com/data/317785

 本文转自 w156445045 51CTO博客，原文链接：http://blog.51cto.com/enetq/759123，如需转载请自行联系原作者