Khóa luận Xây dựng ứng dụng quản lý chất lượng dịch vụ Home Phone sử dụng Struts 2 và Hibernate

ĐẠI HỌC QUỐC GIA HÀ NỘI

TRƯỜNG ĐẠI HỌC CÔNG NGHỆ

Nguyễn Thái Sơn

STRUTS 2 VÀ ỨNG DỤNG QUẢN LÝ CHẤT

LƯỢNG DỊCH VỤ HOME PHONE

KHOÁ LUẬN TỐT NGHIỆP ĐẠI HỌC HỆ CHÍNH QUY

Ngành: Công nghệ thông tin

HÀ NỘI - 2010

ĐẠI HỌC QUỐC GIA HÀ NỘI

TRƯỜNG ĐẠI HỌC CÔNG NGHỆ

Nguyễn Thái Sơn

STRUTS 2 VÀ ỨNG DỤNG QUẢN LÝ CHẤT

LƯỢNG DỊCH VỤ HOME PHONE

KHOÁ LUẬN TỐT NGHIỆP ĐẠI HỌC HỆ CHÍNH QUY

Ngành: Công nghệ thông tin

Cán bộ hướng dẫn: ThS. Lê Hồng Hải

HÀ NỘI - 2010

LỜI CẢM ƠN

Trước tiên, tôi xin gửi lời cảm ơn và lòng biết ơn sâu sắc đến Ths. Lê Hồng

Hải, người đã tận tình chỉ bảo hướng dẫn tôi trong suốt quá trình thực hiện khoá luận

tốt nghiệp.

Tôi xin gửi lời cảm ơn anh Vũ Hoàng Chiến – người hướng dẫn và chỉ bảo tôi

trong suốt thời gian thực hiện dự án.

Tôi xin gửi lời cảm đến các thầy cô giáo đã giảng dạy tôi trong suốt bốn năm

học qua, đã cho tôi nhiều kiến thức quý báu để tôi vững bước trên con đường học tập

của mình.

Tôi xin gửi lời cảm ơn tới các bạn trong lớp K51CC, và K51CHTTT đã ủng hộ

khuyến khích tôi trong suốt quá trình học tập tại trường.

Và cuối cùng, tôi xin bày tỏ niềm biết ơn vô hạn tới bố mẹ, chị tôi, và những

người bạn thân luôn bên cạnh, động viên tôi trong suốt quá trình thực hiện khoá luận

tốt nghiệp.

Hà Nội, ngày 18 tháng 5 năm 2010

Sinh viên

Nguyễn Thái Sơn

TÓM TẮT NỘI DUNG

Khóa luận với đề tài "Xây dựng ứng dụng quản lý chất lượng dịch vụ Home

Phone sử dụng Struts 2 và Hibernate" sẽ đưa ra những cái nhìn tổng quát về công

nghệ JSP/ Servlet chạy trên máy chủ ứng dụng J2EE, những ưu nhược điểm của công

nghệ này và cách khắc phục với điểm mạnh của framework Struts 2. Ngoài ra, sự kết

hợp giữa Struts 2 với Hibernate - một framework hỗ trợ ánh xạ từ cở sở dữ liệu thành

các đối tượng phục vụ tốt nhất cho việc phát triển ứng dụng. Cuối cùng, khóa luận nêu

những vận dụng của công nghệ trong việc xây dựng ứng dụng quản lý chất lượng dịch

vụ Home Phone với các module và chức năng cụ thể sử dụng dữ liệu của ứng dụng

được lấy từ trực tiếp từ cơ sở dữ liệu của Viettel Technologies.

MỤC LỤC

Chương 1: MÔ TẢ HỆ THỐNG.........................................................................................................7

Module Agent:...................................................................................................................................8

Module Core: phần nhân của hệ thống, xử lý các yêu cầu nhận được từ agent............................8

Module Web: (nhiệm vụ chính của khóa luận thực hiện) ..............................................................8

Chương 2: CÔNG NGHỆ STRUTS 2 VÀ HIBERNATE ...............................................................11

2.1. Giới thiệu.................................................................................................................................11

2.2. Servlet/JSP:.............................................................................................................................11

2.3. Struts........................................................................................................................................12

2.4. Struts 2.....................................................................................................................................16

2.4.1. Vòng đời của các yêu cầu trong Struts 2 .....................................................................16

2.4.2. Kiến trúc Struts 2............................................................................................................17

2.4.3. Ứng dụng đơn giản với Struts 2:...................................................................................18

2.5. Truy cập, sử dụng dữ liệu trong database. ............................................................................23

2.6. Hibernate và những ưu việt....................................................................................................23

2.6.1. Hibernate framework ......................................................................................................23

2.6.2 Một ví dụ về kết hợp giữa Struts 2 và Hibernate: ..........................................................27

Chương 3: GIẢI QUYẾT BÀI TOÁN ..............................................................................................35

3.1. Yêu cầu luồng công việc........................................................................................................35

Quản lý người dùng...................................................................................................................35

Thông tin thuê bao.....................................................................................................................35

Các cảnh báo ..............................................................................................................................36

Cấu hình tham số .......................................................................................................................36

Quản lý Agent:...........................................................................................................................36

3.1 Sơ lược về cơ sở dữ liệu của hệ thống...................................................................................37

3.3 Quá trình thực hiện dự án.......................................................................................................40

3.3.1 Module đăng nhập,quản lý người dùng và phân quyền.................................................41

3.3.2 Module thông tin thuê bao:..............................................................................................44

3.3.3 Module: Các cảnh báo......................................................................................................47

3.3.4 Module: Cấu hình tham số...............................................................................................48

3.3.5 Module: Quản lý Agent....................................................................................................49

Chương 4: Kết luận.............................................................................................................................53

Tài liệu tham khảo...............................................................................................................................54

MỞ ĐẦU

Hiện nay, ở Việt Nam, các dịch vụ viễn thông đang trong giai đoạn phát triển

nhanh và mạnh. Điều này làm tăng tính cạnh tranh của mạng viễn thông trong nước.

