Struts 2 và ứng dụng quản lý chất lượng dịch vụ home phone.doc

DỊCH VỤ VIẾT THUÊ ĐỀ TÀI TRỌN GÓI ZALO / TEL: 0909.232.620
TẢI TÀI LIỆU – KẾT BẠN ZALO: 0909.232.620
ĐẠ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
Action classes - Sử dụng lớp abstract (lớp - Action có thể là bất kỳ lớp
(Lớp hoạt trừu tượng), không sử Java nào.
dụng interface (lớp giao
động) - Cung cấp sẵn 1 interface
diện). chung cho các action là
- Action yêu cầu bắt buộc ActionSupport, tuy nhiên
phải kế thừa từ một lớp không bắt buộc thực thi
abstract nào đó. action này
Threading Các Action là độc nhất vì Trong Struts 2 các đối tượng
Model thế chúng phải được được khởi tạo cho mỗi
(Mô hình thread-safe bởi vì chỉ có request do đó không có
một thể hiện của lớp để thread-safety.
luồng)
giữ lại tất cả request đối Một servlet container sinh ra
với Action đó. nhiều đối tượng throw-away
cho mỗi request
Servlet Actions bị phụ thuộc vào Action chỉ là một lớp bình
Dependency thư viện servlet API bởi vì thường và chúng ta không
(Phần phụ HttpServletRequest và cần truyền đối tượng
HttpServletResponse được HttpServletRequest và
thuộc servlet)

truyền vào phương thức HttpServletResponse cho
execute khi Action được phương thức execute.
thực thi. 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.
Testability Ứng dụng Struts1 có một Các Action có thể test các
(Khả năng kiểm vấn đề chính trong việc khởi tạo Action.Các Action là
testing bởi vì phương thức một POJO đơn giản và không
tra)
execute phụ thuộc vào phụ thuộc framework,vì thế
Servlet API. Struts việc test trở lên đơn giản hơn
TestCase cung cấp một tập
hợp các đối tượng Mock
cho Struts 1
Harvesting Struts1 sử dụng một đối Struts2 sử dụng các thuộc
Input tượng ActionForm để giữ tính Action để giới hạn sự
(Kết quả đầu các input.Giống như các cần thiết cho các đôi tượng
Action, tất cả các input thứ 2. Từ đó giảm sự dư
vào)
ActionForms cần được thừa.
thừa kế lớp ActionForm cơ
bản .
Binding values Struts 1 ràng buộc đối Struts 2 sử dụng công nghệ
into views tượng bên trong ngữ cảnh ValueStack để đảm bảo việc
(Ràng buộc giá của trang bằng cách sử truy cập giá trị bằng taglib
dụng cơ chế JSP chuẩn. không thông qua coupling
trị trong việc
(kết nối) hoặc rendering (biểu
hiển thị)
diễn).
Type Trong Struts 1 các thuộc Struts 2 sử dụng OGNL đối
Conversion tính của ActionForm hầu với việc chuyển kiểu dữ liệu.
(Thay đổi kiể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.

Control Of Mỗi module trong Struts 1 Trong Struts 2 các vòng đời
Action có sự tách rời Request khác nhau được tạo ra dựa
Execution Processors (vòng trên nền tảng Action thông
(Kiểm soát thực đời),trong khi tất cả các qua ngăn xếp chặn
Action trong module cần (Interceptor Stacks).Các stack
thi)
phải chia sẻ cùng vòng tùy biến được tạo ra và sử
đời. dụng với Action khác nhau.
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.
o Tạ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-allstruts-2.0.11lib 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
o Sử 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-INFsrcjavaexam
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: struts2tutorialWEB-INFsrc
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"> <struts>
<constant name="struts.enable.DynamicMethodInvocation"
value="false" />
<constant name="struts.devMode" value="true" /> <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>
<filter-name>struts2</filter-name>
<filter-
class>org.apache.struts2.dispatcher.FilterDispatcher</filter
-class>
</filter>
<filter-mapping>
<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>
<h2><s:property value="message" /></h2>
<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
Application Hibernate Properties
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:
<class name=”com.someorg.persist.Order” table=”ORDERS”>…</class>
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 name="id" type="string" unsaved-value="null">
<column name="id" sql-type="char(32)" not-null="true"/>
<generator class="assigned"/>
</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 name="name">
<column name="name" sql-type="char(255)" not null="true"/>
</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>
<property name="connection.username">sa</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.
<mapping resource="Event.hbm.xml"/>
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>
<filter-name>struts-cleanup</filter-name>
<filter-
class>org.apache.struts2.dispatcher.ActionContextCleanUp</filter-
class>
</filter>
<filter>
<filter-
class>org.apache.struts2.dispatcher.FilterDispatcher</filter-
class>
</filter>
<filter-mapping>
<filter-name>struts-cleanup</filter-name>
</filter-mapping>
<filter-mapping>
</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);}
}
}

