(HoaND)giaotrinhjsp 20140318

Lập trình JSP, Servlet Trang 1 / 164
Mục lục
MỤC LỤC
CHƢƠNG I: Bắ t đầ u vớ i Java Server Page (JSP)................................................................................ 5
1. Giới thiệu về Java Server Page và Servlet.................................................................................... 5
1.1. Java Server Page là gì ?.......................................................................................................... 5
1.2. Biên dịch trang JSP ................................................................................................................ 6
1.3. Kịch bản (Script) .................................................................................................................... 6
2. Cài đặt Apache Tomcat................................................................................................................. 7
2.1. Cài đặt Java Runtime Environment (JRE) ............................................................................. 7
2.2. Cài đặt Apache Tomcat.......................................................................................................... 7
3. Tạo project Web application với Netbeans................................................................................. 14
3.1. Cấu hình Tomcat vào Netbeans ........................................................................................... 14
3.2. Tạo ứng dụng Web đầu tiên với Netbeans........................................................................... 19
4. Giới thiệu về Twitter Bootstrap .................................................................................................. 23
4.1. Twitter Bootstrap là gì.......................................................................................................... 23
4.2. Tại sao lại dùng Bootstrap.................................................................................................... 24
4.3. Tạo giao diện đơn giản với Bootstrap.................................................................................. 24
4.4. Tạo trang chủ cho toàn bộ ví dụ trong giáo trình................................................................. 26
CHƢƠNG II: Tổng quan về HTTP, Servlet và JSP........................................................................... 30
1. Cơ bản về HTTP Request/Response........................................................................................... 30
1.1. HTTP Request...................................................................................................................... 31
1.2. HTTP Response.................................................................................................................... 32
2. Giới thiệu về Servlet/JSP............................................................................................................ 34
2.1. Servlet là gì ?........................................................................................................................ 35
2.2. Vòng đời của Servlet............................................................................................................ 35
2.3. JSP và vòng đời của JSP ...................................................................................................... 36
2.4. Các thành phần của JSP ....................................................................................................... 37
2.5. Thiết kế ứng dụng web theo mô hình MVC......................................................................... 40
CHƢƠNG III: Xây dựng Web động với JSP..................................................................................... 44
1. Quy trình xây dựng và triển khai ứng dụng Web với JSP .......................................................... 44
1.1. Tạo mới Web application project với Netbeans................................................................... 44

Mục lục
1.2. Tạo mới trang login.jsp ........................................................................................................ 44
1.3. Tạo mới trang welcome.jsp.................................................................................................. 46
1.4. Khai báo Servlet................................................................................................................... 47
1.5. Khai bá o cấ u hình web.xml.................................................................................................. 50
1.6. Triể n khai ƣ́ ng dụ ng lên Tomcat .......................................................................................... 50
2. Sử dụng các thành phần JSP directive........................................................................................ 51
3. Sử dụng Template text trong JSP................................................................................................ 53
4. Sử dụng các thành phần JSP action (JSTL)................................................................................ 53
CHƢƠNG IV: JavaBeans trong JSP .................................................................................................. 58
1. JavaBeans là gì ?......................................................................................................................... 58
1.1. Khái niệm............................................................................................................................. 58
1.2. Các quy ƣớc của Bean.......................................................................................................... 58
2. Khai báo, khởi tạo và thao tác với các đối tƣợng bean trong JSP .............................................. 58
2.1. Các JSP element dùng cho bean........................................................................................... 58
2.2. Phƣơng pháp chuyển kiểu tự động của JSP với JavaBeans ................................................. 59
3. Introspector trong JSP................................................................................................................. 60
4. Phạm vi hoạt động của JavaBeans.............................................................................................. 61
4.1. Application........................................................................................................................... 61
4.2. Session.................................................................................................................................. 62
4.3. Pages..................................................................................................................................... 63
4.4. Request................................................................................................................................. 64
CHƢƠNG V: Xử lý nhập-xuất trong JSP .......................................................................................... 67
1. Thao tác với dữ liệu từ đối tƣợng Request.................................................................................. 67
1.1. Sử dụng JSTL lấy dữ liệu từ đối tƣợng Request.................................................................. 69
1.2. Truy cập dữ liệu khác của đối tƣợng Request...................................................................... 75
1.3. Sử dụng Javabeans lƣu giữ giá trị đối tƣợng Request.......................................................... 79
2. Kiểm tra xác thực dữ liệu đầu vào (Input).................................................................................. 81
2.1. Sử dụng JSTL....................................................................................................................... 81
2.2. Sử dụng Javabeans ............................................................................................................... 87
3. Định dạng dữ liệu đầu ra (Output).............................................................................................. 91
CHƢƠNG VI: Chia sẻ dữ liệu giữa các trang JSP, Request và giữa các ngƣời dùng ....................... 94
1. Trao đổi điều khiển và dữ liệu giữa các trang............................................................................. 94

Mục lục
1.1. Chuyển quyền điều khiển từ một trang JSP tới trang JSP khác........................................... 95
1.2. Trao đổi dữ liệu từ một trang JSP tới trang JSP khác .......................................................... 97
1.3. Kết hợp chuyển quyền điều khiển và trao đổi dữ liệu giữa các trang.................................. 98
2. Chia sẻ dữ liệu Session và Application..................................................................................... 101
2.1. Theo vết Session................................................................................................................. 101
2.2. Đếm số lƣợt ghé thăm trang............................................................................................... 104
2.3. URL Rewrite ...................................................................................................................... 105
CHƢƠNG VII: Làm việc với Cookies và Database ........................................................................ 110
1. Cookies là gì?............................................................................................................................ 110
1.1. Khái niệm........................................................................................................................... 110
1.2. Vòng đời của cookie........................................................................................................... 110
2. Thao tác với cơ sở dữ liệu (Database) ...................................................................................... 112
2.1. Truy cập cơ sở dữ liệu từ trang JSP ................................................................................... 112
2.2. Sử dụng Transactions......................................................................................................... 129
CHƢƠNG VIII: Khai báo và sử dụng thƣ viện Custom Tag........................................................... 133
1. Thƣ viện Custom Tag là gì ....................................................................................................... 133
2. Cài đặt thƣ viện Custom Tag .................................................................................................... 134
3. Sử dụng thƣ viện Custom Tag .................................................................................................. 135
4. Sử dụng Action trong thƣ viện Custom Tag............................................................................. 139
4.1. Thiết lập giá trị cho thuộc tính của Custom action ............................................................ 140
4.2. Lựa chọn bean hay Custom action ..................................................................................... 140
CHƢƠNG IX: Điều quản lỗi và gỡ rối ............................................................................................ 142
1. Phân biệt các loại lỗi cú pháp ................................................................................................... 142
1.1. Các lỗi cú pháp................................................................................................................... 142
1.2. Lỗi cú pháp của JSTL EL................................................................................................... 147
2. Gỡ rối cho ứng dụng JSP.......................................................................................................... 151
3. Phân biệt các loại lỗi thực thi (Runtime error) ......................................................................... 156
3.1. Bắt ngoại lệ......................................................................................................................... 160
PHỤ LỤC I: Tài nguyên và tài liệu tham khảo................................................................................ 164

Phân bổ chƣơng trình
PHÂN BỔ CHƢƠNG TRÌNH
BUỔI NỘI DUNG
STT Lý thuyết Thực hành
1 Bắt đầu với JSP
2 Lab01
3 Tổng quan về JSP
4 Lab02
5 Xây dựng Web động với JSP
6 Lab03
7 JavaBeans trong JSP
8 Lab04
9 Xử lý nhập – xuất trong JSP
10 Lab05
11 Chia sẻ dữ liệu giữa các trang, Request
12 Lab06
13 Làm việc với Cookies, Database
14 Lab07
15 Làm việc với Cookies, Database
16 Lab08
17 Thƣ viện Custom Tag
18 Lab09
19 Điều quản lỗi và gỡ rối
20 Thi kết thúc môn học

Chƣơng I: Bắ t đầ u vớ i Java Server Page (JSP)
CHƢƠNG I: Bắ t đầ u vớ i Java Server Page (JSP)
Java 2 Enterprise Edition (J2EE) có 1 mục đích to lớn là xây dựng và mở rộng nền
tảng Internet rộng lớn ; là nền tảng giúp cho những lập trình viên có thể sử dụng Java để
phát triển ứng dụng Web đa tầng và ứng dụng phía máy chủ. Ngày nay, Java Enterprise API
đƣợc mở rộng để phù hợp với các lĩnh vực nhƣ: RMI và CORBA cho việc quản lý các đối
tƣợng từ xa ; JDBC cho việc tƣơng tác với Database ; Enterprise JavaBeans để tạo các thành
phần business có tính tái sử dụng cao ; JAXP cho việc xử lý XML, … Thêm nữa, J2EE cũng
hỗ trợ Servlet một công nghệ phổ biến tuyệt vời thay thế cho ngôn ngữ kịch bản CGI. Việc
kết hợp những công nghệ này cho phép lập trình viên để tạo các giải pháp kinh doanh trên
nền tảng phân tán đảm nhiệm các nghiệp vụ phức tạp khác nhau.
Sau năm 1999, Sun Microsystems tăng cƣờng thêm sức mạnh cho nền tảng Java
Enterprise khi cho ra đời công nghệ Java Server Page (JSP). JSP đƣợc xây dựng trên tầng
Servlet và hƣớng tới việc tăng hiệu quả cho lập trình viên và cả những ngƣời ít hiểu biết về
lập trình có thể dễ dàng tạo ra ứng dụng Web.
1. Giới thiệu về Java Server Page và Servlet
1.1. Java Server Page là gì ?
Java Server Page là công nghệ hỗ trợ và cho phép xây dựng nền tảng Web động.
Không nhƣ những trang HTML thuần với nội dung tĩnh luôn hiển thị giống nhau, một trang
JSP có thể thay đổi nội dung tùy thuộc vào các tham số khác nhau nhƣ định danh ngƣời
dùng, loại trình duyệt ngƣời dùng, các thông tin do ngƣời dùng cung cấp, …
JSP còn đƣợc gọi là kịch bản trình chủ (Server script) đƣợc chạy trên nền JDK 1.3 trở
lên và ứng dụng Web Server để quản lý chúng. Web Server đƣợc sử dụng phổ biến hiện nay
nhƣ Apache Tomcat, Java Web Server, JRUN, Glassfish, WebLogic, …
Mục tiêu:
Sau khi kết thúc chƣơng này, bạn có thể:
 Nắm bắt đƣợc ý nghĩa của công nghệ JSP và Servlet
 Tự cài đặt đƣợc trình chủ Web Tomcat
 Sử dụng công cụ hỗ trợ lập trình Netbeans để tạo, triển khai dự án Web bằng
JSP
 Làm quen với công nghệ Twitter Bootstrap phục vụ cho việc thiết kế giao
diện Web chuyên nghiệp, hiệu quả

1.2. Biên dịch trang JSP
Khi ngƣời sử dụng gọi trang JSP lần đầu tiên, Web Server sẽ triệu gọi trình biên dịch
JSP (là JDK) thành tập tin *.java, sau đó tập tin Java (Servlet) sẽ đƣợc biên dịch thành tập
tin *.class. Sau đó tập tin *.class sẽ đƣợc Web Server thực thi và trả kết quả lại cho ngƣời
dùng. Sơ đồ tóm tắt nhƣ sau:
1.3. Kịch bản (Script)
Nội dung của JSP có thể khai báo cùng với với HTML, bạn có thể sử dụng cặp dấu
<%= %> để khai báo mã JSP. Chẳng hạn, chúng ta khai báo:
<br>
Họ tên sinh viên: <%=strStudentName %>
Ngày sinh: <%=strBirthDate %>

