project spring framework

Nhóm BDGSPRING MVC

TRƯỜNG ĐẠI HỌC KHOA HỌC TỰ NHIÊN

KHOA CÔNG NGHỆ THÔNG TIN

LẬP TRÌNH ỨNG DỤNG JAVA

SE08 – SPRINGGV. Nguyễn Hoàng Anh

[Đề tài tìm hiểu lần 3]

[Nhóm BDG]

STT MSSV HỌ TÊN

1 1041309 NGUYỄN CÔNG BÌNH

2 1041317 TRẦN NGỌC HOÀI DUY

3 1041327 LỘ THÔI MINH ĐÔNG

Nhóm BDGSPRING MVC

Mục LụcI. Tổng quan về Spring Framework...............................................................................5

1. Giới thiệu về Spring Framework............................................................................5

2. Spring với Enterprise Java Bean............................................................................5

2.1. Spring.........................................................................................................5

2.2. EJB (Enterprise Java Bean).............................................................................6

2.3. So Sánh Spring và EJB...................................................................................5

3. Mục đích của Spring............................................................................................6

4. Các phiên bản của Spring MVC.........................................................................6

5. Yêu cầu về kỹ thuật..........................................................................................6

6. Yêu cầu cài đặt...................................................................................................6

7. Module trong Spring Framework...........................................................................6

7.1. Spring Core Container....................................................................................8

7.2. Spring Context/ Application Context.................................................................8

7.3. Spring AOP(Aspect- Oriented).........................................................................8

7.4. Spring DAO..................................................................................................8

7.5. Spring ORM.................................................................................................9

7.6. Spring Web Module.......................................................................................9

7.7. Spring MVC Framework................................................................................9

8. Kiến trúc MVC(Model – View- Controller)..............................................................9

8.1. Thành phần của MVC....................................................................................9

8.2. Motivation for MVC.....................................................................................10

8.3. MVC trong Spring.......................................................................................10

9. Cơ chế Validation..............................................................................................10

10. Kiến trúc lưu trữ dữ liệu trên Database(Data access with JDBC)..............................11

10.1. Giới thiệu về Spring Framework JDBC..........................................................11

10.2. Kiểm soát các kết nối cơ sở dữ liệu.................................................................12

11. Kiến trúc ORM(Object Relationship Mapping).....................................................12

11.1. Giới thiệu về ORM trong MVC.....................................................................12

11.2. General ORM integration considerations........................................................13

II. Web MVC FrameWork........................................................................................13

Nhóm BDGSPRING MVC

1. Giới thiệu về Web MVC framework......................................................................14

2. DispatcherServlet..............................................................................................14

3. Implementing Controllers...................................................................................18

3.1. Định nghĩa Controllers với @Controllers.........................................................19

3.2. Lập bản đồ các yêu cầu với @ RequestMapping................................................19

4. Handler Mapping..............................................................................................20

5. Resolving views.................................................................................................23

5.1. Giải quyết các view bằng giao diện ViewResolver...............................................23

5.2. Chaining ViewResolvers................................................................................25

5.3. Chuyển đến view.........................................................................................26

5.4. ContentNegotiatingViewResolver....................................................................27

6. Using locales.....................................................................................................29

6.1. AcceptHeaderLocaleResolver.........................................................................29

6.2. CookieLocaleResolver...................................................................................30

6.3. SessionLocaleResolver..................................................................................30

6.4. LocaleChangeInterceptor..............................................................................30

7. Using themes....................................................................................................31

7.1. Tổng quan về themes....................................................................................31

7.2. Định nghĩa themes.......................................................................................31

7.3. Phân giải Theme..........................................................................................32

8. Spring’s multipart(fileupload) support..................................................................33

8.1. Giới thiệu...................................................................................................33

8.2. Sử dụng MultipartResolver............................................................................33

8.3. Xử lý một tập tin tải lên trong một biểu mẫu.....................................................34

9. Handling exceptions...........................................................................................35

9.1. HandlerExceptionResolver............................................................................35

9.2. @ExceptionHandler.....................................................................................36

10. Convention over configuration support................................................................37

10.1. Controller-ControllerClassNameHandlermapping............................................37

10.2. The Model ModelMap (ModelAndView).........................................................38

10.3. The View – RequestToViewNameTranslator...................................................39

11. Etag support...................................................................................................40

12. Configuring Spring MVC..................................................................................41

Nhóm BDGSPRING MVC

12.1. mvc:annotation-driven................................................................................41

12.2. mvc:interceptors........................................................................................42

12.3. mvc:view-controller....................................................................................43

12.4. mvc:resources............................................................................................43

12.5. mvc:default-servlet-handler.........................................................................43

III. Demo HelloSpringMVC.......................................................................................44

1. Bước 1: Tạo Project...........................................................................................44

2. Bước 2: Tạo Service...........................................................................................46

3. Bước 3: Tạo Controller.......................................................................................46

4. Bước 4: Tạo View..............................................................................................48

5. Bước 5: Cấu hình..............................................................................................49

IV. Ứng Dụng: Đồ án Java Lý thuyết: Chợ Lớn- Gia Dụng..............................................50

V. Tham Khảo........................................................................................................50

Nhóm BDGSPRING MVC

I. Tổng quan về Spring Framework

Spring Framework - Kiến trúc và ứng dụng

1. Giới thiệu về Spring Framework

- Spring là một application framework mã nguồn mở, được giới thiệu vào năm 2002.

Rod Johnson đã đưa ra ý tưởng này từ kinh nghiệm làm việc với kiến trúc J2EE.

- Ông ta đã viết cuốn sách với tiêu đề: “J2EE Develoment without using EJB” để giới

thiệu khái niệm trình chứa hạng nhẹ (lightweight container). Với lý luận: EJB thì có giá

trị của nó, nhưng không phải lúc nào cũng cần thiết và phù hợp cho tất cả các ứng dụng.

- Như Hibernate chống lại CMP về nguyên lý cơ bản của kỹ thuật ORM, Spring chống

lại EJB vì sự phức tạp và không phù hợp cho các unit test. Thay vì EJB, Spring sử dụng

Java bean, với một vài sự thay đổi để thu được tất cả các thuận lợi mà môi trường EJB

đưa ra. Do đó Spring là một sự lựa chọn khác so với EJB.

2. Giới thiệu với Enterprise Java Bean

2.1.Spring

- Spring không phải là một kỹ thuật persistence nhưng nó cho phép tích hợp với các kỹ

thuật khác. EJB thì tập trung vào kỹ thuật persistence và bây giờ nó đã cộng tác với

Nhóm BDGSPRING MVC

Hibernate, một ORM tốt nhất ngày nay. Nó đang dự định cộng tác với một kỹ thuật

ORM tốt khác là JDO (cung cấp cho Object Database).

- Trong Spring, chúng ta có thể sử dụng Java Bean để rút trích các thứ mà lúc trước chỉ

có thể với EJB. Mục tiêu chính của Spring là đơn giản việc phát triển J2EE và testing.

2.2.EJB (Enterprise Java Bean)

- EJB được xuất hiện vào 1988 và là một chuẩn, đặc tả trong thế giới Enterprise. Mặc dù

có một số kỹ thuật Java gần đây, nhưng không có kỹ thuật nào đáng kể so với EJB về

mặc tổng các đặc tính của nó.

- Theo Rod Johnson thì EJB không phức tạp nhưng nó cố gắng cung cấp cách giải quyết

cho các vấn đề phức tạp. EJB được phát triển chính cho các giao dịch, đối tượng được

phân phát ở trên máy khác. Nhưng một số enterprise project không có mức độ phức tạp

và vẫn sử dụng EJB và thậm chí các ứng dụng đơn giản trở nên phức tạp. Trong trường

hợp này thì Spring là một sự chọn lựa.

- Từ lúc Spring hỗ trợ các dịch vụ ở mức enterprise, thì nó tuyên bố là một sự lựa chọn

khác đối với EJB.

Thuận lợi của EJB:a) Transaction Managementb) Declarative Transaction supportc) Persistence ( CMP & BMP)d) Declarative Securitye) Distributed Computing (Container managed RPC)

Spring không cố gắng làm mọi thứ nhưng nó hỗ trợ những kỹ thuật tốt nhất cho mỗi yêu cầu.Thay vì CMP & BMP, nó hỗ trợ một vài kỹ thuật persistence khác như JDO, Hiberbate và OJB. Các ORM tool này thì có nhiều khả năng cài đặt hơn CMP. Để đơn giản coding JDBC, có một tool là iBatis và Spring cũng hỗ trợ nó.

2.3.So Sanh Spring va EJB

Nhóm BDGSPRING MVC

- Spring sử dụng Acegi, một security framework mã nguồn mở và cung cấp để khai báo

security thông qua cấu hình Spring hoặc class metadata, trong khi EJB khai báo security

được cấu hình thông qua mô tả demployment.

- Spring cung cấp proxying cho RMI (kỹ thuật remoting đặc biệt như Burlap) JAX-RPC

& web-service, trong khi EJB cung cấp lời gọi phương thức ở xa được quản lý bởi

container.

- Spring có thể cung cấp khai báo transaction như EJB. Hơn nữa, Spring còn cung cấp

khai báo thủ tục rollback cho các phương thức và exception.

- Do đó, trong khi EJB thì cứng và cố gắng làm mọi thứ, một vài công việc tốt nhưng

một số thì không. Spring chỉ sử dụng Java Bean và thông qua một số kỹ thuật đặc biệt để

cung cấp nhiều chức năng như EJB, bằng cách tích hợp với một số kỹ thuật open source

khác.

Do đó, nó cung cấp một vài thuận lợi hơn EJB như:

a) Testing dễ dàng hơn - không cần khởi động EJB container để test.

b) Spring dựa vào quy ước của chuẩn Java Bean, nên programmer dễ dàng làm việc với

nó.

c) Nó sử dụng AOP (Aspect-Oriented Programming), mô hình hữu ích để bổ sung vào

OOP truyền thống và bảo toàn tính nguyên vẹn của OOP.

d) Nó thì uyển chuyển.

3. Mục đích của Spring

- Mục đích của Spring là trở thành một application framework. Các framework phổ biến khác như Struts, Tapestry, JSF,... là các framework tốt cho tầng web nhưng khi chúng ta sử dụng các framework này, chúng ta phải cung cấp thêm framework khác để giải quyết tầng enterprise mà tích hợp tốt với các framework này. Spring làm giảm bớt vấn đề này bằng cách cung cấp một framework toàn diện bao gồm:

• Core bean container• MVC framework

Nhóm BDGSPRING MVC

• AOP integration framework• JDBC integration frameworkEJB integration framework

1. Các phiên bản của Spring MVC

– Tháng 10/2006: phát hành Spring 2.0

– Tháng 11/2007: phát hành Spring 2.5

– Hiện tại: Spring 3.0

– Download: http://www.springsource.org/download

– Document: http://www.springsource.org/documentation

1. Yêu cầu về kỹ thuật

– Để triển khai ứng dụng web sử dụng Spring framework cần cài đặt PHP 5.1.0 trở lên

– Hiểu rõ phương pháp lập trình hướng đối tượng(OOP) vì đây là một framework được

thiết kế theo phương pháp hướng đối tượng thuần túy.

– Hiểu rõ về mô hình MVC

1. Yêu cầu cài đặt

– Operating System: Windows 7

– NetBeans IDE: 6.9 hoặc 6.9.1, phiên bản Java

