phân tích thiết kế và công nghệ nền tảng

XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
MỞ ĐẦU
Trong thời đại công nghệ phát triển như ngày nay, nhu cầu tìm việc trực tuyến là một
yêu cầu thiết yếu trong cuộc sống. Yêu cầu công việc và nguồn nhân lực là rất lớn. Do đó
xây một hệ thống xử lý trực tuyến nhanh, ổn định và dễ dàng cho người dùng là một yêu
cầu gây khó khăn trong kỹ thuật phân tích và xử lý của website. Qua cách nhìn nhận đó,
nhóm đã tìm hiểu, phân tích và quyết định xây dựng một trang web (nền tảng phát triển
cổng thông tin điện tử) dựa trên kỹ thuật mới để vừa đáp ứng được nhu cầu việc làm lại vừa
đáp ứng được xu hướng thời đại công nghệ.
Khóa luận này được chia làm 4 phần:
- Phần 1: Khảo sát thực tế, tìm hiểu nhu cầu người dùng về việc tìm việc hiện nay.
- Phần 2: Phương pháp phân tích thiết kế và công nghệ nền tảng.
- Phần 3: Phân tích thiết kế hệ thống và hiện thực hệ thống.
- Phần 4: Hướng phát triển và kết luận
1
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
LỜI CẢM ƠN
Trước tiên chúng em xin gửi lời cảm ơn chân thành tới TS.Nguyễn Đình Thuân
đã dành thời gian để hướng dẫn chúng em hoàn thành khóa luận tốt nghiệp này. Ngoài ra
chúng em cũng gửi lời cảm ơn tới các thầy cô khoa hệ thống thông tin thuộc trường đại học
công nghệ thông tin - đại học quốc gia TP.Hồ Chí Minh đã rất tận tâm hướng dẫn việc học
tập của chúng em và các bạn sinh viên khác trong suốt những năm tháng học tập tại trường.
Đồng thời lời cảm ơn này cũng xin dành cho anh Nguyễn Quan Thái đã góp ý và nhiệt tình
cung cấp dữ liệu cho nhóm chúng em. Cuối cùng chúng em xin cảm ơn cha mẹ là những
người sinh ra và dưỡng dục chúng em tới ngày hôm nay. Chúng em xin dành thành quả của
khóa luận này để tặng những người mà chúng em tri ân.
Do kiến thức và thời gian có hạn nên khóa luận này chắc chắn không tránh khỏi
thiếu sót, mong các thầy cô chân thành góp ý.
Sinh viên
Nguyễn Hữu Hữu
Nguyễn Tiến Long

2
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
NHẬN XÉT
(Của giảng viên hướng dẫn)
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................

.........................................................................................................................................
NHẬN XÉT
3
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
(Của giảng viên phản biện)
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................
.........................................................................................................................................

.........................................................................................................................................
.........................................................................................................................................
MỤC LỤC
4
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
5
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
DANH MỤC SƠ ĐỒ, HÌNH
6
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
7
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
CHƯƠNG 1 : GIỚI THIỆU KHÓA LUẬN
1.1. TỔNG QUAN VỀ KHÓA LUẬN
Hệ thống hiện thực trong khóa luận được phát triển theo qui trình ICONIX cùng với
sự phân tích tổng thể nhu cầu về tìm kiếm việc làm hiện nay.
Hệ thống phục vụ cho đối tượng chính yếu là sinh viên và các doanh nghiệp, là cầu
nối giữa sinh viên và các doanh nghiệp.
Ngoài ra hệ thống còn cho phép các trung tâm đào tạo đăng các tin tức đào tạo, các
khóa huấn luyện, qua đó người tìm việc có thể tìm được các khóa đào tạo để rèn luyện và
nâng cao các kỹ năng mà từ đó có thể tìm được công việc phù hợp hơn với nhu cầu thực tế.
1.2. Ý NGHĨA KHÓA LUẬN
Trước thực tế nhu cầu tìm kiếm việc làm cùng với sự phát triển của công nghệ thông
tin mạnh mẽ của Việt Nam, việc xây dựng một hệ thống tìm việc trực tuyến hiệu quả là một
công cụ hết sức cần thiết. Mặc dù có rất nhiều trang web đăng tuyển dụng và tìm việc nhanh
nhưng vẫn còn nhiều vấn đề về việc người tìm việc tạo hồ sơ như:
- Những nội dung nhập liệu quá nhiều.
- Nội dung nhập liệu quá rời rạc chưa hướng tới người dùng như là người dùng
đang ở tình trạng nào? Yêu cầu công việc gì? Và cần thiết nhập nội dung gì cho
hồ sơ của họ?

