Tiểu luận tổng quan về Mối quan hệ giữa chu kỳ kinh tế và đầu tư trong nền ki...
BÀI THÍ NGHIỆM SỐ XÂY DỰNG HIBERNATE CHO ỨNG DỤNG JAVA_10441312092019
1. 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
2. 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. Chạy máy chủ CSDL Java DB (trong tài liệu có tên là Derby)
2. Tạo CSDL lấy tên là “mydatabase”
3. 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)
4. 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
5. 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
6. 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"
7. 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. Tạo lớp POJO, Person.java
2. Tạo file ánh xạ (mapping) cho lớp POJO, Write Hibernate mapping files for the POJO
classes, Person.hbm.xml in this example
3. Tạo file cấu hình cho Hibernate, hibernate.cfg.xml
4. Tạo file Main.java và HibernateUtil.java
5. Thêm thư viện Hibernate và Java DB
6. Thêm log4j.properties vào đường dẫn lớp
7. Dịch và chạy ứng dụng
8. 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
8. • 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 Choose Project,
chọn Java dưới Categories và Java Application dưới Projects. (Hình-1.12)
• Sau đó kích chọn Next.
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.
9. 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.
10. • 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)
11. 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;
}
}
12. 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)
13. 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ình-
1.22)
• Kích Next.
14. 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)
15. 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)
16. 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'?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="Person" table="person">
<id name="id" type="int">
<generator class="increment"/>
</id>
<property name="name" column="cname" type="string"/>
</class>
</hibernate-mapping>
Code-1.27: Person.hbm.xml
17. (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.
18. • 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).
19. • 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.
21. (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");
}
}
22. 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.
23. 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) {
24. 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();
}
}
25. 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], " |");
}
}
26. System.out.println(line);
}
System.out.println(divider);
}
static void overwrite(StringBuffer b, int pos, String s) {
int len = s.length();
for (int i = 0; i < len; i++)
b.setCharAt(pos + i, s.charAt(i));
}
}
Code-1.43: HibernateUtil.java
(1.5) Thêm thư viện Hibernate và driver Java DB
1. Kích chuột phải vào dự án HibernateHelloWorld và chọn Properties. (Hình-1.61)
Hình-1.61: Chọn Properties của dự án
2. Thêm thư viện Hibernate
• Chọn Libraries dưới phần Categories phía bên trái và chọn nút Add Library phía bên phải.
(Hình-1.62)
27. Hình-1.62: Chọn Add Library
• Chọn thư viện Hibernate.
• Kích nút Add Library. (Hình-1.63)
Hình-1.63: Thêm thư viện HibernateCore
3. Thêm driver Java DB. (Nếu dùng phiên bản NetBeans 6.7.1 – sẽ có lỗi vì driver này sẽ không xuất hiện trong
danh sách, người dùng phải tự thêm vào).
28.
29. (1.6) Thêm file log4j.properties
Đây là phần không bắt buộc. Nếu chưa có file log4j.properties trong đường dẫn của dự án, bạn sẽ nhận được một
thông báo cảnh báo, tạm thời lúc này ta không cần để ý đến chúng.
1. Thêm file log4j.properties.
• Kích chuột phải vào nút dự án HibernateHelloWorld và chọn New->Other.
• Chọn Other dưới phần Categories phía bên trái và Empty File dưới File Types phía bên phải.
• Kích Next.
30. • Xuất hiện cửa sổ Name and Location.
• Trong trường File Name, gõ log4j.properties.
• Kích Browse lựa chọn thư mục.
• Xuất hiện cửa sổ lựa chọn thư mục.
• Chọn src.
• Kích Select Folder.
• Kích Finish để hoàn tất.
• Một file chưa có nội dung sẽ xuất hiện trong cửa sổ IDE.
• Gõ nội dung như trong Code-1.71 vào file đó.
31. #
# Log4J Settings for log4j 1.2.x (via jakarta-commons-logging)
#
# The five logging levels used by Log are (in order):
#
# 1. DEBUG (the least serious)
# 2. INFO
# 3. WARN
# 4. ERROR
# 5. FATAL (the most serious)
# Set root logger level to WARN and append to stdout
log4j.rootLogger=WARN, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%c:%L) - %m%n
# Print only messages of level ERROR or above in the package noModule.
log4j.logger.noModule=FATAL
# OpenSymphony Stuff
log4j.logger.com.opensymphony=INFO
log4j.logger.com.opensymphony.webwork=DEBUG
# Spring Stuff
log4j.logger.org.springframework=INFO
32. Code-1.71: File log4j.properties
(1.7) Dịch và chạy ứng dụng
Lúc này ta đã sẵn sang để dịch và chạy ứng dụng.
1. Kích chuột phải vào dự án HibernateHelloWorld và chọn Run. (Hình-1.81)
33. Hình-1.81: Chạy dự án
2. Cửa sổ Output của IDE sẽ có dạng như Hình-1.82. Phần đầu là kết quả thông qua Hinernate và
phần thứ hai hiển thị các dòng trong bảng person.
34. 3.
Hình-1.82: Kết quả thực hiện các thao tác CSDL thông qua Hibernate
Sự cố: Nếu sinh viên nhận được cửa sổ lỗi như dưới đây thì chủ yếu là do máy chủ CSDL chưa chạy.
15 [main] WARN org.hibernate.cfg.SettingsFactory - Could not obtain connection metadata
org.apache.derby.client.am.DisconnectException: java.security.PrivilegedActionException : Error opening socket to
server localhost on port 1527 with message : null
at org.apache.derby.client.net.NetAgent.<init>(Unknown Source)
at org.apache.derby.client.net.NetConnection.newAgent_(Unknown Source)
at org.apache.derby.client.am.Connection.<init>(Unknown Source)
at org.apache.derby.client.net.NetConnection.<init>(Unknown Source)
at org.apache.derby.jdbc.ClientDriver.connect(Unknown Source)
at java.sql.DriverManager.getConnection(DriverManager.java:582)
at java.sql.DriverManager.getConnection(DriverManager.java:154)
at
org.hibernate.connection.DriverManagerConnectionProvider.getConnection(DriverManagerConnectionProvider.java:110)
at org.hibernate.cfg.SettingsFactory.buildSettings(SettingsFactory.java:76)
at org.hibernate.cfg.Configuration.buildSettings(Configuration.java:1933)
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1216)
at HibernateUtil.<clinit>(HibernateUtil.java:26)
at Main.main(Main.java:9)
Got an exception!
Xử lý: Khởi động máy chủ CSDL như hướng dẫn ở Phần 1.
Sự cố: Nếu thấy đoạn lỗi sau trong cửa sổ Output, chủ yếu do driver của máy khách (client), derbyclient.jar cho
CSDL Derby, chứ không phải vấn đề đường dẫn (classpath).
Initial SessionFactory creation failed.org.hibernate.HibernateException: JDBC Driver class not found:
35. org.apache.derby.jdbc.ClientDriver
Exception in thread "main" java.lang.ExceptionInInitializerError
at HibernateUtil.<clinit>(HibernateUtil.java:30)
at Main.main(Main.java:9)
Caused by: org.hibernate.HibernateException: JDBC Driver class not found: org.apache.derby.jdbc.ClientDriver
at
org.hibernate.connection.DriverManagerConnectionProvider.configure(DriverManagerConnectionProvider.java:66)
at
org.hibernate.connection.ConnectionProviderFactory.newConnectionProvider(ConnectionProviderFactory.java:124)
at
org.hibernate.connection.ConnectionProviderFactory.newConnectionProvider(ConnectionProviderFactory.java:56)
at org.hibernate.cfg.SettingsFactory.createConnectionProvider(SettingsFactory.java:397)
at org.hibernate.cfg.SettingsFactory.buildSettings(SettingsFactory.java:62)
at org.hibernate.cfg.Configuration.buildSettings(Configuration.java:1933)
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1216)
at HibernateUtil.<clinit>(HibernateUtil.java:26)
... 1 more
Xử lý: Thêm driver derbyclient.jar, vào đường dẫn như mô tả trong Bước 1.5.
(1.8) Kiểm thử lại CSDL
Trong bước này ta sẽ kiểm tra lại xem bảng person thực tế có cư ngụ trong lớp Main.
1. Chọn thẻ cửa sổ Services.
2. Mở rộng mục Databases.
3. Kích chuột phải vào jdbc:derby://localhost:1527/mydatabase [app on APP] và chọn Connect (nếu chưa ở
trạng thái đã được kết nối). (Hình-1.91)
Hình-1.91: Kết nối với CSDL
4. Mở rộng APP->Tables.
5. Kích chuột phải vào bảng PERSON và chọn View Data. (Hình-1.92)
36. Hình-1.92: Xem dữ liệu trong bảng PERSON
6. Ta sẽ nhận thấy có 2 dòng trong bảng PERSON. (Hình-1.93)
37. Hình-1.93: Kiểm tra lại nội dung của bảng trong CSDL.
Tổng kết
Trong phần này, sinh viên được học cách để xây dựng ứng dụng Hibernate HelloWorld đơn giản từ các lớp của ứng
dụng, các file ánh xạ tương ứng và file cấu hình Hibernate.
Phần 3: Xây dựng ứng dụng "HibernateHelloWorld2"
Trong phần này, sinh viên sẽ được hướng dẫn tạo dự án mới HibernateHelloWorld2 thông qua việc sao
chép lại dự án đã thực hiện trong Phần 1 HibernateHelloWorld. Nếu sao chép một dự án, toàn bộ file thư
viện Hibernate sẽ tự động được sao chép vào dự án mới. Sinh viên cũng có thể thêm lớp POJO khác và file
ánh xạ của nó vào dự án mới.
1. Tạo dự án "HibernateHelloWorld2" thông qua việc sao chép dự án "HibernateHelloWorld" project
2. Thêm lớp POJO mới, Student.java
3. Viết file ánh xạ, Student.hbm.xml
4. Thay đổi hibernate.cfg.xml
5. Thay đổi Main.java
6. Dịch và chạy dự án
7. Nhận lệnh SQL do Hibernate gửi
(2.1) Tạo dự án "HibernateHelloWorld2" sao chép từ dự án "HibernateHelloWorld"
1. Kích chuột phải vào nút dự án HibernateHelloWorld chọn Copy. (Hình-2.10)
38. Hình-2.10: Sao chép dự án Project
2. Đặt tên cho dự án mới.
• Hộp thoại Copy Project xuất hiện.
• Trong trường Project Name gõ tên HibernateHelloWorld2.
• Kích chuột vào Copy. (Hinh-2.11)
Hình-2.11: Sao chép dự án
• Xuất hiện nút dự án HibernateHelloWorld2.
39. (2.2) Thêm lớp POJO mới
Trong bước này ta thêm lớp POJO mới đặt tên là Student.
1. Viết Student.java.
import java.io.Serializable;
public class Student implements Serializable {
private int id;
private String school;
private String grade;
protected Student() {
}
public Student(int id, String school) {
this.id = id;
this.school = school;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getSchool() {
return school;
}
public void setSchool(String name) {
this.school = name;
}
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
}
Code-2.21: Student.java