Bước 6 : Cho phép bộ lọc trong file web.xml như sau:
<!–<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-
class> –>
<filter-class>org.hns.plugin.Struts2Dispatcher</filter-class>
Bước 7: Đặt file cấu hình Hibernate trong thư mục src với tên
hibernate.cfg.xml.
Tạo bảng usermast với các trường
usercode(int), uname(varchar), pwd(varchar), type(varchar)
Sau đó sửa file: hibernate.cfg.xml
<?xml version=’1.0′ encoding=’utf-8′?>
<!DOCTYPE hibernate-configuration PUBLIC
“-//Hibernate/Hibernate Configuration DTD//EN”
“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd”>
<hibernate-configuration>
<session-factory>
<property
name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDri
ver</property>
<property
name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:DB
</property>
<property name="hibernate.connection.username">system
</property>
<property name="hibernate.connection.password">abc123
</property>
<property
name="hibernate.dialect">org.hibernate.dialect.OracleDialect
</property>
</session-factory>
</hibernate-configuration>
DB: tên database
Username, password: tên truy cập vào database

Bước 8: Tạo file Hibernate mapping với bảng trong cơ sở dữ liệu. Tạo lớp
User.java trong package com.net.user
package com.net.user.;
public class User
{
private int id;
private String username;
private String password;
private String usertype;
// add fields setter and getter here (required)}
Tạo file User.hbm.xml trong package com.net.user
<!DOCTYPE hibernate-mapping PUBLIC “-
//Hibernate/Hibernate Mapping DTD 3.0//EN”
“http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd”>
<hibernate-mapping>
<class name=”com.net.user.User” table=”usermast“>
<id name=”id” type=”integer” column=”usercode”>
<generator class=”increment”></generator> </id>
<property name=”username” type=”string” column=”uname” />
<property name=”password” type=”string” column=”pwd” />
<property name=”usertype” type=”string” column=”type” />
</class>
</hibernate-mapping>
Bước 9: Tạo một file java khác là UserHibDao.java để tạo và truy cập User
package com.net.user.dao;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.net.user.User;
import com.net.plugin.HibernateUtil;
public class UserHibDao {
private List<User> userlist;
private User user;

}
catch (RuntimeException e) {
if(tx != null) tx.rollback();
throw e;
} finally {
session.close();}
}
//Liệt kê tất cả các User public List
getAllUser() {
Session session = HibernateUtil.getSession();
try
{
session.beginTransaction();
userlist=session.createQuery(”from User”).list();
return userlist;
}
catch(Exception e)
{
System.out.print(”Error while fetching “+e);
return null;
}
finally
{
session.close();
}}
//Lấy ra một User
public User getuser(Integer id) {
try {
//change query for get proper data
Query q = session.createQuery(”from User u where u.uid=:id”);
q.setInteger(”userid”,id);
return (User) q.uniqueResult();
}finally {
session.close();
}}