– Java Development Kit(JDK) Phiên bản 6

– GlassFish Server Edition nguồn mở 3.0.2, yêu cầu JDK 6

– PHP: 5.3.0

– Máy chủ cơ sở dữ liệu MYSQL: 5.1.3

– Spring Framework 3.5

1. Module trong Spring Framework

http://www.springsource.org/documentation

http://www.springsource.org/download

Nhóm BDGSPRING MVC

– Spring Framework gồm có quy mô của 20 modules, được chia thành các nhóm

Core Container, Data Access/Intergration, Web, AOP(Aspect Oriented Programing),

Instrumentation, and Test như mô hình dưới đây:

– Spring cũng cung cấp module tích hợp với O/R tool như Hibernate và JDO.

Spring có thể được xem như một kiến trúc chứa 7 module. Chức năng của mỗi thành

phần như sau:

Nhóm BDGSPRING MVC

7.1. Core Container:

- Core container cung cấp chức năng cơ bản của Spring. Thành phần chính của nó là Bean Factory, một cài đặt của Factory pattern. BeanFactory áp dụng IoC pattern để đặc tả sự phụ thuộc từ code của ứng dụng.

7.2. Spring Context/Application Context:

- Spring context là một file cấu hình để cung cấp thông tin ngữ cảnh của Spring. Spring context cung cấp các service như JNDI access, EJB integration, e-mail, internalization, validation, và scheduling functionality.

7.3. Spring AOP (Aspect-Oriented):

- Spring AOP module tích hợp chức năng lập trình hướng khía cạnh vào Spring framework thông qua cấu hình của nó. Spring AOP module cung cấp các dịch vụ quản lý giao dịch cho các đối tượng trong bất kỳ ứng dụng nào sử dụng Spring. Với Spring AOP chúng ta có thể tích hợp declarative transaction management vào trong ứng dụng mà không cần dựa vào EJB component.

Nhóm BDGSPRING MVC

- Spring AOP module cũng đưa lập trình metadata vào trong Spring. Sử dụng cái này chúng ta có thể thêm annotation vào source code để hướng dẫn Spring nơi và làm thế nào để liên hệ với aspect.

7.4. Spring DAO:

- Tầng JDBC và DAO đưa ra một cây phân cấp exception để quản lý kết nối đến database, điều khiển exception và thông báo lỗi được ném bởi vendor của database. Tầng exception đơn giản điều khiển lỗi và giảm khối lượng code mà chúng ta cần viết như mở và đóng kết nối. Module này cũng cung cấp các dịch vụ quản lý giao dịch cho các đối tượng trong ứng dụng Spring.

7.5. Spring ORM:

- Spring có thể tích hợp với một vài ORM framework để cung cấp Object Relation tool bao gồm: JDO, Hibernate, OJB và iBatis SQL Maps.

7.6. Spring Web module:

-Nằm trên application context module, cung cấp context cho các ứng dụng web. Spring cũng hỗ trợ tích hợp với Struts, JSF và Webwork. Web module cũng làm giảm bớt các công việc điều khiển nhiều request và gắn các tham số của request vào các đối tượng domain.

7.7. Spring MVC Framework:

- MVC Framework thì cài đặt đầy đủ đặc tính của MVC pattern để xây dựng các ứng dụng Web. MVC framework thì cấu hình thông qua giao diện và chứa được một số kỹ thuật view bao gồm: JSP, Velocity, Tiles và generation of PDF và Excel file.

Ví dụ: Có một số kỹ thuật tuyệt vời cho tầng web như: Spring MVC framework, Struts, JSF, WebWork, JSP, Tapestry, FreeMarker,...Developer sẽ bị lúng túng đối chiếu những điểm mạnh và xấu của tất cả chúng. Mỗi khi họ chọn một kỹ thuật và bắt đầu cài đặt, thì sau đó nếu họ muốn thay đổi một kỹ thuật khác thì rất khó. Nhưng Spring đưa ra các module cho tất cả các kỹ thuật trên, và rất đơn giản để thay đổi file cấu hình.

Với phương pháp này, nó có khả năng cho cả team thử và test các tất cả các hình thức trên và xem ảnh hưởng cùng tốc độ trước khi quyết định chọn lựa.

Nhóm BDGSPRING MVC

JSP là một view template mặc định. "InternalResouceViewResolver" có thể được sử dụng cho mục đích này.

1. Kiến trúc MVC(Model – View- Controller)

– Phân định rõ ràng các bước kết nối, chuyển hướng và logic hiển thị

– Chứng minh cơ chế xây dựng web từng lớp(Web- tier)

1.1.Thành phần của MVC

– Có 3 thành phần chính

○ Controller: quản lý logic chuyển hướng và tương tác với các dịch vụ được

cung cấp từ logic kết nối.

○ Model:

Là lớp giữa Controller và View.

Nơi chứa dữ liệu cần để xử lý và đưa lên View.

Nơi định cư của Controller.

○ View:

Đáp ứng hiển thị theo yêu cầu

Rút và xuất dữ liệu từ Model

1.1.Motivation for MVC

– Bảo trì dễ dàng hơn

○ Thay đổi logic kết nối ít có khả năng phá vỡ logic hiển thị

○ Ngược lại: Tăng khả năng làm việc nhóm

– Giúp Developers có thể chú trọng nhiều hơn đến việc phát triển code liên tục, mà

không cần lo lắng đến việc phá vỡ các thể hiện ban đầu.

– Giúp Designers có thể chú trọng nhiều hơn vào việc xây dựng giao diện sao cho

tiện dụng và bắt mắt mà không cần lo lắng về code Java.

– Sử dụng công cụ tốt nhất cho công việc

○ Java thích hợp để tạo code logic kết nối

○ Đánh dấu hay ngôn ngữ mẫu phù hợp để tạo HTML

Nhóm BDGSPRING MVC

– Dễ kiểm tra

○ Logic kết nối và chuyển hướng được phân cách rõ ràng với logic hiển thị,

nghĩa là có thể áp dụng những thử nghiệm riêng biệt.

○ Thực tế: ta có thể kiểm tra code bên ngoài servlet

1.1.MVC trong Spring

– Front Controller: servlet là các Controller riêng biệt đáp ứng một yêu cầu nào đó.

○ Chứng minh mô hình trong Struts và Core J2EE Patterns

– Yêu cầu định tuyến là hoàn toàn điều khiển bởi Front Controller

○ Các Controller riêng biệt có thể sử dụng để điều khiển cho nhiều URL khác

nhau.

– Controller là POJOs

– Controller được là quản lý trực tiếp giống như bất kỳ Bean khác trong Spring

ApplicationContext

1. Cơ chế Validation

– Validation sử dụng giao diện Spring’s Validator xác nhận đối tượng, chứng thực,

báo cáo các lỗi xác thực cho Errorobject.

– Ví dụ: xem xét một đối tượng dữ liệu nhỏ:

– Cung cấp các hành vi xác nhận cho lớp Person bằng cách thực thi hai phương

thức của org.springframework.validation

○ Supports(class)

