Hibernate学习(一)：第一个Hibernate应用程序

听说Hibernate已经很久了，但是直到最近才开始和它近距离的接触。很早之前在湘计就看到过一份培训的PPT，里面说到Hibernate应用于持久层，并且Hibernate和持久化似乎形影相随，总是成双成对的出现。那么Hibernate到底是做什么用的，它有什么优点呢？关于Hibernate的一些概念诸如ORM、持久化就不赘述了，我们直接开始构建我们的一个Hibernate应用(通常我们的应用都是Web应用，这里我还是建一个Web工程，但是运行的时候我用Java Application的方式运行，这样比较容易理解，因为在Web应用中Hibernate都会和Spring等框架一起使用)。

构建一个Hibernate应用我们需要准备什么东西呢？首先当然是去官网上下一个Hibernate的发布包咯，我下的是3.0。接下来我们按照如下步骤来进行

1．准备一个配置文件hibernate.cfg.xml，它里面定义了一些基本的属性，如数据库连接的相关参数、映射文件的地址等等，这个文件是必须的，Hibernate会首先解析并加载这个xml文件并存放在缓存中，我的hibernate.cfg.xml内容如下：
<?xml version="1.0" encoding="UTF-8"?>

<!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="connection.url">
           jdbc:mysql://localhost:3306/test
       </property>
       <property name="connection.driver_class">
         com.mysql.jdbc.Driver
       </property>
       <property name="connection.username">root</property>
       <property name="connection.password">111111</property>
       <property name="dialect">
           org.hibernate.dialect.MySQLDialect
       </property>
       <property name="show_sql">true</property>

       <mapping resource="cn/edu/hust/cm/mypack/Customer.hbm.xml" />

    </session-factory>
</hibernate-configuration>

2．我用的是Mysql数据库，不同的DBMS有些地方会不同。假设我现在数据库中有一张表存放顾客基本信息，我创建了一个Customer表，Schema如下所示：

