Hibernate学习笔记（一）——简单的Hibernate实例入门

一、Hibernate简介

Hibernate是一个开源的对象/关系映射（ORM）框架，它对JDBC进行了轻量级的封装。所谓ORM就是Object/Relationship Mapping，为什么要使用对象/关系映射呢？因为使用面向对象思想编写的数据库应用程序都是要把信息存储到关系型数据库中的，使用Hibernate就可以使用面向对象的方法来操作和使用数据库了。

二、Hibernate简单实例

下面通过一个简单的例子来介绍一下使用Hibernate的基本步骤，本实例使用了MySQL数据库，并使用JUnit来进行测试。首先要引入使用的jar包，在本例中需要引入Hibernate使用的相关jar包、MySQL数据库连接jar包和JUnit测试jar包，在pom文件中添加以下依赖。

[html]  view plain  copy

1.  <dependencies>  
2.     <dependency>  
3.     <groupId>org.hibernate</groupId>  
4.     <artifactId>hibernate-core</artifactId>  
5.     <version>5.2.0.Final</version>  
6. </dependency>  
7. <dependency>  
8.     <groupId>mysql</groupId>  
9.     <artifactId>mysql-connector-java</artifactId>  
10.     <version>5.1.38</version>  
11. </dependency>  
12.    <dependency>  
13.      <groupId>junit</groupId>  
14.      <artifactId>junit</artifactId>  
15.      <version>4.10</version>  
16.      <scope>test</scope>  
17.    </dependency>  
18.  </dependencies>  

引入了相关jar包之后就可以进行编码了。编写一个Hibernate例子分为以下几个步骤：（1）创建Hibernate的配置文件（hibernate.cfg.xml）；（2）创建持久化类；（3）创建对象/关系映射文件；（4）通过Hibernate的API来编写操作数据库的代码。下面将通过代码依次来讲解每一个步骤。

1、创建Hibernate的配置文件（hibernate.cfg.xml）

首先我们需要创建Hibernate的配置文件hibernate.cfg.xml，配置文件的内容如下：

[html]  view plain  copy

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. <hibernate-configuration>  
6.     <session-factory>  
7.         <!-- 对应的数据库驱动 -->  
8.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
9.         <!-- 数据库密码 -->  
10.         <property name="hibernate.connection.password">root</property>  
11.         <!-- 数据库用户名 -->  
12.         <property name="hibernate.connection.username">root</property>  
13.         <!-- 数据库url，类似于JDBC中连接数据库的url -->  
14.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/shopping?useUnicode=true&characterEncoding=UTF-8</property>  
15.         <!-- 数据库使用的方言 -->  
16.         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  
17.           
18.         <!-- 是否把输出到控制台的sql进行格式化 -->  
19.         <property name="format_sql">true</property>  
20.         <!-- 是否将Hibernate运行时的sql输出到控制台 -->  
21.         <property name="show_sql">true</property>  
22.         <!-- 自动创建|更新|验证数据库表结构 -->  
23.         <property name="hbm2ddl.auto">create</property>  
24.         
25.     </session-factory>  
26. </hibernate-configuration>  

通过观察配置文件的内容我们发现，这个配置文件其实主要是在配置数据库的一些基本信息，包括数据库驱动、用户名密码等。

2、创建持久化类

接下来我们就需要创建一个持久化类User，里面包含了一些基本的用户信息。

[java]  view plain  copy

1. package com.imooc.vo;  
2.   
3. import java.util.Date;  
4.   
5. public class User {  
6.   
7.     private int id;  
8.       
9.     private String name;  
10.       
11.     private int age;  
12.       
13.     private String sex;  
14.       
15.     private Date birthday;  
16.       
17.     private String address;  
18.       
19.   
20.     public User() {  
21.     }  
22.   
23.     public User(int id, String name, int age, String sex, Date birthday, String address) {  
24.         this.id = id;  
25.         this.name = name;  
26.         this.age = age;  
27.         this.sex = sex;  
28.         this.birthday = birthday;  
29.         this.address = address;  
30.     }  
31.   
32.     public int getId() {  
33.         return id;  
34.     }  
35.   
36.     public void setId(int id) {  
37.         this.id = id;  
38.     }  
39.   
40.     public String getName() {  
41.         return name;  
42.     }  
43.   
44.     public void setName(String name) {  
45.         this.name = name;  
46.     }  
47.   
48.     public int getAge() {  
49.         return age;  
50.     }  
51.   
52.     public void setAge(int age) {  
53.         this.age = age;  
54.     }  
55.   
56.     public String getSex() {  
57.         return sex;  
58.     }  
59.   
60.     public void setSex(String sex) {  
61.         this.sex = sex;  
62.     }  
63.   
64.     public Date getBirthday() {  
65.         return birthday;  
66.     }  
67.   
68.     public void setBirthday(Date birthday) {  
69.         this.birthday = birthday;  
70.     }  
71.   
72.     public String getAddress() {  
73.         return address;  
74.     }  
75.   
76.     public void setAddress(String address) {  
77.         this.address = address;  
78.     }  
79.   
80.   
81.     @Override  
82.     public String toString() {  
83.         return "Student [id=" + id + ", name=" + name + ", age=" + age  
84.                 + ", sex=" + sex + ", birthday=" + birthday + ", address="  
85.                 + address + "]";  
86.     }  
87.       
88. }  