//Chèn thêm 1 User
public void insert(User usr) {
Transaction tx=null;
try {
tx = session.beginTransaction();
session.save(usr);//saveOrUpdate()
tx.commit();
} catch (RuntimeException e) {
if(tx != null) tx.rollback();
throw e;
} finally {
session.close();
}}
Bước 10. Kiểm tra
public static void main(String[] args) throws Exception {
UserHibDao user=new UserHibDao(); User user1 = new
User();
user1.setUsername("sonnt");
user1.setPassword("abc123");
user1.setUsertype("Hello world");
user.insert(user1);
System.out.println("Insert Success"); }
Kiểm tra thông báo: Insert Success trên màn hình Console. Không sử dụng server
TomCat.
Đây là một ví dụ đơn giản nhất về sự kết hợp giữa Struts 2 với Hibernate. Công việc
cuối cùng là ứng dụng các công nghệ trên vào để giải quyết bài toán: Xây dựng hệ
thống quản lý chất lượng dịch vụ Home Phone.
Ngoài ra để tiện dụng, trong hệ thống có sử dụng thêm JSTL(JavaServer Pages
Standard Tag Library) để tối ưu và chuyên nghiệp cho source code.

Chương 3: GIẢI QUYẾT BÀI TOÁN
3.1. Yêu cầu luồng công việc
Quản lý người dùng
Phần quản lý người dùng yêu cầu thực hiện việc kiểm tra thông tin đăng nhập. Nếu
đã đăng nhập thành công, thì cho phép hiển thị các module của hệ thống (được phân
quyền hiển thị với user đó.). Ngoài ra phải xây dựng module quản lý người dùng, nhóm
người dùng và quyền truy xuất vào các module đối với từng nhóm người dùng.
Thông tin thuê bao
Lựa chọn địa điểm cần thông tin, với mặc định thời gian là ngày hôm qua (hệ thống
quét dữ liệu vào 3h sáng)
Sau khi lựa chọn, hệ thống sẽ hiển thị 2 bảng với 2 nội dung.
- Báo cáo thống kê:
% các 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 activated mới 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
- Thống kê cảnh báo:
Số lượng các agent không hoạt động
Số lượng các agent đang hoạt động nhưng không phát sinh cuộc gọi
Số lượng các agent thay đổi serving cell
Số lượng các agent sử dụng sóng yếu
Số lượng các agent sử dụng sóng chất lượng tồi
Số lượng các agent có tỷ lệ CSR thấp.

- Bảng “Thống kê cảnh báo”: đều được gắn liên kết trỏ tới thông tin chi tiết
Phần đồ thị mô tả được vẽ ở bên dưới hai bảng.
Các cảnh báo
Nguời điều khiển có thể lựa chọn hiển thị các loại thông tin cảnh báo: (agent
không hoạt động, agent hoạt động nhưng không phát sinh cước gọi, agent đổi serving
sell…).
Thông tin “chi tiết cảnh báo” chi tiết hơn về thông tin của thuê bao, ngoài ra có
hiển thị biểu đồ chi tiết về chất lượng sóng, cường độ sóng để biết được nguyên nhân
tại sao thuê bao từ chối sử dụng dịch vụ.
Cấu hình tham số
Các tham số của hệ thống phải được cấu hình ở một ngưỡng nhất định. Các tham số
này sẽ phục vụ việc đánh giá chất lượng của hệ thống dịch vụ Home Phone.
Quản lý Agent:
Quản lý Agent là một module riêng, chỉ những người có quyền điều khiển hệ thống
mới được phép truy cập vào. Quyền truy cập ở module này yêu cầu người dùng phải
thuộc nhóm người quản trị. Nhóm này được thiết lập trong “Quản lý người dùng”.
Phần này yêu cầu thiết kế một bảng gồm một số thông tin về Agent như : họ tên, số
điện thoại (MSISDN), thông tin chi tiết khác.
Ngoài ra, nó yêu cầu ở mỗi agent có thêm các xử lý với nó. Các xử lý cần thực hiện
là: Sửa; Xóa; Activate; Deactivate; Reset, Chi tiết mẫu đo, Query Config, Query Status,
Measure.
- Chi tiết: Thông tin chi tiết về thuê bao sẽ được hiển thị
- Sửa: Người điều khiển có thể sửa thông tin của thuê bao tại đây
- Xóa: Xóa 1 thuê bao khỏi cơ sở dữ liệu. Lưu ý phải hiển thị một drop box thông
báo.
- Các xử lý Activate, Deactivate, Reset: thêm lần lượt các giá trị ACTIVATE,
DEACTIVATE, RESET tương ứng vào bảng TBL_SERVICE_CONTROL theo các
trường như bảng dưới:
ACTIVATE
AGENT ID SERVICE REQUEST SERVICE STATUS
4 ACTIVATE NP