Vì vậy, việc phân tích nội dung tạo hồ sơ cho người tìm việc là hết sức quan trọng.
Cùng với vấn đề đó, việc phân tích trạng thái người dùng, các dạng hồ sơ, nhóm thông tin
cần điền vừa hướng đến tiêu chí người tìm việc dễ dàng trong việc tạo hồ sơ, cũng như các
nhà tuyển dụng vừa ý khi nhận những hồ sơ theo các chuẩn mà họ yêu cầu trực tuyến qua
chức năng do hệ thống hỗ trợ.
Cùng với sự tích hợp công nghệ mới, nhóm tìm hiểu và phân tích nhu cầu người
dùng dựa trên tiêu chí tốc độ xử lý nhanh, thao tác đơn giản giúp người dùng dễ dàng trong
việc tìm công việc phù hợp tạo và gửi hồ sơ ứng tuyển vừa ý nhà tuyển dụng.
Khóa luận hướng tới việc phân tích nhu cầu của người dùng, xây dựng cổng thông
tin điện tử để cung cấp cho người tìm việc nói chung và các bạn sinh viên nói riêng công cụ
để tạo hồ sơ trực tuyến, là nơi các ứng viên tìm kiếm việc làm phù hợp với khả năng. Bên
8
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
cạnh đó nhà tuyển dụng và trung tâm đào tạo cũng có thể dễ dàng đăng tin tuyển dụng hoặc
tin đào tạo lên website để tìm kiếm nhân viên cho công ty mình.
Trong quá trình thực hiện khóa luận này nhóm đã áp dụng được những điều được
học trong nhà trường vào thực tế và cũng đã biết được thêm các công nghệ mã nguồn mở
trên nền ngôn ngữ JAVA như Java Server Faces framework, Spring framework, Hibernate
framework. Ngoài ra, nhóm còn tìm hiểu qui trình phát triển phần mềm ICONIX áp dụng
vào việc hiện thực khóa luận.
1.3. KHẢO SÁT THỰC TẾ
Hiện nay, nhu cầu tìm kiếm việc làm theo khả năng và nhu cầu tìm kiếm nguồn nhân
lực gặp nhiều khó khăn khiến các nhà tuyển dụng khó tìm được nhân viên phù hợp cũng
như nhân viên không tìm được vị trí công việc phù hợp.
Thực tế hiện nay có rất nhiều website tìm việc và tuyển dụng rất hiệu quả như là
VietNamWork.com, Timviecnhanh.com, … giúp người tìm việc tìm thấy những công việc
rất dễ dàng nhưng ở khâu tạo hồ sơ vẫn chưa thỏa mãn được nhu cầu của người dùng như là
ở bước nhập liệu bị ràng buộc quá nhiều thông tin, nội dung thông tin chưa được gom thành
các nhóm thông tin có liên quan với nhau …
Hệ thống hiện thực trong khóa luận này nhằm đáp ứng nhu cầu trên như:

- Giúp người tìm việc tạo hồ sơ dễ dàng và thuận lợi trong việc gửi hồ sơ đến các
nhà tuyển dụng. Bên cạnh đó còn giúp họ tìm được những thông tin đào tạo mới
của các trung tâm đào tạo.
- Giúp nhà tuyển dụng đăng tuyển dễ dàng và theo những nhóm thông tin mà nhà
tuyển dụng mong muốn.
- Giúp trung tâm đào tạo đăng khóa học, quản lý các khóa học đã đăng, gửi thông
tin khóa học đến các thành viên đã đăng kí nhận tin khi có khóa học mới.
1.4. GIỚI HẠN KHÓA LUẬN
Khóa luận có hướng tìm hiểu sâu về framework vào việc xây dựng hệ thống. Song
song với nội dung đó, nhóm cũng đã phân tích về các đặc điểm về nhu cầu việc làm hiện
nay để xây dựng chức năng chính cho hệ thống.
9
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
Nội dung Trong khóa luận này tập trung vào hiện thực các chức năng của hệ thống
như sau:
- Đối với người tìm việc:
o Tìm việc dễ dàng.
o Giúp người tìm việc tạo được hồ sơ đầy đủ nhất.
o Nội dung trong hồ sơ được gom nhóm một cách súc tích.
- Đối với nhà tuyển dụng:
o Dễ dàng đăng tin tuyển dụng tìm nhân viên cho công ty.
o Vừa ý trong việc nhận hồ sơ trực tuyến.
- Đối với trung tâm đào tạo
o Đăng tin đào tạo chiêu gọi học viên.
o Quản lý danh sách ứng viên trực tuyến.
10
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
CHƯƠNG 2: PHƯƠNG PHÁP PHÂN TÍCH THIẾT KẾ VÀ CÔNG NGHỆ
NỀN TẢNG
2.1. PHƯƠNG PHÁP PHÂN TÍCH THIẾT KẾ