Giới tính: <%=strGender %>
Trong trƣờng hợp có nhiều khai báo, bạn có thể sử dụng Scriptlet <% %> với các
khai báo JSP giống hệt cú pháp Java nhƣ sau:
<%
int i=0;
String str=”Select * from TABLE”;
out.println(str);
%>
2. Cài đặt Apache Tomcat
Apache Tomcat (Tomcat) là một Application Server miễn phí đƣợc phát triển bởi
Apache Software Foundation, Tomcat giúp thực thi các ứng dụng viết bằng Java Servlet và
JSP.
Trong toàn bộ giáo trình này, chúng ta sẽ sử dụng phiên bản Tomcat 7.0 cho phần cài
đặt phía Server và cả môi trƣờng phát triển ứng dụng Web trên Netbeans.
2.1. Cài đặt Java Runtime Environment (JRE)
Tomcat yêu cầu trên máy bạn phải có phiên bản JRE (Java Runtime Environment) đã
đƣợc cài đặt sẵn, nên trƣớc khi bắt đầu bạn hãy kiểm tra xem máy tính của bạn đã có phiên
bản JRE nào chƣa. Bạn vào Command Dos sau đó gõ dòng lệnh sau:
java –version
Nếu có kết quả sau hiện ra thì chứng tỏ máy tính của bạn đã có phiên bản JRE đƣợc
cài đặt, nhƣ hình minh họa dƣới thì phiên bản JRE đó là 1.7.0_45.
Nếu không có thông báo trên bạn có thể vào link sau
http://www.oracle.com/technetwork/java/javase/downloads/index.html để download JRE,
phiên bản mới nhất.
2.2. Cài đặt Apache Tomcat

Sau khi hoàn tất bƣớc kiểm tra JRE, bạn vào đƣờng link sau
https://tomcat.apache.org/download-70.cgi để download Tomcat phiên bản 7.0. Bạn chọn
download bộ Windows Services Installer.
Sau khi download hoàn tất, mở file *.exe và nhấn Next để bắt đầu quá trình cài đặt.
Bạn chọn I Agree để tiếp tục.

Ở màn hình tiếp theo bạn chọn chế độ cài đặt mặc định (Normal) sau đó nhấn Next để
tiếp tục.

Ở bƣớc tiếp theo bạn thiết lập cổng (port, mặc định là 8080) cho Tomcat, và
password để đăng nhập vào phần quản lý Tomcat sau khi hoàn tất cài đặt. Tôi chọn
username / password là admin / admin.
Bƣớc tiếp theo bạn chọn đƣờng dẫn tới thƣ mục cài đặt JRE, mặc định sẽ là
C:Program FilesJavajre7. Sau đó bạn nhấn Next để tiếp tục.

Bạn chọn thƣ mục để chƣa các file cài đặt Tomcat, mặc định là C:Program
FilesApache Software FoundationTomcat 7.0. Sau đó nhấn Next để tiếp tục.
Màn hình tiếp theo thông báo quá trình cài đặt đang diễn ra.

Sau khi vạch chạy trên màn hình cài đặt hiển thị hết, bạn đƣợc chuyển tới màn hình
cuối cùng. Tại đây bạn nhấn chọn Run Apache Tomcat (để khởi động ngay Tomcat server
sau khi quá trình cài đặt hoàn tất), và nhấn Finish để kết thúc.
Sau khi bạn nhấn Finish, 1 màn hình hiện nên thông báo server Tomcat đang đƣợc
khởi động lên.

Sau khi server Tomcat đƣợc khởi động, bạn sẽ thấy có biểu tƣợng sau trên thanh hệ
thống (system tray).
Biểu tƣợng này thông báo server Tomcat đang ở trạng thái hoạt động, để kiểm tra bạn
vào trình duyệt Firefox và truy cập tới http://localhost:8080.
Màn hình trên hiện ra thông báo Tomcat đã đƣợc cài đặt thành công, để xem thêm
thông tin về server Tomcat, bạn nhấn vào link Server Status ở thanh menu bên trái của màn
hình này và nhập vào username / password đã thiết lập ở bƣớc trên (admin / admin).
Màn hình Server status hiện ra cung cấp cho bạn những thông tin tổng quan về môi
trƣờng cài đặt Tomcat, bạn có thể thấy:
 Phiên bản của Tomcat server.
 Phiên bản của JVM JRE (Java Virtual Machine Java Runtime Environment).
 Hệ điều hành của máy chủ.

3. Tạo project Web application với Netbeans
3.1. Cấu hình Tomcat vào Netbeans
Sau khi cài đặt Tomcat thành công ở bƣớc trƣớc, ta sẽ cấu hình để Netbeans sẽ sử
dụng Tomcat Server cho các ứng dụng Web về sau.
Chọn Tools trên thanh menu, sau đó chọn mục Servers nhƣ hình dƣới
Danh sách các cấu hình Server sẽ đƣợc hiển thị, để thêm cấu hình mới cho Tomcat,
bạn chọn nút bấm Add Server.

Chọn loại Server và đặt tên cho nó, ở đây bạn nhập Apache Tomcat 7.
Ấn Next, để tiếp tục cấu hình.

Cung cấp đƣờng dẫn tới vị trí Tomcat Server đƣợc cài đặt ở bƣớc trƣớc, và cung cấp
thông tin tài khoản quản trị server admin/admin. Và ấn Finish, cấu hình mới cho Server sẽ
xuất hiện ở phía bên trái cửa sổ hiện tại. Ta có thể đặt giá trị khác 8080 cho Server Tomcat
port, ví dụ hình vẽ là cổng 8085.

Ấn Close, bây giờ Tomcat 7 có thể sử dụng (Start, Stop, Deploy, …) từ trong
Netbeans. Mở cửa sổ Services (Window > Services) và sử dụng

Cửa sổ Tomcat output xuất hiện trong Netbeans nhƣ sau
Sau vài giây, Tomcat sẽ đƣợc chạy, trang chủ sẽ hiển thị trên trình duyệt với địa chỉ
http://server:port nhƣ sau

3.2. Tạo ứng dụng Web đầu tiên với Netbeans
Sau khi khởi động xong Netbeans, ta tiến hành tạo Web application project lần lƣợt
theo các bƣớc trình tự nhƣ sau:
Mở menu File > New Project > Java Web > Web application nhƣ hình dƣới

Ấn Next, cửa sổ mới mở ra với tên Project mặc định, ta đổi tên Project thành
JspWebApplication, và ấn Next.
Cửa sổ mới mở ra với các thông tin cấu hình đƣợc thiết lập, ta chọn Apache Tomcat
trong mục Server và Java EE 6 Web cho mục Java EE Version. Ấn Finish

Cửa sổ chính hiện lên và tạo sẵn đoạn code mẫu trong file index.jsp trong thƣ mục
Web Pages dƣới project JspWebApplication nhƣ hình sau
Bây giờ thay đổi một chút đoạn code mẫu ở trên: thay đổi tiêu đề thành “JSP Web
Page” và thay đổi phần heading thành “Welcome To The JSP Web World!” nhƣ sau

Tiếp theo, ta chạy ứng dụng với Tomcat Server. Mở cửa sổ Services, và chọn Apache
Tomcat, chọn RUN nhƣ sau

Trên trình duyệt sẽ hiển thị thông tin trên trang index.jsp ở trên nhƣ sau
Vậy là hoàn tất một project mẫu xây dựng ứng dụng Web sử dụng JSP.
4. Giới thiệu về Twitter Bootstrap
4.1. Twitter Bootstrap là gì

Twitter Bootstrap bao gồm các mã CSS và HTML cơ bản cho Grids, Layouts,
Typography, Tables, Forms, Navigation, Alerts, .. và nhiều thành phần khác của website. Đi
kèm với hàng loạt plugin jquery để tạo ra các thành phần giao diện nhƣ Transitions, Modal,
Dropdown, Scrollspy, Tooltip, Tab, Alert, Button, Collapse, Carousel, ...
Style của các phần tử HTML trong Twitter Bootstrap khá đơn giản và thanh lịch. Ví
dụ nhƣ phần đổ bóng trong input, highlight của bảng biểu, các mã CSS hiển thị cảnh báo,
tabs, phân trang…
4.2. Tại sao lại dùng Bootstrap
Bootstrap giúp chúng ta giảm thiểu thời gian thiết kết html và css.
Bootstrap định nghĩa sẵn các class css công việc của chúng ta chỉ là sử dụng các class
đó vào mục đích của mình.
Bootstrap còn hổ trợ Responsive design một cách làm giao diện đa thiết bị rất đƣợc
ƣu chuộng trong thời gian gần đây.
Các lý do trên khiến cho Bootstrap sẽ rất hữu dụng trong các bài học của chúng ta.
Thêm nữa sẽ biến các bài mẫu, ví dụ trở nên sinh động, đẹp hơn; cũng giúp các bạn có thêm
công cụ hỗ trợ tuyệt vời để xây dựng các ứng dụng web.
4.3. Tạo giao diện đơn giản với Bootstrap
Bootstrap tải về tại đây: http://twitter.github.io/bootstrap/
Sau khi tải về, ta sẽ có một file Zip và sau khi tiến hành giải nén ta có một thƣ mục có
tên bootstrap, bên trong có 3 thƣ mục: css, img, js. Nội dung các file, thƣ mục chứa trong đó
nhƣ sau
.
| - Css
| | - Bootstrap.css
| | - Bootstrap.min.css
| | - Bootstrap-responsive.css
| `- Bootstrap-responsive.min.css
| - Img
| | - Glyphicons-halflings.png
| `- Glyphicons-Halflings-white.png
`- Js
| - Bootstrap.js
`- Bootstrap.min.js

Chúng ta tạo 1 file html có tên là index.html ở trong thƣ mục bootstrap vừa giải nén
phía trên. Khai báo phần Head để sử dụng Bootstrap đơn giản nhƣ sau
Ta viết tiếp phần body với 2 textbox và 2 button nhƣ sau:
Vậy là hoàn thành ví dụ đơn giản với Bootstrap, mở file index.html trên trình duyệt,
ta sẽ thấy

Khi thu nhỏ trình duyệt ta sẽ thấy giao diện sẽ đƣợc co giãn tự động và hiển thị nhƣ
sau
Vậy ta đã có một giao diện đơn giản và rất chuyên nghiệp trong khi không cần bận
tâm nhiều tới việc thiết kế HTML, cắt CSS lâu nay vẫn làm.
4.4. Tạo trang chủ cho toàn bộ ví dụ trong giáo trình
Ta sẽ sử dụng kiến thức về Bootstrap để xây dựng giao diện chuyên nghiệp, nhanh
chóng, hỗ trợ việc tra cứu các ví dụ đƣợc sử dụng trong toàn bộ giáo trình.
Giao diện hiển thị nhƣ sau