DEACTIVATE
5 DEACTIVATE NP
RESET
6 RESET NP
Ngoài ra còn một số xử lý khác về agent như Query status, Query config, Measure
cũng tương tự như phần xử lý Activate, tuy nhiên cần đợi thời gian timeout của hệ
thống lên khoảng 10 giây để hệ thống tương tác thông tin với agent.
3.1 Sơ lược về cơ sở dữ liệu của hệ thống
Hệ thống quản lý chất lượng dịch vụ Home Phone
Cở sở dữ liệu gồm có 35 bảng được thiết kế như trên (sử dụng Navicat hoặc SQL
Navigator để hiển thị cơ sở dữ liệu)
Hình 3.1: Các bảng trong cơ sở dữ liệu

TBL_AGENT: bảng này lưu thông tin về các Agent. Mỗi agent đều có một số
thông tin đi kèm như số điện thoại gắn liền, tên chủ thuê bao, số IMEI và một số các
thông tin về khu vực trực thuộc, thông tin về tần số sóng, dải băng tần …
Trong hình 3.1, Các bảng TBL_AGENT_* lưu danh sách các thuê bao có thông tin
cảnh báo.
TBL_USER lưu thông tin của người dùng, là các tài khoản sử dụng cho việc đăng
nhập vào hệ thống.
TBL_CFG_ROLE lưu danh sách các module được phân quyền truy cập với người
dùng.
Các bảng TBL_Q_STATUS, TBL_Q_CONFIGURATION mang cá thông tin xử
lý bên module Quản lý Agent.
Hình 3.2.1 : Chi tiết bảng TBL_AGENT
Bảng TBL_AGENT chứa các thông tin chi tiết về Agent, tất cả các agent đều được lưu
trong bảng này.
Mỗi Agent lưu mã của quốc gia, vùng, tỉnh. Mỗi mã này ứng với dữ liệu bên các bảng
TBL_COUNTRY, TBL_AREA , TBL_PROVINCE. Ngoài ra bảng Agent còn một số
thông tin về Cell ID, trạng thái Agent (Agent Status), IMEI, CUSTOMER ID…
Cuối mỗi bảng đều có một trường là ONDATE lưu thời điểm thêm hoặc điều chỉnh
dữ liệu.