Điển hình như về mạng di động có VinaPhone, MobiFone, Viettel, HaNoi Telecome,

Beeline… Mạng cố định có VNPT, HomePhone, EVNTelecome, .. Các mạng cố định

hiện nay đã dần chuyển từ hệ thống có dây sang hệ thống không dây. Điển hình là dịch

vụ điện thoại không dây Home Phone của Viettel Telecom.

Để có thể phát triển và cạnh tranh, các mạng viễn thông phải không ngừng nâng

cấp dịch vụ, giảm giá cước và chăm sóc khách hàng. Để làm được điều này, Viettel đã

xây dựng một hệ thống có tên là “Hệ thống quản lý chất lượng dịch vụ Home Phone”

(Home Phone service quality management system) để có thể tìm ra những nguyên

nhân, khuyết điểm, trục trặc kỹ thuật trong quá trình triến khai hệ thống, xem xét khách

hàng tin dùng để có những sửa chữa nâng cấp kịp thời cho hệ thống và có những biện

pháp chăm sóc khách hàng hợp lý.

Trong quá trình phát triển hệ thống, rất may mắn cho tôi là được tham gia xây

dựng một bộ phận của hệ thống. Trong khóa luận của tôi, tôi sẽ trình bày kỹ hơn về các

vấn đề này.

Chương 1: MÔ TẢ HỆ THỐNG

Dịch vụ Home Phone (dịch vụ điện thoại cố định không dây) là một dịch vụ tiềm

năng và quan trọng trong sự phát triển viễn thông của tập toàn Viettel. Để phát triển tốt

dịch vụ, cần có một hệ thống đánh giá chất lượng dịch vụ cập nhật thường xuyên các

thông số để có những đánh giá chủ quan về cơ cấu hệ thống (chất lượng cuộc gọi, tiềm

năng phát triển thuê bao và chất lượng sóng…)

Hệ thống quản lý chất lượng dịch vụ Home Phone (Home Phone service quality

management system) đã giải quyết vấn đề này. Mô hình dưới đây mô tả quá trình hoạt

động của hệ thống.

Hình 1.1: Mô hình hệ thống Home Phone.

Trên mỗi máy điện thoại cố định không dây Home Phone đều được gắn thêm một

con chip để tương tác với các tín hiệu nhận được từ hệ thống. Agent được định nghĩa

như là phần nhân trong mỗi máy điện thoại cố định, đặc trưng riêng cho mỗi máy.

Các trạm BTS trải rộng từ các vùng, đến các tỉnh thành phố. Ở phía đầu cuối, các

máy điện thoại (agent) được thiết lập cấu hình trong từng cell của trạm. Khi hệ thống tác

động yêu cầu về các máy Home Phone, yêu cầu sẽ thông qua các cell để tương tác.

Yêu cầu xây dựng ứng dụng web với các module sau:

Module Agent:

Chức năng hệ thống tương tác với agent:

Thu thập thông tin về các cuộc gọi đi(do người thực hiện thực hiện cuộc gọi

cuối cùng), định dạng các trường thông tin theo chuẩn GSM.

Thu thập thông tin về chất lượng mạng.

Cấu hình agent từ xa qua SMS-Class 2

Quản lý và giám sát

Module Core: phần nhân của hệ thống, xử lý các yêu cầu nhận được từ agent.

Giao tiếp với SMSC/SMS Gateway để gửi/nhận tin nhắn.

Giải mã thông tin về các cuộc gọi đi.

Giải mã thông tin về chất lượng mạng.

Giao tiếp với database để lưu trữ thông tin về các cuộc gọi và chất lượng

mạng.

Tương tác với agent qua SMS-Class 2.

Module Web: (nhiệm vụ chính của khóa luận thực hiện)

Quản trị người dùng, nhóm người dùng.

Đăng nhập, đăng xuất.

Hỗ trợ nhóm người dùng(mỗi người dùng phải thuộc một nhóm nào đó)

Phân quyền phạm vi(quản lý Agent) theo nhóm người dùng.

Thêm/xóa người dùng, nhóm người dùng.

Hiển thị/chỉnh sửa danh sách người dùng, nhóm .

Báo cáo đồ thị:

Cường độ sóng (max,min, trung bình của ngày) theo thời gian (của 1 agent),

chọn khoảng thời gian.

Chất lượng sóng (max, min, trung bình của ngày) theo thời gian( của 1

agent), chọn khoảng thời gian.

Đồ thị phân bố số mẫu theo giá trị của cường độ sóng (áp dụng cho 1 agent,

1 cell, 1 tỉnh,/thành, 1 khu vực hoặc toàn mạng) chọn 1 hoặc nhiều khoảng

thời gian.

Đồ thị phân bố số mẫu theo giá trị của chất lượng sóng (áp dụng cho 1

agent, 1 cell, 1 tỉnh/thành, 1 khu vực hoặc toàn mạng) chọn 1 hoặc nhiều

khoảng thời gian.

Đồ thị phân bố % số mẫu cường độ sóng tốt/ tổng số mẫu trong ngày (áp

dụng cho 1 agent, 1 cell, 1 tỉnh/ thành, 1 khu vực hoặc toàn mạng) theo thời

gian, chọn khoảng thời gian( config: ngưỡng tốt)

Đồ thị phân bố % số mẫu chất lượng sóng tốt/ tổng số mẫu trong ngày (áp

dụng cho 1 agent, 1 cell, 1 tỉnh/thành, 1 khu vực, hoặc toàn mạng) theo thời

gian, chọn khoảng thời gian (config: ngưỡng tốt)

Đồ thị giá trị CSR (tỷ lệ cuộc gọi thành công/ tổng số cuộc gọi) trong ngày

(áp dụng cho 1 agent, 1 cell, 1 tỉnh/thành, 1 khu vực hoặc toàn mạng) theo

thời gian, chọn khoảng thời gian.

Đồ thị phân bố % agent đang hoạt động, agent phát sinh nhiều cuộc gọi

(config: số cuộc gọi), % agent thay đổi serving cell, % agent activated mới,

