TÌM HIỂU VỀ STRUT2

P a g e | 2

Đề tài tìm hiểu về Struts 2 Giáo viên hướng dẫn :

o Nguyễn Hoàng Anho Ngô Bá Nam Phương

Nhóm thực hiện : 0512032 - Trần Bình Nguyên0512056 - Vũ Thế Tài0512381 - Nguyễn Thanh Tâm

P a g e | 3

Mục lục 1 GIỚI THIỆU :.....................................................................................................................................4

2 MÔ HÌNH PHÁT TRIỂN :..................................................................................................................4

3 MÔ HÌNH MVC :...............................................................................................................................5

4 SƠ LƯỢC VỀ STRUTS :....................................................................................................................5

5 THÀNH PHẦN CƠ BẢN CỦA STRUTS :.................................................................................................6

6 TÌM HIỂU MODEL LAYER :............................................................................................................7

7 STRUTS & MODEL................................................................................................................................7

8 KIẾN TRÚC STRUTS 2:....................................................................................................................8

9 SO SÁNH STRUTS2 & STRUTS 1 :..................................................................................................8

10 HƯỚNG DẪN XÂY DỰNG STRUT 2 CƠ BẢN :.......................................................................12

11 TÀI LIỆU THAM KHẢO :...........................................................................................................13

P a g e | 4

1 GIỚI THIỆU :

Struts là một framework phục vụ việc phát triển các ứng dụng Web trên Java. Sử dụng mẫu thiết kế Model-View-Controller (MVC), Struts giải quyết rất nhiều các vấn đề liên quan đến các ứng dụng Web hướng business đòi hỏi hiệu năng cao sử dụng Java servlet và JSP. Struts cơ bản định hình lại cách các Web programmer nghĩ về và cấu trúc một ứng dụng Web.

2 MÔ HÌNH PHÁT TRIỂN :

Khi Sun giới thiệu công nghệ JSP, nó cung cấp một hướng phát triển và định nghĩa 2 mô hình xây dựng các ứng dụng Web dựa trên JSP. 2 mô hình đó được biết đến với những cái tên Model 1 và Model 2 và chúng quy định các cách tiếp cận khác nhau để thiết kế các ứng dụng Web dựa trên JSP. Model 1, đơn giản hơn, là giải pháp chính khi JSP lần đầu được đưa ra. Tuy nhiên, qua thời gian, Model 2 trở nên được chấp nhận như là cách tốt nhất để xây dựng các ứng dụng Web dựa trên JSP và là nguồn cảm hứng cho các Web framework dựa trên MVC như Struts.

o Kiến trúc Model 1: hết sức đơn giản. Tóm lại là tất cả mọi thứ đều được gói gọn trong servlet hoặc JSP từ việc xử lý request, xác nhận tính hợp lệ của dữ liệu, điều quản business logic và generate response. Mặc dù về khái niệm hết sức đơn giản, kiến trúc này không phù hợp cho việc phát triển các ứng dụng quy mô lớn vì chắc chắn một số lượng lớn các tính năng sẽ bị lặp lại trong các trang JSP (lặp lại code). Cũng vậy, kiến trúc Model 1 tạo nên sự ràng buộc không cần thiết giữa business logic và presentation logic của ứng dụng. Ví dụ, ngoài giao diện HTML, bạn có thể muốn thêm một giao diện WML cho truy nhập wireless. Trong trường hợp này, việc sử dụng Model 1 yêu cầu sự lặp lại không cần thiết của business logic trong các trang sử dụng HTML và WML.

o Kiến trúc Model 2 : hay cách gọi thông dụng ngày nay, Model-View-Controller (MVC), giải quyết nhiều vấn đề của Model 1 với việc cung cấp một sự phân tách rõ ràng trong ứng dụng. Trong kiến trúc MVC, một serlvet trung tâm, được gọi là Controller, tiếp nhận tất cả các request cho ứng dụng. Sau đó Controller sẽ xử lý request và làm việc với Model để chuẩn bị những dữ liệu cần thiết cho View (thường là JSP) và forward dữ liệu tới trang JSP. Sau đó JSP sử dụng các dữ liệu đã được chuẩn bị bởi Controller để generate một response về cho browser. Trong kiến trúc này, business logic và presentation logic được phân tách nhau. Việc tách business code và presentation code giúp ta có thể sử dụng nhiều giao diện cho ứng dụng, chúng có thể là Web, wireless hay GUI. Thêm vào đó, việc phân tách này còn cung cấp việc tái sử dụng lại code một cách hòan hảo.