Nhƣ ta đã biết khả năng responsive design của Bootstrap đáp ứng việc hiển thị trên
các thiết bị có kích thƣớc, độ phân giải khác nhau mà không cần ta phải thay đổi bất cứ dòng
mã chƣơng trình nào. Ta xem giao diện sẽ hiển thị trên màn hình với kích thƣớc nhỏ nhƣ sau

Tóm tắt bài học
Nhƣ vậy, ta đã đi hết chƣơng I để tìm hiểu về ứng dụng Web, tìm hiểu về công nghệ
JSP và Servlet.

Ta cũng đã biết cách cài đặt trình chủ Web, nơi mà các ứng dụng Web xây dựng bằng
JSP sẽ đƣợc triển khai. Nó thật sự không phải là khó với bạn đúng không nào.
Một lời khuyên là sử dụng Netbeans để phát triển ứng dụng Web của bạn. Đây là
công cụ tuyệt vời để phát triển, tích hợp, gỡ rối và đã đƣợc cộng đồng rộng lớn yêu thích.
Ta cũng đã đƣợc giới thiệu về công nghệ mới thiết kế Web chuyên nghiệp, hiệu quả
trên nhiều nền tảng thiết bị, trình duyệt khác nhau là Twitter Bootstrap. Đây chính là điều
mới mẻ, tôi mang tới cho các bạn; hãy bỏ qua mối lo lắng, băn khoăn của bạn về việc xây
dựng ứng dụng Web với chức năng tốt đã khó, thiết kế hoàn hảo còn khó hơn.
Vậy là đủ trang bị kiến thức, ta bắt tay vào bài học về JSP và Servlet.
Bài tập
 Tự cài đặt môi trƣơng phát triển ứng dụng Web với JSP
o Cài đặt JRE
o Cài đặt Apache Tomcate
o Cài đặt Netbeans
 Tạo project ứng dụng Web với JSP sử dụng công cụ Netbeans
 Cài đặt Twitter Bootstrap vào project vừa tạo
 Sử dụng Bootstrap để xây dựng giao diện cho trang chủ tham khảo ví dụ sau
http://getbootstrap.com/2.3.2/examples/justified-nav.html
 Run project trên Netbeans để kiểm tra giao diện vừa xây dựng

Chƣơng II: Tổng quan về HTTP, Servlet và JSP
CHƢƠNG II: Tổng quan về HTTP, Servlet và JSP
1. Cơ bản về HTTP Request/Response
Hypertext Transfer Protocol (HTTP) là một giao thức không trạng thái (stateless) nằm
ở tầng ứng dụng, đảm nhiệm việc giao tiếp giữa các hệ thống phân tán với nhau, và là nền
tảng của web.
Ngƣời dùng gửi một yêu cầu tới Server thông qua việc click vào link trên trang web
hoặc submit form hoặc nhập thông tin địa chỉ trang web trên thanh địa chỉ của trình duyệt,
… Để gửi đƣợc Request, trình duyệt cần biết Server cần phải nói chuyện và tài nguyên cần
đƣợc yêu cầu. Thông tin này chính là HTTP Uniform Resource Locator (URL).
URL là một cấu trúc đơn giản thƣờng bao gồm:
 Protocol: http hoặc https
 Host: tên miền server
 Port: mặc định là 80
 Resource path: đƣờng dẫn tới resource trên server
 Query: tham số truy vấn
Mục tiêu:
 Hiểu đầy đủ về cách hoạt động, thành phần cấu tạo của 2 đối tƣợng cơ bản
trong giao thức HTTP là HTTP Request và Response
 Hiểu về kiến trúc và vòng đời của JSP và Servlet
 Các cách thiết kế ứng dụng Web bằng công nghệ JSP theo mô hình MVC