% agent activated mới phát sinh cuộc gọi trong ngày theo thời gian (1

tỉnh/thành, 1 khu vực hoặc toàn mạng); chọn khoảng thời gian.

Báo cáo thống kê: (các báo cáo hàng ngày) dạng bảng (gửi qua email hàng ngày, thống

kê cho ngày hôm qua, cho phép list agent-> xem chi tiết agent)

% agent đang hoạt động

% agent phát sinh cuộc gọi.

% agent phát sinh nhiều cuộc gọi.

% agent thay đổi serving cell.

% agent activated mới

% agent mới activated phát sinh cuộc gọi.

% số mẫu có cường độ sóng tốt.

% số mẫu có chất lượng sóng tốt.

% CSR.

Cảnh báo: (là các dạng báo cáo hàng ngày, gửi qua mail hàng ngày) (nếu có dữ liệu)

(config: max, sort: giảm dần)

Danh sách các agent không hoạt động (config: số ngày liên tục không có

thông tin thu thập về hoặc không có mẫu tin nào.)

Danh sách các agent đang hoạt động nhưng không phát sinh cuộc gọi

(config: số ngày liên tục không phát sinh cuộc gọi)

Danh sách các agent thay đổi serving cell.

Danh sách các agent sử dụng sóng yếu (config: số mẫu sóng dưới ngưỡng

trong một số ngày liên tục, config: ngưỡng tốt, config: số ngày.)

Danh sách các agent sử dụng sóng có chất lượng tồi.

Danh sách các agent có tỉ lệ CSR thấp (cf:ngưỡng thấp.)

Quản lý Agent:

Configure & activate/ deactivate (cấu hình, kích hoạt/ tắt) một agent.

Reset (thiết lập lại) agent.

Query agent status (Truy vấn trạng thái agent).

Query agent current configuration information (Truy vấn thông tin cấu hình

hiện tại của agent)

Manual measure activation (Kích hoạt độ đo)

Add/ delete (Thêm/Xóa)

Search/View/Modify agent information (Tìm kiếm/Hiển thị/Tùy chỉnh

thông tin Agent )

Tìm kiếm và xem thông tin chi tiết các mẫu đo thuộc về agent (theo thời

gian)

Danh sách các agent không hoạt động( config: số ngày liên tục )

Hệ thống quản lý chất lượng dịch vụ Home Phone với cơ sở dữ liệu đồ sộ, yêu

cầu thực hiện thành phần web phải được xây dựng bằng một công nghệ mới, có độ an

toàn và bảo mật cao, đồng thời phải dễ dàng tương tác với các thành phần khác của hệ

thống.

Theo những yêu cầu trên, tôi và nhóm thiết kế đã lựa chọn công nghệ Struts 2 –

một framework trên nền Java, sử dụng Hibernate để làm việc với cơ sở dữ liệu. Với

những đặc tính ưu việt của Struts 2 sẽ được trình bày ở chương 2, tôi tin mọi người sẽ

nắm được những tính ưu việt của công nghệ này.

Chương 2: CÔNG NGHỆ STRUTS 2 VÀ HIBERNATE

2.1. Giới thiệu

Java là một nền tảng phát triển các ứng dụng phần mềm có vị trí rất lớn trong

những năm cuối thế kỉ 20, đầu thế kỉ 21. Đánh dấu sự trưởng thành của mô hình lập

trình hướng đối tượng, nó được coi là một nền tảng mang tính cách mạng trong nghành

phần mềm. Mô hình máy ảo Virtual Machine đã cho phép các ứng dụng viết bằng Java

có thể chạy trên nhiều hệ điều hành khác nhau. Vì thế Java là ngôn ngữ vẫn được rất

nhiều các nhà thiết kế lựa chọn làm ngôn ngữ phát triển chính cho hệ thống của mình.

2.2. Servlet/JSP:

Servlet/JSP là một bộ phận của công nghệ J2EE (Java 2 Platform, Enterprise

Edition) phiên bản của Java chạy trên các máy chủ ứng dụng.

Servlet:

Servlet API được phát triển dựa trên những điểm mạnh của Java platform nhằm

giải quyết vấn đề của CGI và trình chủ server API. Nó là một API đơn giản hỗ trợ tất cả

các Web server và thậm chí các ứng dụng máy chủ dùng để kiểm tra và quản lý các

công việc trên server (load –balancing). Nó giải quyết vấn đề thực thi bằng việc thực

hiện tất cả các yêu cầu như những dòng trong một xử lý, hoặc trên một hệ thống load-

balancing sẽ là mỗi xử lý trên một server trong kết chùm cluster. Các servlet dễ dàng

chia sẽ tài nguyên. Bạn có thể sử dụng JavaMail để đọc và gửi mail, Java DataBase

Connect (JDBC) để truy cập các database, lớp File và những lớp quan hệ để truy cập hệ

thống file, RMI, CORBA, Enterprise Java Beans (EJB) để truy cập các hệ thống kế

thừa…

JSP:

(viết tắt của tiếng Anh JavaServer Pages) còn được biết đến với một cái tên khác

là Java Scripting Preprocessor – tạm dịch là “Bộ tiền xử lý văn lệnh Java” – là một

công nghệ Java cho phép các nhà phát triển tạo nội dung HTML, XML hay một số định

dạng khác của trang web một cách năng động, trong khi hồi âm yêu cầu của trình khách.

Công nghệ này cho phép người ta nhúng mã Java và một số hành động xử lý đã được

định trước (pre-defined actions) vào trong nội dung tĩnh của trang.

Trước khi hiển thị ra trình duyệt, tập tin JSP phải được biên dịch thành Servlet,

dùng bộ biên dịch JSP (JSP compiler). Bộ biên dịch JSP có thể tạo servlet thành mã

nguồn Java trước, rồi biên dịch mã nguồn ra tập tin .class dùng bộ biên dịch Java, hoặc

có thể trực tiếp tạo mã byte code cho servlet từ trang JSP.

Hệ thống quản lý chất lượng dịch vụ Home Phone phát triển dựa trên công nghệ