2.1.1. Giới thiệu qui trình phát triển phần mềm ICONIX:
Theo lý thuyết, việc tuân thủ từng khía cạnh của phương pháp UML (phương pháp
mô hình hóa hướng đối tượng) rất có ích cho các giai đoạn trong qui trình phát triển phần
mềm. Nhưng trong thực tế, để hoàn thiện đầy đủ các mô hình theo phương pháp UML đưa
ra mất rất nhiều thời gian cho việc modeling (mô hình hóa), analysis (phân tích ), và thiết
kế. Trong các dự án thực tế luôn có áp lực làm sao để nhanh chóng bước vào giai đoạn
coding (giai đoạn hiện thực chương trình) một cách nhanh nhất và tiến độ các dự án phần
mềm có xu hướng được đánh giá bằng số lượng mã nguồn chương trình. Qui trình ICONIX
là một cách tiếp cận hợp lý tập trung vào giữa giai đoạn đặc tả các usecase (trường hợp sử
dụng) và giai đoạn coding (hiện thực chương trình), nó nhấn mạnh những việc cần và nên
làm vào trong thời điểm bắt đẩu của một khâu trong qui trình phát triển phần mềm.
2.1.2. Qui trình ICONIX
Mô hình qui trình (Hình 2.1.) với các bước qui trình ICONIX được thực hiện như
sau:
- Phân tích yêu cầu:
o Yêu cầu chức năng: Định nghĩa ra các chức năng hệ thống sẽ làm.
o Domain modeling (mô hình hóa phạm vi): Hiểu được không gian vấn đề
và các thuật ngữ nhập nhằng trong khâu phân tích giữa khách hàng và
người phân tích yêu cầu, xác định các đối tượng sẽ tham gia vào hệ thống
ở mức quan niệm.
11
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
Hình 2.1. Mô hình qui trình ICONIX
o Xác định hành vi của yêu cầu: Định ra hệ thống và người dùng sẽ tương
tác thế nào dựa vào các bản GUI prototype (phác thảo giao diện) và xác
định tất cả các trường hợp sẽ hiện thực. Ở bước này, không yêu cầu phải
xác định đầy đủ hết tất cả các usecase (trường hợp sử dụng). Trong các
bước sau sẽ giúp xác định thêm các trường hợp sử dụng mà chưa xác định
được ở bước này.
o Milestone 1 (cột mốc thứ nhất): Xem xét lại các usecase (trường hợp sử

dụng) và domain model (mô hình lĩnh vực) có nhất quán với nhau so với
các yêu cầu chức năng của khách hàng hay chưa.
- Phân tích và thiết kế sơ bộ:
o Viết đặc tả usecase bao gồm: luồng đi cơ bản mô tả bối cảnh chính và các
luồng đi khác thể hiện các tình huống ít khi xảy ra (các tình huống xảy ra
lỗi, các trường hợp ngoại lệ … ).
o Robustness analysis (phân tích sự bền vững và hiệu năng của hệ thống ):
Vẽ ra các lược đồ robustness (lược đồ thể hiện sự bền vững và hiệu năng
12
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
của hệ thống - bức tranh về các đối tượng trong usecase), vẽ lại luồng đi
như trong đặc tả usecase.
o Cập nhật domain model (mô hình phạm vi hay mô hình miền): bước này
tìm các lớp còn thiếu , loại bỏ sự nhập nhằng trong việc đặt tên lớp, thêm
thuộc tính và các phương thức cho cho các lớp.
o Đặt tên tất cả chức năng logic phần mềm cần thiết để usecase hoạt động.
o Viết lại bản nháp đặc tả usecase trước đó.
- Milestone 2 (cột mốc 2): Đánh giá lại khâu phân tích và thiết kế sơ bộ.
- Thiết kế chi tiết:
o Mô hình sequence (tuần tự): Dựa trên bản nháp đặc tả usecase đầu tiên vẽ
ra các sơ đồ trình tự. Mục tiêu của bước này là xác định ra các hành vi của
các lớp, các thông tin trao đổi giữa các đối tượng với nhau.
o Cập nhật lại các mô hình domain (mô hình miền) trong khi đang vẽ sơ đồ
trình tự. Ở bước này mô hình domain gần như tiến sát đến class diagram
(mô hình lớp) vì chúng ta xác định được thêm các thuộc tính và các
phương thức ở bước này.
o Tinh chỉnh lại các static model (mô hình tĩnh), các mô hình này thể hiện
kiến trúc của hệ thống ví dụ như mô hình miền, mô hình lớp.
- Milestone 3 (cột mốc 3): đánh giá lại khâu phân tích một cách kỹ lưỡng và chi tiết
trước khi đi vào hiện thực chương trình.