Hình 3.2.2: Chi tiết bảng TBL_INFO_PERCENT
Bảng TBL_INFO_PERCENT tổng hợp số liệu về số lượng agent đang hoạt động,
agent phát sinh cuộc gọi, agent phát sinh nhiều cuộc gọi … để có những tiêu chí đánh giá
hợp lý cho chất lượng dịch vụ. Ví dụ: với những thuê bao phát sinh nhiều cuộc gọi, nhà
mạng có thể có những dịch vụ chăm sóc khách hàng hợp lý, để làm hài lòng khách hàng
sử dụng.
Các số liệu này đều được lọc qua các Scope (phạm vi nhất định) thuộc một vùng
miền hay một tỉnh thành nào đó. Việc thống kê chi tiết như vậy khiến nhà mạng có thể
hiểu rõ được thị trường phát triển viễn thông của vùng đó, từ đó có những biện pháp phát
triển dịch vụ cho hợp lý.
Một điểm sai sót trong khởi tạo các trường trong cơ sở dữ liệu là chưa xác định rõ
các khóa chính, khóa ngoại của các bảng, điều này gây khó khăn trong lập trình. Ví dụ: 3
bảng TBL_COUNTRY, TBL_AREA, TBL_PROVINCE chỉ gồm có 2 trường trong
mỗi bảng là ID và Tên. Không có mối quan hệ trực tiếp trong 3 bảng này. 3 bảng này liên
quan duy nhất trong hệ thống là thông qua bảng TBL_AGENT. Với mỗi Agent, người
quản lý sẽ phải nêu rõ thuộc nước nào, vùng nào, tỉnh nào rõ ràng. Và bộ lọc phạm vi
(scope) trở lên phức tạp hơn .
Đó là một số mô tả cơ bản về cở sở dữ liệu của hệ thống. Vậy để tiến hành xây
dựng website quản lý chất lượng dịch vụ Home Phone, chúng ta phải nắm rõ quan hệ của
các trường trong cơ sở dữ liệu, từ đó có thể mô phỏng được quan hệ giữa các đối tượng
trong xử lý của các lớp.

3.3 Quá trình thực hiện dự án
Các gói thư viện được đưa vào thư mục WebContentWEB-INFlib
Project được xây dựng như hình vẽ:
Hình 3.3: Ứng dụng xây dựng trên Eclipse Java EE IDE for Web Developers.
Việc cấu hình các file cơ bản như struts.xml , hibernate.cfg.xml , web.xml tương tự
như trong các ví dụ trên.
Thư mục src chứa package cấu hình Model, Action và trình điều khiển Controller.
Các Action xử lý các module khác nhau được đặt riêng trong từng gói (package)
khác nhau, đặt theo tên tiếng Anh của từng xử lý.
Controller là các file struts.xml, web.xml, các file xml đi kèm với các file trong
Model và Action.
Các gói thư viện cần thiết được đặt tại WebContentWEB-INFlib gồm các thư viện
của Struts2, thư viện Hibernate, thư viện jstl và một số thư viện hỗ trợ vẽ biểu đồ.
Phần giao diện:
Nằm trong thư mục WebContentview , được phân chia ra các thư mục riêng để dễ dàng
quản lý.

Các file ảnh cần thiết cho hệ thống được đặt trong thư mục Image.
Style đặt trong thư mục Css.
Một số javascript đặt trong thư mục js
3.3.1 Module đăng nhập,quản lý người dùng và phân quyền.
Hình 3.4: Giao diện đăng nhập
Đăng nhập bằng tài khoản admin /admin (Full Control)
Nếu kiểm tra thông tin đăng nhập chính xác, hệ thống sẽ chuyển đến trang index,
nếu sai thì hủy bỏ yêu cầu truy cập và yêu cầu xác nhận lại
Khi kiểm tra class User trong package : com.srs.model lấy dữ liệu từ bảng
TBL_USER đưa vào 1 danh sách, so sánh giá trị vừa nhập để lấy kết quả trả về
Các tài khoản được phân quyền khác nhau.

<%@ include file="/view/common/init.jsp"%>
<c:choose>
<c:when test="${loginUser.roleLogin
|| loginUser.roleViewGraphicalReports}">
<c:redirect url="/agent/index.do"></c:redirect>
</c:when>
<c:otherwise>
<c:choose>
<c:when test='${loginUser.roleAgentManagement
}'> <c:redirect
url="/agent/list.do"></c:redirect>
</c:when>
<c:otherwise>
<c:if
test=" ${loginUser.roleUserManagement}"> <c:redirect
url="/user/list.do"></c:redirect>
</c:if>
</c:otherwise>
</c:choose>
</c:otherwise>
</c:choose>
Thông tin về file init.jsp (File cấu hình các taglib)
<%@ page language="java" pageEncoding="utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jstl/fmt" prefix="fmt" %>
Khi 1 file jsp có include file init.jsp này, nó có thể sử dụng các thẻ <s: />, <c:/>,
<fmt: />
Quản lý người dùng và phân quyền.
Phần quản lý người dùng được thiết kế các chức năng thêm, sửa xóa giống như
quản lý thuê bao.
Mỗi người dùng đều được đặt trong 1 group, để phân quyền truy cập theo nhóm.
Phần quản lý Nhóm người dùng: Giống như quản lý người dùng, có các chức năng
thêm, sửa, xóa
Thông tin chi tiết của người dùng được hiển thị trong trang liên kết “ Chi tiết”.