CREATE TABLE `customer` (
  `id` bigint(11) NOT NULL DEFAULT '0',
  `name` varchar(40) NOT NULL DEFAULT '',
  `email` varchar(128) CHARACTER SET latin1 NOT NULL DEFAULT '',
  `password` varchar(8) NOT NULL DEFAULT '',
  `phone` int(11) DEFAULT '0',
  `address` varchar(255) DEFAULT NULL,
  `sex` char(1) CHARACTER SET latin1 DEFAULT NULL,
  `is_married` bit(1) DEFAULT NULL,
 `description` text,
 `image` blob,
  `birthday` date DEFAULT NULL,
 `registered_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP)

3．创建一个Customer.java文件(这就是我们所说的持久化类)

1. package cn.edu.hust.cm.mypack;  
2.  
3. import java.io.Serializable;  
4. import java.sql.Date;  
5. import java.sql.Timestamp;  
6. /**  
7.  * @author zhukai  
8.  *  
9.  */ 
10. public class Customer implements Serializable {  
11.  
12.     private Long id;  
13.     private String name;  
14.     private String email;  
15.     private String password;  
16.     private int phone;  
17.     private boolean married;  
18.     private String address;  
19.     private char sex;  
20.     private String description;  
21.     //private byte[] image;  
22.     private Date birthday;  
23.     private Timestamp registeredTime;  
24.     /**  
25.      * hibernate要求持久化类必须提供一个不带参数的默认构造方法  
26.      */ 
27.     public Customer() {  
28.        // TODO Auto-generated constructor stub  
29.     }  
30.     public String getAddress() {  
31.         return address;  
32.     }  
33.  
34.     public void setAddress(String address) {  
35.        this.address = address;  
36.     }  
37.     public String getDescription() {  
38.        return description;  
39.     }  
40.     public void setDescription(String description) {  
41.        this.description = description;  
42.     }  
43.     public Date getBirthday() {  
44.        return birthday;  
45.     }  
46.     public void setBirthday(Date birthday) {  
47.        this.birthday = birthday;    
48.     }  
49.     public String getEmail() {  
50.        return email;  
51.     }  
52.     public void setEmail(String email) {  
53.        this.email = email;  
54.     }  
55.     public Long getId() {  
56.        return id;  
57.     }  
58.     public void setId(Long id) {  
59.        this.id = id;  
60.     }  
61.     public boolean isMarried() {  
62.       return married;  
63.     }  
64.     public void setMarried(boolean married) {  
65.        this.married = married;  
66.     }  
67.     public String getName() {  
68.       return name;  
69.     }  
70.     public void setName(String name) {  
71.        this.name = name;  
72.     }  
73.     public String getPassword() {  
74.        return password;  
75.     }  
76.     public void setPassword(String password) {  
77.        this.password = password;  
78.     }  
79.     public int getPhone() {  
80.        return phone;  
81.     }  
82.     public void setPhone(int phone) {  
83.        this.phone = phone;  
84.     }  
85.     public Timestamp getRegisteredTime() {  
86.        return registeredTime;  
87.     }  
88.     public void setRegisteredTime(Timestamp registeredTime) {  
89.        this.registeredTime = registeredTime;  
90.     }  
91.     public char getSex() {  
92.        return sex;  
93.     }  
94.     public void setSex(char sex) {  
95.        this.sex = sex;  
96.     }  
97. }  

注意，这个类采用的是标准JavaBean形式，通常我们都要按照这个标准来构建我们的持久化类。

4．配置映射文件

一般映射文件采用约定俗成的命名规则：类名.hbm.xml，和这个类的class文件放在一个目录下面，我的Customer.hbm.xml文件如下所示：

1. <?xml version="1.0" encoding="UTF-8"?> 
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping 
3. DTD 3.0//EN" "http://hibernate.sourceforge.net/
4. hibernate-mapping-3.0.dtd" > 
5. <hibernate-mapping> 
6.     <class name="cn.edu.hust.cm.mypack.Customer" table="CUSTOMER"> 
7.        <id name="id" type="long"> 
8.            <column name="ID"></column> 
9.            <generator class="increment"></generator> 
10.        </id> 
11.        <property name="name" type="string"> 
12.            <column name="NAME" not-null="true"></column> 
13.        </property> 
14.        <property name="email" type="string"> 
15.            <column name="EMAIL" not-null="true"></column> 
16.        </property> 
17.        <property name="password" type="string"> 
18.            <column name="PASSWORD" not-null="true"></column> 
19.        </property> 
20.        <property name="phone" type="integer"> 
21.            <column name="PHONE" not-null="true"></column> 
22.        </property> 
23.        <property name="address" type="string"> 
24.            <column name="ADDRESS"></column> 
25.        </property> 
26.        <property name="sex" type="character"> 
27.            <column name="SEX"></column> 
28.        </property> 
29.        <property name="married" type="boolean"> 
30.            <column name="IS_MARRIED"></column> 
31.        </property> 
32.        <property name="description" type="string"></property> 
33.        <property name="birthday" type="date"> 
34.            <column name="BIRTHDAY"></column> 
35.        </property> 
36.        <property name="registeredTime" type="timestamp"> 
37.            <column name="REGISTERED_TIME"></column> 
38.        </property> 
39.     </class> 
40. </hibernate-mapping> 

注意，这个文件是非常关键的，它联系了我们的持久化类以及其在数据库中对应的表，具体的关系如下图所示：

映射文件就像一个字典一样，Hibernate向数据库插入数据时通过“查询”它可以知道属性对应于数据库中哪个列，从数据库中把数据读出赋给持久化类时则通过“查询”知道列对应于持久化类的哪个属性。这个比喻不是很恰当，因为并不是持久化类的所有属性都直接和表的字段匹配。

OK，现在准备工作都已经做好了，可以编写一个程序来使用Hibernate了，我的运行主程序如下所示：

1. package cn.edu.hust.cm.mypack;  
2.  
3. import javax.servlet.*;  
4. import org.hibernate.*;  
5. import org.hibernate.cfg.Configuration;  
6.  
7. import java.io.*;  
8. import java.sql.Date;  
9. import java.sql.Timestamp;  
10. import java.util.Iterator;  
11. import java.util.List;  
12. public class BusinessService {  
13.     public static SessionFactory sessionFactory;  
14.      /*静态块，类加载时即执行，用来初始化Hibernate，创建SessionFatory实例*/ 
15.     static{  
16.        try{  
17.          Configuration configuration=new Configuration();  
18.          sessionFactory=configuration.configure().buildSessionFactory();  
19.        }  
20.        catch(Exception e){  
21.            e.printStackTrace();  
22.        }  
23.        finally{  
24.        }        
25.  
26.     }  
27.  
28.     /*默认的构造方法*/ 
29.     public BusinessService() {  
30.     }  
31.  
32.     public static SessionFactory getSessionFactory() {  
33.        return sessionFactory;  
34.     }  
35.     /**  
36.      * 该方法是测试入口，对各个方法进行测试  
37.      */ 
38.     public void test(){  
39.  
40.        Customer customer=new Customer();  
41.        customer.setName("朱楷");  
42.        customer.setEmail("xiaozhu87487705@163.com");  
43.        customer.setPassword("19840827");  
44.        customer.setPhone(1234);  
45.        customer.setAddress("湖北省武汉市珞瑜路1037号");  
46.        customer.setSex('M');  
47.        customer.setMarried(false);  
48.        customer.setDescription("芒果网员工");  
49.        customer.setBirthday(new Date(14*365*24*3600*1000));  
50.        customer.setRegisteredTime(new Timestamp(36*365*24*3600*10000));  
51.    
52.       saveCustomer(customer);  
53.        findAllCustomers();  
54.        loadAndUpdateCustomer(customer.getId());  
55.        deleteAllCustomers(customer);  
56.  
57.     }  
58.  
59.     /**  
60.      * 把一个Customer对象保存在数据库中  
61.      */ 
62.     public void saveCustomer(Customer customer){  
63.        Session session=sessionFactory.openSession();  
64.        Transaction tx = null;//局部变量必须赋予初始值  
65.        try{  
66.            tx=session.beginTransaction();  
67.            //事务开始  
68.            session.save(customer);  
69.            tx.commit();  
70.        }  
71.        catch(Exception e){  
72.            if(tx!=null) tx.rollback();  
73.            e.printStackTrace();  
74.        }  
75.        finally{  
76.            session.close();  
77.        }  
78.     }  
79.  
80.     /**  
81.      * 查询出数据中所有的持久化对象，并显示它们的基本信息  
82.      */ 
83.    public void findAllCustomers(){  
84.        Session session=sessionFactory.openSession();  
85.        Transaction tx=null;  
86.        try{  
87.            tx=session.beginTransaction();  
88.            //事务开始  
89.            Iterator customers=session.createQuery("from Customer")
90. .list().iterator();  
91.            while(customers.hasNext()){  
92.               Customer cs=(Customer)customers.next();  
93.               System.out.println("姓名："+cs.getName());  
94.               System.out.println("性别："+cs.getSex());  
95.               System.out.println("电子邮箱："+cs.getEmail());  
96.               System.out.println("婚否："+cs.isMarried());  
97.            }  
98.            tx.commit();   
99.        }  
100.        catch(Exception e){  
101.            if(tx!=null) tx.rollback();  
102.           e.printStackTrace();  
103.        }  
104.        finally{  
105.            session.close();  
106.       }  
107.     }      
108.  
109.     /**  
110.      * 加载指定的持久化对象并对其进行修改  
111.      * @param id 对象标识符OID  
112.      */ 
113.     public void loadAndUpdateCustomer(long id){  
114.        Session session=sessionFactory.openSession();  
115.        Transaction tx=null;  
116.        try{  
117.            tx=session.beginTransaction();  
118.            //事务开始  
119.            Customer cs=(Customer)session.load(Customer.class, id);  
120.            cs.setAddress("广东省深圳市");  
121.            tx.commit();   
122.        }  
123.        catch(Exception e){  
124.            if(tx!=null) tx.rollback();  
125.            e.printStackTrace();  
126.        }  
127.        finally{  
128.            session.close();  
129.        }  
130.     }  
131.       
132.     public void deleteAllCustomers(Customer c){  
133.        Session session=sessionFactory.openSession();  
134.        Transaction tx=null;  
135.        try{  
136.            tx=session.beginTransaction();  
137.            //事务开始  
138.            session.delete(c);  
139.            //Query query=session.createQuery("delete from Customer");  
140.            //query.executeUpdate();  
141.            tx.commit();   
142.  
143.        }  
144.        catch(Exception e){  
145.            if(tx!=null) tx.rollback();  
146.            e.printStackTrace();  
147.        }  
148.        finally{  
149.            session.close();  
150.        }  
151.     }  
152.     /**  
153.      * @param args  
154.      */ 
155.     public static void main(String[] args) {  
156.         BusinessService bs=new BusinessService();  
157.         bs.test();    
158.         sessionFactory.close();  
159.     }  
160. } 

这样，我们的第一个Hibernate应用程序就大功告成了，至于Hibernate中的各个类以及接口如Session、SessionFactory接口是干什么用的，在以后的学习中再陆续介绍，主要是因为我还没有好好的学习这几个类，^_^。