- Hiện thực chương trình:
o Lập trình và kiểm thử từng đơn vị nhỏ: Dựa vào các bản thiết kế ở các
bước trên, tiến hành việc lập trình và kiểm thử từng đơn vị nhỏ (các hàm
trong các class).
o Tích hợp các chức năng lại với nhau và kiểm thử theo kịch bản và tình
huống như đặc tả usecase.
o Xem lại sự tương đương giữa các đoạn mã và cập nhật lại các mô hình để
chuẩn bị cho khâu tiếp theo của việc phát triển hệ thống.
13
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
2.1.3. Điểm khác biệt giữa qui trình ICONIX và các qui trình khác:
Qui trình ICONIX đưa ra cách để làm sao từ bước đặc tả usecase đến bước hiện thực
chương trình một cách nhanh và hiệu quả nhất, giảm tải một số khâu chiếm quá nhiều thời
gian trong các qui trình lớn khác, ví dụ như qui trình RUP thường xảy ra tình trạng analysis
paralysis (tình trạng quá tải trong việc phân tích hay suy nghĩ khiến cho tiến trình phát
triển phần mềm bị ngưng trệ dẫn đến không đưa ra được một quyết định hay bất kì hành
động nào) .
Việc đưa thêm lược đồ robustness (robustness diagram) giúp cho việc vẽ các
sequence diagram (lược đồ tuần tự) và các class diagram dễ dàng hơn. Lược đồ robustness
là cầu nối giữa các bản đặc tả usecase và việc vẽ các lược đồ tuần tự, giúp cho người thiết
kế tách bạch rõ ràng các hành vi của hệ thống, hạn chế sự nhập nhằng và thiếu sót khi vẽ
lược đồ tuần tự, bởi vì khi vẽ các robustness diagram chúng ta sẽ khám phá ra các chức
năng, hành vi ẩn không nhìn thấy được lúc viết đặc tả usecase. Nhờ đó mà lược đồ tuần tự
khi vẽ sẽ sát với yêu cầu thực tế của khách hàng hơn.
Đưa ra domain modeling: đây là mô hình tiền thân của class diagram. Mô hình này
được đưa ra trước tiên nhằm đưa ra một từ điển thuật ngữ sử dụng trong dự án. Mục đích là
làm cho mọi người hiểu rõ hơn về không gian của dự án bằng các thuật ngữ rõ ràng. Mô
hình này giúp xác định phạm vi và các hình thức – nền tảng của việc xây dựng các trường
hợp sử dụng. Mô hình này cũng giúp cho việc trao đổi giữa các thành viên trong dự án được
thuận tiện và dễ hiểu hơn dựa vào bảng các thuật ngữ được đưa ra.