Hình 3.5: Quản lý người dùng
Các tài khoản User đểu được thuộc một Group nhất định. Trong menu quản lý Group,
muốn thêm một nhóm mới, người quản trị phải cung cấp các Role (các vai trò, vị trí của
người dùng trong một module). Điều này nghĩa là mỗi group phải được gắn quyền truy
cập vào những menu nhất định.Hình 3.6 chụp lại chức năng thêm một group, với những
thông tin sau:
Hình 3.6: Thêm Group

Phân quyền người dùng
Đăng nhập với tài khoản: chienvh/chienvh
Hình 3.7: Phân quyền người dùng
Với tài khoản đăng nhập là chienvh, người dùng chỉ có quyền truy cập vào 2
module là : Quản lý thuê bao, các cảnh báo. Việc phân quyền này nhằm mục đích quản
lý việc sử dụng hệ thống. Người dùng bình thường không có khả năng thay đổi các cấu
hình của hệ thống, thay đổi thông tin người dùng mà chỉ có thể xem các thông tin cần
thiết phục vụ cho báo cáo hệ thống
3.3.2 Module thông tin thuê bao:

Hình 3.8: Module thông tin thuê bao
Quay trở lại tài khoản Admin, module thông tin thuê bao được sắp xếp từ trên xuống
dưới là: bộ lọc scope (lựa chọn khu vực cần xem thông tin), lựa chọn khoảng thời gian
(khoảng thời gian cách nhau tối đa là 15 ngày).
File index.jsp
var countryId = <c:out value="${countryId}"/>;
var areaId = <c:out value="${areaId}"/>;
var provinceId = <c:out value="${provinceId}"/>;
var cellId = <c:out value="${cellId}"/>;
Tầng View gọi thông tin biến: countryId, areaId, provinceId, cellId , thông tin được gửi
đến Model thông qua cấu hình struts.xml tầng Controller, kết hợp với Hibernate, dữ liệu
được lấy từ các bảng :TBL_AGENT,
TBL_CFG_AREA, TBL_CFG_COUNTRY, TBL_CFG_PROVINCE
Đưa vào các list, được hiển thị ra
Các thẻ select được nằm trong thẻ struts <s:form></s:form> sẽ hiển thị dữ liệu động bởi
các biến countryId, areaId, provinceId, cellId ở trên.
Action được thực thi ở lớp AgentAction.class trong package com.srs.action
public List<Area> list() {
Session session =
HibernateUtil.getSession(); try {
areaList = session.createQuery("from
Area").list();
return areaList;
} catch (Exception e) {
System.out.print("Error while fetching " + e);
return null;
} finally {
session.close();
}
}
Sau khi lọc thông tin thuê bao cần hiển thị, các thông tin yêu cầu sẽ được hiển thị ở 2
bảng (như hình dưới), sau đó, phần biểu đồ được vẽ ngay phía bên dưới

Hình 3.9: Biểu đồ thông tin thuê bao
Phía dưới, theo yêu cầu thiết kế của khách hàng, còn 6 biểu đồ nữa tương tự như các biểu
đồ trên, với trục hoành là khoảng thời gian cần hiển thị, trục tung là thành phần % thông
tin về các thuê bao.
3.3.3 Module: Các cảnh báo
Hiển thị cảnh báo là một trong những module quan trọng nhất của hệ thống. Nhà mạng
luôn phải biết được người sử dụng đang cảm thấy như thế nào về việc sử dụng dịch vụ
của mình, từ đó có thể tìm ra nguyên nhân sai sót, hỏng hóc của hệ thống, để sửa chữa và
nâng cấp, đáp ứng nhu cầu sử dụng của khách hàng.
Hình 3.10: Module cảnh báo
Lựa chọn thông tin cảnh báo , hiện danh sách các thuê bao có cảnh báo.
Phần chi tiết:

Hình 3.11: Chi tiết cảnh báo
Chi tiết về thuê bao, biểu đồ hiển thì cường độ sóng và chất lượng sóng của thuê bao sử
dụng trong khoảng thời gian nhất định (lựa chọn), tối đa 15 ngày. Với hình ảnh trực
quan, biểu đồ đã thể hiện rõ được nguyên nhân gây cảnh báo của hệ thống với một khách
hàng có trong danh sách liệt kê.
3.3.4 Module: Cấu hình tham số
Hình 3.12: Module : Cấu hình tham số
Cấu hình tham số là module quan trọng trong việc đánh giá các thông số kỹ thuật
của hệ thống, đưa ra thông tin cảnh báo, hiển thị thuê bao có ngưỡng dưới mức cho phép
…
Phân tích về cách thực hiện lệnh của module cấu hình tham số này:
Khi nhấn “Đồng ý” lớp ConfigAction trong com.srs.action.config gọi phương thức
editComplate() thực hiện việc chuyển dữ liệu qua bộ lọc dữ liệu (Filter), sau đó nhờ
hibernate, các đối tượng chứa dữ liệu trong các mảng được mapping đến cơ sở dữ liệu.
Sau đó Action hibernate thực hiện lệnh ghi vào database.

public String editComplete(){
System.out.println("ConfigAction::index");
SystemParameterDao systemParameterDao = new
SystemParameterDao();
List<SystemParameter> systemParameters
= systemParameterDao.list();
if (isReset!=null){
System.out.println("ConfigAction::editComplete::reset
value");
for (SystemParameter systemParameter :
PARAMETERS) {
config.setValue(systemParameter);
}
systemParameters) {
systemParameter.setValue(config);
systemParameterDao.update(systemParameter);
}
} else {
System.out.println("ConfigAction::editComplete::update
value");
systemParameters) {
systemParameter.setValue(config);
systemParameterDao.update(systemParameter);
}
}
Phương thức EditComplate kiểm tra xem người dùng có muốn reset các tham số về
mặc định hay không? Nếu có thì thực hiện gán các thông số đang tồn tại về các số đã
mặc định. Ngược lại, nó gọi hàm setValue() để gán giá trị nhập vào cơ sở dữ liệu.
3.3.5 Module: Quản lý Agent
Danh sách Agent được hiển thị sau khi lọc theo vùng miền, tỉnh, cell.
Chức năng thêm thuê bao, xem chi tiết 1 thuê bao trong danh sách.

Hình 3.13: Module: Quản lý Agent
Các chức năng Update Config, Activate, Deactivate, Reset … khi thực hiện click thì
quá trình xử lý thông tin được thực hiện như trong yêu cầu. 1 popUp được hiện ra thông
báo việc thực hiện công việc thành công hoặc chưa thực hiện được:
Hình 3.14: PopUp thông báo xử lý yêu cầu Update Config
Các button Update Config, Activate, Deactivate, Reset … thực hiện các lệnh như yêu
cầu của hệ thống khi click.

Các chức năng khác của menu “Quản lý Agent”:
Hình 3.15: Thêm thuê bao Hình 3.16: Chi tiết agent
Thêm thuê bao, sửa, xóa thuê bao, chi tiết về một agent như hình 3.13, 3.14 là các
module cơ bản trong quản lý một đối tượng. Trong module thêm thuê bao, người sử dụng
phải nhập thông tin về số điện thoại ánh xạ với id của agent, thông tin về vùng sử dụng,
tên người sử dụng dịch vụ, … và được hiển thị chi tiết trong bảng : Chi tiết thuê
bao.
Bảng chi tiết mẫu đo là được hệ thống hiển thị các trường ra trong bảng
TBL_NI_DATA.
Chi tiết từng agent với các lần đo chi tiết, tổng số lần đo các mẫu cường độ sóng, chất
lượng sóng, chuyển vùng dịch vụ, được liệt kê chi tiết trong hình 3.17.

Hình 3.17: Bảng chi tiết mẫu đo
Các mẫu đo này được thực hiện liên tục trong quá trình phát triển hệ thống, được
cập nhật trong những khoảng thời gian nhất định. Để có thể đánh giá được chất lượng
của dịch vụ, việc quản lý và truy vấn các thông số là vô cùng cần thiết.

Chương 4: Kết luận
Hệ thống quản lý chất lượng dịch vụ Home Phone thông qua thành phần Web (hiển
thị số liệu và bảng biểu) đã mô phỏng toàn bộ thông tin chất lượng của dịch vụ Home
Phone. Hệ thống được xây dựng chỉ cho nội bộ nhân viên công ty sử dụng và quản lý. Vì
vậy giao diện sáng sủa, trình bày nội dung khoa học là điều mà chương trình yêu cầu.
Đây chỉ là phiên bản đầu tiên của hệ thống, thiết kế theo yêu cầu của đối tác. Hệ
thống còn nhiều điểm chưa thật sự đạt được như mong muốn của người thiết kế , tuy
nhiên đã thỏa mãn được các yêu cầu của dự án.
Hệ thống hiện vẫn đang trong quá trình chạy thử nghiệm. Hi vọng nó đóng góp
được hiệu quả trong việc đánh giá chất lượng dịch vụ của Viettel Telecom.
Trong quá trình thực hiện công việc, bản thân tôi đã tích lũy được rất nhiều các kinh
nghiệm thực tế giúp tôi vững bước hơn trong tương lai sắp tới. Ngoài ra tôi hiểu biết
thêm được nhiều các công nghệ mới, ứng dụng cho ngành Công nghệ thông tin.

Tài liệu tham khảo
Tài liệu tiếng Anh:
[1] Apache Struts , http://struts.apache.org/
[2] http://www.windofkeltia.com/j2ee/wtp-tutorial.html
[3] Wikipedia, http://en.wikipedia.org/
[4] Java tutorials and Development (Laliluna) http://www.laliluna.de/
[5] http://www.roseindia.net/struts/struts2/struts-2-architecture.shtml
[6] http://www.hibernate.org/
[7] J2EE 1.4 Tutorial
http://java.sun.com/j2ee/1.4/docs/tutorial/doc/
Tài liệu tiếng việt
[8] Tìm hiểu về struts http://my.opera.com/nguyend/blog
[9] http://vovanhai.wordpress.com/
[10] http://www.oravn.com/
[11] Struts và MVC
http://www.humg.edu.vn/cntt/forum?func=view&id=437&catid=21
http://vi.wikipedia.org/wiki/Java_%28c%C3%B4ng_ngh%E1%BB%87%29
[12] Tìm hiểu về Hibernate
http://www.cusc.ctu.edu.vn/forum/index.php?topic=330.0
[13] Tài liệu jstl tiếng việt
http://www.docstoc.com/docs/6971236/tom-tat-jstl-tieng-viet

[14]

Struts 2 và ứng dụng quản lý chất lượng dịch vụ home phone.doc

Recommended

Recommended

More Related Content

Similar to Struts 2 và ứng dụng quản lý chất lượng dịch vụ home phone.doc

Similar to Struts 2 và ứng dụng quản lý chất lượng dịch vụ home phone.doc (20)

More from Dịch Vụ Viết Bài Trọn Gói ZALO 0917193864

More from Dịch Vụ Viết Bài Trọn Gói ZALO 0917193864 (20)

Recently uploaded

Recently uploaded (20)

Struts 2 và ứng dụng quản lý chất lượng dịch vụ home phone.doc