一、基礎入門
從一個最基本的對象關系映像自動化程序，了解Hibernate組成的基本元素，并進一步了解Hibernate的基礎語義、配置等概念。
1．O/R映像入門第一個Hibernate程序很簡單，將一個對象映像至一個數據表
1．1配置Hibernate
Hibernate是ORM的解決方案，其底層對數據庫的操作依賴于JDBC，所以您必須先取得JDBC驅動程序，在這邊所使用的是MySQL，所以您必須至MySQL®Connector/J取得MySQL的JDBC驅動程序。
接下來至Hibernate官方網站取得hibernate 3.0。
解開zip檔案后，當中的hibernate3.jar是必要的，而在lib目錄中還包括了許多jar檔案，您可以在Hibernate
3.0官方的參考手冊上找到這些jar的相關說明，其中必要的是antlr、dom4j、CGLIB、asm、Commons
Collections、Commons Logging、 EHCache，Hibernate底層還需要Java Transaction
API，所以您還需要jta.jar，到這邊為止，總共需要以下的jar檔案：
Hibernate可以運行于單機之上，也可以運行于Web應用程序之中，如果是運行于單機，則將所有用到的jar檔案（包括JDBC驅動程序）設定至CLASSPATH中，如果是運行于Web應用程序中，則將jar檔案置放于WEB-INF/lib中。
如果您還需要額外的Library，再依需求加入，例如JUnit、Proxool等等，接下來可以將etc目錄下的
log4j.properties復制至Hibernate項目的Classpath下，并修改一下當中的
log4j.logger.org.hibernate為error，也就是只在錯誤發生時顯示必要的訊息。
接著設置基本的Hibernate配置文件，可以使用XML或Properties檔案，這邊先使用XML，檔名預設為hibernate.cfg.xml：
hibernate.cfg.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"
<hibernate-configuration>
<session-factory>
<!-- 顯示實際操作數據庫時的SQL -->
<property name="show_sql">true</property>
<!-- SQL 方言，這邊設定的是MySQL -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- JDBC 驅動程序 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- JDBC URL -->
<property name="connection.url">jdbc:mysql://localhost/demo</property>
<!-- 數據庫使用者 -->
<property name="connection.username">caterpillar</property>
<!-- 數據庫密碼 -->
<property name="connection.password">123456</property>
<!-- 以下設置對象與數據庫表格映像文件 -->
</session-factory>
</hibernate-configuration>
|
配置文件中已經加上批注為每一個項目作了說明，其中對象與數據庫表格映像文件還有待加入。
1．2第一個Hibernate
這邊以一個簡單的單機程序來示范Hibernate的配置與功能，首先作數據庫的準備工作，在MySQL中新增一個demo數據庫，并建立user表格：
CreateUser2MySQL.sql
CREATE TABLE user (
id INT(11) NOT NULL auto_increment PRIMARY KEY,
name VARCHAR(100) NOT NULL default '',
age INT
);
|
對于這個表格，您有一個User類別與之對應，表格中的每一個字段將對應至User實例上的Field成員。
User.java
package onlyfun.caterpillar;
public class User {
private Integer id;
private String name;
private Integer age;
// 必須要有一個預設的建構方法
// 以使得Hibernate 可以使用Constructor.newInstance()建立對象
public User() {
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
|
其中id是個特殊的屬性，Hibernate會使用它來作為主鍵識別，您可以定義主鍵產生的方式，這是在XML映像文件中完成，為了告訴Hibernate您所定義的User實例如何映像至數據庫表格，您撰寫一個XML映射文件檔名是User.hbm.xml，如下所示：
User.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"
<hibernate-mapping>
<class name="onlyfun.caterpillar.User" table="user">
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="name" column="name" type="java.lang.String" />
<property name="age" column="age" type="java.lang.Integer" />
</class>
</hibernate-mapping>
|
<class>卷標的name屬性為所映像的對象，而table為所映像的表格；<id>中column屬性指定了表格字
段，而type屬性指定了User實例的中的id之型態，這邊type中所設定的是直接指定Java中的對象型態，Hibernate也定義有自己的映像
型態，作為Java對象與SQL型態的標準對應型態（因為語言所提供的類型并不一定與數據庫的類型對應），這之后會再說明。
<id>中主鍵的產生方式在這邊設定為"native"，表示主鍵的生成方式由Hibernate根據數據庫Dialect的定義來決定，之后還會介紹其它主鍵的生成方式。
同樣的，<property>標簽中的column與type都各自指明了表格中字段與對象中屬性的對應。
接著必須在Hibernate配置文件hibernate.cfg.xml中指明映像文件的位置，如下加入映像文件位置：
hibernate.cfg.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"
<hibernate-configuration>
<session-factor>
....
<!-- 對象與數據庫表格映像文件 -->
<mapping resource="onlyfun/caterpillar/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
|
接下來撰寫一個測試的程序，這個程序直接以Java 程序設計人員熟悉的語法方式來操作對象，而實際上也直接完成對數據庫的操作，程序將會將一筆數據存入表格之中：
FirstHibernate.java
package onlyfun.caterpillar;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class FirstHibernate {
public static void main(String[] args) {
// Configuration 負責管理 Hibernate 配置訊息
Configuration config = new Configuration().configure();
// 根據 config 建立 SessionFactory
// SessionFactory 將用于建立 Session
SessionFactory sessionFactory = config.buildSessionFactory();
//將持久化的物件
User user = new User();
user.setName("caterpillar");
user.setAge(new Integer(30));
//開啟Session，相當于開啟JDBC 的Connection
Session session = sessionFactory.openSession();
//Transaction 表示一組對DB 的交易
Transaction tx = session.beginTransaction();
//將對象映像至數據庫表格中儲存
session.save(user);
tx.commit();
session.close();
sessionFactory.close();
System.out.println("新增資料OK!請先用MySQL 觀看結果！");
}
}
|
如您所看到的，程序中只需要直接操作User 對象，并進行Session 與Transaction 的相關操作，Hibernate 就會自動完成對數據庫的操作，您看不到任何一行JDBC 或SQL 的陳述，撰寫好以上的各個檔案之后，各檔案的放置位置如下：
接著可以開始運行程序，結果如下：
FirstHibernate執行結果
Hibernate: insert into user (name, age) values (?, ?)
|
新增資料OK!請先用MySQL 觀看結果！
執行結果中顯示了Hibernate 所實際使用的SQL，由于這個程序還沒有查詢功能，所以要
進入MySQL 中看看新增的數據，如下：
MySQL 中查詢結果
mysql> select * from user;
+----+-------------+------+
| id | name | age |
+----+-------------+------+
| 1 | caterpillar | 30 |
+----+-------------+------+
1 row in set (0.03 sec)
|
Comments
第四段代碼的標題應該是hibernate.cfg.xml
1．3 第二個 Hibernate
在 第一個 Hibernate
中介紹如何使用Hibernate 在不使用SQL 的情況下，以Java
中操作對象的習慣來插入數據至數據庫中，當然儲存數據之后，更重要的是如何將資料讀出，Hibernate 中也可以讓您不寫一句SQL，而以Java
中操作對象的習慣來查詢數據。
直接來看個范例：
SecondHibernate.java
package onlyfun.caterpillar;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Expression;
import java.util.Iterator;
import java.util.List;
public class SecondHibernate {
public static void main(String[] args) {
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
Criteria criteria = session.createCriteria(User.class);
// 查詢user 所有字段
List users = criteria.list();
Iterator iterator = users.iterator();
System.out.println("id "t name/age");
while (iterator.hasNext()) {
User user = (User) iterator.next();
System.out.println(user.getId() + " "t " + user.getName() + "/" +
user.getAge());
}
// 查詢user 中符合條件的字段
criteria.add(Expression.eq("name", "caterpillar"));
users = criteria.list();
iterator = users.iterator();
System.out.println("id "t name/age");
while (iterator.hasNext()) {
User user = (User) iterator.next();
System.out.println(user.getId() + " "t " + user.getName() + "/" +
user.getAge());
}
session.close();
sessionFactory.close();
}
}
|
Criteria 對SQL 進行封裝，對于不甚了解SQL 的開發人員來說，使用Criteria
也可以輕易的進行各種數據的檢索，您也可以使用 Expression
設定查詢條件，并將之加入Criteria中對查詢結果作限制，Expression.eq()表示設定符合條件的查詢，例如Expression.eq
("name", "caterpillar")表示設定查詢條件為"name"字段中為"caterpillar"的數據。
先來看一下執行結果：
SecondHibernate 執行結果
Hibernate: select this_.id as id0_, this_.name as name0_0_,
this_.age as age0_0_ from user
this_id
id name/age
1 caterpillar/30
3 bush/5
2 momor/26
Hibernate: select this_.id as id0_, this_.name as name0_0_,
this_.age as age0_0_ from user
this_
where this_.name=?
id name/age
1 caterpillar/30
|
Criteria 是對象導向式的查詢方式，讓不了解SQL 的開發人員也可以輕易進行各項查詢，但Criteria 的API
目前還不是很完善，而Hibernate 鼓勵的查詢方式，是透過HQL（Hibernate Query Language）來進行，直接來看個實例：
SecondHibernateUsingHQ.java
package onlyfun.caterpillar;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import java.util.Iterator;
import java.util.List;
public class SecondHibernateUsingHQ {
public static void main(String[] args) {
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
// 使用HQL 建立查詢
Query query = session.createQuery("from User");
List users = query.list();
Iterator iterator = users.iterator();
System.out.println("id "t name/age");
while (iterator.hasNext()) {
User user = (User) iterator.next();
System.out.println(user.getId() + " "t " + user.getName() + "/" +
user.getAge());
}
System.out.println();
// 使用HQL 建立查詢
query = session.createQuery("from User user where user.name like ?");
// 設定查詢參數
query.setParameter(0, "caterpillar");
users = query.list();
iterator = users.iterator();
System.out.println("id "t name/age");
while (iterator.hasNext()) {
User user = (User) iterator.next();
System.out.println(user.getId() + " "t " + user.getName() + "/" +
user.getAge());
}
session.close();
sessionFactory.close();
}
}
|
執行結果：
SecondHibernateUsingHQ 執行結果
Hibernate: select this_.id as id0_, this_.name as name0_0_,
this_.age as age0_0_ from user
this_id
id name/age
1 caterpillar/30
3 bush/5
2 momor/26
Hibernate: select this_.id as id0_, this_.name as name0_0_,
this_.age as age0_0_ from user
this_
where this_.name=?
id name/age
1 caterpillar/30
|
透過Query 接口，您可以先設定查詢參數，之后透過setXXX()等方法，將指定的參數值填入，而不用每次都撰寫完整的HQL，Query 的setParameter()方法第一個參數是指定?出現的位置，從 0 開始，第二個參數則是設定查詢條件。
二、簡單的Hibernate 程序
這邊以一個簡單的單機程序來示范Hibernate的配置與功能，在這個例子中的一些操作，實際上會使用一些自動化工具來完成，而不一定親自手動操
作設定，這邊完全手動的原因，在于讓您可以知道Hibernate實際上會作那些動作，在進行范例之前，請先確定前一個主題中的相關jar檔案都已經設定
在CLASSPATH中。
我們先作數據庫的準備工作，在MySQL中新增一個HibernateTest數據庫，并建立USER表格：
CREATE TABLE USER (
user_id CHAR(32) NOT NULL PRIMARY KEY,
name VARCHAR(16) NOT NULL,
sex CHAR(1),
age INT
);
|
我們先撰寫一個純Java對象，它純綷表示一個數據集合，待會我們會將之映像至數據庫的表格上，程序如下：
User.java
package onlyfun.caterpillar;
public class User {
private String id;
private String name;
private char sex;
private int age;
public int getAge() {
return age;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public char getSex() {
return sex;
}
public void setAge(int i) {
age = i;
}
public void setId(String string) {
id = string;
}
public void setName(String string) {
name = string;
}
public void setSex(char c) {
sex = c;
}
}
|
其中id是個特殊的屬性，Hibernate會使用它來作為主鍵識別，我們可以定義主鍵產生的方式，這是在XML映像文件中完成，為了告訴Hibernate對象如何映像至數據庫表格，我們撰寫一個XML映射文件檔名是User.hbm.xml，如下所示：
User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
"
<hibernate-mapping>
<class name="onlyfun.caterpillar.User" table="USER">
<id name="id" type="string" unsaved-value="null">
<column name="user_id" sql-type="char(32)" />
<generator class="uuid.hex"/>
</id>
<property name="name" type="string" not-null="true">
<column name="name" length="16" not-null="true"/>
</property>
<property name="sex" type="char"/>
<property name="age" type="int"/>
</class>
</hibernate-mapping>
|
這個XML文件定義了對象屬性映像至數據庫表格的關系，您可以很簡單的了解對映的方法，像是User對象對應至USER表格，其中我們使用
uuid.hex來定義主鍵的產生算法，UUID算法使用IP地址、JVM的啟動時間、系統時間和一個計數值來產生主鍵。除了使用uuid.hex之外，
我們還可以使用其它的方式來產生主鍵，像是increment等，這可以在Hibernate參考手冊中找到相關資料。
<property>卷標用于定義Java對象的屬性，而當中的<column/>卷標用于定義與數據庫的對應，如果您是
手工建立Java對象與數據庫表格，則在最簡單的情況下，可以只定義<property
name="sex"/>這樣的方式，而由Hibernate自動判斷Java對象屬性與數據庫表格名稱對應關系，在<
property/>與<column/>標簽上的額外設定（像是not
null、sql-type等），則可以用于自動產生Java對象與數據庫表格的工具上。
接下來我們定義Hibernate配置文件，主要是進行SessionFactory配置，Hibernate可以使用XML或屬性文件來進行配
置，我 們這邊先介紹如何使用XML配置，這也是Hibernate所建議的配置方式，我們的文件名是hibernate.cfg.xml，如下：
hibernate.cfg.xml
<?xml version='1.0' encoding='big5'?>
<!DOCTYPE hibernate-configuration
PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
"
<hibernate-configuration>
<session-factory>
<!-- 顯示實際操作數據庫時的SQL -->
<property name="show_sql">true</property>
<!-- SQL方言，這邊設定的是MySQL -->
<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>
<!-- JDBC驅動程序 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- JDBC URL -->
<property name="connection.url">jdbc:mysql://localhost/HibernateTest</property>
<!-- 數據庫使用者 -->
<property name="connection.username">caterpillar</property>
<!-- 數據庫密碼 -->
<property name="connection.password">123456</property>
<!-- 對象與數據庫表格映像文件 -->
<mapping resource="User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
|
接下來我們撰寫一個測試的程序，這個程序將直接以Java程序設計人員熟悉的語法方式來操作對象，而實際上也直接完成對數據庫的操作，程序將會將一筆數據存入表格之中：
HibernateTest.java
import onlyfun.caterpillar.*;
import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
public class HibernateTest {
public static void main(String[] args) throws HibernateException {
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
User user = new User();
user.setName("caterpillar");
user.setSex('M');
user.setAge(28);
Session session = sessionFactory.openSession();
Transaction tx= session.beginTransaction();
session.save(user);
tx.commit();
session.close();
sessionFactory.close();
System.out.println("新增資料OK!請先用MySQL觀看結果！");
}
}
|
Configuration代表了Java對象至數據庫的映像設定，這個設定是從我們上面的XML而來，接下來我們從Configuration取
得SessionFactory對象，并由它來開啟一個Session，它代表對象與表格的一次會話操作，而
Transaction則表示一組會話操作，我們只需要直接操作User對象，并進行Session與Transaction的相關操作，
Hibernate就會自動完成對數據庫的操作。這邊對程序先只作簡單的介紹，之后再詳加說明。
將所有的.java檔案編譯，并將兩個XML檔案放置在與HibernateTest相同的目錄中，也就是檔案位置如下：
/
|--HibernateTest.class
|--User.hbm.xml
|--hibernate.cfg.xml
/onlyfun
/caterpillar
|--User.class
|
OK!現在您可以執行HibernateTest，程序將會出現以下的訊息：
log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: insert into USER (name, sex, age, user_id) values (?, ?, ?, ?)
|
新增資料OK!請先用MySQL觀看結果！
這邊只先進行數據的存入，要觀看數據存入的結果的話，請進入MySQL觀看，以下是數據庫存入的結果：
mysql> SELECT * FROM USER;
+----------------------------------+-------------+------+------+
| user_id | name | sex | age |
+----------------------------------+-------------+------+------+
| 297e3dbdfea6023d00fea60241000001 | caterpillar | M | 28 |
+----------------------------------+-------------+------+------+
1 rows in set (0.00 sec)
posted on 2008-07-23 16:57
胖胖泡泡 閱讀(462)
評論(0) 編輯 收藏