Servlet/JSP, sử dụng framework: Struts 2, cơ sở dữ liệu Oracle.

Câu hỏi đặt ra là: Mô hình JSP/Servlet có đủ khả đáp ứng được yêu cầu của hệ thống

hay không? Tôi đã tìm hiểu và đưa ra một số những nhược điểm của nó khiến nó không

được ứng dụng trong việc xây dựng các hệ thống lớn:

- Kiến trúc của JSP/servlet khá đơn giản, việc gộp các action (các hàm xử lý thông

tin) là điều rất không nên. Bởi khi thiết kế hệ thống, các module của chương trình cần

phải được sắp xếp hợp lý, các action được chỉnh sửa mà không ảnh hưởng tới giao diện

hiển thị.

- Ngoài ra, việc phân chia các thành phần hợp lý dựa theo mẫu thiết kế chuẩn của

một hệ thống được người dùng đánh giá rất cao. Sau khi hoàn thiện, nếu bản thân người

dùng muốn phát triển tiếp ứng dụng của mình, họ cần có một hướng dẫn chi tiết cách

sửa các thành phần trong các gói (package). Trong quá trình thiết kế một hệ thống lớn,

yêu cầu phải đòi hỏi làm việc theo nhóm, để quá trình phân công công việc hợp lý, việc

phân tách các thành phần của hệ thống là cần thiết. Nếu không, quá trình làm việc sẽ

thường xuyên bị gián đoạn.

Công nghệ Struts đã thành công trong việc tối ưu các khuyết điểm vốn có của

JSP/Servlet. Tính năng của nó sẽ được đề cập nhiều hơn qua nội dung sẽ trình bày sắp

tới.

2.3. Struts

Struts là một framework phục vụ việc phát triển các ứng dụng Web trên Java. Sử

dụng mẫu thiết kế Model-View-Controller (MVC), Struts giải quyết rất nhiều các vấn

đề liên quan đến các ứng dụng Web hướng business đòi hỏi hiệu năng cao sử dụng Java

servlet và JSP. Ứng dụng chạy trực tiếp trên JSP/Servlet chưa đáp ứng hết được yêu cầu

bảo mật và chuyên nghiệp cho một hệ thống lớn. Struts cơ bản định hình lại cách các

Web programmer nghĩ về và cấu trúc một ứng dụng Web.

2.3.1. Kiến trúc 3 tầng MVC

Hình 2.1: Kiến trúc 3 tầng MVC

Kiến trúc MVC là việc chia tất cả mục của một ứng dụng ra làm ba thành phần

(component) khác nhau Model (Mô hình), View (Giao diện) và Controller (Bộ điều

khiển). Các thành phần của kiến trúc MVC có một trách nhiệm duy nhất và không phụ

thuộc vào các thành phần khác.

- Model (Mô hình): Model được giao nhiệm vụ cung cấp dữ liệu cho cơ sở dữ liệu và

lưu dữ liệu vào các kho chứa dữ liệu.

Tất cả các nghiệp vụ logic được thực thi ở Model.

Dữ liệu vào từ người dùng sẽ thông qua View được kiểm tra ở Model trước khi lưu vào

cơ sở dữ liệu. Việc truy xuất, xác nhận, và lưu dữ liệu là một phần của Model .

- View (Giao diện): View hiển thị các thông tin cho người dùng của ứng dụng và được

giao nhiệm vụ cho việc nhận các dữ liệu vào từ người dùng, gửi đi các yêu cầu đến bộ

điều khiển, sau đó là nhận lại các phản hồi từ bộ điều khiển và hiển kết quả cho người

dùng.

Các trang HTML, JSP, các thư viện thẻ và các file nguồn là một phần của thành phần

View

- Controller (bộ điều khiển): Controller là tầng trung gian giữa Model và View.

Controller được giao nhiệm vụ nhận các yêu cầu từ phía máy khách. Một yêu cầu

được nhận từ máy khách được thực hiện bởi một chức năng logic thích hợp từ thành

phần Model và sau đó sinh ra các kết quả cho người dùng và được thành phần View

hiển thị.

ActionServlet, Action, ActionForm và struts-config.xml là các phần của

Controller.

2.3.2. Các thành phần cơ bản của Struts

Struts là tập hợp các thư viện Java có thể phân thành 4 nhóm :

+Framework cơ sở

+Thư viện thẻ JSP

+Tiles Plugin

+Validator plugin

Framework cơ sở:

Framework cơ sở cung cấp các tính năng MVC cốt lõi.

Nền tảng của framework cơ sở là Controller servlet: Action servlet.

Các phần còn lại bao gồm các lớp cơ sở mà ứng dụng của bạn sẽ kế thừa và các

class tiện ích.

Nổi bật nhất trong các lớp là lớp Action và lớp ActionForm:

Lớp Action: được sử dụng bởi ActionServlet để xử lý các request xác định.

Lớp ActionForm: bắt dữ liệu từ các HTML form và được sử dụng để chuyển dữ

liệu trở lại View để sinh ra các trả lời (response).

Thư viện thẻ JSP:

Struts đưa ra các thư viện thẻ hỗ trợ việc lập trình View Logic trong JSP. Các thư

viện thẻ JSP cho phép người lập trình JSP sử dụng các thẻ giống HTML.

Tiles Plugin

Tiles là một JSP template framework giúp thuận tiện cho việc tái sử dụng

mã HTML.

Validator plugin

Validator là một framework với khả năng thực hiện xác nhận tính hợp lệ

của dữ liệu ở cả phía server và client.

2.3.3. Các phiên bản của struts.

Hiện nay struts đã phát triển 2 phiên bản là struts 1x và struts 2x. Có một số khác

biệt trong cấu trúc của 2 phiên bản. Dưới đây là một số khác biệt cơ bản:

Tính năng

Struts 1

Struts 2

- Sử dụng lớp abstract (lớp

trừu tượng), không sử

dụng interface (lớp giao

diện).

- Action có thể là bất kỳ lớp

Java nào.

Action classes

(Lớp hoạt

động)

- Cung cấp sẵn 1 interface