Có một điều khá lý thú ở đây là tôi đã từng cho rằng việc trong một ứng dụng Web có thể có nhiều Controller thì ứng dụng đó cũng sử dụng MVC. Có nghĩa là cứ một view component ta sẽ có một Controller cho nó. Tuy nhiên điều này là hòan tòan sai với mẫu thiết kế MVC.

P a g e | 5

3 MÔ HÌNH MVC :

Để hiểu Struts, việc hiểu rõ kiến trúc MVC là một điều quan trọng (có thể mang tính bắt buộc). Phần này sẽ đi sâu hơn một chút vào từng phần của kiến trúc MVC.

Model component : Trong kiến trúc MVC, các model component cung cấp một giao diện với dữ liệu và/hoặc các dịch vụ được sử dụng bởi ứng dụng. Theo cách này, các controller component không cần phải chứa code để thao tác với dữ liệu của ứng dụng. Thay vào đó, chúng giao tiếp với các model component để thực hiện truy cập và thao tác dữ liệu. Như vậy, các model component cung cấp business logic. Các model component có thể ở nhiều dạng từ các Java bean đến các EJB hay các Web service.

View component : Các view component được sử dụng trong kiến trúc MVC để generate response về browser. Như vậy một view component cung cấp những gì mà user nhìn thấy. Thường thì các view component là các trang JSP hay HTML đơn giản. Tuy nhiên, các view component cũng có thể sử dụng WML hay các công nghệ khác. Đây là một ưu điểm thiết kế chính của MVC. Bạn có thể sử dụng bất kỳ công nghệ hiển thị nào mà không sợ tác động đến lớp Model của ứng dụng.

Controller component : Ở trung tâm của kiến trúc MVC là các controller component. Controller thường là một serlvet tiếp nhận các request cho ứng dụng và quản lý luồng dữ liệu giữa lớp Model và lớp View. Như vậy, nó điều khiển cách mà các lớp Model và View tương tác. Controller thường sử dụng các helper class để chuyển điều khiển qua các request hay tiến trình xác định.

4 SƠ LƯỢC VỀ STRUTS :

Mặc dù kiến trúc MVC cung cấp một khả năng mạnh mẽ trong việc tổ chức code, việc phát triển vẫn gặp phải một số vấn đề “đau khổ”. Đó là nơi Struts nhảy vô. Struts là một Web application framework hướng tới việc phát triển các ứng dụng Web dựa trên Java. Vậy thực sự nó là cái gì? Có phải Struts là một phần bổ xung (add on) hay mở rộng của một ứng dụng Web MVC? Hay Struts chỉ là vài thư viện? Thực sự thì Struts là mỗi thứ một chút. Struts cung cấp nền tảng, hay framework, để xây dựng một ứng dụng hướng MVC cùng với các thư viện và tiện ích để làm cho việc phát triển MVC được nhanh hơn và dễ dàng hơn.

Bạn có thể tạo mới một Controller mỗi lần bạn muốn sử dụng mẫu thiết kế MVC trong ứng dụng Web của mình. Thêm vào đó, bạn cần tạo management/flow logic để chuyển và lấy dữ liệu từ Model và sau đó định hướng tới View. Bạn cũng cần định nghĩa giao diện để tương tác với các Model object và tất cả các utility code đi kèm để sử dụng mẫu thiết kế MVC. Tuy nhiên, thay vì lặp lại tiến trình này mỗi khi bạn tạo một ứng dụng mới, bạn có thể sử dụng Struts. Struts cung cấp cấu trúc và outline cơ bản để xây dựng ứng dụng, cho phép bạn tập trung vào xây dựng bussiness logic mà không phải lo nhiều đến các thứ “linh tinh” khác.

P a g e | 6

5 THÀNH PHẦN CƠ BẢN CỦA STRUTS :

Struts là một tập hợp các thư viện Java và có thể chia ra làm các nhóm sau:

