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 actual Servlet
(it inherits from the HttpServlet
base class),
一个web application中可以有多个DispatcherServlet 实例,
每个DispatcherServlet实例都有他自己的
WebApplicationContext实例
,The WebApplicationContext
is an extension of the plain ApplicationContext
that has some extra features necessary for web applications.
WebApplicationContext有如下功能:
it is capable of resolving themes (see Section 22.9, “Using themes”)
所有的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 |
---|---|
HandlerMapping |
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 |
HandlerAdapter |
Helps the |
HandlerExceptionResolver |
Maps exceptions to views also allowing for more complex exception handling code. |
ViewResolver |
Resolves logical String-based view names to actual |
LocaleResolver &LocaleContextResolver |
Resolves the locale a client is using and possibly their time zone, in order to be able to offer internationalized views |
ThemeResolver |
Resolves themes your web application can use, for example, to offer personalized layouts |
MultipartResolver |
Parses multi-part requests for example to support processing file uploads from HTML forms. |
FlashMapManager |
Stores and retrieves the "input" and the "output" |
要想DispatcherServlet
能够拦截到用户的请求,还需要做一些相应的配置,如使用URL mapping的方式将用户请求映射到DispatcherServlet。可以有多种方法来使得用户请求被映射到DispatcherServlet上,
方法一,直接继承spring MVC 模块的WebApplicationInitializer接口,来配置spring MVC模块的DispatcherServlet,使其可以接收到用户请求
MyWebApplicationInitializer.java
将用户请求以URL方式映射到spring web mvc模块的 DispatcherServlet 上,从而使得用户请求能够通过DispatcherServlet被转交给controller来进行处理,并得到处理结果作为响应反馈给用户
下面的例子中all requests starting with /example
will be handled by the DispatcherServlet
instance named example
.
/*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 |
---|---|
|
Class that implements |
|
String that is passed to the context instance (specified by |
|
Namespace of the |
方法三,实现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 add Filter
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. The get()
method has a further @RequestMapping
refinement: it only accepts GET
requests, meaning that an HTTPGET
for /appointments
invokes this method. The add()
has a similar refinement, and the getNewForm()
combines the definition of HTTP method and path into one, so that GET
requests for appointments/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());
} }
实际使用实例:
spring-projects Org on Github,网站上有一些使用注解方式开发的controllers实例,包括MvcShowcase, MvcAjax, MvcBasic, PetClinic, PetCare, and others.