Bản đặc tả usecase được cập nhật dần theo từng cột mốc của qui trình phát triển, các
qui trình khác (như RUP) thường yêu cầu bản đặc tả usecase chi tiết và bao quát được hết
các luồng đi khác của usecase tại một khâu trong qui trình.
2.1.4. Giải thích lý do chọn qui trình ICONIX
Việc chọn qui trình ICONIX có các lý do sau:
- Chỉ cần sử dụng một tập con các lược đồ lõi của UML: dùng 4 trong 14 lược đồ
của UML.
- Qui trình này dễ dàng được theo dõi ngay từ bước đầu tiên của việc phát triển dự
án.
14
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
- Các đặc tả uscase bao quát được hết toàn bộ các bối cảnh của usecase, và được
cập nhật lại sau bước vẽ robustness diagram và sequence diagram.
- Hướng đến việc thiết kế dự án theo hướng đối tượng từ các usecase.
- Là qui trình thực tế đã được kiểm chứng qua nhiều dự án lớn.
2.1.5. Áp dụng qui trình ICONIX vào khóa luận:
Qui trình ICONIX là một qui trình rất hay trong việc phát triển phần mềm, để áp
dụng được qui trình ICONIX một cách hiệu quả đòi hỏi nhiều kinh nghiệm làm việc thực tế.
Trong quá trình làm khóa luận này nhóm đã tìm hiểu và vận dụng được những kiến
thức sau:
- Khâu phân tích yêu cầu.
- Khâu phân tích thiết kế sơ bộ.
- Thiết kế chi tiết.
2.2. CÔNG NGHỆ NỀN TẢNG:
Trong mục này sẽ giới thiệu về 3 công nghệ được áp dụng vào khóa luận đó là:
Spring, JSF, Hibernate.
2.2.1. Spring framework:
Spring framework là một bộ khung hỗ trợ lập trình ứng dụng bằng ngôn ngữ JAVA.
Spring được phát triển bởi Rod Johnson và được giới thiệu lần đầu tiên trong cuốn Expert
One-on-One J2EE Design and Development năm 2002.

2.2.1.1. Các thành phần chính của Spring:
Spring Framework bao gồm nhiều chức năng được tổ chức thành các module nhỏ.
Những module này lại được gom thành các nhóm sau: Spring Core Container, Spring
Context/Application Context, Spring AOP, Spring DAO, Spring ORM, Spring Web, Spring
MVC Framework. Các nhóm đó được tổ chức và sắp xếp như Hình 2.2. dưới đây.
15
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
Hình 2.2. Các thành phần của Spring
Spring Core Container: Core container là chức năng cơ bản của Spring. Thành
phần chính của nó là Bean Factory, một cài đặt của Factory pattern (Factory pattern là mẫu
thiết kế dùng một lớp trung gian được để tạo ra các đối tượng khi có yêu cầu từ một lớp,
thay vì lớp cần đối tượng phải tự tạo mới đối tượng bằng toán tử new). Nhiệm vụ của
BeanFactory là tạo và phân phát các đối tượng, BeanFactory biết về nhiều đối tượng trong
ứng dụng, nó có thể tạo ra mối kết hợp giữa các đối tượng khi chúng được khởi tạo.
BeanFactory áp dụng IoC pattern để tách bạch và giảm sự phụ thuộc giữa các thành phần
của ứng dụng.
Spring Context/Application Context: Spring context là một tập tin cấu hình để
cung cấp thông tin ngữ cảnh của Spring. Spring context cung cấp các dịch vụ cấp cao như
truy cập JNDI, tích hợp EJB, e-mail, internalization, validation, và scheduling functionality.
Spring AOP (Aspect-Oriented):
 Lập trình hướng khía cạnh (aspect oriented programing) là một sự bổ sung thêm
cho lập trình hướng đối tượng, giúp cho các lập trình viên tập trung vào phần xử
lý nghiệp vụ hơn thay vì phải lặp đi lặp lại các đoạn mã cùng thực hiện một chức
năng nào đó nhiều lần, ví dụ như: ghi nhật ký (logging), thực thi các giao tác
(transaction).
16
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
 Spring AOP module tích hợp chức năng lập trình hướng khía cạnh vào Spring
framework thông qua cấu hình của nó. Spring AOP module cung cấp các dịch vụ
quản lý giao tác cho các đối tượng trong bất kỳ ứng dụng nào sử dụng Spring.

 Với Spring AOP chúng ta có thể tích hợp declarative transaction management