Framework cơ sở : cung cấp các tính năng MVC cốt lõi. Nền tảng của framework cơ sở là Controller servlet: ActionServlet. Phần còn lại của framework cơ sở bao gồm các lớp cơ sở mà ứng dụng của bạn sẽ extend và các class tiện ích. Nổi bật nhát trong các lớp cơ sở là lớp Action và lớp ActionForm. Lớp Action được sử dụng bởi ActionServlet để sử lý các request xác định. Lớp ActionForm được sử dụng để capture dữ liệu từ các HTML form và được sử dụng để chuyển dữ liệu trở lại View để generate response.

Thư viện thẻ JSP : Struts đưa ra các thư viện thẻ để hỗ trợ việc lập trình View logic trong JSP. Các thư viện thẻ JSP cho phép các JSP author sử dụng các thẻ giống HTML

HTML: Sử dụng để generate các THML form tương tac với Struts API Bean: Sử dụng để làm việc với các Java bean object trong JSP Logic: Sử dụng để implement các logic điều kiện đơn giản trong JSP Nested: Sử dụng để cho phép các mức nested tùy ý

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

Validator plugin : là một framework với khả năng thực hiện xác nhận tính hợp lệ của dữ liệu ở cả phía server và client.

Tiến trình thực hiện :

Trước khi đi vào chi tiết các lớp, nghía qua một chút về tiến trình thực hiện của một ứng dụng Web sử dụng Struts cũng có lẽ ko thừa:

1. Trình duyệt tạo một request tới ứng dụng Struts sẽ được xử lý bới ActionServlet (Controller).

2. ActionServlet (Controller) populate subclass của ActionForm (View), do ta viết, với dữ liệu form HTML và invoke method validate() của nó.

3. ActionServlet (Controller) execute subclass của Action do ta viết (Controller).4. Subclass của Action (Controller) đó sẽ tương tác với model component và chuẩn bị dữ

liệu cho để hiển thị.5. Sau đó subclass của Action (Controller) đó sẽ chuyển điều khiển tới JSP (View).6. JSP (View) sử dụng dữ liệu nhận được để generate response về cho trình duyệt.

P a g e | 7

6 TÌM HIỂU MODEL LAYER :

Trong một ứng dụng MVC, Model layer thường là phần lớn nhất và quan trọng nhẩt. Model là ngôi nhà của code bussiness logic và truy nhập dữ liệu; nói cách khác, Model chứa phần nhân của ứng dụng.

Kiến trúc MVC chỉ ra rằng Model layer nên độc lập với các layer View và Controller. Theo cách đó, code nhân ứng dụng có thể được sử dụng lặp lại với nhiều giao diện. Mỗi giao diện (Web, stand-alone, ...) chứa mã riêng nó cho giao diện người dùng (View) nhưng có thể tái sử dụng nhân ứng dụng (Model). Đó là điều cơ bản trong kiến trúc MVC: tạo một sự phân tách rõ ràng và giảm thiểu sự phụ thuộc giữa các layer.

a) Phân rã Model : Thường thì một Model layer của một ứng dụng MVC được thiết kế tốt được chia làm 3 layer con. Mỗi layer con có thể được xem như một thành phần (component) của Model. Mỗi layer con không nhất thiết phải được thể hiện trong các class riêng biệt. Bạn có thể gộp tất cả các phần code cho các layer này vào trong một class lớn. Việc lựa chọn cách thể hiện là tùy thuộc vào bạn nhưng cấn chú ý đến độ phức tạp của chương trình và việc bảo trì cũng như mở rộng sau này. Các layer con bao gồm:

+ External interface: Chứa các code để cung cấp một giao diện cho phép tương tác với Model+ Bussiness logic: Chứa đựng phần lớn mã Model và cung cấp các tính năng business cho ứng dụng+ Data access: Chứa code để tương tác với nguồn dữ liệu của ứng dụng, chẳng hạn CSDL

7 STRUTS & MODEL

Struts framework không cung cấp bất cứ đặc trưng hay ràng buộc xác định nào trong việc phát triển Model layer trong ứng dụng của bạn. Khi nhìn thoáng qua lần đầu, điều này có vẻ hơi kỳ quặc, vì Struts được thiết kế để xây dựng các ứng dụng MVC. Tuy nhiên, nó lại nắm giữ một đặc trưng thiết kế chính của Struts và là một điểm lợi. Vì không bắt buộc Model layer phải được xây dựng như thế nào, Struts mang lại cho bạn sự mềm dẻo đẻ sử dụng bất cứ cách tiếp cận hay công nghệ nào để xây dựng Model layer, chúng có thể là EJB, JDO hay mẫu DAO.