○ Validate(object, org.springframework.validation.Errors

– Thực hiện một Validator đơn giản, sử dụng class ValidationUtilshelper do Spring

framework cung cấp.

Nhóm BDGSPRING MVC

1. Kiến trúc lưu trữ dữ liệu trên Database(Data access with JDBC)

1.1.Giới thiệu về Spring Framework JDBC

– Giá trị được cung cấp bởi Spring Framework JDBC trừu tượng thể hiện bởi các

chuỗi hành động được nếu trong bảng sau. Bảng này cho thấy những action Spring

quan tâm

Action Spring You

Xác định thông số kết nối X

Mở các kết nối X

Xác định các câu lệnh SQL X

Khai báo các thông số và giá trị cung cấp tham số X

Chuẩn bị và thực hiện các statement X

Thiết lập vòng lặp để chuyển đổi thông qua kết quả(nếu có) X

Làm việc cho mỗi lần lặp X

Quy trình các ngoại lệ X

Xử lý giao dịch X

Nhóm BDGSPRING MVC

Đóng kết nối báo cáo và statement và resultset X

– Các cách tiếp cận để truy cập cơ sở dữ liệu JDBC

○ JdbcTemplate

○ NamedParameterJdbcTemplate

○ SimpleJdbcTemplate

○ SimpleJdbcInsert and SimpleJdbcCall

○ RDBMS Objects including MappingSqlQuery, SqlUpdate and

StoredProcedure

– Gói phân cấp: Khung JDBC trừu tượng của Spring Framework bao gồm bốn gói

khác nhau: core, datasource, object, support

○ Org.springframework.jdbc.core

○ Org.springframework.jdbc.datasource

○ Org.springframework.jdbc.object

○ Org.springframework.jdbc.support

1.1.Kiểm soát các kết nối cơ sở dữ liệu

– DataSource

– DataSourceUtils

– SmartDataSource

– AbstractDataSource

– SingleConnectionDataSource

– DriverManagerDataSource

– TransactionAwareDataSourceProxy

– DataSourceTransactionManager

– NativeJdbExtractor

1. Kiến trúc ORM(Object Relationship Mapping)

1.1.Giới thiệu về ORM trong MVC

Nhóm BDGSPRING MVC

– Spring Framework hỗ trợ tích hợp với Hibernate, Java Persistence API (JPA),

Java Data Object và iBATIS SQL Maps dành cho quản lý tài nguyên, truy cập dữ

liệu đối tượng (DAO) triển khai thực hiện, và chiến lược giao dịch. Ví dụ, đối với

Hibernate có lớp đầu tiên hỗ trợ.

– Có thể cấu hình - tất cả các tính năng hỗ trợ cho O / R (đối tượng quan hệ) các

công cụ lập mapping thông qua Dependency Injection.

– Spring thêm những cải tiến đáng kể cho sự lựa chọn các lớp ORM khi tạo truy

cập dữ liệu ứng dụng. Có thể tận dụng càng nhiều các hỗ trợ hội nhập như ý muốn và

có thể so sánh. Sử dụng nhiều hỗ trợ của ORM như là thư viện, bất kể công nghệ bởi

nó được thiết kế như một tập hợp các JavaBeans có thể tái sử dụng. ORM trong một

container IoC Spring tạo điều kiện cấu hình và triển khai.

– Lợi ích của việc sử dụng Spring Framework để tạo ra DAO ORM:

○ Dễ dàng kiểm tra. Thay đổi cấu hình của SessionFactory Hibernate, JDBC

DataSource.

○ Xử lý các ngoại lệ

○ Quản lý tài nguyên, tích hợp quản lý giao dịch.

1.1.General ORM integration considerations

– Mục tiêu của Spring’s ORM intergration là lớp ứng dụng rõ ràng với bất kỳ truy

cập dữ liệu và giao dịch công nghệ. Không có dịch vụ business dựa vào việc truy cập

dữ liệu hoặc chiến lược giao dịch.

– Tất cả các tính năng truy cập dữ liệu cá nhân được sử dụng riêng nhưng tích hợp

với Spring, cung cấp các cấu hình dựa trên XML và tham chiếu chéo của JavaBean.

– Trong một ứng dụng Spring, nhiều đối tượng quan trọng như JavaBean: truy cập

dữ liệu mẫu, dịch vụ business có sử dụng truy cập dữ liệu hướng đối tượng và quản

lý giao dịch, phân giải trên web, điều khiển web có sử dụng dịch vụ business.

– Khi sử dụng Hibernate, JPA hoặc JDO trong DAO, phải quyết định làm thế nào

để xử lý handle the persistence của các lớp ngoại lệ.

Nhóm BDGSPRING MVC

II. Các khái niệm chính của Spring:

- Các khái niệm chính của Spring là: IoC và Aspect Orient Programming. Spring dựa vào Depenecy injection của IoC. Chúng ta không trực tiếp kết nối các component và service lại với nhau trong code mà thông qua file cấu hình. Một container thì chịu trách nhiệm móc nối nó. Khái niệm này thì tương tự với Declarative Management.

1. Dependency Injection:

- Depedency injection là một pattern chịu trách nhiệm tạo đối tượng và các liên kết giữa các đối tượng bị loại bỏ ra khỏi các đối tượng và chuyển đến cho factory quản lý.

- Các đối tượng của ứng dụng không chịu trách nhiệm tìm kiếm các resource mà chúng phụ thuộc. Và vì thế nên sự phụ thuộc được đảo ngược vào trong các đối tượng.

- Theo phương pháp này, các đối tượng có thể được rút trích thông qua Setter Injection (các thuộc tính của Java-Beans) hoặc Constructor Injection (tham số của constructor). Mỗi phương thức có thuận lợi và bất lợi riêng.

- Bình thường trong Java bean, chúng ta sử dụng phương thức setter và getter để thiết lập và lấy giá trị của thuộc tính như sau:

public class namebean { String name; public void setName(String a){ name = a; } public String getName(){ return name; }}

- Chúng ta sẽ tạo một thể hiện của bean "namebean" (gọi là bean1) và thiết lập thuộc tính: bean1.setName("Tom"). Còn trong setter injection, chúng ta thiết lập thuộc tính "name" trong subelement <property> của thẻ <bean> trong file cấu hình Spring như sau:

<bean id="bean1" class="namebean">

Nhóm BDGSPRING MVC

<property name="name" ><value>Tom</value></property></bean>

- Subelement <value> thiết lập thuộc tính "name" bằng cách gọi phương thức set như sau:setName("Tom"); => tiến trình này được gọi là setter injection.

- Ví dụ về constructor injection, chúng ta sử dụng constructor với một tham số:

public class namebean { String name; public namebean(String a){ name = a; } }

- Chúng ta sẽ thiết lập thuộc tính "name" trong khi tạo thể hiện của bean "namebean" như sau: namebean bean1 = new namebean("Tom");

- Ở đây chúng ta sử dụng element <constructor-arg> để thiết lập thuộc tính sử dụng constructor injection như sau:

<bean id="bean1" class="namebean"><constructor-arg><value>My Bean Value</value></constructor-arg></bean>

- Để thiết lập các thuộc tính tham chiếu đến bean khác - <ref>, subelement <property> được sử dụng như sau:

<bean id="bean1" class="bean1impl"><property name="game"><ref bean="bean2"/></property></bean><bean id="bean2" class="bean2impl" />

Nhóm BDGSPRING MVC

2. Aspect-oriented Programming:

- Kỹ thuật lập trình đưa ra cách phân chia các yêu cầu của hệ thống. Hệ thống được phân ra thành một vài component đảm trách một chức năng xác định. Bên cạnh các chức năng cơ bản thì các dịch vụ (yêu cầu hệ thống) như logging, transaction management, security...phải có trong chương trình. Các dịch vụ hệ thống này được gọi là 'cross-cutting concern' - nghĩa là chúng cắt chéo qua nhiều component trong hệ thống. AOP có khả năng module hóa các service này và sau đó cung cấp đến các component và chúng ta có thể tập trung vào yêu cầu chính (core concern). Trong Spring, lát cắt (aspect) được cắm vào trong các đối tượng của XML file như các JavaBean. Tiến trình này gọi là sự đan xen (weaving).

- Container là khái niệm chính của Spring. Để quản lý vòng đời và cấu hình các đối tượng của ứng dụng. Chúng ta có thể cấu hình mỗi bean nên được tạo như thế nào hoặc làm thế nào để tạo một instance của bean hoặc làm thế nào kết hợp chúng lại. Spring không sử dụng các EJB container hạnh nặng. Spring có 2 container phân biệt: Bean Factory được định nghĩa bởi org.springframework. beans.factory.BeanFactory là một container đơn giản nhất, cung cấp hỗ trợ dependency injection. Application context được định nghĩa bởi org.springframework.context.ApplicationContext, cung cấp các service của application framework.

2.1. Bean Factory:

- Bean factory thì cài đặt factory design pattern và chức năng của nó là tạo và phân phát các bean. Bean factory biết về nhiều đối tượng trong ứng dụng, nó có thể tạo mối kết hợp cho các đối tượng khi chúng được khởi tạo. Điều này sẽ giảm bớt gánh nặng cho bean và client.

- Có một vài cài đặt của BeanFactory. Một cái hữu ích nhất là org.springframework.beans.factory.xml.XmlBeanFacto ry. Nó sẽ load các bean dựa vào định nghĩa trong XML file. Để tạo một thể hiện của XmlBeanFactory, hãy chuyển vào constuctor của nó một InputStream. Resource này sẽ cung cấp XML cho factory.

BeanFactory factory = new XmlBeanFactory(new FileInputStream("myBean.xml")); => dòng này bảo bean factory đọc định nghĩa bean từ XML file. Định nghĩa bean bao gồm mô tả bean và các thuộc tính của nó. Nhưng bean factory vẫn chưa khởi tạo nó. Để rút trích một bean từ BeanFactory, hãy gọi phương thức getBean(). Khi phương thức

Nhóm BDGSPRING MVC

getBean() được gọi, factory sẽ khởi tạo bean và bắt đầu thiết lập các thuộc tính của nó sử dụng depedency injection.myBena bean1 = (myBean)factory.getBean("myBean");

2.2. Application Context:

- Trong khi Bean Factory được sử dụng cho các ứng dụng đơn giản, thì Application Context là một container nâng cao của Spring. Giống như BeanFactory, nó có thể được sử dụng để load các định nghĩa bean, gắn các bean với nhau và phân phát các bean theo yêu cầu.

Nó cũng cung cấp:1) giải quyết text message, bao gồm hỗ trợ internationlization.2) cách chung để load file resource.3) các sự kiện để bean được đăng ký như các trình lắng nghe.

Có 3 cách sử dụng cài đặt Application Context:

1) ClassPathXmlApplicationContext: Nó load định nghĩa context từ XML file được đặt trong classpath, xem các định nghĩa context như các tài nguyên của classpath. Application context thì được load từ classpath của ứng dụng như sau:

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

2) FileSystemXmlApplicationContext: Nó load định nghĩa context từ XML file trong từ hệ thống file. Application Context được load từ hệ thống file như sau:

ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml");

3) XmlWebApplicationContext: Nó sẽ load các định nghĩa context từ XML file trong ứng dụng web.

Spring thì nhẹ về cả kích cỡ và chi phí. Toàn bộ framework có thể được phân phát trong JAR file chỉ hơn 1.7MB. Chi phí được yêu cầu bởi Spring thì không đáng kể. Và Spring không ràng buộc, ví dụ: các đối tượng trong ứng dụng Spring không phụ thuộc vào các class của Spring.

III. Release info:

Nhóm BDGSPRING MVC

Spring framework được download ở trang http://www.springframework.org. Trên đó có 2 file zip: một file có dependencies, một file thì không. Spring framework với dependencies thì lớn hơn và chứa tất cả thư viện phụ thuộc.

Nội dung của phân phối "-with-dependencies" (~60 MB):* "dist" chứa các file jar của bảng phân phối và một file nén chứa tất cả source code.* "docs" chứa tài liệu có định dạnh PDF, HTML và javadocs.* "lib" chứa tất cả thư viện cần để xây dựng framework hoặc chạy các ví dụ.* "src" chứa các file Java source của framework.* "mock" chứa các file Java source cho mock và test.* "test" chứa file java cho bộ test của Spring.* "tiger/src" chứa các file JDK-1.5-specific Java source cho framework.* "tiger/test" chứa các file JDK-1.5-specific Java source cho bộ test của Spring.* "aspectj/src" chứa tất cả file AspectJ-specific source cho framework* "aspectj/test" chứa tất cả file AspectJ-specific source cho cho bộ test của Spring.* "samples" chứa các ứng dụng demo và chương trình giới thiệu.

IV. Spring Application:

Các bước tạo ứng dụng sử dụng Spring:

1. Một interface định nghĩa các chức năng.2. Một implementation chứa các thuộc tính, các phương thức settter và getter.3. Một file XML gọi là file cấu hình Spring.4. Chương trình client sử dụng chức năng trên.

//1. Một interface định nghĩa các chức năng.public interface Hello { public String sayHello(String s);}

//2. Một implementation chứa các thuộc tính, các phương thức settter và getter.public class HelloImpl implements Hello{ private String greeting; /** * Class constructor * @param s */ public HelloImpl(){

http://www.springframework.org/

Nhóm BDGSPRING MVC

} public HelloImpl(String s){ greeting = s; } /** * function */ public String sayHello(String s) { return greeting + s; } /** * @return Returns the greeting. */ public String getGreeting() { return greeting; } /** * @param greeting The greeting to set. */ public void setGreeting(String greeting) { this.greeting = greeting; }}

//3. Một file XML gọi là file cấu hình Spring.<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"><beans><bean id="hello" class="HelloImpl"><property name="greeting"><value>Good Morning!</value></property></bean></beans>

//4. Chương trình client sử dụng chức năng trên.import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.xml.XmlBeanFacto ry;

Nhóm BDGSPRING MVC

import org.springframework.core.io.ClassPathResource;

public class HelloClient {

/** * @param args */ public static void main(String[] args) { try { ClassPathResource resource = new ClassPathResource("hello.xml"); BeanFactory factory = new XmlBeanFactory(resource); HelloImpl bean = (HelloImpl) factory.getBean("hello"); String hello = bean.sayHello("LooDong"); System.out.println(hello); } catch (Exception e) { e.printStackTrace(); } }}

Chạy ứng dụng sẽ kết xuất như sau:2007/01/12 13:43:16 org.springframework.core.CollectionFactory <clinit>ld: JDK 1.4+ collections available2007/01/12 13:43:17 org.springframework.beans.factory.xml.XmlBeanDefin itionReader loadBeanDefinitionsld: Loading XML bean definitions from class path resource [hello.xml]Good Morning!LooDong

- Ở đây, HelloImpl cài đặt giao tiếp Hello. Mặc dù không cần thiết phải dấu cài đặt phía sau một giao tiếp. HelloImpl có một thuộc tính greeting. Thuộc tính này có thể được thiết lập theo 2 cách: bằng phương thức setter hoặc bằng constructor. File hello.xml khai báo một thể hiện của HelloImpl trong container của Spring và cấu hình giá trị của thuộc tính greeting là "Good Morning!".

- Root của file hello.xml là <beans> element - là root element của bất kỳ file cấu hình nào của Spring. Element <bean> được sử dụng để bảo Spring container về lớp và nó nên được cấu hình như thế nào. Ở đây, thuộc tính id là tên của interface và thuộc tính class

Nhóm BDGSPRING MVC

xác định tên lớp đầy đủ của bean.

- Trong <element> bean, element <property> được sử dụng để thiết lập thuộc tính, trong trường hợp này là thuộc tính greeting. Sử dụng <property>, chúng ta nói với Spring container gọi phương thức setGreeting(). Giá trị của greeting được định nghĩa trong element <value>.