chung cho các action là

ActionSupport, tuy nhiên

không bắt buộc thực thi

action này

- Action yêu cầu bắt buộc

phải kế thừa từ một lớp

abstract nào đó.

Các Action là độc nhất vì

thế chúng phải được

thread-safe bởi vì chỉ có

một thể hiện của lớp để

giữ lại tất cả request đối

với Action đó.

Trong Struts 2 các đối tượng

được khởi tạo cho mỗi

request do đó không có

thread-safety.

Threading

Model

(Mô hình

luồng)

Một servlet container sinh ra

nhiều đối tượng throw-away

cho mỗi request

Actions bị phụ thuộc vào

thư viện servlet API bởi vì

HttpServletRequest và

Action chỉ là một lớp bình

thường và chúng ta không

cần truyền đối tượng

Servlet

Dependency

(Phần phụ

thuộc servlet)

HttpServletResponse được

HttpServletRequest và

truyền vào phương thức

execute khi Action được

thực thi.

HttpServletResponse cho

phương thức execute.

Struts 2 không phụ thuộc vào

API của servlet bởi chúng tạo

các POJO đơn giản.

Ứng dụng Struts1 có một

vấn đề chính trong việc

testing bởi vì phương thức

execute phụ thuộc vào

Servlet API. Struts

Các Action có thể test các

khởi tạo Action.Các Action là

một POJO đơn giản và không

phụ thuộc framework,vì thế

việc test trở lên đơn giản hơn

Testability

(Khả năng kiểm

tra)

TestCase cung cấp một tập

hợp các đối tượng Mock

cho Struts 1

Harvesting

Input

Struts1 sử dụng một đối

tượng ActionForm để giữ

các input.Giống như các

Action, tất cả các

ActionForms cần được

thừa kế lớp ActionForm cơ

bản .

Struts2 sử dụng các thuộc

tính Action để giới hạn sự

cần thiết cho các đôi tượng

input thứ 2. Từ đó giảm sự dư

thừa.

(Kết quả đầu

vào)

Struts 1 ràng buộc đối

tượng bên trong ngữ cảnh

của trang bằng cách sử

dụng cơ chế JSP chuẩn.

Struts 2 sử dụng công nghệ

ValueStack để đảm bảo việc

truy cập giá trị bằng taglib

không thông qua coupling

(kết nối) hoặc rendering (biểu

diễn).

Binding values

into views

(Ràng buộc giá

trị trong việc

hiển thị)

Trong Struts 1 các thuộc

tính của ActionForm hầu

hết định dạng là

String.Việc chuyển đổi

dựa trên từng lớp, không

được cấu hình dựa trên thể

hiện của lớp.

Struts 2 sử dụng OGNL đối

với việc chuyển kiểu dữ liệu.

Type

Conversion

(Thay đổi kiểu)

Mỗi module trong Struts 1

có sự tách rời Request

Processors (vòng

đời),trong khi tất cả các

Action trong module cần

phải chia sẻ cùng vòng

đời.

Trong Struts 2 các vòng đời

khác nhau được tạo ra dựa

trên nền tảng Action thông

qua ngăn xếp chặn

(Interceptor Stacks).Các stack

tùy biến được tạo ra và sử

dụng với Action khác nhau.

Control Of

Action

Execution

(Kiểm soát thực

thi)

Sự khác nhau như trên, với những ưu điểm của Struts 2 so với Struts 1 làm Struts

2 trở thành công cụ hữu ích cho các nhà thiết kế phần mềm Web hiện tại và tương lai.

2.4. Struts 2

2.4.1. Vòng đời của các yêu cầu trong Struts 2

Hình 2.2 : Dòng xử lý trong Struts 2

- Người sử dụng gửi yêu cầu đến server để yêu cầu một số tài nguyên của ứng

dụng

- Bộ điều khiển lọc (FilterDispatcher) xem xét yêu cầu và sau đó xác định một

Action thích hợp

- Các bộ chặn (Interceptors) được ứng dụng: các cấu hình bộ chặn áp dụng cho

các chức năng chung như: luồng công việc, thẩm định, tải file … được tự động ứng

dụng vào yêu cầu

- Thực thi Action: sau khi phương thức action được thực thi để thực hiện các

hoạt động liên quan đến cơ sở dữ liệu như sắp xếp hoặc nhận dữ liệu từ cơ sở dữ liệu

- Sinh kết quả

- Sau đó kết quả yêu cầu được trả về thông qua bộ chặn theo chiều ngược lại.

Kết quả trả về cho phép chúng ta thực hiện thu dọn hoặc thêm quá trình xử lý

- Hiển thị kết quả cho người sử dụng: việc điều khiển cuối cùng được trả về cho

trình chứa servlet, nó sẽ gửi kết quả trả về cho trình duyệt của người sử dụng.

2.4.2. Kiến trúc Struts 2

Hình 2.3: Kiến trúc của 1 ứng dụng struts 2.

- Action ContextCleanUp filter: là một tùy chọn và nó được sử dụng khi tích

hợp với các công nghệ khác như SiteMash Plugin

- FilterDispatcher: tiếp đến, FilterDispatcher (bộ điều khiển lọc) được gọi, nó

quay lại sử dụng ActionMapper để xác định Action nào được triệu gọi. Nếu action

được yêu cầu được triệu gọi thì FilterDispatcher ủy nhiệm việc điều khiển lại cho

ActionProxy.

- ActionProxy:ActionProxy nhận sự giúp đỡ từ bộ quản lý cấu hình file

(Configuration Files manager), được khởi tạo từ file struts.xml. Sau đó ActionProxy

tạo ra một ActionInvocation, thực thi (implement) từ mẫu lệnh. ActionInvocation xử

lý triệu gọi bộ chặn (Interceptors) nếu nó được cấu hình và sau đó triệu gọi Action.

ActionInvocation tìm kiếm kết quả thích hợp, sau đó kết quả được thực thi, nó triệu

gọi việc sinh ra trang các JSP hoặc các mẫu.

Sau đó, các Interceptor được thực thi một lần nữa theo thứ tự ngược lại. Việc trả