vào trong ứng dụng mà không cần dựa vào EJB component. Spring AOP module
cũng đưa lập trình metadata vào trong Spring. Sử dụng cái này, chúng ta có thể
thêm ký pháp (annotation) vào mã trình (source code) để hướng dẫn Spring, nơi
và làm thế nào để liên hệ với các khía cạnh (aspects).
Spring DAO: Tầng JDBC và DAO đưa ra một cây phân cấp các ngoại lệ (exception)
để quản lý kết nối đến cơ sở dữ liệu, kiểm soát ngoại lệ và thông báo lỗi được ném ra bởi
các nhà cung cấp cơ sở dữ liệu. Tầng ngoại lệ (exception) đơn giản là kiểm soát lỗi và giảm
khối lượng mã nguồn mà chúng ta cần viết như mở và đóng kết nối. Module này cũng cung
cấp các dịch vụ quản lý giao dịch cho các đối tượng trong ứng dụng Spring.
Spring ORM: Spring có thể tích hợp với một vài ORM framework để cung cấp các
công cụ ánh xạ mối quan hệ giữa các bảng trong cơ sở dữ liệu thành các đối tượng có quan
hệ với nhau bao gồm: JDO, Hibernate, OJB và iBatis SQL Maps.
Spring Web module: Nằm trên application context module, cung cấp các ngữ cảnh
cho các ứng dụng web, hỗ trợ tích hợp với các bộ khung làm việc nổi tiếng khác như Struts,
JSF và Webwork… Web module cũng làm giảm bớt các công việc điều khiển nhiều request
và gắn các tham số của request vào các đối tượng domain.
Spring MVC Framework: MVC Framework được cài đặt đầy đủ đặc tính của
MVC pattern để xây dựng các ứng dụng Web. MVC framework được cấu hình thông qua
giao diện và chứa được một số kỹ thuật view bao gồm: JSP, Velocity, Tiles và generation of
PDF và Excel file.
17
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
2.2.1.2. Cơ chế đảo ngược kiểm soát và thêm sự phụ thuộc.
(Inversion of Control and Dependence Injection)
Cơ chế Inversion of Control (Hình 2.4.) dịch ra là cơ chế đảo ngược sự kiểm soát,
nhằm giảm tải mức độ phụ thuộc giữa các đối tượng. Với sự hỗ trợ của cơ chế đảo ngược sự
kiểm soát này các lập trình viên không cần phải tạo đối tượng ngay trong mã nguồn mà mô
tả chúng sẽ được tạo ra thế nào, hơn thế nữa, không cần phải kết nối các thành phần
(components) và các dịch vụ (services) một cách trực tiếp mà chỉ cần mô tả thành phần nào

cần dịch vụ nào trong một tập tin cấu hình. Dưới đây là hình mô tả về cơ chế IOC.
Hình 2.4. Spring IOC
Ví dụ dưới đây trình bày rõ hơn vấn đề được nêu ra ở trên.
 Ví dụ này là một lớp là Speaker. Lớp này có một phương thức là sayHello() được
trình bày theo Hình 2.5..
18
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
import java.io.FileInputStream;
import java.io.InputStream;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
public class Speaker{
public void sayHello(){
System.out.println("Hello Spring");
}
}
Hình 2.5. Lớp speaker
 Cài đặt một hàm main ngay trong lớp để gọi lớp speaker (Hình 2.6.).
public static void main( String args[]) throws Exception{
InputStream is = new FileInputStream("beans.xml");
BeanFactory factory = new XmlBeanFactory(is);
Speaker speaker = (Speaker)factory.getBean("Speaker");
speaker.sayHello();
}
Hình 2.6. Hàm main
Trong hàm main bên trên truy cập đến một tập tin tên là beans.xml. Tập tin này rất
quan trọng đối với các ứng dụng chạy trên Spring. Nó chứa các thông tin cấu hình của các
bean được dùng trong ứng dụng. Với ví dụ này thì ta có nội dung tập tin beans.xml (Hình
2.7.).
Bây giờ chạy hàm main bên trên thì dòng chữ Hello Spring sẽ được in ra.