- Container sẽ khởi tạo HelloImpl dựa vào định nghĩa XML như sau:

HelloImpl hello = new HelloImpl ();hello.setGreeting("Good Morning!...");

- Tương tự, thuộc tính greeting có thể được thiết lập thông qua constructor có 1 tham số của HelloImpl như sau:

<bean id="hello" class=" HelloImpl"><constructor-arg><value>Good Morning!...</value></constructor-arg></bean>

- Bây giờ thì container khởi tạo HelloImpl dựa vào định nghĩa XML như sau:HelloImpl hello = new HelloImpl("Good Morning...");

- Ở chương trình client, lớp BeanFactory được sử dụng là Spring container. Sau đó phương thức getBean() được gọi để lấy tham chiếu đến bean "hello". Với tham chiếu này thì phương thức sayHello() được gọi.

- Bước kế tiếp chúng ta sẽ xem làm thế nào để chạy chương trình này như một servlet. Đầu tiên copy spring.jar đến thư mục common\lib của Tomcat và khởi động tomcat server. Sau khi thiết lập classpath, tạo file HelloServlet.java như sau:

HelloServlet.javaimport java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;

Nhóm BDGSPRING MVC

import javax.servlet.http.HttpServletResponse;import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.xml.XmlBeanFacto ry;import org.springframework.core.io.ClassPathResource;

public class HelloServlet extends HttpServlet{ /** * */ private static final long serialVersionUID = 1L; @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String name = request.getParameter("userName"); response.setContentType("text/html"); ClassPathResource resource = new ClassPathResource("hello.xml"); BeanFactory factory = new XmlBeanFactory(resource); Hello bean = (Hello) factory.getBean("hello"); PrintWriter out = response.getWriter(); out.write(bean.sayHello(name)); }}

index.html<html><body><form method="post" action="http://localhost:8080/springservlet/hello"><input type="text" name="userName"/><input type="submit" value="sayHello"/></form></body></html>

web.xml<?xml version="1.0" encoding="UTF-8"?><web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee

Nhóm BDGSPRING MVC

http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"><display-name>springservlet</display-name><servlet><servlet-name>hello</servlet-name><servlet-class>HelloServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>hello</servlet-name><url-pattern>/hello</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.html</welcome-file></welcome-file-list></web-app>

– Bây giờ chúng ta sẽ vào tiến trình chính của bất kỳ ứng dụng enterprise nào: data persistence. Spring có framework data access riêng của nó. Spring chia phần cố định và tùy biến của tiến trình data access thành hai lớp phân biệt: Template và Callback. Template quản lý phần cố định của framework như data connection, quản lý tài nguyên, điều khiển giao dịch...Trong khi Callback định nghĩa các thứ được xác định trong ứng dụng như tạo statement, móc nối tham số...Lớp Template của Spring là JdbcTemplate. Một data source phải được cung cấp bên trong JdbcTemplate.

- Một ví dụ về kết nối CSDL sử dụng JdbcTemplate như sau. Ở đây chúng ta sử dụng CSDL MySQL. Sau khi tạo bảng user(name text, place text) trong CSDL test, chúng ta tạo chương trình như sau:

1. Tạo interface DataConnection chứa hàm lấy về một dataSource để cung cấp cho JdbcTemplate:

import javax.sql.DataSource;

public interface DataConnection { public DataSource getDataSource();}

Nhóm BDGSPRING MVC

2. Tạo cài đặt của interface đó chứa thuộc tính dataSource và các phương thức setter, getter:

import javax.sql.DataSource;

public class DataConnectionImpl implements DataConnection{ private DataSource dataSource;

public DataSource getDataSource() { return dataSource; } public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; }}

3. Tạo DataConServlet thực hiện nghiệp vụ là insert dữ liệu.:

import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.sql.DataSource;import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.xml.XmlBeanFacto ry;import org.springframework.core.io.ClassPathResource;import org.springframework.jdbc.core.JdbcTemplate;

public class DataConServlet extends HttpServlet { /** * */ private static final long serialVersionUID = 1L;

@Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

Nhóm BDGSPRING MVC

String name = request.getParameter("name"); String place = request.getParameter("place"); response.setContentType("text/html"); PrintWriter out = response.getWriter(); ClassPathResource resource = new ClassPathResource("applicationContext.xml"); BeanFactory factory = new XmlBeanFactory(resource); DataConnection bean = (DataConnection) factory.getBean("dataConnection"); DataSource ds = bean.getDataSource(); try { JdbcTemplate template = new JdbcTemplate(ds); String sql = "insert into user values ('" + name + "','" + place+ "')"; template.execute(sql); out.write("A record is added!"); } catch (Exception e) { e.printStackTrace(); } }}

4. Tạo client sử dụng servlet trên:

<html><body><form method="post" action="http://localhost:8080/springservlet/data"><table><tr><th>Name:</th><td><input type="text" name="name"/></td></tr><tr><th>Place:</th><td><input type="text" name="place"/></td></tr><tr><td><input type="submit" value="Add"/></td></tr></table>

Nhóm BDGSPRING MVC

</form></body></html>

5. Cấu hình bean “dataSource”:

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"><beans><bean id="hello" class="HelloImpl"><property name="greeting"><value>Good Morning!</value></property></bean><bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManager DataSource"><property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property><property name="url"><value>jdbc:mysql://localhost:3306/test</value></property><property name="username"><value>root</value></property><property name="password"><value>root</value></property></bean><bean id="dataConnection" class="DataConnectionImpl"><property name="dataSource"><ref local="dataSource"/></property></bean></beans>

Nhóm BDGSPRING MVC

6. Cấu hình servlet:

<?xml version="1.0" encoding="UTF-8"?><web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"><display-name>springservlet</display-name><servlet><servlet-name>data</servlet-name><servlet-class>DataConServlet</servlet-class></servlet><servlet-mapping><servlet-name>data</servlet-name><url-pattern>/data</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.html</welcome-file></welcome-file-list></web-app>

- Để mapping các resource của Hibernate, cần tạo một thể hiện của SessionFactory, LocalSessionFactoryBean thì được sử dụng cho mục đích này và các thuộc tính: hibernateProperties, mappingResources và mappingDirectoryLocation phải được thiết lập. Giống như framework DAO của Spring, chúng ta có HibernateTemplate để tạo đối tượng SessionFactory. Để truy cập vào dữ liệu với HibernateTemplate, phương thức execute(HibernateCallback) phải được sử dụng.

- Tương tự như SessionFactory của hibernate, JDO có PersistenceManagerFactory. Nó được cấu hình bởi LocalPersistenceManagerFactoryBean. JDOTemplate cũng để tạo một đối tượng của PersistenceManagerFactory. Để truy cập vào dữ liệu với JDOTemplate, phương thức execute(JDOCallback) phải được sử dụng.

Nhóm BDGSPRING MVC

V. Web MVC FrameWork

1. Giới thiệu về Web MVC framework

– Spring MVC(Model-View-Controller) framework được thiết kế xung quanh một

DispatcherServlet gởi thông điệp yêu cầu xử lý với các cấu hình handler mappings,

view resolution, local and theme resolution, hỗ trợ uploading files.

– Việc xử lý mặc định là dựa trên điều khiển @Controller và @RequestMapping

cung cấp một loạt xử lý linh hoạt. Với sự ra đời của Spring 3.0, các @Controller

điều khiển cơ chế cũng cho phép bạn tạo các trang web RESTful Web và ứng dụng,

thông qua các chú thích @PathVariable và các tính năng khác.

Nhóm BDGSPRING MVC

– Phân chia rạch ròi 3 công việc business logic, presentation logic và navigation

logic.

○ Model: chịu trách nhiệm đóng gói dữ liệu của ứng dụng

○ Views: có nhiệm vụ hiển thị thông tin trả về cho người dung

○ Controllers: chịu trách nhiệm nhận request từ người dung và gọi các dịch vụ

bên dưới để xử lý.

– Những thuận lợi trong Spring MVC framework

○ Bạn có thể sử dụng bất kỳ đối tượng như là một lệnh hoặc form-backing.

○ Bạn không cần phải tạo ra một framework cụ thể hoặc là một lớp cơ sở.

○ Dữ liệu ràng buộc của Spring là rất linh động

1. DispatcherServlet

– Spring framework web MVC cũng giống như nhiều web MVC framework khác

yêu cầu điều khiển xung quanh một servlet chính, dispatches yêu cầu tới controller

và các chức năng khác tạo điều kiện phát triển ứng dụng web.

– Việc xử lý yêu cầu công việc của Spring web MVC DispatcherServlet được minh

hoạ trong mô hình sau.

Nhóm BDGSPRING MVC

– DispatcherServlet thực chất là một servlet(nó thừa kế từ lớp cơ sở HttpServlet)

– Tiếp nhận tất cả các request từ Browser. Điều khiển luồng xử lý và trung chuyển

giữa các thành phần trong MVC. Được khai báo trong web.xml của ứng dụng web

của bạn. Bạn muốn DispatcherServlet xử lý map(biều đồ) mà bạn mong muốn bằng

cách sử dụng một ánh xạ URL trong file web.xml như nhau. Như ví dụ dưới đây:

Nhóm BDGSPRING MVC

– Trong ví dụ trên, tất cả các yêu cầu kết thúc bằng form sẽ được xử lý bởi các

DispatcherServlet. Điều này chỉ là bước đầu tiên trong việc thiết lập Spring Web

MVC. Bây giờ bạn cần phải cấu hình các bean khác nhau được sử dụng bởi các

Spring Web MVC framework.

– Trong khuôn khổ Web MVC, mỗi DispatcherServlet WebApplicationContext của

riêng mình, mà thừa hưởng tất cả các bean đã được xác định trong

WebApplicationContext gốc. Những bean được thừa kế có thể thay đổi trong phạm

vi servlet-cụ thể.

Nhóm BDGSPRING MVC

– Sau khi khởi tạo của một DispatcherServlet, khung hình cho một tập tin có tên

[Tên servlet-]-servlet.xml trong thư mục WEB-INF của ứng dụng web của bạn và tạo

ra các hạt được xác định ở đó, trọng các định nghĩa của bất kỳ hạt được xác định với

cùng một tên trong scope.Consider cấu hình DispatcherServlet servlet sau đây(trong

các file web.xml):

Nhóm BDGSPRING MVC

– Với cấu hình servlet trên bạn sẽ cần phải có một tập tin gọi là

/ WEB-INF/golfing-servlet.xml trong ứng dụng của bạn, tập tin này sẽ chứa tất cả

các thành phần của bạn Spring Web MVC-cụ thể (bean). Bạn có thể thay đổi vị trí

chính xác của tập tin cấu hình thông qua một tham số khởi tạo servlet .

– WebApplicationContext là một phần mở rộng của ApplicationContext nhưng có

thêm một số tính năng bổ sung cần thiết cho các ứng dụng web. Nó khác với một

– ApplicationContext bình thường ở chỗ nó có khả năng giải quyết các chủ đề

(theme)và nó biết nó là servlet liên quan .Các WebApplicationContext là ràng buộc

trong ServletContext, và bằng cách sử dụng phương pháp tĩnh trên lớp

RequestContextUtils bạn luôn có thể tìm các WebApplicationContext nếu bạn cần

truy cập vào nó.