về kết quả cuối cùng thông qua các bộ lọc được cấu hình trong file web.xml. Nếu bộ

lọc ActionContextCleanUp được cấu hình, thì FilterDispatcher không dọn dẹp

ThreadLocal ActionContext. Nếu bộ lọc ActionContextCleanUp không có thì

FilterDispatcher sẽ dọn dẹp tất cả các ThreadLocal tồn tại.

2.4.3. Ứng dụng đơn giản với Struts 2:

Hiển thị thông điệp “Hello world”

Sử dụng Eclipse Java EE IDE for Web Developers.

oTạo 1 project mới:

Tải gói struts 2 tại trang chủ của struts:

http://struts.apache.org/2.1.8.1/index.html

Copy các file sau từ thư mục \struts-2.0.11-all\struts-2.0.11\lib vào thư mục

WEB_INF/lib của ứng dụng ta mới tạo:

struts2-core.jar, xwork.jar, ognl.jar, freemarker.jar, commons-logging.jar

oSử dụng Server: Apache TomCat 6.0.20 download tại địa chỉ:

http://tomcat.apache.org/

Với Eclipse, chọn New ->Project-> Dynamic Web Project. Sau đó đặt tên cho

project, mặc định để chạy trên server Tom Cat 6.0 . Các bước thiết lập cấu hình cho hệ

thống như dưới đây:

Hình 2.4: Tạo web project trên eclipse

Bước 1: Xây dựng Action tương tác với thành phần “Model”.

- Tạo lớp Struts2HelloWorld.java trong struts2tutorial \WEB-INF\src\java\exam

package java.exam;

import com.opensymphony.xwork2.ActionSupport;

import java.util.Date;