HTTP cho phép giao tiếp giữa rất nhiều loại server/client với nhau, chủ yếu thông qua
TCP/IP. Cổng giao tiếp chuẩn là 80, tuy nhiên có thể dùng bất kỳ cổng khác nhƣ 8080 (mặc
định của Tomcat). Giao tiếp giữa client và server dựa vào một cặp request/response. Client
khởi tạo HTTP request và nhận HTTP response từ server gửi về.
HTTP request bao gồm hai thành phần quan trọng là URL và Verb (phƣơng thức),
đƣợc gửi từ client. Ở phía ngƣợc lại, server trả về HTTP response trong đó chứa Status code
và Message body.
1.1. HTTP Request
Mỗi request bắt đầu với một Request-Line. Dòng này chỉ ra phƣơng thức mà client
yêu cầu, tài nguyên, và phiên bản của HTTP mà client có thể hỗ trợ. Request-Line có thể có
tiếp sau một hay nhiều header và một message body.
GET / HTTP/1.1
Accept: */*
Accept-Language: en-us
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)
Host: www.ft.com
Connection: Keep-Alive
a. Request-Line
Request-Line chứa ba mục phân biệt, đó là method, uri, và phiên bản HTTP, mỗi mục
đƣợc phân tách bởi một hay nhiều khoảng trống.
 Một số các phƣơng thức thƣờng dùng nhƣ:
 GET: đƣợc thiết kế để truy vấn dữ liệu, tài nguyên trên server, với các tham số và giá
trị nằm ngay trên URL.
 POST: đƣợc dùng trong các trƣờng hợp tạo ra sự thay đổi về dữ liệu, tài nguyên trên
server nhƣ upload một file hoặc submit một web form.

 PUT: đƣợc thiết kế để cập nhật dữ liệu, tài nguyên trên server.
 DELETE: đƣợc thiết kế để xóa dữ liệu, tài nguyên trên server.
 Ngoài ra còn có một số phƣơng thức khác ít đƣợc sử dụng nhƣ HEAD, TRACE,
OPTIONS.
 Request-uri
Cung cấp địa chỉ định danh tài nguyên cho một tài nguyên. Ví dụ, Request-uri là /,
chỉ ra một request cho tài nguyên gốc. Cho các request không yêu cầu một tài nguyên cụ thể
(nhƣ là TRACE request hay trong một số trƣờng hợp cả OPTIONS request), client có thể
dùng một dấu * cho Request-uri.
 Phiên bản HTTP
Nhƣ trong ví dụ, phiên bản HTTP là 1.1 chứa trong đoạn text HTTP/1.1.
b. Message header
Một message header có thể chứa các loại general header, request header, hoặc entity
header. General header áp dụng trong truyền dữ liệu; request header áp dụng cho các request
cụ thể, và entity header áp dụng cho message body trong request.
 Host: là hostname đƣợc sử dụng trong URL.
 User-Agent: chứa thông tin về loại trình duyệt, thiết bị tạo ra Request. Vì server có thể sẽ
trả về các Response khác nhau và phù hợp nhất dựa trên thông tin về loại trình duyệt
hoặc loại thiết bị đang đƣợc sử dụng.
 Accept: cung cấp thông tin về ngôn ngữ, định dạng file, … chỉ định loại Response đƣợc
trình duyệt mong đợi.
c. Message body
Một HTTP request luôn chứa một dòng trống sau Request-Line và bất kỳ header nào.
Nếu request bao gồm một message body, phần body đi sau một dòng trống. Dòng trống rất
quan trọng vì server xác định đƣợc phần kết của request, hoặc phần kết của header. Không
có dòng trống, server nhận các message sẽ không biết đƣợc các header khác nữa có tiếp tục
đƣợc truyền không.
Message body có thể chứa các thông tin về tham số nhƣ các giá trị đƣợc client thiết
lập trong form, hoặc trong chuỗi URL.
1.2. HTTP Response
Một HTTP response bắt đầu với một Status-Line và có thể chứa các header và một
message body. Header có thể mô tả quá trình truyền dữ liệu, xác định response, hoặc phần
body kèm theo. Dòng bắt đầu với phiên bản cao nhất của HTTP mà server hỗ trợ.
HTTP/1.1 200 OK
Date: Sun, 08 Oct 2000 18:46:12

GMT Server: Apache/1.3.6 (Unix)
Keep-Alive: timeout=5, max=120
Connection: Keep-Alive
Content-Type: text/html
<html>
<body>
<h1>Hello World!</h1>
</body>
</html>
HTTP Status-Line bắt đầu với chỉ báo HTTP, mã trạng thái, và một đoạn text mô tả
response. Hai mục còn lại trong Status-Line là Status-Code và Reason-Phrase. Status-Code
là một bộ ba kí tự chỉ báo kết quả của request.
a. Status code
Status code là thông tin quan trọng server trả về cho client, cho biết kết quả xử lý
request của server. Các loại status code thƣờng gặp:
Status code Mô tả
1xx Informational Message: Loại status code này đƣợc mô tả ở HTTP/1.1 và
hoàn toàn mang tính chất tạm thời, client có thể bỏ qua chúng.
2xx Successful: Server trả về status dạng này khi đã xử lý thành công request của
client. Đối với GET request, dữ liệu trả về nằm trong message body. Phổ biến
nhất là mã 200 OK. Ngoài ra còn có:
 202 Accepted: request từ client đã đƣợc chấp nhận nhƣng có thể server
không trả về kết quả cho client. Điều này hữu dụng trong trƣờng hợp xử lý
bất đồng bộ phía server: server thông báo cho client không phải tiếp tục
chờ đợi cho tới khi quá trình xử lý trên server hoàn tất.
 204 No content: không có phần message body trong response.
 205 Reset content: tƣơng tự nhƣ 204, nhƣng mã trả về này yêu cầu client
reset document view.
 206 Partial content: server chỉ gửi về một phần dữ liệu phụ thuộc và giá
trị range header client gửi lên. Giá trị này đƣợc sử dụng bởi các tool hỗ
trợ download nhƣ wget, IDM để phân mảnh dữ liệu thành nhiều phần
nhằm tải về đồng thời hoặc hỗ trợ tiếp tục download khi bị ngắt giữa
chừng.
3xx Redirection: Server thông báo cho client phải thực hiện thêm action để hoàn
thành request. Ngoài ra còn có:

 301 Moved Permanently: resource đã đƣợc chuyển hoàn toàn tới địa chỉ
trong trƣờng Location của response.
 303 See Other: resource đƣợc chuyển tạm thời tới địa chỉ trong trƣờng
Location của response.
 304 Not Modified: resource không thay đổi từ lần cuối cùng client gửi
request, và client nên sử dụng dữ liệu đã lƣu trong bộ nhớ cache. Điều này
đƣợc thực hiện bằng cách khi gửi request, client gửi đi trƣờng ETag là
định danh của phần dữ liệu đã request lần trƣớc, server so sánh với trƣờng
ETag ứng với dữ liệu của nó để kiểu tra sự thay đổi.
4xx Client error: Có lỗi đối với yêu cầu của client. Ngoài ra còn có:
 400 Bad Request: request không đúng định dạng, cú pháp.
 401 Unauthorized: client chƣa xác thực.
 403 Forbidden: client không có quyền truy cập.
 404 Not Found: không tìm thấy resource.
 405 Method Not Allowed: phƣơng thức (HTTP verb) không đƣợc server
hỗ trợ.
5xx Server error: Có lỗi xảy ra trong quá trình xử lý của server. Mã 500 Internal
Server Error là phổ biến nhất. Ngoài ra còn có:
 501 Not Implemented: server không hỗ trợ chức năng client yêu cầu.
 503 Service Unavailable: một thành phần xử lý trên server bị lỗi hoặc
server bị quá tải.
b. Last-Modified
Cung cấp thông tin về thời gian lần cuối cùng thông tin tài nguyên từ Server đƣợc
thay đổi. Dựa vào thông tin này, trình duyệt có thể so sánh với thời gian trong local cache
của mình để yêu cầu Server gửi về các thông tin cập nhật mới nhất so với lần yêu cầu cuối.
c. Content-Type
Cung cấp thông tin về loại dữ liệu phản hồi chứa trong phần body.
d. Content-Length
Cung cấp thông tin kích thƣớc phần header.
2. Giới thiệu về Servlet/JSP
Vai trò của Servlet và JSP đƣợc thể hiện trong kiến trúc J2EE ở hình dƣới

2.1. Servlet là gì ?
Java servlet là những chƣơng trình độc lập platform và nhỏ chạy ở phía server đƣợc
lập trình để mở rộng chức năng của web server. Nghĩa là ta có thể nhúng logic của ứng dụng
riêng vào việc xử lý các HTTP request và tạo HTTP response.
Một servlet đƣợc thực thi động trên máy chủ và cho phép mở rộng thêm chức năng
cho máy chủ này nhƣ: xử lý/lƣu dữ liệu gởi từ mẫu HTML (HTML form), cung cấp dữ liệu
động qua việc lấy thông tin thông qua kết nối với cơ sở dữ liệu, thực hiện giao dịch thƣơng
mại điện tử ...
JSP đƣợc xây dựng hoàn toàn trên nền tảng Servlet. Trong thực tế, JSP luôn đƣợc sử
dụng kết hợp với Servlet để tạo ra các ứng dụng Web.
Một servlet là một chƣơng trình Java, cụ thể hơn, nó là một thể hiện của một lớp, lớp
này thực thi (implements) Interface javax.servlet.Servlet. Interface Servlet thừa kế (extends)
từ 2 Interface javax.servlet.GenericServlet, javax.servlet.http.HttpServlet.
2.2. Vòng đời của Servlet
Servlet đƣợc quản lý bởi Servlet Container. Container sẽ đón nhận các Request từ
trình duyệt khách, sau đó sẽ phân phối tới ứng dụng Web phù hợp. Dựa vào tham số trong
Request, Container sẽ biết để kích hoạt các Servlet tƣơng ứng dựa vào các thông tin cấu hình
của ứng dụng đã đƣợc đăng ký. Container sẽ khởi tạo Servlet và quản lý vòng đời hoạt động
của Servlet. Vòng đời của Servlet gồm 6 trạng thái nhƣ sau

 Tạo ra: web container tạo một thực thể servlet
 Sẵn sàng phục vụ: gọi method init() của servlet
 Phục vụ: nếu có một request thì container sẽ gọi method service() của servlet.
 Huỷ: container gọi method destroy() của servlet.
 Không sẵn sàng: thực thể đƣợc đánh dấu cho garbage collection.
Khi servlet ở trạng thái Phục vụ, hàm service() của servlet sẽ nhận 2 đối tƣợng
Request, Reponse truyền tới. Dựa vào đối tƣợng Request đƣợc gửi đến phƣơng thức HTTP
phù hợp và phân bổ (dispatch) truy vấn này đến phƣơng thức xử lý tƣơng ứng của servlet,
thông qua các khai báo phƣơng thức doXXX của các servlet.
Các phƣơng thức Servlet doPost(), doGet(), doHead(), doDelete(), doHead(),
doOptions(), doPut(), doTrace() lần lƣợt tƣơng ứng với các phƣơng thức HTTP POST,
GET, HEAD, DELETE, HEAD, OPTIONS, PUT, TRACE.
protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
protected void doHead(HttpServletRequest req, HttpServletResponse resp)
protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
protected void doPut(HttpServletRequest req, HttpServletResponse resp)
2.3. JSP và vòng đời của JSP

Nhƣ ta đã biết, việc tạo nội dung html trả lời trong servlet bằng cách dùng các lệnh
out.println() là một việc tốn nhiều công sức, đặc biệt khi nội dung html trả lời càng phức tạp.
Việc này còn tệ hơn khi ta muốn bảo trì hay thay đổi nội dung trả lời. JSP đem lại một giải
pháp tiện lợi hơn khi cho phép chèn nội dung động vào trang web, nó còn cho phép việc tách
bạch phần trình bày và logic xử lý nội dung. Với servlet thì ta chèn mã html để phát sinh
trong lớp java còn JSP thì ngƣợc lại, ta chèn mã java trong trang html.
Sau khi trang jsp đƣợc dịch (translate) và đƣợc biên dịch (compile) thành các servlet,
thì vòng đời của jsp này có vòng đời nhƣ của servlet.
 Nếu trong bộ chứa chƣa có một hiện thể (instance) nào của servlet của trang jsp thì bộ
chứa sẽ:
 Tải lớp servlet của trang jsp
 Tạo một hiện thể của lớp servlet này
 Khởi tạo hiện thể của lớp này bằng cách gọi hàm jspInit.
 Bộ chứa gọi hàm _jspService, và truyền vào tham số là hai đối tƣợng Request và
Response. Nếu bộ chứa muốn loại bỏ servlet của trang jsp này, nó sẽ gọi hàm
jspDestroy.
2.4. Các thành phần của JSP
a. Chỉ thị JSP (JSP directives)
Chỉ thị JSP có dạng sau:
<%@ directive attribute=value ...%>
Ví dụ:
<%@page contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"
import="java.util.List, java.util.Date"
language="java" %>
<%@ page import="java.io.IOException" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ include file="../includes/header.jspf"%>
Hoặc đối với JSP 2.0, ta còn thêm các cách khai báo khác nhƣ sau
<jsp:include page="../includes/header.jspf" />
Cách sử dụng khai báo JSTL

<c:import url="../includes/header.jspf" />
Hai cách này tuy đƣa lại kết quả nhƣ nhau nhƣng chúng có sự khác biệt cơ bản sau:
 Chỉ thị include <%@ include ...%> sẽ gộp tập tin khi trang jsp đƣợc chuyển thành
servlet. Nếu tập tin đƣợc include ít thay đổi thì ta nên dùng phƣơng pháp này vì nó sẽ
nhanh hơn về mặt hiệu năng vì chỉ thực hiện 1 lần đầu tiên.
 Hành động include <jsp:include ... /> sẽ thêm tập tin phát sinh vào trang jsp sau khi
trang đƣợc thực thi. Ta nên dùng chọn lựa này nếu nội dung tập tin đƣợc include hay
thay đổi.
b. Sử dụng thẻ đặc biệt để chèn các khai báo Java vào trong trang JSP
 Thẻ khai báo (declaration): cho phép thêm trực tiếp mã vào lớp servlet, định nghĩa
các biến toàn cục hay khai báo các phƣơng thức. Trong ví dụ sau, ta ghi đè hai hàm
jspInit và jspDestroy trong thẻ khai báo này.
<%! ResourceBundle rb;
public void jspInit() {
rb = ResourceBundle.getBundle("messages");
}%>
Hoặc có thể thay thế bằng đoạn mã sau
<jsp:declaration>
ResourceBundle rb;
public void jspInit() {
rb = ResourceBundle.getBundle("messages");
}
</jsp:declaration>
 Thẻ scriptlet: đƣợc dùng để chèn mã vào phƣơng thức _jspService() của servlet. Nói
chung là thành phần đƣợc sử dụng để chèn mã Java ngoại trừ các biến toàn cục và
phƣơng thức.
<%
session.setAttribute("user", null);
String sucessPath = rb.getString("process.logoff");
%>
<jsp:scriptlet>

session.setAttribute("user", null);
String sucessPath = rb.getString("process.logoff");
</jsp:scriptlet>
 Thẻ biểu thức (expression): dùng để hiển thị kết quả của một biểu thức. Biểu thức
này sẽ đƣợc chuyển làm tham số của một gọi hàm out.print() bên trong phƣơng thức
_jspService()
<title><%=rb.getString("logoff.title")%></title>
<title><jsp:expression>rb.getString("logoff.title")</jsp:expression></title>
c. Các biến ngầm định
Trong một trang jsp ta có thể sử dụng các biến khai báo sẵn sau:
 request: đối tƣợng javax.servlet.http.HttpServletRequest
 response: đối tƣợng javax.servlet.http.HttpServletResponse
 out: đối tƣợng javax.servlet.jsp.JspWriter
 session: đối tƣợng javax.servlet.http.HttpSession
 application: đối tƣợng javax.servlet.ServletContext
 config: đối tƣợng avax.servlet.ServletConfig
 pageContext: đối tƣợng javax.servlet.jsp.PageContext
 page: là servlet
d. Các hành động của JSP (JSP actions)
 jsp:include: chỉ định cho trình biên dịch gộp tập tin vào trang
<jsp:include page="../includes/header.jspf" />
 <jsp:param>: có thể đƣợc sử dụng trong jsp:include, jsp:forward, jsp:params. Nhằm
xác định một thông số gởi kèm
 <jsp:forward>: chuyển truy vấn sang một servlet hay trang jsp khác.
<jsp:forward page="<%=sucessPath%>" />
 <jsp:plugin>: thực thi hay hiển thị một đối tƣợng, đối tƣợng này có thể là một applet
hay bean. Trong trả lời dƣới dạng HTML, thì thẻ này đƣợc chuyển thành thẻ <object>
hay <embed>
 <jsp:fallback>: nội dung hiển thị nếu phía khách không hỗ trợ applet, dùng kèm với
<jsp:plugin>
 <jsp:getProperty>: lấy giá trị một thuộc tính của một JavaBean.
<jsp:getProperty property="username" name="userBean" />

 <jsp:setProperty>: gán giá trị cho một thuộc tính của một JavaBean.
<jsp:setProperty property="*" name="userBean" />
 <jsp:useBean>: khởi tạo hay tái sử dụng một JavaBean đã tồn tại để dùng trong
trang.
<jsp:useBean id="userBean" class="com.openspace.UserService" scope="session" />
2.5. Thiết kế ứng dụng web theo mô hình MVC
Kể từ khi ra đời công nghệ JSP và Servlet, có hai mô hình chính của Phƣơng pháp
thiết kế MVC trong Java là MVC model 1 và MVC model 2.
a. Sơ đồ của MVC model 1
Trong MVC model 1, các trang JSP đóng vai trò hiển thị (View) và điều khiển
(Controller). Có thể có nhiều trang JSP khác nhau đóng các vai trò khác nhau.
 Khi ngƣời sử dụng dùng các nút bấm, menu hoặc link … trên trình duyệt Web (Web
browser) để thực hiện một thao tác, một lệnh (có thể kèm theo các tham số) đƣợc gửi
tới một trang JSP tƣơng ứng.
 Trang JSP này sẽ khởi tạo một hoặc nhiều JavaBeans (nếu cần thiết), truyền các lệnh
cần thi hành tới JavaBeans.
 Sau khi JavaBeans thực hiện xong việc truy xuất hoặc cập nhật dữ liệu, trang JSP ban
đầu có thể hiển thị dữ liệu lấy từ Beans (JSP ban đầu đóng luôn vai trò View), hoặc
chọn một trang JSP khác để hiện dữ liệu từ Beans (JSP ban đầu đóng luôn vai trò
Controller). Trong một thiết kế tốt, để bảo đảm việc tách rời phần trình bày và logic
của chƣơng trình, trang JSP nhận request chỉ đóng vai trò Điều khiển (Controller).
MVC model 1 có một nhƣợc điểm là phần logic điều khiển đƣợc viết trong trang
JSP, nhƣ vậy phần chƣơng trình Java phức tạp dùng để điều khiển sẽ bị lẫn vào trong mã
HTML dùng để trình bày. Độ phức tạp của chƣơng trình càng cao, thì trang JSP càng khó
bảo trì. Hơn nữa trong các dự án phần mềm phức tạp, thì phẩn hiển thị của trang JSP thƣờng

đƣợc làm bởi ngƣời thiết kế Web, giỏi về HTML và đồ họa, còn phần chƣơng trình Java
đƣợc viết bởi lập trình viên chuyên về lập trình. Trong các dự án phức tạp, dùng JSP làm
phần điều khiển sẽ làm lẫn lộn việc phân chia ranh giới trách nhiệm giữa nhóm thiết kế đồ
họa và nhóm lập trình, đôi khi dẫn đến việc bảo trì và phát triển trở nên rất khó khăn, gần
nhƣ không thể làm đƣợc.
Để khắc phục nhƣợc điểm này, MVC model 2 ra đời.
b. Sơ đồ của MVC model 2
Trong MVC model 2, một hoặc nhiều servlet (thƣờng là một) đóng vai trò điều khiển,
các JavaBeans đóng vai trò mô hình và các trang JSP đóng vai trò hiển thị.
Trong model 2, các logic phức tạp của chƣơng trình đƣợc viết hoàn toàn trong các
servlet, là các chƣơng trình Java. Phần hiển thị chỉ gồm các trang JSP với một vài mã đơn
giản để lấy dữ liệu có sẵn, không có logic phức tạp, vì thế hoàn toàn có thể đƣợc tạo ra bằng
những ngƣời thiết kế Web.
Các yêu cầu của ngƣời dùng đƣợc gửi từ trình duyệt Web tới servlet. Servlet sẽ khởi
tạo JavaBeans (nếu cần thiết), ra lệnh thu thập, cập nhật thông tin. Khi JavaBeans hoàn
thành công việc, servlet sẽ chọn trang JSP thích hợp để hiển thị thông tin trong JavaBeans
cho ngƣời dùng.
Đây chính là một cách sử dụng MVC rất hiệu quả trong Java. Tất nhiên là sử dụng
MVC model 2 một cách hoàn toàn cứng nhắc, phần điều khiển chỉ dùng servlet, phần hiển
thị chỉ dùng JSP sẽ dẫn đến một vài trƣờng hợp kém hiệu quả, nhất là khi có các request từ
trình duyệt Web chỉ đòi hỏi việc hiển thị thông tin.
c. Ƣu điểm MVC
 Phát triển phần mềm: Có tính chuyên nghiệp hóa, có thể chia cho nhiều nhóm đƣợc
đào tạo nhiều kỹ năng khác nhau, từ thiết kế mỹ thuật cho đến lập trình đến tổ chức
database.
 Bảo trì: Với các lớp đƣợc phân chia theo nhƣ đã nói, thì các thành phần của một hệ
thống dễ đƣợc thay đổi, nhƣng sự thay đổi có thể đƣợc cô lập trong từng lớp, hoặc chỉ

ảnh hƣởng đến lớp ngay gần kề của nó, chứ không phát tán náo loạn trong cả chƣơng
trình.
 Mở rộng: Với các lớp đƣợc chia theo ba lớp nhƣ đã nói, việc thêm chức năng vào cho
từng lớp sẽ dễ dàng hơn là phân chia theo cách khác.
 Tiện về bug lỗi, kiểm soát code, workflow dễ dàng hơn và nhiều ngƣời có thể tham
gia phát triển cùng trên 1 module.
d. Nhƣợc điểm MVC:
 Đối với dự án nhỏ: Cồng kềnh, tốn thời gian phát triển.
 Trade-off là performance, do tốn thời gian trung chuyển DTO (Data Transfer Object)
giữa các layers
HTTP request bao gồm hai thành phần quan trọng là URL và Verb (phƣơng thức),
đƣợc gửi từ client. Ở phía ngƣợc lại, server trả về HTTP response trong đó chứa Status code
và Message body.
JSP đƣợc xây dựng hoàn toàn trên nền tảng Servlet. Trong thực tế, JSP luôn đƣợc sử
dụng kết hợp với Servlet để tạo ra các ứng dụng Web.
Một servlet là một chƣơng trình Java, cụ thể hơn, nó là một thể hiện của một lớp, lớp
này thực thi Interface javax.servlet.Servlet. Interface Servlet thừa kế (extends) từ 2 Interface
javax.servlet.GenericServlet, javax.servlet.http.HttpServlet.
Vòng đời của Servlet gồm 6 trạng thái nhƣ sau
 Tạo ra: web container tạo một thực thể servlet
 Sẵn sàng phục vụ: gọi method init() của servlet
 Phục vụ: nếu có một request thì container sẽ gọi method service() của servlet.
 Huỷ: container gọi method destroy() của servlet.
 Không sẵn sàng: thực thể đƣợc đánh dấu cho garbage collection.
Trong MVC model 1, các trang JSP đóng vai trò hiển thị (View) và điều khiển
(Controller).
Trong MVC model 2, một hoặc nhiều servlet (thƣờng là một) đóng vai trò điều khiển,
các JavaBeans đóng vai trò mô hình và các trang JSP đóng vai trò hiển thị.
Trong model 2, các logic phức tạp của chƣơng trình đƣợc viết hoàn toàn trong các
servlet, là các chƣơng trình Java. Phần hiển thị chỉ gồm các trang JSP với một vài mã đơn
giản để lấy dữ liệu có sẵn, không có logic phức tạp, vì thế hoàn toàn có thể đƣợc tạo ra bằng
những ngƣời thiết kế Web.

Bài tập
Sử dụng các khai báo Scriptlet để thực hiện các yêu cầu sau
1. Tính toán tổng các giá trị của dãy số liên tiếp từ 1 đến 99 và hiển thị kết quả lên trang
Web
2. Hiển thị thời gian, ngày tháng hiện tại của hệ thống lên trang Web
3. Hiển thị số lƣợng các phần tử của mảng 1 chiều kiểu double và chuyển đổi giá trị của
các phần tử về kiểu String và hiển thị chúng
4. Hiển thị giá trị các phần từ của mảng 2 chiều kích thƣớc 3x4 kiểu double (giá trị bạn
tự khởi tạo)
5. Hiển thị kết quả thực hiện việc nối 2 chuỗi
6. Chuyển đổi chuỗi String sang mảng các phần tử kiểu char và hiển thị danh sách các
phần tử của mảng
7. Hãy xây dựng hàm thay thế chuỗi khai báo nhƣ sau
public String replaceString(String strSource,String oldStr,String newStr)
Hàm sẽ thay thế chuỗi oldStr trong chuỗi strSource bởi các chuỗi newStr. Kiểm tra
kết quả thực thi hàm ở trên và hiển thị kết quả đạt đƣợc

Chƣơng III: Xây dựng Web động với JSP
CHƢƠNG III: Xây dựng Web động với JSP
1. Quy trình xây dựng và triển khai ứng dụng Web với JSP
1.1. Tạo mới Web application project với Netbeans
Tạo mới Web application project đặt tên “JspWebApplication” theo hƣớng dẫn của
phần trƣớc.
Giải nén 3 thƣ mục css, js, image của Twitter Bootstrap theo hƣớng dẫn của phần
trƣớc và đặt cùng thƣ mục với WEB-INF và META-INF.
Tạo mới file đặt tên design-global.css chứa các style chỉnh sửa của các class Twitter
Bootstrap và đặt trong thƣ mục css, nhập nội dung sau vào file
@import url("bootstrap.min.css");
Tạo mới thƣ mục và đặt tên pages để chứa các trang JSP.
1.2. Tạo mới trang login.jsp
Tạo mới thƣ mục ch3 nằm trong thƣ mục pages và tạo mới file login.jsp. Chọn chuột
phải vào thƣ mục ch3, chọn New > JSP nhƣ sau
Mục tiêu:
 Nắm vững đầy đủ một quy trình xây dựng một ứng dụng Web với JSP bằng
Netbeans, cho tới việc triển khai ứng dụng ra bên ngoài qua việc cài đặt ứng
dụng tới trình chủ Web cụ thể nhƣ Tomcat
 Hiểu rõ các vấn đề về JSP directive, template text và gói thƣ viện JSTL

Cửa sổ mới mở ra, ta điền tên file login vào mục File Name, ấn Finish.
Cửa sổ lập trình mở ra với nội dung mặc định sẵn cho trang login.jsp. Ta sửa lại nội
dung cho trang login.jsp nhƣ sau:
 Khai báo sử dụng Bootstrap: thêm đƣờng dẫn tới file *.css và *.js
 Tạo mới 1 form, đặt tên là loginForm, sƣ̉ dụ ng phƣơng thƣ́ c POST và gọi servlet xử
lý thông qua khai báo ${pageContext.request.contextPath}/checkLogin (action tên là
checkLogin sẽ đƣợc khai báo trong file cấu hình web.xml, khai bá o
${pageContext.request.contextPath} sẽ giúp lấy về URL gốc của ứng dụng – ta sẽ tìm
hiể u về khai bá o nà y ở phầ n sau)

 Trong form khai bá o 2 trƣờ ng có name là username và password (name sẽ giú p
servlet lấy đƣợc giá trị client gửi lên thông qua đối tƣợng Request ). Trong ví dụ , ta sƣ̉
dụng sẵn việc validate form của Bootstrap để kiểm tra email
 Khi ngƣờ i dù ng nhậ p đú ng username và password (admin@designglobal.edu.vn-
admin), ngƣờ i dù ng sẽ đƣợ c chuyể n tớ i trang welcome .jsp ; nế u không đú ng , ngƣờ i
dùng sẽ đƣợc yêu cầu nhập lại thông tin
Mở trình duyệt và gõ URL để xem kết quả
http://localhost:8084/JspWebApplication/pages/ch3/login.jsp
1.3. Tạo mới trang welcome.jsp

Tạo mới trang welcome.jsp để trả về kết quả hành động đăng nhập ở trên. Khi thông
tin ngƣời dùng, mật khẩu nhập vào trang login.jsp khớp sẽ chuyển ngƣời dùng tới trang
welcome.jsp. Trang sẽ hiển thị thông tin tên ngƣời dùng nhƣ sau
1.4. Khai báo Servlet
Tạo mới package và đặt tên vn.edu.designglobal.ch3 nhƣ sau

Tạo mới servlet và đặt tên Login nhƣ sau

Cửa sổ mới sẽ hiển thị nội dung đƣợc sinh sẵn cho file Login.java. Ta chỉnh sửa lại
nội dung file này nhƣ sau:
 Thêm mớ i 2 biế n url_success và url_fail để chuyển hƣớng ngƣời dùng sang trang phù
hợ p khi đã kiể m tra thông tin username, password
 Thêm mới hàm getUser, init
 Chỉnh sửa lại hàm processRequest: kiể m tra thông tin username , password; nế u khớ p
sẽ trả về chuỗi DesignGlobal hoặc trả về chuỗi trắng và đặt vào đối tƣợng Request (sẽ
đƣợ c lấ y ra trong file welcome.jsp ; hàm sẽ chuyển hƣớng ngƣời dùng tới trang tƣơng
ứng
Khi ngƣờ i dù ng nhậ p đú ng thông tin , sẽ đƣợc chuyển tới trang hiển thị kết quả nhƣ
bên dƣớ i

1.5. Khai bá o cấ u hình web.xml
Khai bá o cấ u hình web.xml là bƣớc cuối cùng để ứng dụng có thể hoạt động theo
đú ng mong muố n và là bƣớ c quan trọ ng nhấ t trong ƣ́ ng dụ ng Web viế t bằ ng JSP.
 Khai bá o action tên checkLogin để chuyển yêu cầ u xƣ̉ lý củ a Form tớ i đú ng servlet
Login.java trong mụ c <servlet-mapping>
 Tên servlet sẽ đƣợ c so khớ p trong mụ c <servlet> để tìm tới servlet xử lý tƣơng ứng
1.6. Triể n khai ƣ́ ng dụ ng lên Tomcat
Sƣ̉ dụ ng công cụ Deploy của Netbeans để tạo ra file *.war nhƣ sau
 Chuộ t phả i và o tên Web application và chọ n Deploy , Netbeans sẽ tạo ra file
JspWebApplication.war trong thƣ mụ c dist của project

 Copy file JspWebApplication.war vào thƣ mục webapps tƣơng ƣ́ ng củ a Tom cat (ví
dụ C:Program FilesApache Software FoundationTomcat 7.0webapps)
Vậ y là ta đã hiể u toàn bộ các bƣớc phát triển 1 ứng dụng web với JSP từ bƣớc tạo
project tớ i triể n khai project lên môi trƣờ ng Web Server (Apache Tomcat 7.0).
2. Sử dụng các thành phần JSP directive
Có 3 loại JSP directive là page, include và taglib. Trong chƣơng 2, ta cũ ng đã đề cậ p
tớ i cá c directive nà y ; ở chƣơng này, ta sẽ tậ p trung nó i về cá c thuộ c tính củ a cá c khai bá o
này.
a. Page
Trang JSP đƣợ c bắ t đầ u bở i khai bá o page directive để xá c định loạ i nộ i dung củ a
trang. Tên các thuộc tính và giá trị của chúng có phân biệt chữ hoa, chữ thƣờng ; giá trị
thuộc tính phải đƣợc đặt trong cặp dấu nháy đơn hoặc nháy kép.
<@page contentType="text/html" %>

Giá trị mặc định (khi không khai báo) cho thuộc tính contentType là “text/html”. Bên
cạnh đó còn có các giá trị khác nhƣ text/plain, text/xml, text/vnd.wap.xml đƣợc sử dụng
trong các môi trƣờng phù hợp.
Một số thuộc tính khác nhƣ errorPage, isErrorPage, session, pageEncoding, buffer
và autoFlush.
 import: kết quả là câu lệnh import của Java đƣợc chèn vào trong tập tin.
 contentType: Chỉ định nội dụng của tập tin đƣợc khởi tạo. Chúng ta nên dùng chỉ
phối này nếu chúng ta không dùng HTML, hoặc bộ ký tự (character set) đƣợc dùng
không phải là bộ ký tự mặc định.
 errorPage: Chỉ định rằng trang web sẽ đƣợc hiển thị nếu có một ngoại lệ (exception)
xảy ra trong quá trình xử lý yêu cầu HTTP.
 isErrorPage: Nếu định giá trị là true thì nó nói rằng trang này là trang báo lỗi (error
page).
 isThreadSafe: Chỉ định cho biết servlet tạo ra có tính an toàn về luồng xử lý
(threadsafe) hay không.
<%@ page import="java.util.*" %> //example import
<%@ page contentType="text/html" %> //example contentType
<%@ page isErrorPage=false %> //example for non error page
<%@ page isThreadSafe=true %> //example for a thread safe JSP
b. Include
Khai báo sẽ thông báo cho bộ biên dịch JSP cho nhập toàn bộ nội dung của một tập
tin vào trong nội dung hiện có.
JSP cho phép chia trang thành nhiều phần (fragment) và sau đó sử dụng khai báo
include để gộp chúng lại. Lợi ích lớn mang lại là tính tái sử dụng cao, làm gọn các đoạn mã
chƣơng trình.
<%@ include file="header.htmlf" %>
c. Taglib
Khai báo taglib cho phép sử dụng thƣ viện thẻ mở rộng hỗ trợ bên cạnh thƣ viện thẻ
của JSP.
Thuộc tính uri chứa chuỗi để định danh duy nhất thƣ viện thẻ mở rộng. Thuộc tính
prefix định nghĩa tên rút gọn của thƣ viện thẻ này đƣợc gọi khi sử dụng tập thẻ mở rộng.
d. Comment

Chuỗi ký tự đặt trong cặp thẻ <%-- và --%>, JSP sẽ xem là comment cho chƣơng
trình và sẽ không đƣợc đƣa vào trong quá trình biên dịch trang.
<%-- Calculate the sum of 1 + 2 + 3 dynamically --%>
3. Sử dụng Template text trong JSP
Bên cạnh các thành phần JSP, trong trang JSP còn có các thành phần theo chuẩn
HTML gọi là Template text. Các khai báo thuộc về Template text, JSP sẽ để nguyên trong
quá trình biên dịch và sẽ gửi về trình khách trong phản hồi của nó.
<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>JSP is Easy</title>
</head>
<body bgcolor="white">
<h1>JSP is as easy as ...</h1>
1 + 2 + 3 =<c:out value="${1 + 2 + 3}" />
</body>
</html>
4. Sử dụng các thành phần JSP action (JSTL)
Các JSP action chính là thành phần mang lại tính động cho các ứng dụng Web động.
Các action đƣợc thực thi khi trang JSP đƣợc yêu cầu. Action có thể đƣợc sử dụng để ghi ra
file trên server, gửi email hoặc lấy dữ liệu từ database, …
<%@ page contentType="text/html" %>
<html>
<head>
<title>JSP is Easy</title>
</head>
<h1>JSP is as easy as ...</h1>
1 + 2 + 3 = <c:out value="${1 + 2 + 3}" />
</body>

</html>
Cú pháp chính khai báo một action nhƣ sau
<prefix:action_name attr1="value1" attr2="value2">
action_body
</prefix:action_name>
Action đƣợc khai báo giống nhƣ một thành phần HTML. Nếu action có phần body,
khai báo sẽ có thẻ mở chƣa các cặp attribute=”value”, tiếp đến là body, kết thúc là thẻ đóng.
Body có thể là dạng text hoặc chứa các khai báo action khác.
Khi action không có body, khai báo có thể đƣợc rút gọn nhƣ sau
<prefix:action_name attr1="value1" attr2="value2" />
Các action hoặc thẻ (tags) có thể đƣợc nhóm vào các thƣ viện (tag libraries). Khi
muốn sử dụng các tag libraries, ta sẽ sử dụng khai báo taglib với tên định danh rút gọn nhƣ
sau
<%@ taglib prefix="c"uri="http://java.sun.com/jsp/jstl/core" %>
...
<c:out value="${1 + 2 + 3}" />
Action có thể chia vào 3 nhóm chính là standard, custom và JSP Standard Tag
Library (JSTL).
a. Standard actions
Mặc định trong trang JSP ta có thể sử dụng các standard actions mà không cần khai
báo, chúng có tiền tố là “jsp:”
 <jsp:include>: Tƣơng tự nhƣ mục đích sử dụng một thủ tục con (subroutine), Java
servlet tạm thời trao nhiệm vụ đặt yêu cầu và hồi âm cho trang JavaServer
(JavaServer Page) chỉ định nào đấy. Quyền khống chế sẽ đƣợc hoàn lại cho trang JSP
hiện tại, một khi trang JSP kia hoàn thành nhiệm vụ của nó. Dùng phƣơng pháp này,
mã trang JSP đƣợc chia sẻ với nhiều trang JSP, thay vì phải sao mã.
 <jsp:include>: mã trang JSP đƣợc chia sẻ với nhiều trang JSP, thay vì phải copy mã
 <jsp:param>: Có thể đƣợc dùng bên trong khối jsp:include, khối <jsp:forward> hoặc
khối <jsp:params>. Nó đƣợc dùng để xác định một thông số, và thông số này sẽ đƣợc
cộng thêm vào chuỗi các thông số hiện có của yêu cầu.
 <jsp:forward>: Đƣợc dùng để trao nhiệm vụ đặt yêu cầu và hồi âm sang cho một
trang JSP khác, hoặc cho một servlet khác. Quyền khống chế sẽ đƣợc hoàn trả lại cho
trang JSP hiện tại.

 <jsp:plugin>: Những phiên bản cũ của Netscape Navigator và Internet Explorer dùng
những thẻ khác để nhúng một chƣơng trình nhỏ (applet). Hành động này tạo nên thẻ
thuộc trình duyệt web cần thiết để bao gồm một chƣơng trình nhỏ.
 <jsp:fallback>: Phần nội dung sẽ đƣợc hiển thị nếu trình duyệt web không hỗ trợ
chƣơng trình nhỏ (applets).
 <jsp:getProperty>: get of property của một JavaBean chỉ định.
 <jsp:setProperty>: set Property value sở hữu của một JavaBean chỉ định.
 <jsp:useBean>: Kiến tạo hoặc dùng lại một JavaBean, là cái có thể dùng đƣợc trong
trang JSP.
b. Custom actions
Đặc tả JSP định nghĩa tập các lớp Java cho phép ngƣời lập trình tạo ra các action mới
sử dụng lại cho các dự án.
c. JSTL
Thƣ viện thẻ của JSTL đƣợc chia làm 4 loại nhƣ sau:
 Core (c): Chứa các hành động cơ bản nhƣ if, forEach….
 Formatting (fmt): Định dạng và quốc tế hóa
 SQL (sql): Truy xuất CSDL
 XML (x): Phân tích và đọc dữ liệu từ XML
Bảng tập hợp Tag Core action
<c:catch> Catch những exception xảy ra trong code body
<c:choose> Chọn 1 trong nhiều đoạn mã để thi hành khi thỏa mãn điều kiện nào đó
<c:forEach> Vòng lặp quét hết tập hợp nào đó
<c:forToken> Vòng lặp quét hết 1 chuỗi nào đó theo chuỗi phân cách
<c:if> Thi hành đoạn code khi thỏa mãn điều kiện
<c:import> Import một URL nào đó
<c:otherwise> Xác định giá trị mặc định cho <c:choose>
<c:out> Gửi output cho JspWriter hiện hành
<c:param> Xác định 1 tham số URL cho <c:import> hay <c:url>
<c:redirect> Điều hƣớng request sang URL mới
<c:remove> Xóa 1 đối tƣợng trong 1 scope nào đó

<c:set> Tạo 1 đối tƣợng trong 1 scope nào đó
<c:url> Tạo 1 URL
<c:when> Khai báo điều kiện trong <c:choose>
Bảng tập hợp Tag của Format action
<fmt:bundle> Xác định resoure bundle cho các messge đi kèm trong thẻ
fmt:bundle
<fmt:setBundle> Xác định resoure bundle và gán vào 1 biến để dùng sau này
<fmt:formatDate> Định dạng ngày theo 1 vùng địa lý nào đó
<fmt:formatNumber> Định dạng số theo 1 vùng địa lý nào đó
<fmt:message> Truy xuất vào 1 message trong bundle
Ta đã đƣợc giới thiệu và hƣớng dẫn các bƣớc làm cụ thể để phát triển một ứng dụng
Web sử dụng công nghệ JSP bằng công cụ Netbeans. Và tự triển khai ứng dụng lên trên trình
chủ Web nhƣ Tomcat.
Ta cũng đã đƣợc học về các thành phần của JSP nhƣ các directive, thẻ script,
scriptlet, các biến ngầm định.
Action có thể chia vào 3 nhóm chính là standard, custom và JSP Standard Tag
Library (JSTL).
 Standard action: Mặc định trong trang JSP ta có thể sử dụng các standard actions mà
không cần khai báo, chúng có tiền tố là “jsp:”
 Custom action: Đặc tả JSP định nghĩa tập các lớp Java cho phép ngƣời lập trình tạo ra
các action mới sử dụng lại cho các dự án.
 JSTL action: Thƣ viện thẻ của JSTL đƣợc chia làm 4 loại nhƣ sau:
o Core (c): Chứa các hành động cơ bản nhƣ if, forEach….
o Formatting (fmt): Định dạng và quốc tế hóa
o Formatting (fmt): Định dạng và quốc tế hóa
o XML (x): Phân tích và đọc dữ liệu từ XML
Bài tập

Tham khảo ví dụ trong mục 1 và trong mã nguồn project (xem ở Phụ Lục 1) để xây
dựng các ứng dụng nhƣ sau
1. Ứng dụng có trang login.jsp chứa 1 ô Text để nhập tên ngƣời dùng, sau khi Submit,
ngƣời dùng sẽ đƣợc chuyển hƣớng tới trang welcome.jsp hiển thị lời chào ngƣời dùng
2. Ứng dụng cho phép ngƣời dùng nhập thông tin userName/password tại trang user.jsp,
nếu thông tin khớp design/global thì chuyển hƣớng ngƣời dùng tới trang
introduce.jsp giới thiệu thông tin về Học viện Design Global; trái lại yêu cầu ngƣời
dùng nhập lại thông tin userName/password
3. Ứng dụng sẽ hiển thị danh sách 10 lớp học của Học viện Design Global trong file
list.jsp, mỗi lớp học hiển thị trên 1 dòng gồm các trƣờng: 1 checkbox, trƣờng ClassID
(tăng dần từ 0-9), trƣờng ClassName.
Ngƣời dùng sẽ lựa chọn các lớp trong cùng lĩnh vực của mình (thời trang, đồ họa, lập
trình) và sẽ Submit thông tin.
Ứng dụng sẽ chuyển hƣớng ngƣời dùng tới trang confirm.jsp hiển thị danh sách các
lớp học đã đƣợc chọn.

Chƣơng IV: Javabeans trong JSP
CHƢƠNG IV: JavaBeans trong JSP
1. JavaBeans là gì ?
1.1. Khái niệm
JavaBeans hay Bean, là một lớp Java đơn giản mà tên của các thành phần đƣợc
đặt theo qui ƣớc của các đặc tả cú pháp JavaBeans.
Giống nhƣ bất kỳ lớp Java nào, các thể hiện của bean đơn thuần là các đối tƣợng
Java. Ta có thể sử dụng trực tiếp qua mã Java để tham chiếu tới đối tƣợng, phƣơng thức của
bean hoặc có thể sử dụng Scriptlet.
1.2. Các quy ƣớc của Bean
Các quy tắc khi khai báo bean bao gồm:
 Tên lớp bean phải có tiếp vị ngữ Bean ở cuối nhƣ CustomerBean, StudentBean, …
 Bean phải có hàm khởi tạo không tham số
 Các thuộc tính của bean không nên khai báo public
 Giá trị các thuộc tính nên đƣợc truy cập thông qua các phƣơng thức getXXX, setXXX
 Đối với server-side, bean không nên sử dụng các thƣ viện đồ họa
2. Khai báo, khởi tạo và thao tác với các đối tượng bean trong JSP
2.1. Các JSP element dùng cho bean
a. jsp:useBean
Khai báo cho phép tải bean với tên chỉ định và thiết lập phạm vi sử dụng vào trang
JSP. Cú pháp
<jsp:useBean id=”beanName” scope=”value” typeSpec>
…
Mục tiêu:
 Nắm bắt đƣợc vai trò của JavaBeans đối với JSP và các quy ƣớc đi kèm
 Hiểu rõ các bƣớc khai báo, khởi tạo, sử dụng một đối tƣợng bean
 Nắm bắt cơ chế Introspector của công nghệ JSP
 Hiểu về phạm vi hoạt động của bean

</jsp:useBean>
 id: tham chiếu tới đối tƣợng bean sẽ đƣợc sử dụng trong trang JSP
 scope: là một trong các phạm vi nhƣ application, session, page, request (đề cập trong
phần sau)
 typeSpec: có thể là một trong các khai báo sau
o class=‟className‟
o class=‟className‟ type=‟typeName‟
o beanName=‟beanName‟ type=‟typeName‟
o type=‟typeName‟
b. jsp:setProperty
Gán giá trị cho thuộc tính của bean. Cú pháp
<jsp:setProperty name=”beanName” options />
 options: có thể là một trong các khai báo sau
o property=‟propertyName‟
o property=‟propertyName‟ param=‟paramName‟
o property=‟propertyName‟ value=‟{<%= expression %> | String}‟
c. jsp:getProperty
Lấy giá trị của thuộc tính bean. Cú pháp
<jsp:getProperty name=‟beanName‟ property=‟propertyName‟ />
2.2. Phƣơng pháp chuyển kiểu tự động của JSP với JavaBeans
Các thuộc tính của một thành phần JSP không giới hạn giá trị chuỗi. Và các giá trị
thuộc tính đƣợc lấy thông qua thẻ <jsp:getProperty> sẽ đƣợc chuyển đổi thành kiểu chuỗi.
Tuy nhiên các phƣơng thức getXXX trong bean không cần trả về kiểu String vì JSP
Container đã tự động tiến hành việc chuyển kiểu. Đối với các kiểu dữ liệu cơ bản của Java,
sự chuyển đổi đƣợc thể hiện trong bảng sau:
Property Type Conversion to String
boolean java.lang.Boolean.toString(boolean)
byte java.lang.Byte.toString(byte)
char java.lang.Character.toString(char)
int java.lang.Integer.toString(int)
float java.lang.Float.toString(float)

double java.lang.Double.toString(double)
long java.lang.Long.toString(long)
Tƣơng tự, tất cả các phƣơng thức setter của thuộc tính đƣợc truy cập với thẻ
<jsp:setProperty> sẽ đƣợc tự động chuyển từ String sang một kiểu gốc thích hợp bởi JSP
Container. Sự chuyển đổi này đƣợc thể hiện trong bảng sau:
Property Type Conversion to String
boolean or Boolean Java.lang.Boolean.valueOf(String)
byte or Byte Java.lang.Byte.valueOf(String)
char or Character Java.lang.Character.valueOf(String)
int or Integer Java.lang.Integer.valueOf(String)
float or Float Java.lang.Float.valueOf(String)
double or Double Java.lang.Double.valueOf(String)
long or Long Java.lang.Long.valueOf(String)
3. Introspector trong JSP
a. Introspector là gì ?
Introspector là bộ phận phân tích hỗ trợ Java trong việc tìm ra từng phƣơng thức đƣợc
áp dụng cho từng thuộc tính và tình huống cụ thể từ đoạn mã chƣơng trình.
public void setAge(int iAge)
public int getAge()
Dựa vào đó, Java sẽ biết chƣơng trình muốn tạo ra thuộc tính age kiểu int.
b. Thiết kế các phƣơng thức mẫu dùng cho thuộc tính
Đối với thuộc tính mang giá trị đơn, hai phƣơng thức getter/setter phải đƣợc khai báo
nhƣ sau
public void setAttributeName (AttributeType param)
public AttributeType getAttributeName()
Đối với thuộc tính kiểu boolean, phƣơng thức getter/setter sẽ dùng tiếp đầu ngữ is
thay cho get.
public void setAttributeName (boolean param)
public boolean isAttributeName()

Đối với thuộc tính là kiểu tập hợp, ta có thể sử dụng cả 2 cặp khai báo sau
public void setAttributeName (AttributeType param)
public AttributeType getAttributeName()
public void setAttributeName (AttributeType[] param)
public AttributeType[] getAttributeName()
c. Khai báo các phƣơng thức tƣờng minh
Nếu không muốn sử dụng ngầm định của Introspector, ta có thể khai báo tƣờng minh
thông qua việc tạo lớp phụ và thực thi BeanInfo Interface. Khi bean có tên là xxx đƣợc biên
dịch thì Bean Container sẽ tìm đến lớp có tên là xxxBeanInfo; khi này các phƣơng thức đƣợc
tìm thấy sẽ đƣợc ƣu tiên áp dụng, trái lại Introspector sẽ sử dụng ngầm định.
4. Phạm vi hoạt động của JavaBeans
4.1. Application
 Đối tƣợng bean với phạm vi ứng dụng có vòng đời hoạt động cùng với ứng dụng.
 Đối tƣợng này đƣợc giải phóng khi môi trƣờng thực thi tạo mới đối tƣợng
ServletContext.
 Đối tƣợng beans với phạm vi ứng dụng đƣợc sử dụng khi cần chia sẻ thông tin giữa
JSP và servlet trong suốt vòng đời của ứng dụng.
 Phạm vi ứng dụng đƣợc thông dịch với hằng số
PageContext.APPLICATION_SCOPE
 Đối tƣợng đƣợc gắn với javax.servlet.ServletContext
 Đây là phạm vi hoạt động cao nhất.
 Đối tƣợng này đƣợc lƣu trong đối tƣợng ServletContext sử dụng phƣơng thức
setAttribute(String key, Object value)
 Các trình duyệt khách truy cập cùng tới một đối tƣợng trong vòng đời ứng dụng
Ví dụ:
Trang thứ nhất
<HTML>. . .
<%@ page language = "java" %>
<%@ page import = "Counter" %>
<jsp:useBean id = "id_counter" scope = "application"
class = "Counter" />

<H1> An Application bean: The First Example </H1>
<B>The current count for the counter bean is: </B>
<%= id_counter.getCount() %>
. . . </HTML>
Trang thứ hai
<HTML> . . .
<jsp:useBean id = "id_counter" scope = "application"
<H1> An Application bean: The Second Example </H1>
. . . </HTML>
Cả hai trang này sử dụng đối tƣợng bean Counter giống nhau. Mỗi trang sẽ tăng giá
trị đếm lên 1. Việc chia sẽ này sẽ kết thúc khi JSP engine bị ngừng hoạt động.
4.2. Session
 Các bean có phạm vi session đƣợc truy cập trong trang thuộc cùng session đó.
 Bean không thể tạo ra đƣợc khi trang sử dụng thuộc tính session=false.
 Tham chiếu tới bean có phạm vi session đƣợc lƣu trữ trong đối tƣợng session.
 Phạm vi session đƣợc thông dịch với hằng PageContext.SESSION_SCOPE.
 Đối tƣợng bean này đƣợc gắn vào đối tƣợng javax.servlet.jsp.PageContext.
 Sever sử dụng phƣơng thức của đối tƣợng HttpSession là setAttribute(String key,
Object value) để lƣu trữ giá trị.
 Các đối tƣợng bean là khác nhau với mỗi session.
Ví dụ:
Trang thứ nhất
<HTML> . . .
<jsp:useBean id = "id_counter" scope = "session"

<H1> A Session bean: The First Example </H1>
. . . </HTML>
Trang thứ hai
<HTML> . . .
<jsp:useBean id = "id_counter" scope = "session"
<H1> A Session bean: The Second Example </H1>
. . . </HTML>
Khi bạn duyệt trang JSP thứ nhất lần đầu, biến đếm là 1. Khi ban duyệt trang JSP thƣ
2 với cùng trình duyệt web, biến đếm sẽ tăng giá trị hiện có của trang thứ nhất lên 1 đơn vị.
Nếu một thể hiện mới của trình duyệt web đƣợc mở, biến đếm hiện tại sẽ đƣợc thiết
lập lại (phiên mới).
4.3. Pages
 Bean sẽ trong trang hiện hành.
 Tham chiếu tới bean sẽ giải phóng sau khi đối tƣợng response đƣợc gởi cho client.
 Các bean với phạm vi trang đƣợc lƣu trữ trong pageContext.
 Đƣợc biên dịch bằng: PageContext.PAGE_SCOPE
 Sau khi kết thúc hàm Servlet.service() hiện hành thì các bean bị giải phóng.
o Bean đƣợc tạo trong hàm service().
o Bean tồn tại cho mỗi client.
Ví dụ:
<HTML> . . .
<%@ page errorPage = "errorpage.jsp" %>
<jsp:useBean id = "id_counter" scope = "page"

<B> The current count for the
counter bean is: </B>
. . .</HTML>
4.4. Request
 Thể hiện bean sẽ tồn tại cùng với đối tƣợng request.
 Tham chiếu tới đối tƣợng này đƣợc giải phóng khi xử lý Request xong.
 Đối tƣợng này đƣợc lƣu trữ trong đối tƣợng request.
 Phạm vi request đƣợc thông dịch nhƣ là PageContext.REQUEST_SCOPE
 Đối tƣợng này đƣợc gắn với javax.servlet.jsp.PageContext
 Tham chiếu tới đối tƣợng sống cùng với đối tƣợng HttpRequest, thậm chí khi đối
tƣợng đƣợc gởi sang một trang khác.
 Đƣợc lƣu trong đối tƣợng Request giống nhƣ dùng phƣơng thức setAttribute(String
key, Object value).
Ví dụ:
Trang thứ nhất
<HTML>. . .
<jsp:useBean id = "id_counter" scope = "request"
<% id_counter.setCount(10); %>
<jsp:forward page = "RequestBean.jsp" />
. . .</HTML>
Trang thứ hai
<HTML> . . .
<jsp:useBean id = "id_counter" scope = "request"
<B> The current count for the

counter bean is: </B>
. . . </HTML>
JavaBeans hay Bean, là một lớp Java đơn giản mà tên của các thành phần đƣợc đặt
theo qui ƣớc của các đặc tả cú pháp JavaBeans.
Giống nhƣ bất kỳ lớp Java nào, các thể hiện của bean đơn thuần là các đối tƣợng
Java. Ta có thể sử dụng trực tiếp qua mã Java để tham chiếu tới đối tƣợng, phƣơng thức của
bean hoặc có thể sử dụng Scriptlet.
 <jsp:useBean>: Khai báo cho phép tải bean với tên chỉ định và thiết lập phạm vi sử
dụng vào trang JSP.
 <jsp:setProperty>: Gán giá trị cho thuộc tính của bean
 <jsp:getProperty>: Lấy giá trị của thuộc tính bean
Các giá trị thuộc tính đƣợc lấy thông qua thẻ <jsp:getProperty> sẽ đƣợc chuyển đổi
thành kiểu chuỗi. Tuy nhiên các phƣơng thức getXXX trong bean không cần trả về kiểu
String vì JSP Container đã tự động tiến hành việc chuyển kiểu.
Introspector là bộ phận phân tích hỗ trợ Java trong việc tìm ra từng phƣơng thức đƣợc
áp dụng cho từng thuộc tính và tình huống cụ thể từ đoạn mã chƣơng trình.
Bean có thể có các phạm vi hoạt động sau: Application, Session, Page và Request.
Bài tập
1. Khai báo lớp JavaBeans mới đặt tên StudentBean:
Với các thuộc tính sau: FirstName, LastName, BirthDate, Identity, Email, Gender.
Khai báo các hàm getter, setter tƣơng ứng.
Tạo mới trang sample1.jsp, khai báo sử dụng đối tƣợng StudentBean ở trên có phạm
vi Session. Và thiết lập giá trị ban đầu cho các thuộc tính của đối tƣợng bean.
vi Session (id cùng tên) để hiển thị giá trị của các thuộc tính đối tƣợng bean.
vi Session (id cùng tên) và cập nhật lại giá trị của các thuộc tính đối tƣợng bean. Mở lại
trang sample2.jsp để xem kết quả sau khi cập nhật.

2. Khai báo lớp JavaBeans mới đặt tên ClassBean:
Với các thuộc tính sau: Name, Quantity và khai báo các hàm getter, setter tƣơng ứng.
Tạo mới trang sample4.jsp, khai báo sử dụng đối tƣợng ClassBean ở trên có phạm vi
Request. Và thiết lập giá trị ban đầu cho các thuộc tính của đối tƣợng bean.
Tạo mới trang sample5.jsp, khai báo sử dụng đối tƣợng ClassBean ở trên có phạm vi
Request (id cùng tên) để hiển thị giá trị của các thuộc tính đối tƣợng bean.
Quan sát kết quả hiển thị trên trang sample5.jsp và so sánh với kết quả trên trang
sample2.jsp.

Chƣơng V: Xử lý nhập-xuất trong JSP
CHƢƠNG V: Xử lý nhập-xuất trong JSP
1. Thao tác với dữ liệu từ đối tượng Request
HTML định nghĩa sẵn tập hợp các thành phần (thẻ) để biểu diễn các trƣờng thông tin
trong form cho phép ngƣời dùng nhập nội dung hoặc lựa chọn từ các giá trị đặt sẵn.
Ta cùng xem ví dụ phổ biến sử dụng form trong HTML nhƣ sau
<html>
<head>
<title>User Info Entry Form</title>
</head>
<form action="process.jsp" method="post">
<table>
<tr>
<td>Name:</td>
<td>
<input type="text" name="userName">
</td>
</tr>
<tr>
<td>Birth Date:</td>
<td>
<input type="text" name="birthDate">
</td>
Mục tiêu:
 Nắm bắt cách tƣơng tác với đối tƣợng Request trong JSP thông qua JSTL và
JavaBeans
 Hiểu về cách kiểm tra xác thực dữ liệu thông qua JSTL và JavaBeans

<td>(Use format yyyy-mm-dd)</td>
</tr>
<tr>
<td>Email Address:</td>
<td>
<input type="text" name="emailAddr">
</td>
<td>(Use format name@company.com)</td>
</tr>
<tr>
<td>Gender:</td>
<td>
<input type="radio" name="gender" value="m" checked>Male<br>
<input type="radio" name="gender" value="f">Female
</td>
</tr>
<tr>
<td>Lucky number:</td>
<td>
<input type="text" name="luckyNumber">
</td>
<td>(A number between 1 and 100)</td>
</tr>
<tr>
<td>Favorite Foods:</td>
<td>
<input type="checkbox" name="food" value="z">Pizza<br>
<input type="checkbox" name="food" value="p">Pasta<br>
<input type="checkbox" name="food" value="c">Chinese
</td>
</tr>
<tr>
<td colspan=2>
<input type="submit" value="Send Data">
</td>
</tr>

</table>
</form>
</body>
</html>
Form là ví dụ cho một trang cho ngƣời dùng đăng ký nhận tin tức mới trên website.
Form yêu cầu ngƣời dùng nhập vào các thông tin nhƣ ngày sinh, giới tính, món ăn yêu thích,
cùng với họ tên và email để đăng ký.
Thẻ <form> bao ngoài cùng, thuộc tính action chƣa URI tới tài nguyên server
(process.jsp - xử lý yêu cầu từ client), thuộc tính method khai báo rằng client sẽ dùng
phƣơng thức HTTP POST để yêu cầu.
Trong thẻ <form> đặt các khai báo <input> cho phép ngƣời dùng nhập và lựa chọn
các thông tin của mình. Để hoàn tất, ngƣời dùng sẽ click vào nút Submit để gửi các thông tin
vừa nhập lên server thông qua đối tƣợng Request.
Đối tƣợng Request sẽ chứa các cặp khai báo attribute-value, với attribute là các thuộc
tính name của các thẻ HTML cho phép ngƣời dùng nhập, lựa chọn ở trên và value chính là
các giá trị đƣợc ngƣời dùng nhập, lựa chọn.
Đó chính là cách mà trình duyệt xử lý với dữ liệu trong thẻ <form> để hoàn tất việc
gửi dữ liệu ngƣời dùng cần trao đổi lên server.
Để tìm hiểu kỹ hơn về đối tƣợng Request, tài liệu sẽ đề cập ở chƣơng sau. Trong
chƣơng này, ta sẽ cùng xem việc xử lý những dữ liệu này trên server thông qua JSTL tiến
hành cụ thể ra sao.
1.1. Sử dụng JSTL lấy dữ liệu từ đối tƣợng Request
Trong ví dụ, ta có sử dụng thƣ viện bên ngoài http://java.sun.com/jsp/jstl/core, đối
với phiên bản JSP 1.2 trở đi có sự thay đổi nhỏ với việc gọi thƣ viện. Ta sẽ cần download
thƣ viện JSTL 1.2 tại http://download.java.net/maven/1/jstl/jars/jstl-1.2.jar và include vào
project để có thể sử dụng nhƣ sau

 Chọn chuột phải vào mục Libraries và chọn Add JAR/Folder
 Tìm tới đƣờng dẫn chứa file vừa download, và add vào project
 Thay đổi uri="http://java.sun.com/jstl/core" bằng cách thêm jsp vào nhƣ sau
uri="http://java.sun.com/jsp/jstl/core"
Vậy mọi thứ đã sẵn sàng, ta sẽ xem xét ví dụ tƣơng tự, tạo trang input_jstl.jsp và khai
báo <form> với việc xử lý dữ liệu trao đổi client-server sẽ đƣợc đảm nhiệm bởi chính nó.
<%@ page contentType="text/html" pageEncoding="utf-8" %>
<head>
<title>User Info Entry Form</title>
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/design-global.css" />
</head>
<form action="input_jstl.jsp" method="post" class="form-horizontal">
<h1 class="alert text-center">Please enter information about an employee below</h1>
<div class="span6" >
<div class="control-group success">
<label class="control-label" for="inputSuccess">Name: </label>
<div class="controls">
<input type="text" id="inputName" placeholder="Name" name="userName" />
</div>
</div>
<div class="control-group success">
<label class="control-label" for="inputSuccess">Birth Date: </label>

(HoaND)giaotrinhjsp 20140318

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (9)

Similar a (HoaND)giaotrinhjsp 20140318

Similar a (HoaND)giaotrinhjsp 20140318 (20)

Último

Último (20)

(HoaND)giaotrinhjsp 20140318