我们发现所谓的持久化类其实就是一个基本的JavaBean，里面包含了一些属性和相应的get和set方法。

3、创建对象/关系映射文件

接下来我们就需要根据持久化类创建一个对象/关系映射文件User.hbm.xml。

[html]  view plain  copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
4. <!-- Generated 2016-9-19 19:59:35 by Hibernate Tools 3.4.0.CR1 -->  
5. <hibernate-mapping>  
6.     <class name="com.imooc.vo.User" table="USER">  
7.         <id name="id" type="int">  
8.             <column name="ID" />  
9.             <generator class="assigned" />  
10.         </id>  
11.         <property name="name" type="java.lang.String">  
12.             <column name="NAME" />  
13.         </property>  
14.         <property name="age" type="int">  
15.             <column name="AGE" />  
16.         </property>  
17.         <property name="sex" type="java.lang.String">  
18.             <column name="SEX" />  
19.         </property>  
20.         <property name="birthday" type="java.util.Date">  
21.             <column name="BIRTHDAY" />  
22.         </property>  
23.         <property name="address" type="java.lang.String">  
24.             <column name="ADDRESS" />  
25.         </property>  
26.     </class>  
27. </hibernate-mapping>  

这个对象/关系映射文件其实就是将定义的持久化类与数据库表进行映射，这里将User类映射为一个名为USER的表，将对象的属性映射为数据库的列，将属性的类型映射为数据库列的类型。在创建了这个对象/关系映射文件之后，我们需要在Hibernate配置文件hibernate.cfg.xml中声明这个映射关系，在session-factory标签下声明如下内容。

[html]  view plain  copy

1. <mapping resource="com/imooc/map/User.hbm.xml"/>  

4、通过Hibernate的API来编写操作数据库的代码

在上面一系列的配置完成之后我们就可以使用JUnit来编写一个测试类UserTest来使用Hibernate了。

[java]  view plain  copy

1. package com.imooc.test;  
2.   
3. import java.util.Date;  
4.   
5. import org.hibernate.Session;  
6. import org.hibernate.SessionFactory;  
7. import org.hibernate.Transaction;  
8. import org.hibernate.cfg.Configuration;  
9. import org.junit.After;  
10. import org.junit.Before;  
11. import org.junit.Test;  
12.   
13. import com.imooc.vo.User;  
14.   
15. public class UserTest {  
16.       
17.     private SessionFactory sessionFactory;  
18.     private Session session;  
19.     private Transaction transaction;  
20.   
21.     @Before  
22.     public void init() {  
23.         //创建配置对象  
24.         Configuration config = new Configuration().configure();   
25.         //创建会话工厂对象  
26.         sessionFactory = config.buildSessionFactory();  
27.         //创建会话对象  
28.         session = sessionFactory.openSession();  
29.         //开启事务  
30.         transaction = session.beginTransaction();  
31.     }  
32.       
33.     @After  
34.     public void destory() {  
35.         //提交事务  
36.         transaction.commit();  
37.         //关闭会话  
38.         session.close();  
39.         //关闭会话工厂  
40.         sessionFactory.close();       
41.     }  
42.       
43.       
44.     @Test  
45.     public void saveNewUser() throws Exception{  
46.         User s = new User(1, "张三", 12, "男", new Date(), "上海市");  
47.         session.save(s);  
48.     }  
49.       
50. }  

我们来分析一下代码，在执行数据库操作方法之前需要执行一个初始化方法init()，这个初始化方法主要是对Hibernate进行初始化操作，包括读取配置文件，创建会话工厂和会话、开启事务等。然后执行测试方法，测试方法很简单，只是新建了一个对象，然后将对象保存进数据库，我们可以发现这里将对象保存进数据库没有写复杂的SQL语句，而是直接使用了一个save方法就完成了插入操作，这也体现了Hibernate的优势，不用在代码中编写复杂的SQL语句，代码的可移植性和复用性大大增强了。最后当测试方法执行结束之后执行一个销毁方法destory()，这个方法主要用于提交事务和关闭资源。

下面使用JUnit执行saveNewUser()方法，执行完成后，我们去数据库中会发现新生成了一张表USER，查询表中的内容，我们会发现刚刚定义的名为张三的用户已经插入成功了，这说明使用Hibernate操作数据库成功了。