public class Struts2HelloWorld extends ActionSupport {

public static final String MESSAGE = "Struts 2

Hello World !";

public String execute() throws Exception {

setMessage(MESSAGE);

return SUCCESS;

}

private String message;

public void setMessage(String message){

this.message = message;

}

public String getMessage() {

return message;

}

public String getCurrentTime(){

return new Date().toString();

}

Bước 2: Thành phần “Controller”.

- Tạo file cấu hình điều khiển struts.xml trong thư mục: struts2tutorial\WEB-INF\src

với nội dung:

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration

2.0//EN"

"http://struts.apache.org/dtds/struts-2.0.dtd">

<constant name="struts.enable.DynamicMethodInvocation"

value="false" />

<package name="exam" namespace="/exam" extends="struts-

default">

<action name="HelloWorld"

class="java.exam.Struts2HelloWorld">

<result>/pages/HelloWorld.jsp</result>

</action>

</package>

</struts>

File struts.xml sẽ có mặt trong classpath của ứng dụng, ta có thể đặt file này

trong jar và trong thư mục lib của ứng dụng hoặc cũng có thể đặt nó trong thư mục

classes của ứng dụng web.

- Cấu hình file web.xml của ứng dụng web

<filter-name>struts2</filter-name>

<filter-

class>org.apache.struts2.dispatcher.FilterDispatcher</filter

-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

Bước 3: Tạo thành phần “View”.

- Tạo trang HelloWorld.jsp trong thư mục struts2tutorial/pages với nội dụng:

<%@ taglib prefix="s" uri="/struts-tags" %>

<html>

<head>

<title>Struts 2 Hello World Application!</title>

</head>

<body>

<p>Current date and time is: <b><s:property

value="currentTime" /></b>

</body>

</html>

Chú thích:

- Dòng <%@ taglib prefix=”s” uri=”/struts-tags” %> khai báo dữ liệu thư viện

thẻ của struts. Dữ liệu thẻ của struts được sử dụng để hiển thị dữ liệu động.

- Thẻ

<s:property value="message"/>

và <s :property value="currentTime"/>

gọi lần lượt các phương thức getMessage() và getCurrentTime() của lớp action

HelloWorld và kết hợp các giá trị với response.

Luồng hoạt động:

Sau khi run sử dụng server Tom Cat, mở trình duyệt chạy liên kết :

http://localhost:8080/struts2tutorial/exam/HelloWorld.action

Hình 2.5: Chương trình sau khi chạy

- Khi chạy trên Tom Cat 6.0, trình chứa sẽ yêu cầu tài nguyên HelloWorld.action. File

web.xml trong ứng dụng này đã cấu hình việc định tuyến tất cả các yêu cầu *.action

đều thông qua org.apache.struts2.dispatcher.FilterDispatcher.

- Framework sẽ tìm mapping cho action HelloWorld, sau đó tạo một thể hiện của lớp

thích hợp và gọi phương thức execute() của lớp action đó. Trong trường hợp này là

lớp Struts2HelloWorld. Dưới đây là đoạn cấu hình mapping cho action này trong file

struts.xml

<action name="HelloWorld"

class="java.exam.Struts2HelloWorld">

<result>/pages/HelloWorld.jsp</result>

</action>

- Phương thức execute() được gọi và trả về SUCCESS

- Struts Framework xác định trang thích hợp để nạp nếu kết quả SUCCESS được trả

về, trong trường hợp này thì HelloWorld.jsp được gọi và sinh ra kết quả hiển thị

- Trong struts2, action được sử dụng để xử lý form và yêu cầu của người dùng.

Phương thức execute của action trả về các giá trị SUCCESS hoặc ERROR hoặc

INPUT. Đây là 3 giá trị cơ bản mà framework chỉ cho trình chứa biết để nạp và sinh ra

kết quả thích hợp

- Trình chứa nạp HelloWorld.jsp và sinh ra kết quả hiển thị

- Hiển thị kết quả định dạng HTML

2.5. Truy cập, sử dụng dữ liệu trong database.

- Như chúng ta đã biết, một ứng dụng web động luôn được thiết kế với một cơ sở dữ

liệu nhất định. Với từng tổ chức dữ liệu và độ bảo mật riêng, một hệ thống sẽ sử dụng

một hệ quản trị cơ sở dữ liệu khác nhau.

- Các hệ quản trị cơ sở dữ liệu thường dùng :

o MySQL

o PostgreSQL

o SQL server

o Oracle

o …..

- ORACLE là một bộ phần mềm được cung cấp bởi công ty ORACLE , nó bao gồm

một bộ xây dựng các ứng dụng và các sản phẩm cuối cùng cho uer (end_uer product).

- Oracle cung cấp một hệ quản trị CSDL mềm dẻo nó bao gồm CSDL Oracle, môi

trường cho việc thiết kế các cơ sở dữ liệu (Designer) và các công cụ phát triển

(Developer)….

- Bởi tính an toàn , bảo mật cao,tính nhất quán và toàn vẹn dữ liệu, cho phép các

user truy nhập tới cơ sở dữ liệu phân tán như một khối thống nhất … Oracle đang là

lựa chọn hàng đầu cho các doanh nghiệp trong việc quản trị database. Hệ thống quản

lý chất lượng dịch vụ Home Phone đã lựa chọn Oracle làm hệ quản trị cơ sở dữ liệu

bởi những đặc tính ưu việt đó.

2.6. Hibernate và những ưu việt.

2.6.1. Hibernate framework [13]

Framework là một khái niệm trong phát triển phần mềm dùng để chỉ những “cấu

trúc hỗ trợ được định nghĩa” mà trong đó những dự án phần mềm khác có thể được sắp

xếp vào đó và phát triển.

Hibernate là một cơ chế cho phép người lập trình thao tác với database một cách

hoàn toàn tự nhiên thông qua các đối tượng. Lập trình viên hoàn toàn không quan tâm đến

loại database sử dụng, SQL, … Nó là một trong những ORM (Object Relational

Mapping) Framework.

Chức năng chính của hibernate chính là ánh xạ từ các lớp Java đến các bảng cơ sở

dữ liệu ( và từ các kiểu dữ liệu Java sang kiểu dữ liệu SQL).

Khái niệm “Peristence layer”: một ứng dụng có thể được chia làm 3 phần như

sau: giao diện người dùng (presentation layer), phần xử lý nghiệp vụ (business layer) và

phần chứa dữ liệu (data layer). Cụ thể ra, business layer có thể được chia nhỏ thành 2

layer con là business logic layer (các tính toán nhằm thỏa mãn yêu cầu người dùng) và

persistence layer. Persistence layer chịu trách nhiệm giao tiếp với data layer (thường là

một hệ quản trị cơ sở dữ liệu quan hệ - Relational DBMS). Persistence sẽ đảm nhiệm các

nhiệm vụ mở kết nối, truy xuất và lưu trữ dữ liệu vào các Relational DBMS.

Hibernate framework là một framework cho persistence layer. Như vậy, nhờ có

Hibernate framework mà giờ đây khi bạn phát triển ứng dụng bạn chỉ còn chú tâm vào

những layer khác mà không phải bận tâm nhiều về persistence layer nữa.

Hibernate là một dịch vụ lưu trữ và truy vấn dữ liệu quan hệ mạnh mẽ và nhanh.

+ Hibernate giúp bạn phát triển các class dùng để lưu trữ dữ liệu theo cách thức

hướng đối tượng: association, inheritance, polymorphism, composition và collections

+ Hibernate cho phép bạn 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 thủy cũng

như là sử dụng các API.

+ Hibernate được license (đăng kí) theo LGPL (Lesser GNU Public License). Theo

đó, bạn có thể thoải mái sử dụng Hibernate trong các dự án open source hoặc các dự án

thương mại (commercial).

Hibernate

Database

Hibernate Properties

Application

Hibernate XML Mapping

Persistent

Objects

Hình 2.6: Kiến trúc Hibernate

Hình 2.6 miêu tả kiến trúc của Hibernate, với Hibernate một ứng dụng khi

tương tác với 1 cơ sở dữ liệu (database), nó cần được ánh xạ các bảng trong database

thành các đối tượng vững bền (Persistent).

Sáng tạo lại, quay vòng, đó là nguyên nhân của sự phát triển phần mềm. Đây là

thực tế cho mỗi và mọi thành phần của phần mềm. Một trong những thành phần cơ

bản và hầu như phức tạp (trong khái niệm thiết kế và bổ sung) là cơ sở dữ liệu. Tính

phức tạp tăng lên khi các thành phần tương tác nhau khác nhau.

Khi một thành phần dựa trên một kiểu giải pháp (ví dụ hướng đối tượng) cố

gắng tương tác trực tiếp với đối tượng khác có kiểu giải pháp khác (ví dụ quan hệ),

tính phức tạp tăng lên theo cấp số nhân của việc giao tiếp các giải pháp với nhau. Đây

là điều hiển nhiên trong tất cả các API cơ sở dữ liệu được cung cấp bởi các ngôn ngữ

khác nhau.

Ví dụ tốt nhất là API Java Database Connectivity (JDBC). Thông qua JDBC

cung cấp một phương thức dễ dàng để truy cập đến những cơ sở dữ liệu khác nhau mà

không phải thay đổi nhiều, nó cơ bản là một API ở mức thấp cung cấp chỉ một layer

trừu tượng.

Đây là sự tiện dụng đối với những dự án nhỏ và vừa, nhưng không thích hợp

cho các ứng dụng mức enterprise. Những gì mà một Framework yêu cầu đó là có thể

tương tác như một trung gian giữa nhiều bên với nhau (ví dụ các giải pháp khác nhau).

Các ORM framework mang đến cho các developer những tư duy trong khái

niệm về quan hệ trong khi vẫn làm việc với các lớp. Có nhiều framework mang mục

đích này. Những gì làm cho Hibernate khác với những framework khác chính là tính

đơn giản và khả chuyển của nó. Để tạo nên ứng dụng Hibernate, có ba điều cần phải

có, đó là:

Persistence Class: (Lớp bền vững)

Persistence class là một Plain Old Java Object hay POJO model. 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 instance variable (biến thực thể). Persistence class 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 instance variable của persistence

class.

c. Kiểu dữ liệu của các instance variable là domain của các thuộc tính.

d. Đối tượng của persistence class thay hế cho hàng của bảng.

Mapping file: (Tệp định hướng)

Mapping file là một file XML chứa ánh xạ chi tiết giữa persistence class và

bảng nó thay thế. Các thành phần bắt buộc của file XML này là:

a. hibernate-mapping: Đây là thành phần gốc bao tất cả các thành phần khác.

b. class: được sử dụng để ánh xạ tên bảng thành persistence class (lớp bền

vững). Tên thuộc tính được sử dụng để xác định tên lớp, và thuộc tính bảng được sử

dụng để xác định bảng mà lớp thay thế. Ví dụ để ánh xạ một bản mang tên ORDERS

thành một persistence class với tên đầy đủ là com.someorg.persist.Order sẽ như dưới

đây:

c. id: Thành phần này sử dụng để ánh xạ khóa chính của table thành một

instance variable của class. Thành phần cột con của id có thể sử dụng để ánh xạ thành

biến tương ứng. Giá trị của khóa chính có thể tự động tạo ra được công bố ở đây.

Thành phần generator có thể được sử dụng để nói cho Hibernate một lớp sẽ được sử

dụng ở đâu để tự động tạo id, hoặc id được gán bởi ứng dụng:

</id>

Ví dụ trên nói cho Hibernate rằng, tên của khóa chính là id mà nó đã được ánh xạ

thành instance variable “id”. Kiểu dữ liệu của nó là “string” được ánh xạ cho cột “id”

có kiểu “char(32)” thay thế bởi thuộc tính sql-type. Thuộc ính lớp của generator chứa

giá trị “assigned” nghĩa là ứng dụng bản thân nó sẽ cung cấp giá trị cho khóa chính.

d. property: thành phần này, thuộc về các cột thành phần con của nó, ánh xạ

những thuộc tính khác (hoặc các côt thành những instance variable của persistence

class. Thuộc tính name của property chứa tên của biến như một giá trị. Thuộc tính

name của thành phần column chứa tên của cột mà instance variable được ánh xạ. Các

thuộc tính length và sql-type trỏ đến độ dài và kiểu dữ liệu của cột:

</property>

Hibernate Configuration file: (Tệp cấu hình Hibernate)

File này có thể được gọi trỏ đến ứng dụng sử dụng Hibernate. Nguyên nhân là nó

chứa cấu hình điều khiển giao tiếp với database ở phía dưới. Ở đây, tất cả các file

mapping được sử dụn bởi ứng dụng được công bố. Địnn dạng thành phần của

hibernate-configuration là thành phần gốc. Hầu hết các thành phần thông dụng sử

dụng trong file XML là:

a. property: Thuộc tính name của thành phần property có thể được sử dụng để

cấu hình những tham số khác nhau. Trong công nghệ Hibernate, những tham số này

được biết như là những tham số property. Kiểu database server (MySQL, Oracle…),

dialect class, URL của database, username/password… là những tham số property

khác nhau. Để đặt chúng vào trong mã:

<session-factory>

<property

name="connection.driver_class">org.hsqldb.jdbcDriver</property>

<property

name="connection.url">jdbc:hsqldb:data/tutorial</property>

:

</session-factory>

b. mapping: Nó là thành phần kết nối tất cả các file mapping,, cũng gọi là các file

hbm, được sử dụng bởi ứng dụng đã công bố. Thuộc tính resource được cho giá trị của

đường dẫn file hbm.

Apache đã phát triển Struts rất mềm dẻo để có thể kết hợp dễ dàng với Hibernate

phát triển các ứng dụng có quy mô lớn.

2.6.2 Một ví dụ về kết hợp giữa Struts 2 và Hibernate:

Xây dựng ứng dụng quản lý các tài khoản của một hệ thống bằng Struts 2

Kết hợp giữa Struts 2 và Hibernate.

Bước 1: Tạo ứng dụng web trong Eclipse.

Hình 2.7: Cấu trúc Project

Bước 2: Cấu hình file: web.xml

<filter-name>struts-cleanup</filter-name>

<filter-

class>org.apache.struts2.dispatcher.ActionContextCleanUp</filter-

class>

</filter>

<filter-name>struts2</filter-name>

<filter-

class>org.apache.struts2.dispatcher.FilterDispatcher</filter-

class>

</filter>

<filter-mapping>

<filter-name>struts-cleanup</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

Tạo file struts.xml trong thư mục src của project.

Thêm thư viện của struts 2, gồm 5 file sau:

• common-logging.jar

• freemarker.jar

• ognl.jar

• struts2-core.jar

• xwork.jar

Bước 3: Để cấu hình Hibernate với Struts chúng ta cần thư viện của Hibernate

đặt trong thư mục Web-inf/lib, gồm những file sau: antlr.jar ,asm.jar, cglib.jar,

commons beanutils.jar, common-logging.jar, dom4j.jar, freemarker.jar,

hibernate.jar, jta.jar, <jdbc drivers libs>, ognl.jar, struts2.jar, xwork.jar

Bước 4: Tạo đối tượng SessionFactory của Hibernate trong bộ lọc Struts 2, sau

đó sẽ kế thừa bộ lọc Struts 2,tạo một thư mục để plugin vào trong kiến trúc package.

HibernateUtil.java

package com.net.plugin;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.hibernate.Session;

public class HibernateUtil {

private static SessionFactory sessionFactory;

public static void createSessionFactory() {

sessionFactory = new Configuration().configure().buildSessionFactory();

}

public static Session getSession() {

return sessionFactory.openSession();

}

Bước 5: Override bộ lọc của Struts 2

Struts2dispatcher.java

package com.net.plugin;

import javax.servlet.*;

import org.apache.struts2.dispatcher.FilterDispatcher;

import org.hibernate.HibernateException;

public class Struts2Dispatcher extends FilterDispatcher {

@Override

public void init(FilterConfig filterConfig) throws ServletException {

super.init(filterConfig);

try {

HibernateUtil.createSessionFactory();

System.out.print(”application initializing successfully”);

} catch (HibernateException e) {

throw new ServletException(e);}

}