Vì Model định nghĩa business logic, nó là nơi kết thúc của Struts và code ứng dụng của bạn bắt đầu. Code Model của bạn sẽ được truy nhập bởi các subclass của Action (Action là một phần của Controller của Struts framework). Các subclass của Action tương tác với Model thông qua giao diện của Action và sử dụng Data Transfer Object để chuyển và lấy dữ liệu.

Bạn ko nên đặt bất cứ code business logic hay truy cập dữ liệu nào trong các Action object. Điều này bỏ qua việc phân tách Model và Controller. Tương tự, code Model của bạn không nên tham chiếu tới bất cứ Struts code hay object. Vi phạm luật này, sẽ tạo sự ràng buộc không cần thiết giữa code nhân ứng dụng và Struts.

P a g e | 8

8 KIẾN TRÚC STRUTS 2:

Struts và webwork đã kết hợp với nhau để phát triển nên Struts 2 Framework. Struts 2 Framework rất thích hợp và dễ dàng mở rộng để phát triển các ứng dụng web với mức độ khác nhau.

a) Vòng đời của các yêu cầu trong ứng dụng Struts 2 Người sử dụng gửi yêu cầu đến server để yêu cầu một số tài nguyên của ứng dụng

Bộ điều khiển lọc (FilterDispatcher) xem xét yêu cầu và sau đó xác định một Action thích hợp.

Các bộ chặn (Interceptors) được ứng dụng: các cấu hình bộ chặn áp dụng cho các chức năng chung như: luồng công việc, thẩm định, tải file … được tự động ứng dụng vào yêu cầu.

Thực thi Action: sau khi phương thức action được thực thi để thực hiện các hoạt động liên quan đến cơ sở dữ liệu như sắp xếp hoặc nhận dữ liệu từ cơ sở dữ liệu

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

quả trả về cho phép chúng ta thực hiện thu dọn hoặc thêm quá trình xử lý. Hiển thị kết quả cho người sử dụng: việc điều khiển cuối cùng được trả về cho

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

Action ContextCleanUp filter : là một tùy chọn và nó được sử dụng khi tích hợp với các công nghệ khác như SiteMash Plugin

FilterDispatcher : tiếp đến, FilterDispatcher (bộ điều khiển lọc) được gọi, nó quay lại sử dụng ActionMapper để xác định Action nào được triệu gọi. Nếu action được yêu cầu được triệu gọi thì FilterDispatcher ủy nhiệm việc điều khiển lại cho ActionProxy.

ActionProxy :ActionProxy nhận sự giúp đỡ từ bộ quản lý cấu hình file (Configuration Files manager), được khởi tạo từ file struts.xml. Sau đó ActionProxy tạo ra một ActionInvocation, thực thi (implement) từ mẫu lệnh. ActionInvocation xử lý triệu gọi bộ chặn (Interceptors) nếu nó được cấu hình và sau đó triệu gọi Action. ActionInvocation tìm kiếm kết quả thích hợp, sau đó kết quả được thực thi, nó triệu gọi việc sinh ra trang các JSP hoặc các mẫu.Sau đó, các Interceptor được thực thi một lần nữa theo thứ tự ngược lại. Việc trả về kết quả cuối cùng thông qua các bộ lọc được cấu hình trong file web.xml. Nếu bộ lọc ActionContextCleanUp được cấu hình, thì FilterDispatcher không dọn dẹp ThreadLocal ActionContext. Nếu bộ lọc ActionContextCleanUp không có thì FilterDispatcher sẽ dọn dẹp tất cả các ThreadLocal tồn tại.

P a g e | 9

9 SO SÁNH STRUTS2 & STRUTS 1 :

Những điểm khác nhau của Strut 2 so với Strut 1 :

1. Phụ thuộc vào Servlet API : Các Action trong Struts 1 bị phụ thuộc vào servlet API bởi vì các đối tượng HttpServletRequest và HttpServletResponse được truyền vào phương thức execute của Action khi Action được thực thi. Trong trường hợp của Struts 2, Action chỉ là một class bình thường và chúng ta không cần truyền đối tượng HttpServletRequest và HttpServletResponse cho phương thức execute.