– The Spring DispatcherServlet sử dụng bean đặc biệt để xử lý yêu cầu và đưa ra

các quan điểm thích hợp. Bean là một phần của Spring Framework. Bạn có thể cấu

hình chúng trong WebApplicationContext này, cũng giống như bạn cấu hình bất kỳ

bean khác. Tuy nhiên, đối với hầu hết các loại bean, giá trị mặc định được cung cấp

ban đầu để bạn không cần phải cấu hình chúng. Những bean này được mô tả trong

Bảng sau đây.

– Bean trong WebApplicationContext

Nhóm BDGSPRING MVC

Kiểu bean Giải thích

controllers Form C của MVC

handler mappings Xử lý việc thực hiện một danh sách các bộ vi xử lý trước và sau xử lý và controller mà sẽ được thực thi.

view resolvers Giải quyết name view đến view

locale resolver Một locale resolver là một thành phần có khả năng giải quyết các locale a client đang sử dụng, để có thể cung cấp cho view.

Theme resolver Một Theme resolver có khả năng giải quyết các theme ứng dụng web của bạn có thể sử dụng.

multipart file resolver Có chức năng để xử lý file uploads từ HTML.

handler exception resolvers Có chức năng khác là bản đồ (map) để xem hoặc thực hiện chúc năng khác phức tạp hơn.

– Sau khi bạn thiết lập một DispatcherServlet, và yêu cầu đến DispatcherServlet cụ

thể, các DispatcherServlet bắt đầu xử lý yêu cầu như sau:

○ WebApplicationContext là tìm kiếm và ràng buộc trong các yêu cầu như là

một thuộc tính có controller và các yếu tố khác trong quá trình này có thể sử

dụng. Đó là bị ràng buộc bởi mặc định theo khoá

DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE.

○ Các locale resolver giải quyết yêu cầu để cho phép các yếu tố trong quá trình

giải quyết các locale để sử dụng khi xử lý yêu cầu (rendering the view, preparing

data, and so on). Nếu bạn không cần phải giải quyết các locale.

Nhóm BDGSPRING MVC

○ Các theme có nghĩa vụ giải quyết yêu cầu để cho các yếu tố như view xác

định theme để sử dụng. Nếu bạn không sử dụng các theme, bạn có thể bỏ qua nó.

○ Nếu bạn chỉ định một tập tin giải quyết nhiều lần, yêu cầu được kiểm tra cho

multiparts, nếu multiparts được tìm thấy, yêu cầu được bao bọc trong một

MultipartHttpServletRequest để chế biến tiếp bởi các yếu tố khác trong quá trình

này.

○ Một bộ xử lý thích hợp là tìm kiếm. Nếu xử lý được tìm thấy, các dây chuyền

thực hiện liên quan đến việc xử lý (preprocessors, postprocessors, và controllers)

được thực hiện để chuẩn bị một model or rendering.

○ Nếu model trả về view, view sẽ gửi kết quả ra. Nếu như model không được trả

lại nên view cũng không được trả về.

1. Implementing Controllers

– Controller cung cấp truy cập vào các ứng dụng mà bạn thường xác định thông qua

một service interface. Controller điều khiển người dùng nhập vào và chuyển qua

model và cuối cùng người dùng sẽ vào view để xem lại. Spring thực hiện controller

một cách rất trừu tượng cho phép bạn tạo ra một loạt các controller mới.

– Spring 2.5 giới thiệu một mô hình lập trình model từ MVC controllers có sử dụng

các chú thích như @RequestMapping, @RequestParam, @ModelAttribute. Sự hổ trợ

này có sẵn cho cả hai Servlet MVC và Portlet MVC. Controller thực hiện theo kiểu

này không cần mở rộng các lớp cơ sở cụ thể hoặc các giao diện củ thể. Hơn nữa, họ

thường không có phụ thuộc trực tiếp trên Servlet hoặc Portlet API, mặc dù bạn có thể

dễ dàng cấu hình truy cập đến các cơ sở Servlet hoặc Portlet.

1.1.Định nghĩa Controllers với @Controllers

Nhóm BDGSPRING MVC

1.2.Lập bản đồ các yêu cầu với @ RequestMapping

Nhóm BDGSPRING MVC

2. Handler Mapping

– Trong các phiên bản trước của Spring, người dùng đã được yêu cầu xác định

HanderMappings trong các ứng dụng web, yêu cầu mapping để xử lý web thích hợp.

Với sự giới thiệu ở Spring 2.5, DispatcherServlet cho phép

DefaultAnnotationHandlerMapping, tìm kiếm @RequestMapping giải thích trên

@Controllers. Bình thường, bạn không cần phải thay đổi các mapping mặc định, trừ

khi bạn cần thay đổi các giá trị của thuộc tính mặc định.

Các thuộc tính đó là:

– interceptors: danh sách của chức năng bị chặn sử dụng, HandlerInterceptors đã

được thảo luận ở các phần “Interceptingrequests-the HandlerInterceptorinterface”.

– defaultHandler: quyền điều khiển được mặc định sử dụng, khi mapping

controller không dẫn tới kết quả tìm kiếm tương ứng.

– order: dựa vào giá trị của thuộc tính(như trong giao diện

org.springframework.core.Ordered)

– alwaysUseFullPath(luôn sử dụng đường dẫn tuyệt đối): nếu đúng thì Spring sử

dụng đường dẫn tuyệt đối bên trong các servlet hiện tại tùy theo tìm kiếm thích hợp

của điều khiển. Nếu sai(mặc định) đường dẫn bên trong các mappingservlet hiện tại

