Phần I : Tổng quan ngôn ngữ java .4
1. Lịch sử phát triển của Java .4
2. Mục đích của Java .4
3. Đặc điểm của Java 4
4. Các loại chương trình trong java .5
5. Các thành phần của Java Environment 5
6. Các loại ứng dụng java .5
Phần II : Môi Trường Phát Triển Ứng Dụng Java 6
1. Khái niệm 6
2. Kiến trúc Eclipse 6
3. The Platform runtime .7
4. The workspace .7
5. The Workbench 7
6. Team support .7
7. Help .7
Phần III : Giới thiệu J2EE và các thành phần liên quan .8
1. Applet .8
2. JavaBean 9
3. JSP . 10
4. Servlets .11
Phần IV : Kiến trúc MVC (Model _View_Controller) .13
1. Khái niệm .13
2. Mối quan hệ giữa View và controller 14
3. Mối quan hệ giữa Model và view 14
4. Các lợi điểm của MVC 15
5. Hạn chế của MVC 15
Phần V : Áp dụng kiến trúc MVC xây dựng ứng dụng triển khai thực tế .16
1. Qui trình thực hiện 16
1.1. View .16
1.2. Controller .17
1.3. Model 20
2. Triển khai ứng dụng 23
2.1. Cơ sở dữ liệu .23
2.2. Bố trí các tập tin trên Eclipse 23
2.3. Kết quả 24
Phần VI : Struts Framework .25
1. Struts 1.0 25
1.1. Khái niệm 25
1.2. Cấu trúc của Struts 26
1.3. Các thành phần chính của một ứng dụng Struts .27
1.4. Các file cấu hình cần thiết để xây dựng một ứng dụng Struts 27
1.5. Ưu điểm của Struts (so với MVC sử dụng RequestDispatcher) .28
1.6. Nhược điểm của Struts 28
2. Struts 2.0 29
Phần VI: Áp dụng kiến trúc MVC xây dựng ứng dụng triển khai thực tế 30
1. Qui trình thực hiện .30
1.1. Các trang hiển thị(View) 30
1.2.Action 37
1.3.Bean 40
1.4.Utils 46
1.5.Struts.xml 47
1.6.Build.xml 49
2 . Triển Khai Ứng Dụng .50
2.1.Cơ sở dữ liệu .50
2.2. Bố trí các tập tin trên Eclipse 50
51 trang |
Chia sẻ: lvcdongnoi | Lượt xem: 8636 | Lượt tải: 5
Bạn đang xem trước 20 trang tài liệu MVC Architecture và Struts Framework In Java(J2EE), để xem tài liệu hoàn chỉnh bạn click vào nút DOWNLOAD ở trên
.........................................................................................29
Trang 2
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần VI: Áp dụng kiến trúc MVC xây dựng ứng dụng triển khai thực tế ........30
1. Qui trình thực hiện ...........................................................................................30
1.1. Các trang hiển thị(View)......................................................................30
1.2.Action....................................................................................................37
1.3.Bean ......................................................................................................40
1.4.Utils ......................................................................................................46
1.5.Struts.xml ..............................................................................................47
1.6.Build.xml ..............................................................................................49
2 . Triển Khai Ứng Dụng .....................................................................................50
2.1.Cơ sở dữ liệu.........................................................................................50
2.2. Bố trí các tập tin trên Eclipse..............................................................50
Website Tham Khảo
www.vietcore.net¾
www.javavietnam.org¾
www.sun.java.com¾
www.apache.com¾
www.manguon.com¾
Trang 3
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần I
Tổng quan ngôn ngữ java
1. Lịch sử phát triển của Java
• Ra đời tại Sun Microsystems bởi James Gosling
• 1991: Version đầu tiên với tên “Oak”
• 1995: Tên chính thức là Java
2. Mục đích của Java:
• Dùng để phát triển ứng dụng cho các thiết bị điện tử “thông minh”
• Tạo các trang web có nội dung động (web applet)
• Hiện nay, Java được sử dụng để phát triển nhiều loại ứng dụng khác
nhau: cơ sở dữ liệu, mạng, Internet, viễn thông...
3. Đặc điểm của Java :
• Giống C/C++
• Đơn giản
• Object-oriented, hướng đối tượng
• Platform-independent, không phụ thuộc nền
• Mạnh
• Secure, bảo mật
• Distributed, phân bố
• Multithreaded, xử lý đa luồng
• Dynamic, động
Chương trình dịch cổ điển
Trang 4
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Chương trình dịch trong java
4. Các loại chương trình trong java :
• Applets
• Command Line Applications
• GUI Applications
• Servlets
• Database Applications
5. Các thành phần của Java Environment
• Java language
• Bytecode definitions
• Java/Sun class libraries
• Java Virtual Machine
• Structure of .class files
6. Các loại ứng dụng java :
• J2SE : Java 2 Standard Edition (Dùng để phát triển các ứng dụng vừa và nhỏ)
• J2EE : Java 2 Enterprise Edition (Dùng để phát triển các ứng dụng lớn)
• J2ME : Java 2 Micro Edition (Dụng để phát triển các ứng dụng trên đtdd)
Trang 5
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần II
Môi Trường Phát Triển Ứng Dụng Java
1. Khái niệm :
Eclipse là phần mềm miễn phí, được các nhà phát triển sử dụng để xây dựng
những ứng dụng J2EE, sử dụng Eclipse nhà phát triển có thể tích hợp với nhiều
công cụ hỗ trợ khác để có được một bộ công cụ hòan chỉnh mà không cần dùng
đến phần mềm riêng nào khác.Eclipse SDK bao gồm 3 phần chính : Platform,
Java Development Toolkit (JDT), Plug-in Development Environment (PDE).
Với JDT, Eclipse được xem như là một môi trường hỗ trợ phát triển Java mạnh
mẽ. PDE hỗ trợ việc mở rộng Eclipse, tích hợp các Plug-in vào Eclipse Platform.
Eclipse Platform là nền tảng của toàn bộ phần mềm Eclipse, mục đích của nó là
cung cấp những dịch vụ cần thiết cho việc tích hợp những bộ công cụ phát triển
phần mếm khách dưới dạng Plug-in, bản thân JDT cũng có thể được coi như là
một Plug-in làm cho Eclipse như là một Java IDE (Integrated Development
Enviroment).
2. Kiến trúc Eclipse :
Trang 6
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
3. The Platform runtime :
• Công việc chính của Platform runtime là phát xem plug-in nào đang có
trong thư mục plug-in của Eclipse.Mỗi Plug-in đều có 1 tập tin Manifest liệt
kê những kết nối mà plug-in cần.Pug-in chỉ được tải vào Eclipse mỗi khi
thực sự cần thiết để giảm lượng tài nguyên yêu cầu và thời gian khởi tạo.
4. The workspace :
• Workspace chịu trách nhiệm quản lý tài nguyên người dùng được tồ chức
dưới dạng Project. Mỗi Project là một thư mục con trong thư mục
Workspace.
• Workspace bảo quản cấp thấp lịch sử những sự thay đổi tài nguyên, tránh
thất thoát tài nguyên người dùng.
• Workspace đồng thời chịu trách nhiệm thông bào những công cụ cấn thiết
cho việc thay đổi tài nguyên.
5. The Workbench :
• Workbench là giao diện đồ họa người dùng của Eclipse, gồm có Standard
Widget Toolkit (SWT) và JFace. Eclipse không hòan toàn bắt buộc phải sử
dụng SWT hay Jface để lập trình giao diện, bạn vẫn có thể sử dụng AWT
hay SWING của Java thông qua việc cài đặt các Plug-ins.
6. Team support :
• Trang bị hệ thống quản trị để quản lý dự án của người dùng : Concurrent
Versions System (CVS).
7. Help :
• Cung cấp hệ thống tài liệu mở rộng, có thể là định dạng HTML hay XML.
Cửa sổ chính của eclipse3.2
Trang 7
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần III
Giới thiệu J2EE và các thành phần liên quan
(Applet , JavaBean , JSP , Servlet , EJB)
Là 1 thành phần rất quan trọng và rộng lớn trong lĩnh vực java , J2EE được
dùng để phát triển các ứng dụng lớn mang tính chất phân tán rộng khắp. Đây
là lĩnh vực được chú trọng và ứng dụng nhiều nhất của java trong thực tế.
Sơ đồ các thành phần trong J2EE
1. Applet :
• là một chương trình Java chạy trên web browser
• Tất cả các applets phải là lớp con của lớp Applet hoặc JApplet
• Để tạo ra một applet, ta phải import:
¾ java.applet
¾ java.awt
• Một applet có 4 phương thức. Mỗi phương thức được tự động gọi khi có
event tương ứng.
• Methods:
• init( )
• start( )
• stop( )
• destroy( )
Trang 8
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Sự khác nhau giữa Applet và Application
• Applications chạy bằng Java interpreter, còn applets chạy trên browser có hổ
trợ Java, hoặc dùng ‘AppletViewer’ có trong JDK.
• Việc thực hiện một applications bắt đầu trong hàm ‘main()’. Còn applet thì
không cần hàm main.
• Applications dùng ‘System.out.println()’ để xuất, trong khi applets dùng hàm
‘drawString()’ để hiển thị.
•
Các hạn chế về Security trên Applets
• Không thể đọc hoặc viết các file trên hệ thống file của user.
• Không thể trao đổi với một site trên.
• Không thể chạy được các chương trình trên hệ thống hiện hành
• Không thể tải bất kỳ chương trình được lưu trữ trên hệ thống của user.
2. JavaBean:
JavaBeans là software component model
Nó có thể tương tác với các đối tượng của các software khác và có thể được
dùng lại
Các software components mà có thể dùng lại này được gọi là ‘beans’
Components được dùng trong distributed environments. JavaBeans được thiết
kế để dùng khi cần.
Java thường xây dựng các software thông qua các JavaBeans.
Khi mà Java Beans được tạo ra, thì chúng có thể được dùng như một thư viện
không phụ thuộc nền
Trang 9
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Các qui tắc để tạo ra một Beans
Là một class.
phải có một default constructor.
Có ít nhất một thuộc tính và là non-public
Các thuộc tính được truy xuất từ bên ngoài thông qua các hàm getXXX và
setXXX.
3. JSP : (Java Server Pages)
JSP technology đươc xây dựng trên ngôn ngư lap trình Java
No thừa ke tat ca cac ưu điem cũng như cac đac tính cua ngôn ngư Java.
JSP co the dung trên tat ca cac platforms
Cách làm việc của JSP
Các bước xử lý của 1 request
Trang 10
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Cấu trúc của trang JSP :
Các thẻ lệnhHTML.
Mã lệnh Java. Có 3 thành phần chính:
o Directives
o Scripting Elements
o Actions
Cơ chế hoạt động của JSP
4. Servlets :
Lịch sử của Web Application
Servlets đươc dùng để mở rộng các chức năng của Java-enabled server
Dùng để thay thế cho CGI Scripts
Trươc servlets, chung ta co cac công nghev đe tao ra web applications:
Common Gateway Interface (CGI)
FastCGI
ASP
Server-side Java Script
Chay trong Java Virtual Machine
Không bat buoc Web browser phai ho trơ Java
Đặc điểm Servels :
Không phu thuoc nen
Lam viec trên nhieu web servers
Trang 11
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
La công nghe đau tiên cua java đe tao ra web Application
Không nam trong core Java API ma nam trong hai package
javax.servlet va javax.servlet.http cua Java Servlet Development Kit
(JSDK)
Kiến trúc Servlets
Vòng đời của 1 Servlet
Cấu trúc của 1 Servlet:
Là lớp con của lớp HttpServlet
Override phương thức doGet và doPost nếu cần. Hai phương thức này
đều nhận vào hai tham số HttpServletRequest và HttpServletResponse.
Hai phương thức này đều ném ra IOException và ServletException
Trang 12
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần IV
Kiến trúc MVC (Model _View_Controller)
1. Khái niệm :
Mô hình Model-View-Controller chia các components của ứng dụng thành 3 loại
khác nhau đó là Model (mẫu), View (hiển thị), và Controller điều khiển). Các
components của mô hình MVC đảm nhận một trách nhiệm nhất định và mỗi
components đều độc lập với các components khác. Việc thay đổi 1 components sẽ
không ảnh hưởng hoặc ảnh hưởng rất ít đến các components khác .Nhiệm vụ của
các components này là:
Model (mẫu) : Model đảm nhận nhiệm vụ cung cấp dữ liệu từ cơ sở dữ
liệu và lưu các thông tin đó ở nơi chứa dữ liệu. Tất cả cac Business Logic
đều được thực thi ở Model. Dữ liệu được nhập vào bởi người sử dụng qua
View sẽ được kiểm tra ở Model trước khi được lưu vào cơ sở dữ liệu. Truy
xuất dữ liệu,sự hợp lệ của dữ liệu và data saving logic là các thành phần
của Model.
View (hiển thị) : View trình bày việc hiển thị của ứng dụng và nhận trách
nhiệm lấy dữ liệu từ người sử dụng, gửi các yêu cầu đến Controller rồi sau
đó nhận trả lời từ Controller và hiển thị kết quả đến người sử dụng. HTML,
JSPs, các thư viện Tag và các file nguồn là các phần của view component.
Controller (điều khiển) : Controller là trung gian giữa Model và View.
Controller có trách nhiệm nhận các yêu cầu từ Client. Khi mà yêu cầu đuợc
nhận từ Client,Controller sẽ thực thi business logic thích hợp từ Model và
sau đó xuất ra dữ liệu cho user sử dụng View component. ActionServlet,
Action, ActionForm và struts-config.xml là các thành phần của Controller.
Trang 13
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Các mối quan hệ giữa các thành phần
2. Mối quan hệ giữa View và controller
Trong MVC truyền thống, các view và controller được kết hợp chặc chẻ với
nhau. Mỗi view được kết hợp với một controller duy nhất. Controller được
xem như một Strategy (sự quản lý) mà view sử dụng cho đầu vào. View cũng
chịu trách nhiệm tạo ra các khung nhìn và controller mới.
Có sự logic rằng các khung nhìn và các controller có quan hệ mạnh mẽ với
nhau, đầu vào và đầu ra của một ứng ụng được liên hệ chặc chẽ với nhau. Hầu
hết các nền GUI MVC, view và controller được trộn trong một đối tượng.
Điều này được gọi là Document View. View và controller được kết hợp thành
view. Model trở nên được biết như là tài liệu.
Passive model luân phiên chiệu trách nhiệm nhiều hơn về controller, vì nó
phải thông báo cho các view khi nó có sự cập nhật.
Sự hữu ích web hiện đại của MVC luân phiên thậm chí là nhiều hơn các MVC
truyền thống về việc chiệu trách nhiệm của view đối với controller. Controller
chiệu trách nhiệm tạo ra và lựa chọn các view và view hướng đến việc chiệu
trách nhiệm ít hơn đối với các controller của nó.
3.Mối quan hệ giữa Model và view
View phụ thuộc vào model. Các sự thay đổi đối với giao diện model đòi hỏi
các sự thay đổi song song trong view.
Thật khó để có được một sự tách biệt rõ rành giữa model và view. Chẳng hạn
như, xét một yêu cầu “hiển thị một cán cân âm bằng mầu đỏ”. Đầu tiên cán
cân, điều này xuất hiện là yêu cầu đầu ra rõ ràng và sự kiểm tra có thể được
đặt trong view theo một hình thức rõ ràng như sau:
if balance < 0 then red
Điều này có thể xâm phạm đến sự tách biệt của các thành phần trong MVC.
Qua sự phân tích ở trên yêu cầu thực sự là “hiển thị sự cân bằng được cường
điệu bằng mầu đỏ” và định nghĩa của cường điệu = cán cân < 0= nên được đặc
trong model vì đó là thuộc về sự mô tả miền. Thật dễ dàng cho tác nghiệp để
chuyển ra của model và chuyển vào view.
Trang 14
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Mối quan hệ giữa model và controller
Controller phụ thuộc vào model. Các sự thay đổi đối với giao diện model có
thể yêu cầu sự thay đổi song song đối với controller.
4. Các lợi điểm của MVC:
Giao diện người sử dụng có khả năng thay thế dễ dàng
Các view và các controller khác nhau có thể được thay đổi để đưa ra sự lựa
chọn các giao diện người sử dụng đối với cùng một model. Chẳng hạn như,
cùng một dữ liệu model có thể được hiển thị bởi biểu đồ bar, hay biểu đồ pie,
hoặc spreadsheet.
Các thành phần hợp thành giao diện người sử dụng
Bởi vì MVC đòi hỏi giao diện người sử dụng ứng dụng được cấu trúc thành
các đối tượng kế thừa nhau và định nghĩa các quan hệ chuẩn giữa các đối
tượng này, các phiên bản chung của các đối tượng này là có thể có được.
Chúng thông thường được gọi là cá thành phần giao diện kết hợp với các view
và các controller thành một đối tượng đơn. WACT là một sự nổ lực để đưa ra
một tập các thành phần phong phú tương tự nhau đối với việc phát triển web
mà duy trì được sự tách biệt giữa view và controller. Các thành phần thúc đẩy
sự sử dụng lại và cắt giảm sự cần thiết đối với các lớp con đặc biệt. Các thành
phần này được biết như là các view có khả năng cắm vào trong tuyến tính
smlltalk MVC.
Nhiều view đồng thời của một model
Nhiều view khác nhau có thể hoạt động tại cùng một thời điểm. Mỗi view mô
tả đồng thời và độc lập thông tin giống nhau từ một model. Điều này áp dụng
nhiều đối với GUI MVC hơn là web MVC.
Các khung nhìn được đồng bộ hóa
Cơ chế truyền sự thay đổi đảm bảo rằng tất cả các khung nhìn có thể được
phản ứng một cách đồng thời trạng thái hiện tại của model.
Dễ dàng hơn trong việc thay đổi giao diện người sử dụng
Kiểm thử dễ dàng hơn
Với MVC thật dễ dàng để kiểm thử chức năng chính của ứng dụng vì nó được
đóng gói bởi model.
5. Hạn chế của MVC
Gia tăng sự phức tạp
Sự kết nối chặc chẻ của view và controller đối với model
Sự thay đổi đối với giao diện model đòi hỏi sự thay đổi song song trong view
và có thể đòi hỏi sự thay đổi thêm đối với controller. Sự thay đổi code nào đó
có thể trở nên khó khăn hơn.
Tìm ẩn sự cập nhật dư thừa
Cơ chế truyền sự thay đổi có thể không hiệu quả khi model thay đổi thường
xuyên đòi hỏi nhiều thông báo thay đổi. Đây không phải là vấn đề chung nếu
passive model được sử dụng.
Sự kết nối chặc chẻ giữa view và controller
Sự tách biệt rõ ràng là rất khó, đôi khi là không thể
Trang 15
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần V
Áp dụng kiến trúc MVC xây dựng ứng dụng
triển khai thực tế
Chương trình : Java WebMail
Minh họa cách thức đăng nhập hệ thống.
Tổng quan ứng dụng:
Người dùng tương tác với các component Controller (thường được thể hiện
bằng các Servlet) bằng cách gửi các yêu cầu cho nó. Đến lượt mình, các
component Controller tạo nên các thực thể (instatiate) component Model
(thường được thể hiện bằng các JavaBean hoặc bằng công nghệ khác tương
đương), và thao tác nó theo yêu cầu của ứng dụng. Khi Model được khởi tạo,
Controller sẽ quyết định chọn View (thường thể hiện bởi JSP) nào để trình bày
kết quả đến người dùng, View này sẽ tương tác với Model để trình bày kết quả.
1. Qui trình thực hiện :
1.1 .View :
Để thực hiện phần View của ứng dụng, chúng ta dùng 2 JSP đơn giản như sau:
Trang login.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
Please Login
Please enter your information for login seminar about Java (J2EE)
Username
Password
Trang 16
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Trang login.jsp để người dùng nhập vào username và password, thường gọi là
trang JSP front-end. Thông tin này được chuyển đến Controller Servlet, báo
controller triệu gọi action là login
Trang Welcome.jsp
Welcome
<jsp:setProperty name="user" property="path"
value="" />
Welcome
Trang welcome.jsp hiển thị một thông điệp chào người dùng với tên được cung
cấp từ cơ sở dữ liệu do JavaBean truy xuất. Thất ra trang View chỉ cần truy xuất
JavaBean (jsp:getProperty) với scope request (jsp:useBean). Bean này được đặt trong
request bởi Controller, như chúng ta sẽ thấy sau. Tuy nhiên, ở đây ta cũng thiết lập
thuộc tính path của JavaBean để minh họa việc dùng đối tượng ẩn application.
Thuộc tính path chỉ ra vị trí thực của cơ sở dữ liệu Access mà ta truy xuất bằng
DSN-less.
1.2. Controller:
Một Servlet thực hiện phần controller trong ứng dụng chúng ta:
Controller.class
package mvc.controller;
import mvc.controller.actions.LoginAction;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
Trang 17
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
import javax.servlet.ServletException;
import javax.servlet.RequestDispatcher;
import java.io.IOException;
public class Controller extends HttpServlet
{
protected void doGet( HttpServletRequest
httpServletRequest,HttpServletResponse httpServletResponse ) throws
ServletException, IOException
{
doPost( httpServletRequest, httpServletResponse );
}
protected void doPost( HttpServletRequest
httpServletRequest,HttpServletResponse httpServletResponse ) throws
ServletException, IOException
{
//Lay thuoc tinh action tu request
String theAction = httpServletRequest.getParameter(
"action" );
Action action = null;
if ( theAction.equalsIgnoreCase( "login" ) )
{
action = new LoginAction( httpServletRequest,
httpServletResponse );
}
// Thuc hien phuong thuc execute cua doi tuong lop
Action, tra ve mot duong dan page kieu string
String page = action.execute( httpServletRequest,
httpServletResponse );
RequestDispatcher rd =
httpServletRequest.getRequestDispatcher( page );
// forward trang ke tiep bang giao dien
RequestDispatcher
rd.forward( httpServletRequest, httpServletResponse );
}
}
Servlet trên chỉ dùng một tham số của request là action để quyết định hành
động được triệu gọi. Trang login.jsp gửi hành động login và đối tượng action lớp
LoginAction sẽ được triệu gọi. Đối tượng action này cài đặt một giao diện chuẩn
(Action) với một phương thức execute, có các đối số là các đối tượng Request và
Response. Phương thức này trả về đường dẫn (page) đến trang sẽ gọi kế tiếp (phần
View), người dùng chuyển tiếp (forward) đến trang này bằng giao diện
RequestDispatcher.
Trang 18
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Action.class
package mvc.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public interface Action
{
public String execute( HttpServletRequest req, HttpServletResponse res );
}
LoginAction.class
package mvc.controller.actions;
import mvc.controller.Action;
import mvc.model.UserBean;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class LoginAction implements Action
{
public LoginAction( HttpServletRequest request, HttpServletResponse response )
{
}
public String execute( HttpServletRequest req, HttpServletResponse res )
{
String username = req.getParameter( "username" );
String password = req.getParameter( "password" );
// Tao mot UserBean
try
{
UserBean user = new UserBean();
// Thiet lap cac thuoc tinh cua UserBean, co the thiet lap ca thuoc tinh path o day
user.setUser( username );
user.setPassword( password );
// Dat no vao trong request
req.setAttribute("user", user);
} catch ( Exception e )
{
System.out.println( e.getMessage() );
}
return "/welcome.jsp";
}
}
Trang 19
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phương thức execute() của lớp LoginAction tạo (instantiate) một đối tượng
Model mới (UserBean), đặt nó vào trong Session, và trả về đường dẫn đến trang kế
tiếp tức welcome.jsp. Chú ý phần Controller này sẽ thiết lập các thuộc tính cho
JavaBean, nếu ở đây dùng trang JSP thì sẽ có action jsp:setProperty
1.3. Model
Phần Model trong ứng dụng đơn giản này chỉ có đúng một JavaBean
UserBean.class
package mvc.model;
import java.sql.ResultSet;
import mvc.util.*;
public class UserBean
{
private String user = "";
private String password = "";
private String name = "";
private String path = "";
public UserBean() throws ClassNotFoundException
{
}
public void setUser( String user )
{
this.user = user.toUpperCase();
}
public String getUser()
{
return user;
}
public void setPassword( String password )
{
this.password = password;
}
public String getPassword()
{
return password;
}
public void setPath( String path )
{
Trang 20
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
this.path = path;
}
public String getName()
{
try {
String strQuery = "SELECT name FROM accounts WHERE user = '"+ user +"'
AND password = '"+ password +"'";
ResultSet result = DataUtil.ReadData(strQuery, path);
while ( result.next() )
{
name = result.getString( 1 );
//if( user.equalsIgnoreCase(result.getString(1))
//&& password.equalsIgnoreCase(result.getString(2)));
}
} catch ( Exception e )
{
System.out.println( e.getMessage() );
}
return name;
}
}
DataUtil.class
package mvc.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.sql.*;
public class DataUtil
{
public static ResultSet ReadData(String SQL,String path) throws
Exception
{
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
Connection connect = DriverManager.getConnection
("jdbc:odbc:Driver={Microsoft Access Driver
(*.mdb)};"
+ "DBQ=" + path,
"", "" );
Statement stmt = connect.createStatement();
ResultSet result = stmt.executeQuery( SQL );
return result;
}
}
Trang 21
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Xây dựng tập tin build.xml để đóng gói ứng dụng ra định dạng war dạy trên
tomcat
Build.xml
<property name="tomcat.home" value="C:\Program Files\Apache Software Foundation\Tomcat
5.0"/>
<javac srcdir="${src.home}"
destdir="${build.home}"
debug="${compile.debug}"
deprecation="${compile.deprecation}"
optimize="${compile.optimize}">
<war destfile="${dist.home}/${ant.project.name}.war" webxml="${web.home}/WEB-
INF/web.xml">
Trang 22
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
2. Triển khai ứng dụng :
2.1. Cơ sở dữ liệu
Cơ sở dữ liệu Access: members.mdb có một bảng accounts
2.1. Bố trí các tập tin trên Eclipse :
Trang 23
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
2.3. Kết quả:
Trang 24
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần VI
Struts Framework
1. Struts 1.0:
1.1 Khái niệm :
• Struts là một MVC Framework: Struts cung cấp một framework thống nhất để
deploy các ứng dụng Servlet và JSP sử dụng kiến trúc MVC.
• Struts là một tập các Utilities: Struts cung cấp các lớp tiện ích để điều khiển
hầu hết các tác vụ trong việc phát triển các ứng dụng Web.
• Struts là một tập thư viện các thẻ JSP tùy chọn (Custom JSP Tag): Struts cung
cấp các thư viện thẻ tùy chọn cho việc thể hiện các thuộc tính của bean, quản
lý các HTML forms, lặp lại các kiểu cấu trúc dữ liệu, và đưa ra các HTML có
điều kiện.
Struts thực thi mô hình MVC
Mô hình Struts Framework thực thi mô hình MVC bằng cách sử dụng tập
hợp các thẻ JSP, các thẻ tùy chọn JSP (custom JSP tag), và các Java servlet.
Dưới đây chúng ta sẽ mô tả ngắn gọn cách mà Struts Framework ánh xạ đến
mỗi thành phần trong mô hình MVC.
9 Hình trên mô tả tiến trình mà hầu hết các ứng dụng Struts phải tuân theo.
Tiến trình này có thể được chia thành 5 bước căn bản:
1. Request được tạo ra từ một View
2. Request được tiếp nhận bởi một ActionServlet (đóng vai trò là một
Controller), và ActionServlet này sẽ lookup URI cần thiết trong file XML
và xác định tên của lớp Action sẽ thực hiện các bussiness logic cần thiết.
Trang 25
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
3. Lớp Action thực hiện các logic của nó trong các thành phần Model kết hợp
với ứng dụng.
4. Khi Action hoàn tất tiến trình sử lý của nó, nó sẽ trả điều khiển về cho
ActionServlet. Là một phần của thành phần trả về, lớp Action cung cấp
một khóa xác định kết quả quả của tiến trình sử lý đó. ActionServlet sử
dụng khóa này để xác định kết quả sẽ được forward đến đâu để trình diễn
ra ngoài.
5. Yêu cầu được hoàn tất khi ActionServlet đáp ứng nó bằng cách forward
yêu cầu đó đến một View được liên kết đến để trả về khóa đã đề cập ở trên
bước 4, và View này sẽ trinh diễn kết quả của Action.
Cấu trúc của Struts 1.0
1.2. Cấu trúc của Struts bao gồm:
• Một hoặc nhiều Action, mỗi action trong trang web sẽ ánh xạ chính xác đến
một thành phần được định nghĩa trong file struts-config.xml. Action
được triệu gọi bởi người dùng từ một trang HTML hoặc JSP thông qua một
liên kết hay thông qua thuộc tính action trong thẻ .
• Một thành phần sẽ định nghĩa một lớp ActionForm, trong một số
trường hợp, nó sẽ được sử dụng để validate các dữ liệu trong form được
submit bởi người sử dụng. Nó cũng định nghĩa lớp Action nào sẽ được sử
dụng để xử lý các yêu cầu từ phía người dùng.
Trang 26
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
• Một lớp ActionForm có thể sử dụng một hoặc nhiều forward được định nghĩa
trong thẻ đề nói cho một ActionServlet trả về các response tương
ứng với các request của người dùng. Chúng ta có thể định nghĩa nhiều forward
trong thẻ .
1.3. Các thành phần chính của một ứng dụng Struts:
• ActionServlet: đóng vai trò như là một controller trong mô hình MVC, hay nói
cách khác ActionServlet là sự thực thi controller của Struts đối với mô hình
MVC. ActionServlet lấy về các request từ phía người dùng và ánh xạ chúng
đến thành phần trong file struts-config.xml.
• Action: định nghĩa một tác vụ có thể được gọi bởi người dùng. Nó cũng định
nghĩa lớp sẽ sử lý các request từ phía người dùng và trang JSP sẽ hiển thị kết
quả về cho người sử dụng.
• Lớp Action: chứa toàn bộ những sử lý cho các yêu cầu của người dùng.
• ActionForm: đi kèm với thẻ trong file struts-config.xml, nó quản lý
toàn bộ các dữ liệu được submit lên từ phía người dùng và có thể thực hiện
validate các dữ liệu đó.
• Trang JSP: được sử dụng để trả về trang HTML để thể hiện kết quả đã được
sử lý cho người dùng.
1.4. Các file cấu hình cần thiết để xây dựng một ứng dụng Struts:
• web.xml: file này chứa toàn bộ các cấu hình của ActionServlet, các sự ánh xạ
của các yêu cầu từ phía người dùng đến ActionServlet, và tất các Struts Tag
Library Definitions (TLDs).
struts-config.xml: file này chứa tất cả các thông tin cấu hình cho một ứng
dựng xây dựng dựa trên Struts.
•
ApplicationResources.properties: file này trung tâm chứa các nội dung tĩnh
được sử dụng trong toàn bộ ứng dụng Struts. Nó cho phép các nhà phát triển
dễ dàng thay đổi nội dung các text và các nội dung dùng chung sử dụng trong
ứng dụng.
•
Các thư viện thẻ Struts để xây dựng các thành phần trình diễn trong một ứng
dụng:
+ : cung cấp cho nhà phát triển ứng dụng một tập các thẻ JSP để
chia nhỏ giao diện người dùng thành các thành phần có thể dễ dàng tháo rắp.
+ : cung cấp cho nhà phát triển ứng dụng một tập các thẻ JSP để quản
lý đầu ra từ một JavaBean.
+: có thể được sử dụng để ứng dụng các điều kiện logic trong một
trang JSP.
+ : có thể sử dụng để tạo ra các thành phần form
Trang 27
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
1.5. Ưu điểm của Struts (so với MVC sử dụng RequestDispatcher)
- Cấu hình được tập trung dựa vào file:
• Thay vì viết hàng loạt những thông tin vào chương trình Java, hầu hết
những giá trị Struts được thể hiện trong file .xml và file property. Phương
pháp này cho phép người lập trình Web và Java chỉ chú tâm vào phần công
việc cụ thể của họ (cài đặt business logic, hiển thị những giá trị cụ thể cho
clients, etc) mà không cần quan tâm về tổng thể hệ thống.
- Form beans:
• Trong JSP, ta có thể sử dụng thuộc tính property=”*” với jsp:setProperty để
tự động sinh ra JavaBean component dựa trên những thông số yêu cầu
chuyển đến. Apache Struts mở rộng thêm khả năng này và thêm vào vài
tiện ích khác, tất cả nhằm phục vụ cho việc đơn giản hóa tiến trình xử lý
những thông số yêu cầu từ client.
- Bean tags:
• Apache Struts cung cấp 1 tập custom JSP tags (cụ thể là bean:write) cho
phép dể dàng xuất ra những thuộc tính của JavaBean components.
- HTML tags:
• Apache Struts cung cấp 1 tập custom JSP tags để tạo HTML forms - những
cái hổ trợ cho JavaBean components. Sự hổ trợ bean/form này phục vụ 2
mục đích sau:
+ Nó cho phép ta khởi tạo các giá trị field của form từ các đối tượng Java.
+ Nó cho phép ta hiển thị lại các form với 1 vài hoặc tất cả những giá trị
nhập vào lúc trước 1 cách nguyên vẹn.
- Kiểm tra giá trị các field của form :
• Apache Struts tích hợp sẵn những khả năng cho việc kiểm tra những giá trị
form được định dạng theo yêu cầu. Nếu những giá trị không định dạng
hoặc định dạng sai, form có thể tự động hiển thị những thông báo lỗi. Cách
ràng buộc này có thể thực hiện trên server (Java) hoặc trên client
(JavaScript).
- Kiểm tra gi trị các field của form :
• Struts hổ trợ tính nhất quán của MVC xuyên suốt ứng dụng.
1.6. Nhược điểm của Struts :
- Nhược điểm của Struts :
• Để sử dụng MVC với chuẩn RequestDispatcher, ta cần nghiên cứu sâu với
chuẩn JSP và Servlet APIs. Để sử dụng MVC với Struts, ta còn phải hiểu rõ
cả framework rộng lớn và phức tạp, nó tương tự như việc tìm hiểu cả cái
cốt lõi của hệ thống. Điều bất lợi này đặc biệt đáng kể với những dự án
nhỏ, những dự án có ít thời gian để thực hiện, và những lập trình viên có ít
kinh nghiệm; ta mất rất nhiều thời gian trong việc nghiên cứu Struts khi
thực hiện đề án.
Trang 28
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
- Ít có tài liệu hỗ trợ
• So sánh với chuẩn servlet và JSP APIs, Struts có ít tài liệu hổ trợ hơn nhiều.
- Less transparent:
• Với những ứng dụng Struts, có nhiều lỗi bên dưới hơn những ứng dụng
Web dựa trên ngôn ngữ Java bình thường. Vì thế, ứng dụng Struts thì:
+ Khó tìm hiểu.
+ Khó chuẩn hóa và đánh giá.
- Cứng nhắc:
• Struts khó áp dụng các phương pháp khác
2. Struts 2.0:
• Java framework để phát triển các ứng dụng web theo mô hình MVC.
• Linh hoạt cho việc chuẩn hóa dữ liệu người dùng.
• Các file cấu hình sử dụng package và namespace để quản lý tất cả các
action.
• Dễ dàng tích hợp các hợp các module của nhà cung cấp thứ 3 (Hibernate,
Spring, Ajax…).
• Sử dụng các Interceptor.
• Tích hợp Inversion of Control.
Trang 29
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Phần VI
Áp dụng Struts 2.0 Framework xây dựng ứng
dụng triển khai thực tế
Chương trình: Quản Lý Nhân Viên
Minh họa chức năng cập nhật tài khoản.
I. Qui trình thực hiện :
1. Các trang hiển thị (View)
Index.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN">
Index page
<META HTTP-EQUIV="Refresh"
CONTENT="0;URL=employee/getEmployeeList.action">
Initializing...
Trang 30
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Employee.jsp
<%@ page language="java" contentType="text/html;
charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN" "">
<meta http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1">
Insert title here
function edit()
{
alert("edit.......");
document.getElementById("btnAdd").disabled = true;
document.getElementById("btnSave").disabled = false;
}
Demo Struts 2.0 Framework in J2EE
<form id="frmEmployee" name="Employee" method="post"
theme="simple">
ID
Name
Sex
Birthday
City
Email
Action
Trang 31
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
<s:url id="urlDelete"
action="EmployeeDelete">
<s:param name="id"
value="%{id}"/>
<s:a
href="%{urlDelete}">Delete
<s:url id="urlEdit"
action="EmployeePrepareUpdate">
<s:a href="%{urlEdit}"
onclick="return edit();">Edit
Trang 32
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Success.jsp
<%
String path = request.getContextPath();
String basePath =
request.getScheme()+"://"+request.getServerName()+":"+req
uest.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN">
">
My JSP 'Success.jsp' starting page
<meta http-equiv="keywords"
content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my
page">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
Successful!.
Trang 33
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Fail.jsp
<%
String path = request.getContextPath();
String basePath =
request.getScheme()+"://"+request.getServerName()+":"+req
uest.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN">
">
My JSP 'Fail.jsp' starting page
<meta http-equiv="keywords"
content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my
page">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
Invalid Employee.
Trang 34
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Update.jsp
<%@ page language="java" contentType="text/html;
charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN" "">
<meta http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1">
Insert title here
<s:textfield label="Name" name="name"
value="%{name}"/>
<s:radio label="Sex"
value="%{sex}"name="sex"
list="{'Male','Female'}">
<s:textfield label="BirthDay"
value="%{birthday}" name="birthday"/>
<s:select label="City" name="city"
value="%{city}" list="{'Ho Chi Minh','Ha Noi','Da
Nang'}">
Trang 35
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
<s:textfield label="Email"
name="email" value="%{email}"/>
<s:textarea label="History"
name="history" value="%{history}" cols="20" rows="3"
/>
<s:submit id="btnAdd" name="btnAdd"
value="Add" action="EmployeeAdd" theme="simple"
align="right"/>
<s:submit id="btnSave" name="btnSave"
value="Save" action="EmployeeUpdate" theme="simple"
align="right">
<s:submit id="btnGetList"
name="btnGetList" value="Get Employee List"
action="getEmployeeList"/>
Trang 36
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
2. Action :
EmployeeAction.class
package net.vietcore.demo.action;
import net.vietcore.demo.bean.Employee;
import net.vietcore.demo.bean.EmployeeService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.Preparable;
import com.opensymphony.xwork2.ModelDriven;
public class EmployeeAction extends ActionSupport implements ModelDriven,
Preparable{
/**
*
*/
private static final long serialVersionUID = 1L;
private int id;
private Employee employee;
private EmployeeService service = new EmployeeService();
Trang 37
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
/*
* This method is call automatically when the Class is called.
*
*/
public void prepare() throws Exception {
System.out.println("prepare() in Employee Action");
System.out.println("EmployeeID = "+id);
if (id==0){
employee = new Employee();
System.out.println("Tao moi ");
}else {
employee = service.findById(id);
System.out.println("Tim ");
}
}
/*
* This method is call automatically when the Class is called.
*
*/
public Object getModel() {
System.out.println("getModel() in Employee Action");
return employee;
}
public String addEmployee(){
System.out.println("addEmployee() in Employee Action");
service.addEmployee(employee);
return SUCCESS;
}
public String deleteEmployee(){
System.out.println("deleteEmployee() in Employee Action");
System.out.println(employee.getId());
service.deleteEmployee(employee.getId());
return SUCCESS;
}
public String updateEmployee(){
System.out.println("updateEmployee() in Employee Action");
service.updateEmployee(employee);
return SUCCESS;
Trang 38
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
}
public String execute() throws Exception{
System.out.println("execute() in Employee Action");
return SUCCESS;
}
public String input() throws Exception{
System.out.println("input() in Employee Action");
return INPUT;
}
}
ListEmployeeAction.class
package net.vietcore.demo.action;
import java.util.List;
import net.vietcore.demo.bean.EmployeeService;
import com.opensymphony.xwork2.ActionSupport;
public class ListEmployeeAction extends ActionSupport{
/**
*
*/
private static final long serialVersionUID = 1L;
EmployeeService service = new EmployeeService();
private List employeeList;
public List getEmployeeList() {
System.out.println("getEmployeeList() in class
ListEmployeeAction");
return employeeList;
}
public String execute() throws Exception{
System.out.println("execute() in class ListEmployeeAction");
service.addEmployeeToList();
employeeList = service.list();
return SUCCESS;
}
}
Trang 39
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
3. Bean:
Employee.class
package net.vietcore.demo.bean;
public class Employee {
private int id;
private String name;
private String sex;
private String birthday;
private String city;
private String email;
private String history;
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getHistory() {
return history;
}
Trang 40
public void setHistory(String history) {
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
this.history = history;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
EmployeeService.class
package net.vietcore.demo.bean;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import net.vietcore.demo.utils.DataUtils;
public class EmployeeService {
private ArrayList employeeList;
public ArrayList list(){
return employeeList;
}
public void addEmployeeToList(){
//System.out.println("addEmployeeToList() in Employee
Action....");
ResultSet rs;
Trang 41
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
int i=0;
//PreparedStatement pstmt = null;
try {
//DataUtils.connectDb();
//pstmt =
DataUtils.getConnect().prepareStatement("Select * from tblEmployee");
rs= DataUtils.Doc("Select * from tblEmployee");
//rs = pstmt.executeQuery();
employeeList = new ArrayList();
while (rs.next()) {
i++;
Employee employee = new Employee();
employee.setId(rs.getInt("ID"));
employee.setName(rs.getString("name"));
employee.setSex(rs.getString("sex"));
employee.setBirthday(rs.getString("birthday"));
employee.setCity(rs.getString("city"));
employee.setEmail(rs.getString("email"));
employee.setHistory(rs.getString("history"));
employeeList.add(employee);
}
} catch (Exception e) {
//e.printStackTrace();
}
System.out.println(i);
}
public int addEmployee(Employee employee){
System.out.println("addEmployee method in EmployeeService
class");
int ret = -1;
PreparedStatement pstmt = null;
try {
DataUtils.connectDb();
pstmt =
DataUtils.getConnect().prepareStatement("INSERT INTO tblEmployee (Name,
Sex, Birthday, City, Email, History) VALUES(?, ?, ?, ?, ?, ?)");
pstmt.setString(1, employee.getName());
pstmt.setString(2, employee.getSex());
pstmt.setString(3, employee.getBirthday());
pstmt.setString(4, employee.getCity());
pstmt.setString(5, employee.getEmail());
pstmt.setString(6, employee.getHistory());
int result = pstmt.executeUpdate();
if(result > 0)
{
Trang 42
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
System.out.println("Employee insert
successfully");
ret = 1;
}
else
{
ret = 0;
}
} catch (Exception e) {
e.printStackTrace();
} finally
{
if(pstmt != null)
{
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
DataUtils.disconnectDb();
}
return ret;
}
public int updateEmployee(Employee employee){
System.out.println("updateEmployee method in
EmployeeService class");
int ret = -1;
PreparedStatement pstmt = null;
try {
DataUtils.connectDb();
pstmt =
DataUtils.getConnect().prepareStatement("UPDATE tblEmployee SET Name=?,
Sex=?, Birthday=?, City=?, Email=?, History=? WHERE ID=?");
pstmt.setString(1, employee.getName());
pstmt.setString(2, employee.getSex());
pstmt.setString(3, employee.getBirthday());
pstmt.setString(4, employee.getCity());
pstmt.setString(5, employee.getEmail());
pstmt.setString(6, employee.getHistory());
pstmt.setInt(7, employee.getId());
int result = pstmt.executeUpdate();
if(result > 0)
{
Trang 43
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
System.out.println("Employee saved
successfully");
ret = 1;
}
else
{
ret = 0;
}
} catch (Exception e) {
e.printStackTrace();
} finally
{
if(pstmt != null)
{
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
DataUtils.disconnectDb();
}
return ret;
}
public int deleteEmployee(int id){
System.out.println("deleteEmployee method in
EmployeeService class");
int ret = -1;
PreparedStatement pstmt = null;
try {
DataUtils.connectDb();
pstmt =
DataUtils.getConnect().prepareStatement("DELETE FROM tblEmployee
WHERE id=?");
pstmt.setInt(1, id);
pstmt.executeUpdate();
ret = 1;
} catch (Exception e) {
e.printStackTrace();
} finally
{
Trang 44
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
if(pstmt != null)
{
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
DataUtils.disconnectDb();
}
return ret;
}
public Employee findById(int id){
addEmployeeToList();
System.out.println("findById method in EmployeeService
class");
for (Employee employee : employeeList) {
if(employee.getId()==id)
return employee;
}
return null;
}
public Employee getEmployee(int id){
Employee employee = new Employee();
ResultSet rs = null;
PreparedStatement pstmt = null;
try {
DataUtils.connectDb();
pstmt =
DataUtils.getConnect().prepareStatement("SELECT * FROM tblEmployee
WHERE id=?");
pstmt.setInt(1, id);
rs = pstmt.executeQuery();
while (rs.next()) {
employee.setId(rs.getInt("ID"));
employee.setName(rs.getString("Name"));
employee.setSex(rs.getString("Sex"));
employee.setBirthday(rs.getString("Birthday"));
employee.setCity(rs.getString("City"));
employee.setEmail(rs.getString("Email"));
employee.setHistory(rs.getString("History"));
}
Trang 45
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
} catch (Exception e) {
e.printStackTrace();
} finally
{
if(pstmt != null)
{
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(rs != null)
{
//rs.close();
}
DataUtils.disconnectDb();
}
return employee;
}
}
4. Utils :
DataUtils.class
package net.vietcore.demo.utils;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class DataUtils {
private static Connection con;
private static int count;
public static void connectDb() {
try {
// Connect Normal
String DBDriver = "sun.jdbc.odbc.JdbcOdbcDriver";
String connString = "jdbc:odbc:dataStruts2";
Class.forName(DBDriver).newInstance();
con = DriverManager.getConnection(connString);
Trang 46
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
// chuong trinh DEMO
System.out.println("Connection number: " +
(++count));
} catch (ClassNotFoundException cnfe) {
try {
throw new Exception("Cannot find the specified
driver.", cnfe);
} catch (Exception e) {
}
} catch (Exception e) {
System.out.println("Error, class Connect \n Method:
connectDb()");
System.out.println(e);
}
}
public static Connection getConnect() {
return con;
}
public static void disconnectDb() {
try {
System.out.println("Disconnecting..." + count);
con.close();
} catch (SQLException sqle) {
System.out.println(sqle.getMessage());
}
}
public static ResultSet Doc(String chuoi_lenh) throws Exception
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection conn=
DriverManager.getConnection("jdbc:odbc:dataStruts2");
Statement stmt = conn.createStatement();
ResultSet rs= stmt.executeQuery(chuoi_lenh);
return rs;
}
}
5. Struts.xml
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts
Configuration 2.0//EN"
Trang 47
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
"">
<package name="tokenPackage" namespace="/employee"
extends="struts-default">
<action name="getEmployeeList"
class="net.vietcore.demo.action.ListEmployeeAction"
method="execute">
/Employee.jsp
/error.jsp
-->
<action name="EmployeeInput" method="input"
class="net.vietcore.demo.action.EmployeeAction">
<result
name="input">/Employee.jsp
<action name="EmployeeAdd" method="addEmployee"
class="net.vietcore.demo.action.EmployeeAction">
<result type="redirect-
action">getEmployeeList
error.jps
<action name="EmployeeDelete"
method="deleteEmployee"
class="net.vietcore.demo.action.EmployeeAction">
<result
type="redirect">getEmployeeList.action
<action name="EmployeePrepareUpdate"
class="net.vietcore.demo.action.EmployeeAction">
/Update.jsp
<interceptor-ref
name="paramsPrepareParamsStack"/>
<action name="EmployeeUpdate"
method="updateEmployee"
class="net.vietcore.demo.action.EmployeeAction">
<result type="redirect-
action">getEmployeeList
Trang 48
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
6. Build.xml:
<property name="lib.home" value="${basedir}/web/WEB-
INF/lib"/>
<property name="tomcat.home" value="C:\Program
Files\Apache Software Foundation\Tomcat 5.5"/>
<target name="prepare" description="Prepare some
necessary steps">
<target name="clean" description="Delete old build and
dist directories">
<target name="compile" depends="prepare"
description="Compile Java sources">
<javac srcdir="${src.home}"
destdir="${build.home}"
debug="${compile.debug}"
deprecation="${compile.deprecation}"
optimize="${compile.optimize}">
-->
Trang 49
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
<target name="dist" depends="compile" description="Create
binary distribution">
<war destfile="${dist.home}/${ant.project.name}.war"
webxml="${web.home}/WEB-INF/web.xml">
-->
-->
--
>
<!--<zipfileset dir="${web.home}/images"
prefix="images"/> -->
-->
II . Triển Khai Ứng Dụng:
1. Cơ sở dữ liệu:
2 . Bố trí các tập tin trên Eclipse :
Trang 50
MVC Architecture & Struts Framework in J2EE (Java) 10/2007
Trang 51
Các file đính kèm theo tài liệu này:
- MVC Architecture & Struts Framework In Java(J2EE).pdf