Ví dụ đơn giản trên trình bày cách đơn giản để sử dụng spring. Như đã thấy trong
hàm main, việc khởi tạo đối tượng Speaker từ lớp Speaker không làm theo cách truyền
thống nghĩa là: Speaker speaker = new Speaker() . Nhưng thay vào đó, speaker được tạo
thành với đoạn mã: Speaker speaker = (Speaker)factory.getBean(“Speaker”);
19
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "<a
href="
target="_blank"> /><beans>
<bean name="Speaker" class="Speaker" singleton="true">
</bean>
</beans>
Hình 2.7. Tập tin beans.xml
Trong đó, factory là một đối tượng của lớp BeanFactory (Spring có hơn một ngàn
class và interface như vậy) có tác dụng như một nhà máy tạo ra các đối tượng khi người
dùng đưa các yêu cầu vào. Ở trường hợp này, người dùng đã yêu cầu factory tạo ra 1 đối
tượng từ mẫu có tên là Speaker.
Ví dụ trên chỉ ra rằng thay vì phải tạo đối tượng trong hàm main thì lại tạo bằng cách
của Spring, tuy nhiên vẫn chưa thấy rõ lắm sự khác biệt. Để hiểu rõ hơn xét ví dụ mở
rộng thêm như sau:
Bây giờ, giả sử các cái loa trước khi sayHello thì cần phải đi qua một bộ phiên dịch
Translator. Ta sẽ viết lớp Translator có một phương thức traslate in ra dòng chữ Hello. Để
lớp này có thể in ra được nhiều thứ tiếng ta sẽ viết dưới dạng 1 interface với đoạn mã như
sau: public interface Translator { public void translate(); }
Sau đó viết lớp EnglishTranslator để hiện thực interface này (Hình 2.8.).
Kế tiếp thêm vào lớp Speaker thêm một thuộc tính gọi là translator (Hình 2.9.).
Tiếp đến viết hàm main để chạy thử. Trong hàm main này không dùng Spring để tạo
đối tượng nữa mà dùng theo cách truyền thống (Hình 2.10.) để so sánh sự khác biệt.
Chạy thử sẽ in ra câu chào bằng tiếng Anh. Nếu không thích tiếng Anh có thể in ra