được sử dụng. Ví dụ: nếu bản đồ servlet đang được sử dụng /testing/* và luôn là

đường dẫn tuyệt đối, thuộc tính sẽ luôn đúng thì sử dụng /testing/viewPage.html.

Ngược lại nếu thuộc tính là sai, sử dụng /viewPage.html.

– urlDecode: mặc định là đúng với Spring 2.5. Nếu bạn để so sánh giữa các đường

dẫn được mã hóa, thiết lập này sẽ sai. Tuy nhiên, HttpServletRequest luôn luôn thấy

nhiều đường đi ở dạng giải mã.

– lazyInitHandlers: cho phép khởi tạo của bộ xử lý lazyInitHanders. Các giá trị

này mặc định là sai.

Nhóm BDGSPRING MVC

– Chú ý: Các alwaysUseFullPath, urlDecode, và lazyInitHandlers là thuộc tính duy

nhất, có chứa sẵn các lớp con của

org.springframework.web.servlet.handler.AbstractUrlHandlerMapping. Ví dụ sau chỉ

ra làm sao để ghi đè lên các mapping mặc định và thêm một interceptor

– Chặn yêu cầu- giao diện HandlerInterceptor

– Cơ chế xử lý mapping của Spring bao gồm điều khiển interceptors, nó sẽ hữu ích

khi bạn muốn áp dụng các chức năng cụ thể với các yêu cầu nhất định.

– Interceptors đặt tại các mapping xử lý phải được thực hiện HandlerInterceptor từ

org.springframework.web.servlet. Giao diện này xác định ba phương thức:

○ Một là gọi trước khi xử lý thực tế được thực thi

○ Hai là được gọi sau khi xử lý được thực thi

○ Ba là gọi khi yêu cầu hoàn thành đã hoàn tất.

Ba phương thức cung cấp sự linh hoạt, đủ để hoàn tất các tiền xử lý và sau xử lý.

– preHandle(..) phương thức trả về giá trị Boolean. Bạn có thể sử dụng phương

thức này để thoát hoặc tiếp tục thực hiện chuỗi điều khiển. Khi phương thức này trả

về true, chuỗi thực thi sẽ xử lý tiếp tục, ngược lại khi phương thức trả về false

DispatcherServlet giả sử đã chặn và trả về một view thích hợp và không tiếp tục thực

hiện chuỗi interceptors

– Ví dụ sau định nghĩa một ánh xạ xử lý mà các mapping yêu cầu phù hợp với mẫu

URL “/*.form” và “/*.view” vào một controller đặc biệt,

editAccountFormController. Một interceptor đã được thêm vào để chặn các yêu cầu

này và reroutes chuyển người dùng đến một trang cụ thể nếu thời gian không ở giữa

9a.m và 6 a.m.

Nhóm BDGSPRING MVC

– Bất cứ yêu cầu xử lý nào của mapping bị chặn bởi các

TimeBasedAccessInterceptor. Nếu thời gian hiện tại nằm ngoài thời gianthực thi,

Nhóm BDGSPRING MVC

người dùng sẽ được chuyển hướng đến một tập tin HTML tĩnh, có nội dung thông

báo: bạn chỉ có thể truy cập vào các trang web trong thời gian quy định.

– Như các bạn có thể thấy, Spring chuyển đổi lớp HandlerInterceptorAdapter làm

cho nó dễ dùng hơn để có thể mở rộng giao diện HandlerInterceptor.

1. Resolving views

– Tất cả framework MVC cho những ứng dụng web cung cấp cách để gửi các view.

Spring cung cấp view, những bộ phân tích cho phép bạn trả lại model bằng trình

duyệt không có những công nghệ đặc biệt. Ngoài ra Spring cho phép xử dụng JSPs,

template velocity và XSLT view.

– Hai giao diện mà quan trọng đối với cách Spring xử lý view là ViewResolver và

View. ViewResolver cung cấp một mapping giữa name và view thực tế. Giao diện

View gửi những yêu cầu của handler tới một trong những view.

1.1.Giải quyết các view bằng giao diện ViewResolver

– Như đã thảo luận ở trên, những “Implementing Controllers” mọi phương pháp

handler trong điều khiển Spring Web MVC các controller phải giải quyết tới name

của view rõ ràng(bằng việc trả lại một chuỗi, view hay ModelAndView) hay tuyệt

đối(dựa vào những quy ước). Views trong Spring được gửi bởi tên view và giải quyết

bởi view resolver . Spring đưa đến khá nhiều cách giải quyết.

View resolvers

ViewResolver Description

AbstractCachingViewResolver View trừu tượng giải quyết bởi các caches views. Thường với các views cần chuẩn bị trước khi sử dụng. Mở rộng các view này bằng cách cung cấp caching.

XmlViewResolver Thi hành của ViewResolver là chấp nhận cấu hình được viết ở XML với cùng DTD(Document Type Definitions) là

Nhóm BDGSPRING MVC

Spring’s XML bean factories. Mặc định cấu hình file là /WEB-INF/views.xml.

ResourceBundleViewResolver Sự thi hành của ViewResolver sẽ sử dụng những định nghĩa bean trong ResourceBundle, được chỉ rõ ràng bởi tên. Điển hình, bạn định nghĩ bundle trong thuộc tính, vị trí trong đường dẫn lớp. Mặc định tên file là views.properties.

UrlBasedViewResolver Giao diện ViewResolver thực thi đơn giản, đưa ra những quyết định trực tiếp của tên view logic tới URLs ngoài định nghĩa rõ ràng của mapping. Điều này là phù hợp với sự logic của tên, của các tài nguyên view mà không rắc rối.

InternalResourceViewResourcer Thuận lợi cho lớp con của UrlBasedViewResolver hỗ trợ InternalResourceView (hiệu ứng, Servlets, JSPs) và các lớp con như JstlView và TilesView. Bạn có thể chỉ định lớp view cho tất cả các quan điểm được tạo ra bằng cách giải quyết nó với setViewClass(..)

VelocityViewResolver/ FreeMarkerViewResolver

Thuận tiện lớp con của UrlBasedViewResolver hỗ trợ VelocityView (hiệu ứng, tốc độ của templates) hoặc FreeMaKerView, tùy chỉnh với các lớp con của chúng.

ContentNegotiatingViewResolver Thực thi các giao diện ViewResolver, giải quyết dựa trên tên file yêu cầu hoặc chấp nhận tiêu đề.

1.1.Chaining ViewResolvers

Nhóm BDGSPRING MVC

– Spring hỗ trợ đa cách giải quyết View. Bạn có thể giải quyết chuỗi, ví dụ ghi đè

các phương thức view đặc biệt tùy từng trường hợp nhất định.

Trong ví dụ sau, các chuỗi của view có hai cách giải quyết, một là InternalResourceViewResolver, luôn tự động định vị như là giải quyết cuối cùng trong chuỗi, và XmlViewResolver xác định các view Excel. Các view Excel không được hỗ trợ bởi InternalResourceViewResolver.

– Nếu cách giải quyết rõ ràng không cho ra kết quả một view, Spring sẽ xem xét

cách giải quyết khác. Nếu giải quyết thêm view tồn tại, Spring tiếp tục kiểm tra

chúng cho đến khi được giải quyết. Nếu không có cách giải quyết trả lại một view,

Spring đưa ra một ServletException.

– Giải quyết vấn đề của view trả về null nếu view có thể không được tìm thấy.

Không phải tất cả các cách giải quyết đều làm được điều này, tuy nhiên, bởi trong

một số trường hợp, việc giải quyết đơn giản là không thể phát hiện có hoặc không

thấy tồn tại. Ví dụ: InternalResourceViewResolver sử dụng RequestDispatcher bên

trong, và là cách duy nhất để tìm hiểu xem JSP là tồn tại, nhưng thực thi này chỉ có

thể thực hiện một lần. Tương tự cũng cho VelocityViewResolver và một số cách

khác. Kiểm tra Javadoc để giải quyết view, xem view tồn tại chưa. Vì vậy việc đưa ra

một InternarlResourceViewResolver trong chuỗi ở một nơi khác là cuối cùng, kết

quả trong chuỗi không được kiểm tra đầy đủ, bởi các InternalResourceViewResoler

sẽ luôn luôn trả lại view.

Nhóm BDGSPRING MVC

1.1.Chuyển đến view

– Như đã đề cập trước đây, một controller thông thường trả về một view tương

ứng , có một giải quyết cho một kỹ thuật view cụ thể. Đối với các kỹ thuật view như

là JSP được biên dịch thông qua Servlet hay JSP , sự thông dịch này thường được xử

lý thông qua sự kết hợp của InternalResourceViewResolver và

InternalResourceView, mà vấn đề là một tiến bộ hay bao gồm thông qua

RequestDispatcher.forward các API của phương thức Servlet (..)hoặc phương thức

RequestDispatcher.include(). Đối với các công nghệ view khác, chẳng hạn như

Velocity, XSLT, view sẽ tự cho nội dung vào từng dòng.

– RedirectView

○ Một cách để thực hiện chuyển hướng là kết quả của controller trả về controller

đã tạo và trả về một View của SpringRedirectView. Trong trường hợp này,

DispatcherServlet không sử dụng các cơ chế View phân giải bình thường. Thay vì

nó đã được trả về view đã có, DispatcherServlet đơn giản chỉ thị nhằm làm việc

với RedirectView.

○ Vấn đề một HttpServletResponse.sendRedirect () gọi trả về cho trình duyệt

của client như là một HTTP chuyển hướng. Tất cả các thuộc tính mô hình được

thể hiện như các tham số truy vấn HTTP. Điều này có nghĩa là các model phải có

các đối tượng (thường Strings hoặc các đối tượng chuyển đổi sang một đại diện

String), mà có thể dễ dàng chuyển đổi sang một parameter. Nếu truy vấn văn bản

HTTP bạn sử dụng RedirectView và view là được tạo ra bởi controller chính nó,

nó cảnh cáo bạn cấu hình các URL chuyển hướng được thêm vào controller để

nó không phải là thêm vào controller, nhưng cấu hình cùng với tên View.

1.1.ContentNegotiatingViewResolver

– Các ContentNegotiatingViewResolver không giải quyết được chính nó mà fải cần

có 1 đại diện khác để xem độ phận giải của nó. Chọn chế độ View tương tự như các

đại diện theo yêu cầu của phía client. Tồn tại hai chiến lược cho client để yêu cầu

một đại diện từ máy chủ.

Nhóm BDGSPRING MVC

○ Sử dụng một URI riêng biệt cho mỗi tài nguyên, thông thường bằng cách sử

dụng một phần mở rộng tập tin khác nhau trong các URL.

○ Sử dụng URL tương tự cho các client để xác định vị trí các nguồn lực, nhưng

thiết lập các tiêu đề chấp nhận yêu cầu HTTP vào danh sách các loại phương tiện

truyền thông mà nó hiểu được. Ví dụ, một yêu cầu HTTP cho

http://www.example.com/users/fred với một tiêu đề Chấp nhận đặt application /

pdf yêu cầu một đại diện của người sử dụng PDF fred, trong khi

http://www.example.com/users/fred với một tiêu đề Chấp nhận thiết lập để text /

xml yêu cầu một đại diện XML

– Ghi chú:

○ Để hỗ trợ nhiều đại diện của một tài nguyên, Spring cung cấp

ContentNegotiatingViewResolver để giải quyết view dựa trên phần mở rộng tập

tin hoặc chấp nhận tiêu đề của yêu cầu HTTP. Ở trong firefox nó được cố định

- ContentNegotiatingViewResolver không thực hiện việc giải quyết View chính nó

mà thay vào đó các delegate cho một danh sách các phân giải View mà bạn

chỉ định thông qua các thuộc tính bean ViewResolvers.The

ContentNegotiatingViewResolver lựa chọn một View thích hợp để xử lý các yêu cầu

bằng cách so sánh các yêu cầu loại truyền thông (s) với các loại truyền thông (còn

gọi là Content-Type) hỗ trợ các View liên kết với nhau của ViewResolvers. View

đầu tiên trong danh sách có một Content-Type tương thích với các đại diện cho

client. Nếu một View tương thích có thể không được cung cấp bởi các chuỗi

ViewResolver, sau đó danh sách các điểm quy định thông qua các thuộc tính sẽ được

DefaultViews lấy ý kiến.

http://www.example.com/users/fred

http://www.example.com/users/fred

Nhóm BDGSPRING MVC

– Chú ý :○ Nếu trong ContentNegotiatingViewResolver danh sách các ViewResolvers

không được cấu hình một cách rõ ràng, nó sẽ tự động sử dụng bất kỳ

ViewResolvers quy định trong ứng dụng

○ Các mã điều khiển tương ứng để trả về một Atom, nguồn cấp dữ liệu RSS cho

một URI có dạng

Nhóm BDGSPRING MVC

http://localhost/content.atom hoặc http://localhost/content:

1. Using locales

– Hầu hết các bộ phận của kiến trúc quốc tế của Spring được hỗ trợ, cũng như

khuôn khổ Spring MVC web. DispatcherServlet cho phép bạn tự động giải quyết các

thông tin sử dụng locales của client. Điều này được thực hiện với các đối tượng

LocaleResolver.

– Khi yêu cầu đến, DispatcherServlet sẽ tìm một LocaleResolver, và nếu nó tìm

thấy một LocaleResolver, nó cố gắng sử dụng LocaleResolver để đặt 1 locale Sử

dụng phương pháp RequestContext.getLocale (), bạn có thể luôn lấy các locale đã

được giải quyết bằng các LocaleResolver.

– Ngoài độ phân giải locales tự động, bạn cũng có thể đính kèm một sơ đồ chặn để

xử lý, để thay đổi locale trong những hoàn cảnh cụ thể, ví dụ, dựa trên vào một tham

số trong yêu cầu.

– Vị trí phân giải và sơ đồ chặn được định nghĩa tại các gói

org.springframework.web.servlet.i18n và được cấu hình trong ứng dụng của bạn theo

cách thông thường. Đây là một sự chọn lọc của LocaleResolver trong Spring.

Nhóm BDGSPRING MVC

1.1.AcceptHeaderLocaleResolver

– Bộ LocaleResolver kiểm tra tiêu đề accept-language trong yêu cầu đã được gửi

của client (Ví dụ, một trình duyệt web). Thông thường lĩnh vực này tiêu đề chứa các

locale của hệ điều hành của client.

1.1.CookieLocaleResolver

– Nếu locale được chỉ định thì LocaleResolver này có thể thấy được sự tồn tại của

Cookie trên các client bằng việc kiểm tra Cookie . Nếu vậy, nó sử dụng locale quy

định. Sử dụng các tính chất của LocaleResolver này, bạn có thể chỉ định tên của

cookie cũng như độ dài tối đa. Dưới đây một ví dụ về xác định một

CookieLocaleResolver.

Bảng Những thuộc tính của CookieLocaleResolverThuộc tính Mặc định Mô tả

cookieName classname + LOCALE Tên của cookie

cookieMaxAge Integer.MAX_INT Thời gian tối đa một cookie sẽ ở lại lâu dài đối với client. Nếu -1 là quy định, các cookie sẽ không tồn tại, nó sẽ chỉ có sẵn cho đến khi client tắt trình duyệt của mình.

cookiePath Giới hạn khả năng hiển thị của các tập tin cookie cho

Nhóm BDGSPRING MVC

một phần nào đó của trang web. Khi cookiePath được quy định, các cookie sẽ chỉ được hiển thị cho con đường và các đường dẫn bên dưới.

1.1.SessionLocaleResolver

– SessionLocaleResolver cho phép bạn lấy địa điểm locale từ session có thể được

kết hợp với yêu cầu của người dùng.

1.1.LocaleChangeInterceptor

– Bạn có thể cho phép thay đổi của locale bằng cách thêm các

LocaleChangeInterceptor một trong các sơ đồ Handler .Nó sẽ phát hiện một số yêu

cầu và thay đổi locale. Nó gọi setLocale () trên LocaleResolver đó cũng tồn tại trong

trường hợp đó. Ví dụ sau đây cho thấy rằng cách gọi đến tất cả các nguồn tài nguyên

*.view có chứa một tham số siteLanguage được đặt tên sẽ thay đổi local. Vì vậy, ví

dụ, một yêu cầu cho các URL, http://www.sf.net/home.view?siteLanguage=nl sẽ

thay đổi ngôn ngữ trang web thành tiếng Hà lan.

Nhóm BDGSPRING MVC

1. Using themes

1.1.Tổng quan về themes

– Bạn có thể áp dụng Spring Web MVC framework themes để thiết lập khuôn khổ

tổng thể cái nhìn và cảm nhận của ứng dụng của bạn, qua đó nâng cao kinh nghiệm

người dùng. Theme là tập hợp các tài nguyên tĩnh, thường là phong cách sheets and

images, có ảnh hưởng đến phong cách trực quan của ứng dụng.

1.1.Định nghĩa themes

– Để sử dụng các theme trong ứng dụng web của bạn, bạn phải thiết lập một giao

diện thực hiện org.springframework.ui.context.ThemeSource. Các giao diện

WebApplicationContext mở rộng ThemeSource nhưng uỷ quyền những trách nhiệm

(của) nó cho một phiên thực hiện. Theo mặc định các ủy quyền sẽ là một

org.springframework.ui.context.support.ResourceBundleThemeSource thực hiện có

tính chất tải file từ thư mục gốc của classpath này. Để sử dụng thực hiện

Nhóm BDGSPRING MVC

ThemeSource tùy chỉnh hoặc để cấu hình các tiền tố tên cơ sở của các

ResourceBundleThemeSource, bạn có thể đăng ký một bean trong từng trường hợp

ứng dụng với tên themeSource được bảo lưu. Từng trường hợp ứng dụng web tự

động phát hiện một bean với tên đó và sử dụng nó.

– Khi sử dụng ResourceBundleThemeSource, theme được định nghĩa trong một tập

tin thuộc tính đơn giản. Các thuộc tính tập tin liệt kê các nguồn tài nguyên tạo nên

theme. Đây là một ví dụ:

styleSheet=/themes/cool/style.cssbackground=/themes/cool/img/coolBg.jpg

– Các khoá của các thuộc tính là tên tham chiếu đến các themes element từ view code. Đối với JSP, bạn thường làm được điều này bằng cách sử dụng Spring: theme custom tag,tương tự như Spring: message tag.

– Theo mặc định, ResourceBundleThemeSource sử dụng empty base name prefix.

Kết quả là, các thuộc tính tập tin được tải từ thư mục gốc của classpath này. Vì vậy,

bạn sẽ đặt các định nghĩa theme cool.properties trong một thư mục ở gốc của

classpath, ví dụ, trong / WEB-INF/classes. ResourceBundleThemeSource sử dụng

các gói Java resource bundle chuẩn để tải cơ chế, cho phép quốc tế hóa đầy đủ của

theme. Ví dụ, chúng ta có thể có một WEB-INF/classes/cool_nl.properties / , các tài

liệu tham khảo một hình nền đặc biệt với văn bản của Hà Lan về nó.

1.1.Phân giải Theme

– Sau khi bạn xác định theme, như trong phần trước, bạn quyết định theme để sử

dụng. Các DispatcherServlet sẽ tìm một bean có tên themeResolver để tìm ra sự thi

hành ThemeResolver để sử dụng. Một bộ phân tích theme làm việc trong nhiều cách

Nhóm BDGSPRING MVC

tương tự như LocaleResolver. Nó nhận diện các theme để sử dụng cho một yêu cầu

cụ thể và cũng có thể thay đổi theo yêu cầu của theme. Việc phân giải theme sau đây

được cung cấp bởi Spring:

Bảng 15.5. Sự thi hành ThemeResolver

Lớp Mô tả

FixedThemeResolver FixedThemeResolverSelects là một theme cố định, thiết lập bằng cách sử dụng các thuộc tính defaultThemeName.

SessionThemeResolver Theme này được duy trì trong HTTP session của người dùng. Nó chỉ cần được thiết lập một lần cho mỗi session, nhưng không tồn tại giữa session.

CookieThemeResolver Các theme được chọn là lưu trữ trong một cookie trên client.

– Spring cũng cung cấp một ThemeChangeInterceptor cho phép thay đổi theme trên

tất cả các yêu cầu với một request parameter đơn giản.

1. Spring’s multipart(fileupload) support

1.1.Giới thiệu

– Spring được tích hợp trong hỗ trợ nhiều phần xử lý tập tin tải lên trong các ứng

dụng web. Bạn kích hoạt tính năng này nhiều lần hỗ trợ với các đối tượng

MultipartResolver, được xác định trong gói org.springframework.web.multipart.

Spring cung cấp MultipartResolver để sử dụng với Commons FileUpload.

– Theo mặc định,Spring không xử lý nhiều multipart, bởi vì một số nhà phát triển

muốn xử lý chính multiparts. Bạn cho phép xử lý nhiều multipart dữ liệu Spring

bằng cách thêm một multipart resolver để các ứng dụng web. Mỗi yêu cầu được kiểm

tra để xem nếu nó có chứa nhiều multipart. Nếu không có nhiều multipart được tìm

thấy, các yêu cầu tiếp tục. Nếu một multipart được tìm thấy trong yêu cầu, các

MultipartResolver đã được khai báo trong context của bạn là được sử dụng. Sau đó,

Nhóm BDGSPRING MVC

các thuộc tính nhiều multipart trong yêu cầu của bạn được xử lý như các thuộc tính

khác.

1.1.Sử dụng MultipartResolver

– Ví dụ sau đây cho thấy làm thế nào để sử dụng CommonsMultipartResolver:

– Tất nhiên bạn cũng cần phải đặt các jar thích hợp trong classpath của bạn để làm

việc với bộ phân tích nhiều phần. Trong trường hợp của

CommonsMultipartResolver, bạn cần phải sử dụng commons-fileupload.jar.

– Khi Spring DispatcherServlet nhận diện một yêu cầu nhiều multipart, nó kích

hoạt bộ phân tích được khai báo trong resoler (của) các bạn và sự trao tay của bạn

trên yêu cầu. Giải quyết sau đó kết thúc bao bọc dòng HttpServletRequest thành một

MultipartHttpServletRequest tập tin hỗ trợ nhiều phần tải lên. Sử dụng

MultipartHttpServletRequest, bạn có thể nhận được thông tin về các multiparts có

theo yêu cầu này và thực sự có được quyền truy cập vào các tập tin nhiều lần mình

trong bộ controller của bạn.

1.1.Xử lý một tập tin tải lên trong một biểu mẫu

– Sau khi MultipartResolver hoàn thành, yêu cầu được xử lý như bất kỳ công việc

khác. Đầu tiên, tạo một form với một đầu vào tập tin đó sẽ cho phép người dùng tải

lên một form. Các thuộc tính mã hóa (Enctype = "multipart / form-data") cho phép

trình duyệt biết làm thế nào để mã hóa các hình thức theo yêu cầu nhiều multipart

Nhóm BDGSPRING MVC

– Bước tiếp theo là tạo ra một controller để xử lý các tập tin tải lên. Controller này

tương tự như một normal annotated @Controller, ngoại trừ việc chúng tôi sử dụng

MultipartHttpServletRequest hoặc MultipartFile trong các method parameters:

– Lưu ý @RequestParam method parameters nhập vào khai báo trong form. Trong

ví dụ này, không có gì được thực hiện với byte[], nhưng trên thực tế bạn có thể lưu

nó vào cơ sở dữ liệu, lưu trữ nó trên hệ thống tập tin và nhiều hơn nữa.

– Cuối cùng, bạn sẽ phải khai báo bộ controller and the resolver trong context ứng

dụng.

Nhóm BDGSPRING MVC

1. Handling exceptions

1.1.HandlerExceptionResolver

– Spring HandlerExceptionResolvers giảm thiểu sai sót của trường hợp exception

bất ngờ xảy ra khi bạn yêu cầu được xử lý bởi một controller nào phù hợp yêu cầu.

HandlerExceptionResolvers phần nào giống với sơ đồ ngoại trừ bạn có thể định

nghĩa trong web.xml trong bộ mô tả ứng dụng web. Tuy nhiên, họ cung cấp một cách

linh hoạt hơn để xử lý các trường hợp exception. Họ cung cấp thông tin về những xử

lý đã được thực hiện khi exception được đưa ra. Hơn nữa, một chương trình xử lý

exception cho bạn tùy chọn hơn cho phản ứng thích hợp trước khi yêu cầu được

chuyển tiếp đến một URL (kết quả cuối cùng như khi bạn sử dụng sơ đồ exception cụ

thể servlet).

– Bên cạnh việc thực hiện các giao diện HandlerExceptionResolver, chỉ là vấn đề

thực hiện phương thức resolveException (exception, Handler) và trả về một

ModelAndView, bạn cũng có thể sử dụng các SimpleMappingExceptionResolver.

Resolver này cho phép bạn lấy tên class của bất kỳ trường hợp exception có thể được

đưa ra và sơ đồ này để tên cho view. Đây là chức năng tương đương với các tính

năng lập sơ đồ exception từ Servlet API, nhưng nó cũng có thể thực hiện 1 sơ đồ rõ

ràng hơn của các exception từ những xử lý khác nhau.

– Theo mặc định, DispatcherServlet đăng ký việc

DefaultHandlerExceptionResolver. Bộ phân tích này giải quyết một số tiêu chuẩn xử

lý của Spring MVC exceptions bằng cách thiết lập một mã phản hồi trạng thái cụ thể:

Exception Mã Tình trạng HTTP

Nhóm BDGSPRING MVC

ConversionNotSupportedException 500 (Internal Server Error)HttpMediaTypeNotAcceptableException 406 (Not Acceptable)HttpMediaTypeNotSupportedException 415 (Unsupported Media Type)HttpMessageNotReadableException 400 (Bad Request)HttpMessageNotWritableException 500 (Internal Server Error)HttpRequestMethodNotSupportedException 405 (Method Not Allowed)

MissingServletRequestParameterExceptio 400 (Bad Request) NoSuchRequestHandlingMethodException 404 (Not Found)TypeMismatchException 400ad Request)

1.1.@ExceptionHandler

– Một thay thế cho các giao diện HandlerExceptionResolver là chú thích

@ExceptionHandler. Bạn sử dụng các chú thích phương pháp @ExceptionHandler

trong vòng controller một để xác định các phương pháp được gọi khi một Exception

của một loại hình cụ thể được đưa ra trong khi thực hiện các phương pháp controller.

Ví dụ:

Sẽ gọi phương pháp "handlerIOException ' khi java.io.IOException được đưa ra.

– Các giá trị @ExceptionHandler có thể được thiết lập để một loạt các loại

exception. Nếu exception được đưa vào phù hợp với một trong các loại trong danh

sách, sau đó các phương pháp chú thích với các kết hợp @ ExceptionHandler sẽ

được gọi lại. Nếu giá trị annotation không được thiết lập sau đó liệt kê các loại

exception như các đối số phương pháp được sử dụng.

Nhóm BDGSPRING MVC

– Cũng giống như các phương pháp controller methods annotated với một chú thích

@RequestMapping, phương pháp đối số và giá trị trả về của phương pháp

@ExceptionHandler là rất linh hoạt. Ví dụ, HttpServletRequest có thể được truy cập

trong môi trường Servlet và các PortletRequest tại môi trường Portlet. Các kiểu trả về

có thể là một String.

1. Convention over configuration support

– Đối với nhiều project, việc gắn kết để thiết lập các quy ước và những mặc định

hợp lý chỉ là những gì mà chúng cần…theme về quy ước trên cấu hình này bây giờ

đã được hỗ trợ rõ ràng trong Spring Web MVC. Điều này có nghĩa là nếu bạn thiết

lập các quy ước đặt tên tương tự như vậy, về căn bản bạn có thể cut down 1 trong số

những cấu hình mà đòi hỏi cài đặt bộ điều khiển ánh xạ, xem lại các view, ví dụ như

ModelAndView,…

– Việc hỗ trợ quy ước trên cấu hình đó là 3 vấn đề cốt lõi của MVC—model, view

và controller

1.1.Controller-ControllerClassNameHandlermapping

– Class ControllerClassNameHandlerMapping được bổ sung cho HandlerMapping,

sử dụng quy ước để xác định ánh xạ giữa các request URL và các Controller để truy

cập các request

– Đây là đoạn mã giả từ file cấu hình Spring Web MVC

Nhóm BDGSPRING MVC

– ControllerClassNameHandlerMapping tìm ra các xử lý khác nhau (hoặc

Controller), beans được định nghĩa trong các ứng dụng ngữ cảnh và làm toát lên tên

Controller được định nghĩa ánh xạ xử lý của nó. Theo cách đó, các ánh xạ

ViewShoppingCartController đến /viewshoppingcart* request

○ WelcomeController maps to the /welcome* request URL

○ HomeController maps to the /home* request URL

○ IndexController maps to the /index* request URL

○ RegisterController maps to the /register* request URL

– Trong trường hợp các lớp xử lý MultiActionController, các ánh xạ được tạo ra

hơi phức tạp hơn. Tên các Controller trong ví dụ sau được cho rằng nó là sự bổ sung

cho MultiActionController:

○ AdminController maps to the /admin/* request URL

○ CatalogController maps to the /catalog/* request URL

1.1.The Model ModelMap (ModelAndView)

– Class ModelMap về cơ bản là 1 Map có thể add thêm các object để hiển thị trong

1 View tham gia vào theo 1 quy ước đặt tên chung. Xem thêm các bổ sung Cotroller;

chú ý rằng các object được thêm vào ModelAndView không có bất kỳ tên kết hợp

nào được chỉ định

Nhóm BDGSPRING MVC

– Class ModelAndView sử dụng 1 class ModelMap là sự bổ sung của 1 Map tùy

chọn để có thể tự động generate 1 key cho 1 object được add vào nó. Các chiến lượt

để xác định để add thêm 1 object đó là, trong trường hợp object vô hướng như là

User, để dùng tên ngắn của 1 class của 1 class object. Các ví dụ sau đây là những cái

tên được tạo ra cho các object vô hướng đặt trong 1 ModelMap

○ Trường hợp x.y.User được add thì tên user sẽ được tạo ra.

○ Trường hợp x.y.Registration được add thì tên registration sẽ được tạo ra.

○ Trường hợp x.y.Foo được add thì tên foo được tạo ra.

○ Trường hợp java.util.HashMap được add thì tên hashMap được tạo ra. Trong

trường hợp này có thể bạn muốn rõ ràng hơn về tên bởi vì về trực giác thì

hashMap nhỏ hơn.

○ Add null thì kết quả trả ra sẽ là IllegalArgumentException được đưa ra. Nếu

như object (hoặc các object) được add null thì chúng ta cũng cần làm rõ về tên.

– Để tạo ra 1 name sau khi add thêm 1 object Set, List hoặc array là tham khảo

trong collection, lấy tên ngắn class của đối tượng đầu tiên trong collection và sử dụng

nó gắn với tên List . Ví dụ:

○ 1 mảng x.y.User[] với 1hoặc nhiều phần tử x.y.User được add sẽ có tên

userList được tạo.

○ 1 mảng x.y.Foo[] với 1 hoặc nhiều phần tử x.y.User được add sẽ có tên

fooList được tạo ra.

– Một java.util.ArrayList với 1 hoặc nhiều phần tử x.y.User được add sẽ có tên

userList được tạo.

Nhóm BDGSPRING MVC

– Một java.util.HashSet với 1 hoặc nhiều phần tử x.y.Foo được add sẽ có tên

fooList được tạo.

– Một java.util.ArrayList rỗng sẽ không được add vào tất cả (trong effect,

addObject(..) khi gọi về cơ bản sẽ là 1 no-op).

1.1.The View – RequestToViewNameTranslator

– Khi không có tên View logic thì Giao diện RequestToViewNameTranslator sẽ

xác định 1 cách rõ ràng. DefaultRequestToViewNameTranslator chỉ là 1 lớp bổ sung.

– Các ánh xạ DefaultRequestToViewNameTranslator yêu cầu các URL đến tên các

view logic, như trong ví dụ:

Nhóm BDGSPRING MVC

– Chú ý trong việc thực hiện bổ sung các phương thức handleRequest(..) không

View hoặc tên view logic bao giờ cũng được đặt vào ModelAndView và được trả về.

Các DefaultRequestToViewNameTranslator được thao tác với việc tạo ra 1 tên view

logic từ URL của yêu cầu. Trong trường hợp phía trên các RegistrationController

được dùng liên kết với các ControllerClassNameHandlerMapping, một request URL

của http://localhost/registration.html trả về kết quả trong tên 1 view local của

registration bắt đầu được tạo ra bằng DefaultRequestToViewNameTranslator. Tên

View logic này sau đó được giải quyết bên trong view /WEB-

INF/jsp/registration.jsp bằng bean InternalResourceViewResolver.

1. Etag support

– Một ETag (entity tag) là 1 header phản hồi HTTP được trả về bởi 1 lệnh

HTTP/1.1 của web server, dùng để xác định rõ những thay đổi trong nội dung tại 1

URL được đưa lên. Nó có thể được coi là sự kế thừa tinh vi đối với header Last-

Modified. Khi server trả về 1 đại diện với 1 header ETag, client có thể dùng header

này trong GET tiếp theo, ở trong 1 header If-None-Match. Nếu nội dung không thay

đổi thì server trả về 304: No Modified.

http://localhost/registration.html

Nhóm BDGSPRING MVC

– Hỗ trợ cho ETag thì được cung cấp bởi bộ lọc servlet ShallowEtagHeaderFilter.

Nó là 1 Servlet Filter, và do đó có thể được sử dụng kết hợp bất kỳ framework web

nào. Bộ lọc ShallowEtagHeaderFilter tạo ra cái gọi là ETag cạn (trái ngược với ETag

sâu, sẽ tìm hiểu sau). Bộ lọc lưu trữ nội dung trả về JSP (hoặc nội dung khác), tạo ra

1 MD5 băm trên đó, và trả về như 1 header Etag trong phản hồi. Lần sau, 1 client gửi

1 yêu cầu với tài nguyên tương tự như thế, nó sủ dụng để băm giá trị If-None-Match.

Bộ lọc dò tìm giá trị này , trả về lại 1 view và so sánh giữa 2 lần băm. Nếu chúng

bằng nhau, sẽ trả về giá trị 304. Bộ lọc này sẽ không lưu các xử lý lũy thừa bởi vì

view hãy còn được hoàn trả lại. Nó chỉ lưu lại băng thông vì phản hồi trả lại không

được gửi trở về wire

– Bạn có thể cấu hình ShallowEtagHeaderFilter trong Web.xml :

1. Configuring Spring MVC

– Spring 3 giới thiệu mvc XML cấu hình namespace làm đơn giản hóa quá trình cài

đặt Spring MVC vào trong ứng dụng web của bạn. Thay vì đăng ký các bean cấp

thấp như là AnnotationMethodHandlerAdapter, đơn giản là chúng ta có thể dùng

namespace và nhữn g thiết lập cấp cao.

– Các namespace mvc bao gồm 3 tag: mvc: annotation-driven, mvc:interceptors và

mvc: view-controller. Mỗi tag này đượcghi dưới đây và trong lược đồ XML:

1.1.mvc:annotation-driven

Nhóm BDGSPRING MVC

1.2.mvc:interceptors

– Một ví dụ về việc đăng ký ngăn chặn có giới hạn 1 đường dẫn URL cụ thể:

1.1.mvc:view-controller

1.2.mvc:resources

Nhóm BDGSPRING MVC

1.3.mvc:default-servlet-handler

VI. HƯỚNG DẪN DEMO SPRING

1. Cài Đặt Spring IDE

– Spring IDE là một plug-in eclipse giúp phát triển ứng dụng Spring. Trước tiên chúng ta sẽ thấy làm thế nào để cài đặt các Spring IDE và sau đó chúng ta sẽ tạo ra dự án Spring đầu tiên .

Để cài đặt Spring IDE , Go to Help => Eclipse Marketplace=> trong tab search , nhập Spring => click search. Sau khi search , sẽ thấy như hình sau :

http://1.bp.blogspot.com/-uoArfx3hX9M/TV8k7j7JV3I/AAAAAAAABB4/Usz2wmSS0T8/s1600/untitled.PNG

Nhóm BDGSPRING MVC

Click button Install để cài đặt Spring IDE từ Eclipse Marketpalce.

1. Download framework mới nhất từ


Sau khi truy cập vào trang http://www.springsource.org/download , nhấn vào nút Download như hình vẽ



http://2.bp.blogspot.com/-O-_eemDrgj4/TV8jHfIjEII/AAAAAAAABBw/QRQZylmT7Tk/s1600/untitled.PNG

http://1.bp.blogspot.com/-FlwMULje7iA/TV8lT-6WNWI/AAAAAAAABB8/h-iBbuq-zzE/s1600/untitled.PNG

Nhóm BDGSPRING MVC

Sau đó nhấn vào More

Nhóm BDGSPRING MVC

Chọn link để download 2 cái framework :

– spring-framework-2.5.6-with-dependencies.zip

– spring-framework-2.5.6-with-docs.zip

Sau khi download xong ,ta giải nén 2 tập tin vừa download. Sẽ nhận được 2 thư mục : spring-framework-2.5.6-with-dependencies và spring-framework-2.5.6-with-docs. Hai thư mục này dùng để add thư viện vào trong project của chương trình .

Nhóm BDGSPRING MVC

Nhóm BDGSPRING MVC

1. Tạo project

Nhóm BDGSPRING MVC

1. Đặt tên project

Nhóm BDGSPRING MVC

2. Tạo package Helloword

Nhóm BDGSPRING MVC

Chọn Finish.

3. Tạo Class Main và Hello

Nhóm BDGSPRING MVC

Tạo Class Main :

Nhóm BDGSPRING MVC

Tạo Class Hello

Nhóm BDGSPRING MVC

4. Add thư viện cho project :

Chọn tên của project , click phải chọn Properties

Nhóm BDGSPRING MVC

Sau đó :

Chọn vào Add External JARs như hình vẽ :

Nhóm BDGSPRING MVC

Nhóm BDGSPRING MVC

Tìm thư mục spring-framework-2.5.6 đã được tải như đã nói ở ban đầu

Nhóm BDGSPRING MVC

Chọn spring.jar , sau đó chọn Open

Tiếp tục thao tác chọn vào Add External JARs 1 lần nữa

Ta làm các bước như hình (có khoanh tròn màu đỏ)

Nhóm BDGSPRING MVC

Nhóm BDGSPRING MVC

Chọn commons-logging.jar

Nhóm BDGSPRING MVC

Sau 2 bước thực hiện

Nhóm BDGSPRING MVC

Chọn OK.

Khi add thư viện thành công , project sẽ có cấu trúc như sau :

Nhóm BDGSPRING MVC

5. Tạo file Hello.xlm

Đặt tên file

Nhóm BDGSPRING MVC

Chọn Finish.

Nhóm BDGSPRING MVC

6. Sau khi thực hiện các bước tạo Class ,file xml và add thư viện . Cấu

trúc Project sẽ như sau :

7. Nội dung các file trong cấu trúc

a. Hello.java

Nhóm BDGSPRING MVC

b. Main.java

Nhóm BDGSPRING MVC

c. Hello.xml

Nhóm BDGSPRING MVC

1. Để chạy kết quả : Nhấn ctrl + f11 hoặc chọn class Main =>Run As =>

Java Application.

12 . Kết quả sau khi chạy chương trình :

Nhóm BDGSPRING MVC

-----HẾT----

project spring framework

Documents