Do Struts 2 không phụ thuộc vào API của servlet nên chúng ta có thể dễ dàng test các Action mà không cần chạy chúng trong web container. Mặc dù vậy các Action của Struts 2 vẫn có cách để truy cập đến các đối tượng request và response khi cần.

2. Các lớp Action : Tư tưởng lập trình dựa trên việc extends từ class có sẵn chứ không phải dựa vào việc sử dụng interface chính là nhược điểm của Struts 1.Action của Struts 1 được quy định phải extends một lớp abstract của Struts 1, trong khi đó trong Struts 2 Action của bạn có thể là bất kỳ một lớp Java nào.Struts 2 cũng cung cấp một interface chung cho các Action là interface ActionSupport, tuy vậy việc implement interface này không bắt buộc.

3. Validate dữ liệu : Struts1 and Struts 2 both supports the manual validation via a validate method. Cả Struts 1 và 2 đều hỗ trợ validate dữ liệu thông qua phương thức validate.Struts 1 sử dụng phương thức validate dữ liệu trong class ActionForm, hoặc validate dựa vào thành phần mở rộng Common Validator. Struts 2 hỗ trợ validate bằng phương thức validate và sử dụng XWork Validation. XWORK Validation hỗ trợ việc validate dữ liệu bằng việc kết hợp một chuỗi các bộ validate và validate dữ liệu dựa vào kiểu của thuộc tính và ngữ cảnh.

Action classes Nhược điểm của Struts 1 chính là sử dụng lớp abstract chứ không phải interface. Action yêu cầu phải kế thừa từ một lớp abstract nào đó.

Trong Struts 2 Action có thể là bất kỳ một lớp Java nào. Struts 2 cũng cung cấp một interface chung cho các Action là interface ActionSupport, tuy vậy việc thực thi interface này không bắt buộc. Một vài đối tượng POJO có thể được sử

P a g e | 10

dụng như là một đối tượng Action trong Struts 2.

Threading Model Các Action là singleton vì thế chúng phải được thread-safe bởi vì chỉ có một thể hiện của lớp để giữ lại tất cả request đối với Action đó.Trong vấn đề phát triển ứng dụng, đảm bảo tài nguyên Action được thread safe hoặc đồng bộ.

Trong Struts 2 các đối tượng được khởi tạo cho mỗi request ,do đó không có thread-safety.Một servlet container sinh ra nhiều đối tượng throw-away cho mỗi request.

Servlet Dependency Actions bị phụ thuộc vào thư viện servlet API bởi vì HttpServletRequest và HttpServletResponse được truyền vào phương thức execute khi Action được thực thi.

Action chỉ là một lớp bình thường và chúng ta không cần truyền đối tượng HttpServletRequest và HttpServletResponse cho phương thức execute. Struts 2 không phụ thuộc vào API của servlet bởi chúng tạo các POJO đơn giản.Chúng ta có thể dễ dàng test các Action mà không cần chạy chúng trong web container. Mặc dù vậy các Action của Struts 2 vẫn có thể truy cập đến các đối tượng request và response nếu cần.Các servlet context thường được biểu diễn bởi đối tượng Map đơn giản.

Testability Ứng dụng Struts1 có một vấn đề chính trong việc testing bởi vì phương thức execute phụ thuộc vào Servlet API. Struts TestCase cung cấp một tập hợp các đối tượng Mock cho Struts 1.

Các Action có thể test các khởi tạo Action.Các Action là một POJO đơn giản và không phụ thuộc framework,vì thế việc test trở lên đơn giản hơn

Harvesting Input Struts1 sử dụng một đối tượng ActionForm để giữ các input.Giống như các Action, tất cả các ActionForms cần được thừa kế lớp ActionForm cơ bản . Các JavaBean không thể sử dụng như ActionForms, trong khi các nhà phát triển tạo các lớp không cần thiết để giữ input.

Struts2 sử dụng các thuộc tính Action để giới hạn sự cần thiết cho các đôi tượng input thứ 2. Từ đó giảm sự dư thừa. Thêm vào đó, các thuộc tính Action có thể truy cập từ các trang web thông qua các thẻ taglib. Struts2 cũng hỗ trợ các ActionForm

P a g e | 11

Các DynaBean là cách thức tốt nhất để tạo ActionForm chuyển đổi.

tốt hơn là các đối tượng POJO và các Action POJO. Nhiều kiểu đối tượng bao gồm các nghiệp vụ hoặc các đối tượng domain có thể sử dụng như là một đối tượng input/output.

