spring framework中的spring web MVC模块
1.概述
- spring web mvc是spring框架中的一个模块
- spring web mvc实现了web的MVC架构模式,可以被用于开发web网站
- spring web mvc 实现web网站的原理,如下图:
2.使用spring web mvc开发web应用的步骤
step1:在自己的工程中引入spring web mvc模块
step2:配置spring web mvc模块 中的DispatcherServlet,告诉他要拦截哪些请求
step3:编写controller类
3.spring web mvc中相关知识点
3.1关于spring web mvc 中的DispatcherServlet
-
DispatcherServlet是spring web mvc 模块的核心部分,DispatcherServlet有如下功能
接收用户请求,并将其分发给controller中的handling method
The
DispatcherServlet
is an actualServlet
(it inherits from theHttpServlet
base class),- 一个web application中可以有多个DispatcherServlet 实例,
- 每个DispatcherServlet实例都有他自己的
WebApplicationContext实例
,TheWebApplicationContext
is an extension of the plainApplicationContext
that has some extra features necessary for web applications.- WebApplicationContext有如下功能:
- it is capable of resolving themes (see Section 22.9, “Using themes”)
- WebApplicationContext有如下功能:
所有的WebApplicationContext实例都继承自root
WebApplicationContext实例
,- The root
WebApplicationContext
应该包含 all the infrastructure【基础】 beans that should be shared between your other contexts and Servlet instances. These inherited beans can be overridden in the servlet-specific scope, and you can define new scope-specific beans local to a given Servlet instance. -
Figure 22.2. Typical context hierarchy in Spring Web MVC
- It is also possible to have just one root context for single DispatcherServlet scenarios.
-
Figure 22.3. Single root context in Spring Web MVC
Table 22.1. Special bean types in the WebApplicationContext
Bean type Explanation Maps incoming requests to handlers and a list of pre- and post-processors (handler interceptors) based on some criteria the details of which vary by
HandlerMapping
implementation. The most popular implementation supports annotated controllers but other implementations exists as well.HandlerAdapter
Helps the
DispatcherServlet
to invoke a handler mapped to a request regardless of the handler is actually invoked. For example, invoking an annotated controller requires resolving various annotations. Thus the main purpose of aHandlerAdapter
is to shield theDispatcherServlet
from such details.Maps exceptions to views also allowing for more complex exception handling code.
Resolves logical String-based view names to actual
View
types.Resolves the locale a client is using and possibly their time zone, in order to be able to offer internationalized views
Resolves themes your web application can use, for example, to offer personalized layouts
Parses multi-part requests for example to support processing file uploads from HTML forms.
Stores and retrieves the "input" and the "output"
FlashMap
that can be used to pass attributes from one request to another, usually across a redirect.-
要想
DispatcherServlet
能够拦截到用户的请求,还需要做一些相应的配置,如使用URL mapping的方式将用户请求映射到DispatcherServlet。可以有多种方法来使得用户请求被映射到DispatcherServlet上,
-
方法一,直接继承spring MVC 模块的WebApplicationInitializer接口,来配置spring MVC模块的DispatcherServlet,使其可以接收到用户请求
将用户请求以URL方式映射到spring web mvc模块的 DispatcherServlet 上,从而使得用户请求能够通过DispatcherServlet被转交给controller来进行处理,并得到处理结果作为响应反馈给用户
- 下面的例子中all requests starting with
/example
will be handled by theDispatcherServlet
instance namedexample
. -
/*
1)WebApplicationInitializer
is an interface provided by Spring MVC that ensures your code-based configuration is detected and automatically used to initialize any Servlet 3 container.
2)
*/
public class MyWebApplicationInitializer implements WebApplicationInitializer { @Override
public void onStartup(ServletContext container) {
ServletRegistration.Dynamic registration = container.addServlet("example", new DispatcherServlet());
registration.setLoadOnStartup(1);
registration.addMapping("/example/*");
} }使用上述方法(即Java代码的方法)配置URL映射,将用户请求交给DispatcherServlet来分发给对应的Controller,这与传统情况下使用web.xml文件配置相应映射的效果是一样的,如本例中上述代码的效果和下面的web.xml的配置代码是等价的(传统模式下使用web.xml配置用户请求URL,使得用户请求能够被Servlet拦截(如被spring web mvc的DispatcherServlet拦截))
- 方法二:传统模式下使用web.xml将用户请求URL映射待DispatcherServlet上
- 传统模式下在web.xml中配置请求URL和servlet的映射关系,如下所示:
<!--上面的Java代码和传统模式下web.xml文件下这一段代码是等效的 都是将用户请求/example/*交给web应用的servlet(例子中指的是spring web mvc中的DispatcherServlet)去处理 让servlet把接收到的用户请求交给controller层相应的handling method去处理--> <web-app>
<servlet>
<servlet-name>example</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet> <servlet-mapping>
<servlet-name>example</servlet-name>
<url-pattern>/example/*</url-pattern>
</servlet-mapping> </web-app>- You can customize individual
DispatcherServlet
instances by adding Servlet initialization parameters (init-param
elements) to the Servlet declaration in theweb.xml
file. See the following table for the list of supported parameters.Parameter Explanation contextClass
Class that implements
WebApplicationContext
, which instantiates the context used by this Servlet. By default, theXmlWebApplicationContext
is used.contextConfigLocation
String that is passed to the context instance (specified by
contextClass
) to indicate where context(s) can be found. The string consists potentially of multiple strings (using a comma as a delimiter) to support multiple contexts. In case of multiple context locations with beans that are defined twice, the latest location takes precedence.namespace
Namespace of the
WebApplicationContext
. Defaults to[servlet-name]-servlet
.
方法三,实现WebApplicationInitializer接口
import org.springframework.web.WebApplicationInitializer; public class MyWebApplicationInitializer implements WebApplicationInitializer { @Override
public void onStartup(ServletContext container) {
XmlWebApplicationContext appContext = new XmlWebApplicationContext();
appContext.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml"); ServletRegistration.Dynamic registration = container.addServlet("dispatcher", new DispatcherServlet(appContext));
registration.setLoadOnStartup(1);
registration.addMapping("/");
} }-
(推荐使用本方法)方法四,继承AbstractAnnotationConfigDispatcherServletInitializer类(方法三中所提及的WebApplicationInitializer接口的实现类)
-
example1,使用Java-based Spring configuration:
public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer { @Override
protected Class<?>[] getRootConfigClasses() {
return null;
} @Override
protected Class<?>[] getServletConfigClasses() {
return new Class[] { MyWebConfig.class };
} @Override
protected String[] getServletMappings() {
return new String[] { "/" };
} } -
example2,If using XML-based Spring configuration, you should extend directly from
AbstractDispatcherServletInitializer
:public class MyWebAppInitializer extends AbstractDispatcherServletInitializer { @Override
protected WebApplicationContext createRootApplicationContext() {
return null;
} @Override
protected WebApplicationContext createServletApplicationContext() {
XmlWebApplicationContext cxt = new XmlWebApplicationContext();
cxt.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");
return cxt;
} @Override
protected String[] getServletMappings() {
return new String[] { "/" };
} }AbstractDispatcherServletInitializer
also provides a convenient way to addFilter
instances and have them automatically mapped to theDispatcherServlet
:public class MyWebAppInitializer extends AbstractDispatcherServletInitializer { // ... @Override
protected Filter[] getServletFilters() {
return new Filter[] { new HiddenHttpMethodFilter(), new CharacterEncodingFilter() };
} }
-
-
-
3.2 Implementing Controllers
方法一:annotion-based Controller
概述:使用 @RequestMapping
, @RequestParam
,@ModelAttribute
,等注解可以定义一个类为controller类,使得该类可以处理用户的请求。
编程思路:
- step1,要想spring能够识别上述注解,必须要先在配置文件中开启上述注解的识别方式
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd"> <context:component-scan base-package="org.springframework.samples.petclinic.web"/> <!-- ... --> </beans>
- step2,The
@Controller
annotation indicates that a particular class serves the role of a controller.- The ServletDispatcher scans such annotated classes for mapped methods and detects @RequestMapping annotations (see the next section).
- step3,
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping - 例如,
@Controller
public class HelloWorldController { @RequestMapping("/helloWorld")
public String helloWorld(Model model) {
model.addAttribute("message", "Hello World!");
return "helloWorld";
}
}@Controller
@RequestMapping("/appointments")
public class AppointmentsController { private final AppointmentBook appointmentBook; @Autowired
public AppointmentsController(AppointmentBook appointmentBook) {
this.appointmentBook = appointmentBook;
} @RequestMapping(method = RequestMethod.GET)
public Map<String, Appointment> get() {
return appointmentBook.getAppointmentsForToday();
} @RequestMapping(path = "/{day}", method = RequestMethod.GET)
public Map<String, Appointment> getForDay(@PathVariable @DateTimeFormat(iso=ISO.DATE) Date day, Model model) {
return appointmentBook.getAppointmentsForDay(day);
} @RequestMapping(path = "/new", method = RequestMethod.GET)
public AppointmentForm getNewForm() {
return new AppointmentForm();
} @RequestMapping(method = RequestMethod.POST)
public String add(@Valid AppointmentForm appointment, BindingResult result) {
if (result.hasErrors()) {
return "appointments/new";
}
appointmentBook.addAppointment(appointment);
return "redirect:/appointments";
}
}上面的例子和下面的例子等价:
@Controller
@RequestMapping("/appointments")
public class AppointmentsController { private final AppointmentBook appointmentBook; @Autowired
public AppointmentsController(AppointmentBook appointmentBook) {
this.appointmentBook = appointmentBook;
} @GetMapping
public Map<String, Appointment> get() {
return appointmentBook.getAppointmentsForToday();
} @GetMapping("/{day}")
public Map<String, Appointment> getForDay(@PathVariable @DateTimeFormat(iso=ISO.DATE) Date day, Model model) {
return appointmentBook.getAppointmentsForDay(day);
} @GetMapping("/new")
public AppointmentForm getNewForm() {
return new AppointmentForm();
} @PostMapping
public String add(@Valid AppointmentForm appointment, BindingResult result) {
if (result.hasErrors()) {
return "appointments/new";
}
appointmentBook.addAppointment(appointment);
return "redirect:/appointments";
}
}In the above example,
@RequestMapping
is used in a number of places. The first usage is on the type (class) level, which indicates that all handler methods in this controller are relative to the/appointments
path. Theget()
method has a further@RequestMapping
refinement: it only acceptsGET
requests, meaning that an HTTPGET
for/appointments
invokes this method. Theadd()
has a similar refinement, and thegetNewForm()
combines the definition of HTTP method and path into one, so thatGET
requests forappointments/new
are handled by that method.The
getForDay()
method shows another usage of@RequestMapping
: URI templates. (See the section called “URI Template Patterns”).A
@RequestMapping
on the class level is not required. Without it, all paths are simply absolute, and not relative. The following example from the PetClinic sample application shows a multi-action controller using@RequestMapping
:@Controller
public class ClinicController { private final Clinic clinic; @Autowired
public ClinicController(Clinic clinic) {
this.clinic = clinic;
} @RequestMapping("/")
public void welcomeHandler() {
} @RequestMapping("/vets")
public ModelMap vetsHandler() {
return new ModelMap(this.clinic.getVets());
} }
- step1,要想spring能够识别上述注解,必须要先在配置文件中开启上述注解的识别方式
实际使用实例:
- spring-projects Org on Github,网站上有一些使用注解方式开发的controllers实例,包括MvcShowcase, MvcAjax, MvcBasic, PetClinic, PetCare, and others.