BÀI THÍ NGHIỆM SỐ: XÂY DỰNG HIBERNATE CHO ỨNG DỤNG JAVA
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (3.8 MB, 51 trang )
BÀI THÍ NGHIỆM SỐ: XÂY DỰNG HIBERNATE CHO ỨNG DỤNG JAVA ....................................... 2
I.
Lý thuyết .......................................................................................................................................... 2
II.
Thí nghiệm ................................................................................................................................... 2
Thời gian thực hiện thí nghiệm: 60 phút.............................................................................................. 2
Tiến trình thực hiện: ............................................................................................................................. 2
Phần 1: Tạo CSDL "mydatabase" ........................................................................................................ 2
(0.1) Chạy máy chủ CSDL Java DB (Derby) nếu chưa được khởi động ........................................ 3
(0.2) Tạo CSDL lấy tên là “mydatabase" (nếu trên máy bạn chưa có) ......................................... 3
(0.3) Kiểm tra xem plug-in Hibernate đã được cài đặt chưa .......................................................... 5
Phần 2: Xây dựng ứng dụng Hibernate "HelloWorld" ....................................................................... 6
(1.1) Tạo lớp POJO ............................................................................................................................. 7
(1.2) Tạo file ánh xạ Hibernate cho các lớp POJO. ........................................................................ 12
(1.3) Tạo file cấu hình Hibernate ..................................................................................................... 17
(1.4) Tạo file Main.java và HibernateUtil.java............................................................................... 21
(1.5) Thêm thư viện Hibernate và driver Java DB ........................................................................ 26
(1.6) Thêm file log4j.properties ........................................................................................................ 29
(1.7) Dịch và chạy ứng dụng ............................................................................................................. 32
Tổng kết ............................................................................................................................................. 37
Phần 3: Xây dựng ứng dụng "HibernateHelloWorld2" .................................................................... 37
(2.1) Tạo dự án "HibernateHelloWorld2" sao chép từ dự án "HibernateHelloWorld" ............ 37
(2.2) Thêm lớp POJO mới ................................................................................................................ 39
(2.3) Viết file ánh xạ, Student.hbm.xml, cho lớp Student .............................................................. 40
(2.4) Sửa file Main.java ..................................................................................................................... 41
(2.5) Thay đổi file hibernate.cfg.xml ............................................................................................... 42
(2.6) Dịch và chạy ứng dụng ............................................................................................................. 43
(2.7) Nhận lệnh SQL từ Hibernate .................................................................................................. 44
Tổng kết ............................................................................................................................................. 46
Phần 3: Cấu hình Hibernate JavaDoc ................................................................................................. 46
(3.1) Cấu hình thư mục Hibernate Javadoc cho NetBeans IDE ................................................... 46
(3.2) Hiển thị Javadoc của giao diện Session Hibernate một cách trực quan .............................. 50
Tổng kết ............................................................................................................................................. 51
BÀI THÍ NGHIỆM SỐ: XÂY DỰNG HIBERNATE CHO ỨNG DỤNG JAVA
I. Lý thuyết
1. Hibernate là gì
Hibernate là một dịch vụ lưu trữ và truy vấn dữ liệu quan hệ mạnh mẽ và nhanh chóng. Hibernate
giúp phát triển các lớp (class) dùng để lưu trữ dữ liệu theo cách thức hướng đối tượng: kết hợp
(association), thừa kế (inheritance), đa hình (polymorphism), tổ hợp (composition) và tập hợp
(collections). Hibernate cho phép ta thực hiện các câu truy vấn dữ liệu bằng cách sử dụng ngôn ngữ
SQL mở rộng của Hibernate (HQL) hoặc là ngôn ngữ SQL nguyên thuỷ cũng như là sử dụng các API.
Không giống như các tầng bền vững (persistence layer) khác, Hibernate không ẩn đi sức mạnh của
ngôn ngữ SQL mà Hibernate còn đảm bảo cho chúng ta việc đầu tư vào công nghệ và tri thức cơ sở
dữ liệu quan hệ là luôn luôn chính xác. Và điều quan trọng hơn nữa là Hibernate được cấp phép theo
LGPL (Lesser GNU Public License). Theo đó, bạn có thể thoải mái sử dụng Hibernate trong các dự
án mã nguồn mở (open source) hoặc các dự án thương mại (commercial).
Hibernate là một dự án mã nguồn mở chuyên nghiệp và là một thành phần cốt tuỷ của bộ sản phẩm
JBoss Enterprise Middleware System (JEMS). JBoss, như chúng ta đã biết là một đơn vị của Red Hat,
chuyên cung cấp các dịch vụ 24x7 về hỗ trợ chuyên nghiệp, tư vấn và huấn luyện sẵn sàng hỗ trợ
trong việc dùng Hibernate.
Các thành phần của dự án Hibernate:
* Hibernate Core: Cung cấp các chức năng cơ bản của một tầng bền vững cho các ứng dụng Java với
các APIs và hỗ trợ ánh xạ XML metadata.
* Hibernate Annotations: Các lớp ánh xạ với JDK 5.0 annotations, bao gồm Hibernate Validator.
* Hibernate EntityManager: Sử dụng EJB 3.0 EntityManager API trong JSE hoặc với bất kỳ JEE
server nào.
* Hibernate Tools: Các công cụ tích hợp với Eclipse và Ant dùng cho việc sinh ra các đối tượng bền
vững (persistence object) từ một lược đồ có sẵn trong CSDL và từ các file hbm sinh ra các lớp java để
hiện thực các đối tượng bền vững, rồi Hibernate tự tạo các đối tượng trong CSDL.
* NHibernate: Hibernate cho .Net framework.
* JBoss Seam: Một Java EE 5.0 framework cho phát triển các ứng dụng JSF, Ajax và EJB 3.0 với sự
hỗ trợ của Hibernate. Seam khá mới và tỏ ra rất mạnh để phát triển các ứng dụng Web 2.0. Nó tích
hợp đầy đủ tất cả các công nghệ mới nhất hiện nay.
II. Thí nghiệm
Bài thí nghiệm hướng dẫn sinh viên các bước cơ bản xây dựng ứng dụng Hibernate HelloWorld. Trên cơ sở đó hiểu
được đầy đủ các khái niệm của Hibernate, cũng như cách hiển thị trực quan tài liệu Java trên các lớp của Hibernate.
Thời gian thực hiện thí nghiệm: 60 phút
Tiến trình thực hiện:
• Phần 1: Trên máy chủ CSDL (database server), tạo CSDL lấy tên “mydatabase”, thêm plug-in
Hibernate.
• Phần 2: Xây dựng ứng dụng Hibernate “HelloWorld” (20 phút)
• Phần 3: Xây dựng ứng dụng Hibernate “HelloWorld2” (20 phút)
• Phần 4: Cấu hình Javadoc cho Hibernate và hiển thị trực quan Javadoc
• Phần 5: Bài tập tự thí nghiệm
Phần 1: Tạo CSDL "mydatabase"
Sinh viên thực hiện tạo CSDL "mydatabase" trên máy theo thứ tự sau.
1.
2.
Chạy máy chủ CSDL Java DB (trong tài liệu có tên là Derby)
Tạo CSDL lấy tên là “mydatabase”
3.
Cài đặt plug-in Hibernate cho NetBeans IDE (phiên bản 6.1 trở lên)
Dưới đây là hướng dẫn thực thi từng bước trên
(0.1) Chạy máy chủ CSDL Java DB (Derby) nếu chưa được khởi động
1. Chọn máy chủ Java DB. (như Hình-0.10)
•
•
•
Kích chọn tab Services.
Kích mở rộng vùng Databases.
Kích chuột phải Java DB và chọn Start Server. Nếu đã chạy rồi mục chọn này sẽ bị chuyển sang
màu xám.
Hình-0.10: Chạy máy chủ CSDL
(0.2) Tạo CSDL lấy tên là “mydatabase" (nếu trên máy bạn chưa có)
1. Tạo CSDL
•
Kích chuột phải vào Java DB và chọn Create Database. (Hình-0.20)
Hình-0.20: Tạo CSDL mydatabase
2. Điền vào các mục trong hộp thoại Create Java DB Database.
•
•
•
•
Trong mục Database Name, gõ tên "mydatabase".
Trong mục User name, gõ app.
Mục Password, gõ "app". (như Hình-0.21)
Kích OK để hoàn tất.
Hình-0.21: Tạo CSDL
3. Kết nối đến CSDL mydatabase. Chú ý là lúc này bạn chưa cần tạo các bảng biểu trong CSDL.
•
•
Mở rộng mục Drivers.
Kích chuột phải vào jdbc:derby://localhost:1527/mydatabase [app on App] và chọn Connect...
•
Kích vào thẻ cửa sổ Projects để quay lại xem hiển thị của dự án (project)
(0.3) Kiểm tra xem plug-in Hibernate đã được cài đặt chưa
Nếu không thấy Hibernate trong danh sách các mục của thẻ Installed, điều đó có nghĩa là plug-in này chưa cài đặt
trong NetBeans IDE của bạn. Kích vào thẻ Available Plugins và lựa chọn Hibernate sau đó cài đặt bằng cách kích
vào Install.
Phần 2: Xây dựng ứng dụng Hibernate "HelloWorld"
Trong phần này, sinh viên sẽ viết và chạy ứng dụng Hibernate khá đơn giản "HelloWorld". Trong ứng dụng này,
chúng ta sẽ làm việc với đối tượng Person kết nối CSDL thông qua Hibernate.
Các bước lần lượt thực hiện như sau:
1.
2.
3.
4.
5.
6.
7.
8.
Tạo lớp POJO, Person.java
Tạo file ánh xạ (mapping) cho lớp POJO, Write Hibernate mapping files for the POJO
classes, Person.hbm.xml in this example
Tạo file cấu hình cho Hibernate, hibernate.cfg.xml
Tạo file Main.java và HibernateUtil.java
Thêm thư viện Hibernate và Java DB
Thêm log4j.properties vào đường dẫn lớp
Dịch và chạy ứng dụng
Kiểm thử lại CSDL
(1.1) Tạo lớp POJO
Trong ứng dụng đơn giản này, chúng ta chỉ viết một lớp POJO. Ta sẽ đặt tên lớp là Person.java.
POJO là đại diện tiêu biểu cho lớp persistence. Một POJO là tương tự như một JavaBean, có những getter và setter
để truy câp các thuộc tính của nó là những biến thực thể (instance variable). Lớp persistence có những đặc điểm
dưới đây:
a. Nó là thay thế hướng đối tượng cho bảng ở cơ sở dữ liệu
b. Các thuộc tính của bảng trở thành những biến thực thể của lớp persistence.
c. Kiểu dữ liệu của biến thực thể là miền xác định của thuộc tính.
d. Đối tượng của lớp thay cho hàng của bảng.
1. Tạo dự án NetBeans
•
Chọn File->New Project (hoặc Ctrl+Shift+N). (như Hình-1.11 dưới đây)
Hình-1.11: Tạo dự án mới
•
•
•
Sau khi xuất hiện cửa sổ New Project.
Trong cửa sổ nhỏ các bước công việc, thực hiện chọn
chọn Java dưới Categories và Java Application dưới Projects. (Hình-1.12)
Sau đó kích chọn Next.
Choose
Hình-1.12: Tạo dự án ứng dụng Java
•
•
•
Ở bước Name and Location , trong mục Project Name, gõ tên HibernateHelloWorld.
Trong mục Create Main Class, gõ Main. (Hình-1.13 ở dưới)
Kích Finish để hoàn tất.
Project,
Hình-1.13: Đặt tên cho dự án
•
Bạn sẽ thấy cửa sổ dự án HibernateHelloWorld và IDE sinh ra cửa sổ sửa đổi mã nguồn của
Main.java của NetBeans IDE.
2. Xây dựng lớp Person.java như đoạn mã hiển thị trong Hình-1.14 dưới đây. Chú ý đây là lớp POJO.
•
Kích chuột phải vào nút dự án HibernateHelloWorld và chọn New->Java Class.
•
•
•
•
Cửa sổ New Java Class xuất hiện.
Trong mục Class Name, gõ Person.
Bỏ trống mục Package. Nếu bạn muốn dùng package mặc định thì bỏ trống trường này. (Đối với
bài thí nghiệm đơn giản này chúng ta tạm sử dụng package mặc định.)
Kích Finish để hoàn tất. (Hình-1.14)
Hình-1.14: Cửa sổ đặt Name and Location
•
Sửa đổi đoạn mã nguồn Person.java như hình Code-1.15 dưới đây.
import java.io.Serializable;
public class Person implements Serializable {
private int id;
private String name;
protected Person() {
}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Code-1.15: Person.java
(1.2) Tạo file ánh xạ Hibernate cho các lớp POJO.
Trong ứng dụng này do chỉ có 1 lớp Person, nên chúng ta chỉ phải viết một file ánh xạ. (Thực tế, một file ánh xạ
cũng có thể chứa các thông tin ánh xạ tới nhiều lớp trong ứng dụng nhưng để tránh nhầm lẫn ta nên viết từng file
ánh xạ cho mỗi lớp trong ứng dụng.)
1. Tạo file Person.hbm.xml.
Trong file ánh xạ này, bạn phải xác định lớp Person sẽ được ánh xạ tới bảng person. Trường id của lớp Person sẽ
được sử dụng như là khóa chính trong bảng CSDL person. Trường name sẽ tương ứng với cột cname.
•
Kích chuột phải vào nút dự án HibernateHelloWorld và chọn New->Other. (Hình-1.21)
Hình-1.21: Tạo file XML
•
•
•
Xuất hiện cửa sổ Choose File Type.
Chọn XML dưới phần Categories bên trái và XML Document dưới File Types bên phải. (Hình1.22)
Kích Next.
Hình-1.22: Tạo tài liệu XML
•
•
•
Cửa sổ Name and Location xuất hiện.
Trong mục File Name, gõ Person.hbm. (Hình-1.23)
Kích Browse để chọn Folder.
Hình-1.23: Xác định thư mục tạo file.
•
•
•
Xuất hiện cửa sổ lựa chọn thư mục.
Chọn src.
Kích Select Folder. (Hình-1.24)
Hình-1.24: Chọn src
•
Kích Next. (Hình-1.25)
Hình-1.25: Kích Next.
•
•
Xuất hiện cửa sổ Select Document Type.
Kích Finish để hoàn tất. (Hình-1.26)
Hình-1.26: Kết thúc quá trình tạo tài liệu XML
•
•
•
Cửa sổ IDE sẽ hiển thị file XML để có thể thay đổi.
Thay bằng đoạn mẫu XML như trong nội dung Code-1.27 ở dưới.
Chú ý đoạn code in đậm.
<?xml version='1.0' encoding='utf-8'?>
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
" /><hibernate-mapping>
<class name="Person" table="person">
<id name="id" type="int">
<generator class="increment"/>
</id>
</class>
</hibernate-mapping>
Code-1.27: Person.hbm.xml
(1.3) Tạo file cấu hình Hibernate
File cấu hình dành riêng cho từng ứng dụng. Trong file này người lập trình phải xác định thông tin kết nối CSDL với
tên và file ánh xạ. Ngoại trừ tên của file ánh xạ, hầu hết các ứng dụng Hibernate có cùng tên với file cấu hình
Hibernate.
1. Tạo file hibernate.cfg.xml.
•
•
•
•
Kích chuột phải vào nút dự án HibernateHelloWorld và chọn New->XML Document.
Cửa sổ Name and Location xuất hiện.
Trong trường File Name, gõ hibernate.cfg.
Kích Browse chọn thư mục.
•
•
•
Xuất hiện cửa sổ lựa chọn thư mục.
Chọn nút src.
Kích vào Select Folder.
•
Kích Next (trong cửa sổ Name and Location).
•
•
Xuất hiện cửa sổ Select Document Type
Kích Finish để hoàn tất.
•
•
Lúc này IDE sẽ hiển thị cửa sổ file XML để có thể thay đổi.
Thay thế bằng đoạn file mẫu XML với nội dung như trong Code-1.31.
<?xml version='1.0' encoding='utf-8'?>
"-//Hibernate/Hibernate Configuration DTD//EN"
" /><hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<!-- JDBC connection pool (use the built-in) -->
<!-- SQL dialect -->
<!-- Echo all executed SQL to stdout -->
<!-- Mapping files -->
<mapping resource="Person.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Code-1.31: hibernate.cfg.xml
(1.4) Tạo file Main.java và HibernateUtil.java
1. Thay đổi nội dung của file Main.java trong IDE như đoạn mã nguồn trong Code-1.21. Chú ý ý nghĩa đoạn mã in
đậm.
Nếu không thêm các file thư viện Hibernate vào đường dẫn (classpath), IDE sẽ phát hiện ra một loạt các lỗi khi biên
dich
(hộp
màu
đỏ).
Phần
sau
sẽ
hướng
dẫn
để
thêm
các
thư
viện
này.
Trong phương thức main() của lớp Main, đối tượng lớp được khởi tạo và tiếp tục tồn tại thông qua đối tượng
Session của Hibernate.
import org.hibernate.*;
import org.hibernate.cfg.Configuration;
public class Main {
public static void main(String[] args) {
// Set up database tables
HibernateUtil.droptable("drop table person");
HibernateUtil.setup("create table person ( id int, cname VARCHAR(20))");
// Create SessionFactory and Session object
SessionFactory sessions = new Configuration().configure().buildSessionFactory();
Session session = sessions.openSession();
// Perform life-cycle operations under a transaction
Transaction tx = null;
try {
tx = session.beginTransaction();
// Create a Person object and save it
Person p1 = new Person();
p1.setName("Sang Shin");
session.save(p1);
// Create another Person object and save it.
Person p2 = new Person();
p2.setName("Young Shin");
session.save(p2);
// Retrieve the person objects
Person person = (Person)session. get(Person.class, p1.getId());
System.out.println("First person retrieved = " + person.getName());
person = (Person)session.get(Person.class, p2.getId());
System.out.println("Second person retrieved = " + person.getName());
tx.commit();
tx = null;
} catch ( HibernateException e ) {
if ( tx != null ) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
// Display tables
HibernateUtil.checkData("select * from person");
}
}
Code-1.41: Person.hbm.xml
2. Viết file HibernateUtil.java như trong Code-1.42.
Đây là lớp tiện ích giúp người lập trình có thể kiểm thử và gỡ rối chương trình mình viết. Trong bài thí nghiệm này,
sinh viên sẽ được hướng dẫn sử dụng lớp tiện ích này để tạo và hiển thị bảng trong CSDL. Có thể sử dụng một cách
thuật tiện lớp tiện ích này cho các dự án Hibernate khác mà không cần quan tâm hiểu rõ đoạn mã của nó.
•
•
•
•
Kích chuột phải nút dự án HibernateHelloWorld và chọn New->Java Class.
Xuất hiện cửa sổ nhỏ Name and Location.
Trong mục Class Name, gõ HibernateUtil. (Hình-1.42)
Kích Finish để hoàn tất.
Hình-1.42: Tạo file HibernateUtil.java
•
Thay thế đoạn mã file HibernateUtil.java bằng đoạn mã trong Code-1.43.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
// Database configuration
public static String url = "jdbc:derby://localhost:1527/mydatabase";
public static String dbdriver = "org.apache.derby.jdbc.ClientDriver";
public static String username = "app";
public static String password = "app";
public static final SessionFactory sessionFactory;
static {
try {
// Create the SessionFactory from hibernate.cfg.xml
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static final ThreadLocal session = new ThreadLocal();
public static Session currentSession() throws HibernateException {
Session s = (Session) session.get();
// Open a new Session, if this thread has none yet
if (s == null) {
s = sessionFactory.openSession();
// Store it in the ThreadLocal variable
session.set(s);
}
return s;
}
public static void closeSession() throws HibernateException {
Session s = (Session) session.get();
if (s != null)
s.close();
session.set(null);
}
static Connection conn;
static Statement st;
public static void setup(String sql) {
try {
createStatement();
st.executeUpdate(sql);
} catch (Exception e) {
System.err.println("Got an exception! ");
e.printStackTrace();
System.exit(0);
}
}
public static void createStatement() {
try {
Class.forName(dbdriver);
conn = DriverManager.getConnection(url, username, password);
st = conn.createStatement();
} catch (Exception e) {
System.err.println("Got an exception! ");
e.printStackTrace();
System.exit(0);
}
}
// Drop table if exists
public static void droptable(String sql) {
try {
createStatement();
st.executeUpdate(sql);
} catch (Exception e) {
}
}
public static void checkData(String sql) {
String[] starray = sql.split(" ");
System.out.println("\n******** Table: " + starray[starray.length-1] + " *******");
try {
createStatement();
ResultSet r = st.executeQuery(sql);
HibernateUtil.outputResultSet(r);
//
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void outputResultSet(ResultSet rs) throws Exception{
ResultSetMetaData metadata = rs.getMetaData();
int numcols = metadata.getColumnCount();
String[] labels = new String[numcols];
int[] colwidths = new int[numcols];
int[] colpos = new int[numcols];
int linewidth;
linewidth = 1;
for (int i = 0; i < numcols; i++) {
colpos[i] = linewidth;
labels[i] = metadata.getColumnLabel(i + 1); // get its label
int size = metadata.getColumnDisplaySize(i + 1);
if (size > 30 || size == -1)
size = 30;
int labelsize = labels[i].length();
if (labelsize > size)
size = labelsize;
colwidths[i] = size + 1; // save the column the size
linewidth += colwidths[i] + 2; // increment total size
}
StringBuffer divider = new StringBuffer(linewidth);
StringBuffer blankline = new StringBuffer(linewidth);
for (int i = 0; i < linewidth; i++) {
divider.insert(i, '-');
blankline.insert(i, " ");
}
// Put special marks in the divider line at the column positions
for (int i = 0; i < numcols; i++)
divider.setCharAt(colpos[i] - 1, '+');
divider.setCharAt(linewidth - 1, '+');
// Begin the table output with a divider line
System.out.println(divider);
// The next line of the table contains the column labels.
// Begin with a blank line, and put the column names and column
// divider characters "|" into it. overwrite() is defined below.
StringBuffer line = new StringBuffer(blankline.toString());
line.setCharAt(0, '|');
for (int i = 0; i < numcols; i++) {
int pos = colpos[i] + 1 + (colwidths[i] - labels[i].length()) / 2;
overwrite(line, pos, labels[i]);
overwrite(line, colpos[i] + colwidths[i], " |");
}
System.out.println(line);
System.out.println(divider);
while (rs.next()) {
line = new StringBuffer(blankline.toString());
line.setCharAt(0, '|');
for (int i = 0; i < numcols; i++) {
Object value = rs.getObject(i + 1);
if (value != null){
overwrite(line, colpos[i] + 1, value.toString().trim());
overwrite(line, colpos[i] + colwidths[i], " |");
}
}