Expression Language Struts 1 tương tác với JSTL, do đó sử dụng JSTL-EL.EL Struts1 có một đối tượng đồ họa cơ bản, nhưng có quan hệ tập hợp và hỗ trợ chỉ mục thuộc tính yếu.

Struts 2 có thể sử dụng JSTL,nhưng framework cũng hỗ trợ nhiều chức năng mạnh mẽ và ngôn ngữ biểu thức linh hoạt gọi là “Object Graph Notation Language) (OGNL).

Binding values into views Struts 1 ràng buộc đối tượng bên trong ngữ cảnh của trang bằng cách sử dụng cơ chế JSP chuẩn.

Struts 2 sử dụng công nghệ ValueStack để đảm bảo việc truy cập giá trị bằng taglib không thông qua coupling hoặc rendering. The ValueStack strategy cho phép sử dụng lại các view thông qua một lượng lớn các kiểu mà nó có thể có các tên thuộc tính giống nhau nhưng khác kiểu thuộc tính

Type Conversion Trong Struts 1 các thuộc tính của ActionForm hầu hết định dạng là String.Việc chuyển đổi dựa trên từng lớp, không được cấu hình dựa trên thể hiện của lớp.

Struts 2 sử dụng OGNL đối với việc chuyển kiểu dữ liệu.

Validation Struts 1 sử dụng phương thức validate dữ liệu trong lớp ActionForm,hoặc sử dụng thành phần mở rộng của Commons Validator.Các lớp có thể có các ngữ cảnh validate khác nhau cho các lớp tương tự nhau,trong khi đó việc móc nối validate trên

Struts 2 hỗ trợ validate bằng phương thức validate và sử dụng XWork Validation. XWORK Validation hỗ trợ việc validate dữ liệu bằng việc kết hợp một chuỗi các bộ validate và validate dữ liệu dựa vào kiểu của thuộc

P a g e | 12

các đối tượng con là không được phép.

tính và ngữ cảnh.

Control Of Action Execution

Mỗi module trong Struts 1 có sự tách rời Request Processors (vòng đời),trong khi tất cả các Action trong module cần phải chia sẻ cùng vòng đời.

Trong Struts 2 các vòng đời khác nhau được tạo ra dựa trên nền tảng Action thông qua Interceptor Stacks. Các stack tùy biến được tạo ra và sử dụng với Action khác nhau.

10 HƯỚNG DẪN XÂY DỰNG STRUT 2 CƠ BẢN :

Download Struts framwork từ http:// struts .apache.org .Để tạo một ứng dụng mới chúng ta sẽ bắt đầu tạo một ứng dụng web từ đầu.

Tạo cấu trúc ứng dụng web  với các thư mục như sau. Ứng dụng web của chúng ta sẽ chạy trên Tomcat server:

\MyStrutsFolder\\MyStrutsFolder\META-INF\\MyStrutsFolder\WEB-INF\\MyStrutsFolder\WEB-INF\classes\\MyStrutsFolder\WEB-INF\lib\

Sau đây là những file cơ bản nhất ta cần cho ứng dụng.

Copy các file sau từ thư mục \struts-2.0.11-all\struts-2.0.11\lib vào thư mục WEB_INF/lib của ứng dụng ta mới tạo:

struts2-core.jarxwork.jarognl.jarfreemarker.jarcommons-logging.jar

Nếu bạn cần thêm plugin hoặc thư viện nào khác thì cũng copy vào thư mục WEB_INF/lib

Tạo file web.xml trong thư mục \WEB-INF như sau:

<?xml version="1.0"?><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""http://java.sun.com/dtd/web-app_2_3.dtd">

P a g e | 13

<web-app> <display-name>My Application</display-name> <filter> <filter-name>struts2</filter-name> <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class> </filter>

<filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping></web-app>

Tạo file struts.xml file trong thư mục \WEB-INF\classes như sau:

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts><!-- Configuration for the default package. --><package name="default" extends="struts-default">

...</package>

</struts>

Ta đã có một ứng dụng Struts 2 bạn có thể bắt đầu viết code bằng việc thêm vào các file jsp, java ...etcPosted in Advance java. Tags: advance, java, struts, struts 2 . No Comments »

11 TÀI LIỆU THAM KHẢO :