câu chào bằng tiếng Việt bằng cách viết tiếp một class VietnameseTranslator (Hình 2.11.).
20
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
public class EnglishTranslator implements Translator{
public void translate(){
System.out.println("Hello Spring");
}
}
Hình 2.8. Hàm English Translator
import java.io.FileInputStream;
import java.io.InputStream;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
public class Speaker{
private Translator translator;
public Speaker(Translator translator) {
this.translator = translator;
}
public void sayHello(){
translator.translate();
}
Hình 2.9. Lớp speaker
public static void main( String args[]) throws Exception{
Translator translator = new EnglishTranslator();
Speaker speaker = new Speaker (translator);
speaker.sayHello();
}
Hình 2.10. Hàm main
public class VietnameseTranslator implements Translator{
public void translate(){

System.out.println("Xin chao Spring"); } }
21
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
Hình 2.11. Class VietnameseTranslator
22
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
Để in ra đuợc tiếng Việt ta phải chỉnh lại hàm main một chút. Thay vì viết:
Translator translator = new VietnameseTranslator();
Viết lại như sau:
Translator translator = new EnglishTranslator();
Như vậy rõ ràng sự bất tiện xuất hiện mỗi khi thay đổi qua lại giữa tiếng Anh và
tiếng Việt. Sự phụ thuộc giữa đối tượng thuộc lớp Speaker và Translator được giải quyết
trong chương trình nghĩa là khi nào muốn tiếng Việt thì chỉnh lại đoạn code một ít. Sự điều
khiển (control) và phụ thuộc (dependency) giữa các đối tượng do chương trình đảm trách.
Nó là cách thông thường ta vẫn làm gọi là sự điều khiển bình thường.
Bây giờ hàm main được sửa lại như Hình 2.12. để sử dụng Spring
public static void main( String args[]) throws Exception{
InputStream is = new FileInputStream("beans.xml");
BeanFactory factory = new XmlBeanFactory(is);
Speaker speaker = (Speaker)factory.getBean("Speaker");
speaker.sayHello(); }
Hình 2.12. Hàm main
Theo hình Hình 2.12. hàm main bây giờ không dính dáng gì đến Vietnamese và
English nữa. Tiếp theo Sửa lại tập tin beans.xml (Hình 2.13.).
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "<a
href="
target="_blank"> /><beans> <bean name = "Translator" class = "EnglishTranslator" singleton = "true"></bean>
<bean name = "Speaker" class = "Speaker" singleton = "true">
<constructor-arg><ref bean = "Translator"></constructor-arg>

</bean></beans>
Hình 2.13. Beans.xml
23
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM
Tập tin beans.xml bây giờ đảm nhận việc lắp ráp EnglishTranslator hoặc là
VietnameseTranslator. Sự điều khiển (control) đã được đảo ngược (inversion) sang cho
BeanFactory đảm trách. Hay nói cách khác Spring đã tiêm đối tượng EnglishTranslator
(hoặc là VietnameseTransslator) vào trong đối tượng Speaker (Injection Dependency). Đó là
nguyên lý chính yếu nhất, nổi tiếng nhất của Spring.
2.2.2. JSF
2.2.2.1. Tổng quan về JSF
Khi phát triển ứng dụng web trên nền tảng công nghệ J2EE, việc lặp đi lặp lại các
đoạn mã trình giống nhau cùng thực hiện một chức năng hay chỉ để hiển thị một thành phần
nào đó của giao diện là công việc tốn nhiều thời gian và dễ gây nhàm chán. JSF cung cấp
một bộ khung làm việc trực quan giúp cho việc phát triển các ứng dụng web một cách dễ
dàng và tránh lặp đi lặp lại các thao tác giống nhau.
JSF được phát triển dựa trên mẫu thiết kế (design pattern) MVC (một trong những
mẫu thiết kế nổi tiếng thường dùng cho các hệ thống lớn). JSF là bộ khung làm việc hướng
đến việc xử lý tương tác giữa các thành phần giao diện và các sự kiện phát ra từ các thành
phần giao diện đó. JSF bao gồm các thành phần giao diện phía server và các API. Các thành
phần này dùng để trình bày các gói giao diện người dùng, quản lý trạng thái của các gói đó,
xử lý các sự kiện phát ra từ các gói giao diện khi người dùng thao tác lên các gói giao diện
đó, xác thực dữ liệu, chuyển đổi dữ liệu, phân luồng điều hướng giữa các trang, hỗ trợ đa
ngôn ngữ và cung cấp các mở rộng cho các gói giao diện người dùng này.
JSF tách bạch rõ ràng giữa phần giao diện người dùng và các hành vi tương ứng của
các thành phần. Lấy một ví dụ đơn giản: khi người dùng nhấp chuột vào một nút trên giao
diện trang web (UI component) thì sẽ phát ra một sự kiện để gửi đến backing bean (sẽ được
trình bày phần sau) đang chờ lắng nghe và xử lý sự kiện được phát ra từ nút đó.
24
XÂY DỰNG WEBSITE HỖ TRỢ TÌM KIẾM VIỆC LÀM

2.2.2.2. Các thành phần quan trọng của JSF:
UI Component (còn gọi là một control hay đơn giản là component): một đối tượng
phía server, cung cấp các chức năng cụ thể để tương tác với một người dùng cuối. UI
component là những JavaBean với các thuộc tính, phương thức, sự kiện. Chúng được tổ
chức thành một cây bao gồm các component và thường hiển thị như một trang.
Renderer: Hiển thị một UI component và trao đổi một dữ liệu nhập của người dùng
vào giá trị của component. Renderer có thể được thiết kế để làm việc với một hoặc nhiều
UI component, và một UI component có thể tập hợp với nhiều renderer khác nhau.
Validator: Trả lời cho việc chắc chắn rằng giá trị nhập vào bởi người dùng được
chấp nhận. Một hoặc nhiều validator có thể được tập hợp với một UI component
Backing beans: Các Java Bean xác định tập hợp các giá trị từ các UI component và
bổ sung các phương thức event listener (bộ lắng nghe sự kiện). Chúng cũng có thể nắm giữ
các tham chiếu đến các UI component.
Converter: chuyển đổi một giá trị của component thành một chuỗi để hiển thị. Một
UI component có thể được tập hợp với một converter duy nhất.
Event/listener: JSF sử dụng mô hình event/listener JavaBeans (cũng được sử dụng
cho Swing). UI component (và những đối tượng khác) tạo ra các event, và các listener có
thể đăng ký để xử lý các sự kiện. Các backing bean sẽ hiện thực các phương án để xử lý
các sự kiện phát ra từ các UI component.
Messages: Hiển thị thông tin cho người dùng. Chỉ bất kỳ thành phần ứng dụng
trong (backing beans, validators, converter …) mới có thể tạo ra thông tin hoặc thông điệp
lỗi nhằm hiển thị cho người dùng.
Navigation: Định vị và điều phối từ trang này đến trang khác. JSF có một hệ thống
định vị mạnh mẽ tích hợp với những event listeners.
2.2.2.3. Vòng đời của việc xử lý request:
Vòng đời của 1 request (Hình 2.14.) chia làm 6 bước được mô tả như sau:
 Restore View: hiển thị thay thế tất cả các component tạo nên một trang
giao diện cụ thể.
25