spring mvc 的文档学习

最新推荐文章于 2024-09-14 23:01:09 发布

weixin_34361881

最新推荐文章于 2024-09-14 23:01:09 发布

阅读量112

点赞数

文章标签：测试 java python

原文链接：https://my.oschina.net/iioschina/blog/670595

版权

2019独角兽企业重金招聘Python工程师标准>>>

Spring 4.1..6文档笔记

Spring mvc

Mvc框架围绕着一个DispatcherServlet设计，它用来分发处理请求，配合着处理映射，视图解析，语言，时间区，主题解析，支持文件上传。默认的处理由@Controller and @RequestMapping来支持。Spring3.0控制器机制也支持创建Restful类型的网站，通过@PathVariable等一系列注解来声明。

Springmvc视图解析很灵活，一个控制器负责准备数据和选择的视图名组成的模板映射，或者直接将数据写到响应流，完成请求。

DispatcherServlet是一个Servlet继承了HttpServlet基类。你需要映射请求用DispatcherServlet来处理

<web-app>

<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>

上面配置中所有以/example开头的请求都会由DispatcherServlet的实例example处理，同样相等的在a Servlet 3.0+environment环境中，可以用以下的代码代替上面的xml中的内容。

public class MyWebApplicationInitializer implements WebApplicationInitializer {

@Override

public void onStartup(ServletContext container) {

ServletRegistration.Dynamic registration = container.addServlet("dispatcher", new DispatcherServlet());

registration.setLoadOnStartup(1);

registration.addMapping("/example/*");

}

WebApplicationInitializer由mvc提供的接口，保证的的类被检测并自动初始化Servlet 3容器，一个抽象类实现了AbstractDispatcherServletInitializer接口使得注册DispatcherServlet更容易？（不怎么了解）

上下文关系图

初始化dispatcherServlet,寻找应用中WEB-INF目录中的[servlet-name]-servlet.xml。

考虑一下的web.xml中的配置

<web-app>

<servlet-name>golfing</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>golfing</servlet-name>

<url-pattern>/golfing/*</url-pattern>

</servlet-mapping>

</web-app>

以上的配置对应的你的应用中得有一个/WEB-INF/golfing-servlet.xml对用的配置文件。

也可以只有一个根目录下的上下文文件包含了初始化的参数，指定具体的servlet配置路径

<web-app>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/root-context.xml</param-value>

</context-param>

<servlet-name>dispatcher</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value></param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>dispatcher</servlet-name>

<url-pattern>/*</url-pattern>

</servlet-mapping>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

</web-app>

WebApplicationContext是ApplicationContext的扩展，有一些其他的特性。可以来解析主题，并且知道了哪个servlet相关（有一个和ServletContext的连接）。

Dispatcherservlet用特殊的bean来处理请求返回视图，你可以通过配置选择一些ben在web上下文中，也可以使用默认的一系列bean。

HandlerMapping 匹配请求和一系列的前后处理（处理拦截器）。

HandlerAdapter 帮助DispatcherServlet调用映射的处理器

HandlerExceptionResolver 将异常对应到视图

ViewResolver 解析逻辑的基于字符串的视图名到实际的视图类型

LocaleResolver & LocaleContextResolver 提供国际化的视图

ThemeResolver 在应用中提供个性化的布局资源(css,jpg)

MultipartResolver 处理多媒体请求，如处理文件上传来自表单

FlashMapManager 储存输入，输出 FlashMap，传递属性组从一个请求到另一个请求在重定向中

默认的DispatcherServlet配置保存在org.springframework.web.servlet的DispatcherServlet.properties文件中

DispatcherServlet处理请求的顺序

1.应用上下文查找并绑定请求中的信息作为属性，提供以后的处理器或其他使用

2.Locale resolver 解析方言在处理请求中（渲染视图，准备数据）使用

3.The theme resolver 请求中使视图决定要使用哪些主题

4.a multipart file resolver 请求中检查多媒体，找到了，请求被包装成MultipartHttpServletRequest，待后续处理

5.寻找合适的处理器，找到了处理器相关的执行链（前处理，后处理，控制器），来处理业务和数据

6.如果业务实体返回，视图被渲染；无返回不处理视图

DispatcherServlet 初始化参数组

contextClass 实现了WebApplicationContext，初始化servlet使用的上下文，默认使用XmlWebApplicationContext

contextConfigLocation 根据字符串标识的一个或多个上下文类名，或者是位置信息来配置，最后的起作用。

Namespace WebApplicationContext命名空间，默认是 [servlet-name]-servlet

实现Controllers

解析用户输入，转变为model，通过view展示给user

使用注解@RequestMapping, @RequestParam, @ModelAttribute（Spring2.5）

@Controller

public class HelloWorldController {

@RequestMapping("/helloWorld")

public String helloWorld(Model model) {

model.addAttribute("message", "Hello World!");

return "helloWorld";

}

定义控制器 @Controller

自动检测注解控制器xml配置

<?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>

请求映射@RequestMapping

将URLS到对应的实体类或特定处理方法

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(value="/{day}", method = RequestMethod.GET)

public Map<String, Appointment> getForDay(@PathVariable @DateTimeFormat(iso=ISO.DATE) Date day, Model model) {

return appointmentBook.getAppointmentsForDay(day);

}

@RequestMapping(value="/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";

}

@RequestMapping 类上，表示控制器类中方法和url相关

方法上，表示方法和不同URLS相关

@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());

}

可以用@RequestMapping(method=GET)缩小动作范围

有时候一个控制器需要运行时用AOP代理装饰，比如在控制器上用@Transactional，这种情况下使用基于类的代理

在Spring MVC 3.1中支持@RequestMapping methods的类

RequestMappingHandlerMapping 是3.1中唯一一个地方决定请求处理的方法，RequestMappingHandlerAdapter 是实际调用方法。

在3.1之前，类型和方法级别的请求映射由两个阶段检查，先是DefaultAnnotationHandlerMapping，然后实际方法调用是AnnotationMethodHandlerAdapter。

@PathVariable在方法参数上绑定URI模板变量的值

@RequestMapping(value="/owners/{ownerId}", method=RequestMethod.GET)

public String findOwner(@PathVariable String ownerId, Model model) {

Owner owner = ownerService.findOwner(ownerId);

model.addAttribute("owner", owner);

return "displayOwner";

}

url模板“/owners/{ownerId}”表面变量是ownerId,当控制器处理这个请求时，URI中合适地方发现的值设置为ownerId的值，比如，当一个请求来自/owners/fred时，ownerId的值是fred。

或者你可以在参数注解中明确指定变量名，如下：@RequestMapping(value="/owners/{ownerId}", method=RequestMethod.GET)

public String findOwner(@PathVariable("ownerId") String theOwner, Model model) {

// implementation omitted

}

一个方法参数中，可以有多个@PathVariable；

@RequestMapping(value="/owners/{ownerId}/pets/{petId}", method=RequestMethod.GET)

public String findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {

Owner owner = ownerService.findOwner(ownerId);

Pet pet = owner.getPet(petId);

model.addAttribute("pet", pet);

return "displayPet";

}

还有一种路径中参数变量的请求方式URL/owners/42/pets/21.

@Controller

@RequestMapping("/owners/{ownerId}")

public class RelativePathUriTemplateController {

@RequestMapping("/pets/{petId}")

public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {

// implementation omitted

}

路径参数可以使任何简单类型int,long,Date等，Spring自动转化类型或者失败时表现TypeMismatchException异常

@RequestMapping支持URI模板中变量表达式的使用，如{varName:regex}，第一部分是变量名，第二部分是匹配表达式，比如：

/spring-web/spring-web-3.0.5.jar

@RequestMapping("/spring-web/{symbolicName:[a-z-]}-{version:\\d\\.\\d\\.\\d}{extension:\\.[a-z]}")

public void handle(@PathVariable String version, @PathVariable String extension) {

// ...

}

请求路径匹配规则

默认MVC执行文件后缀匹配，匹配路径/person也适合匹配/person.*；

Matrix Variables

模型变量：在URL中eg: "/cars;color=red;year=2012"，以；或，分割，Eg: "color=red,green,blue" 或"color=red;color=green;color=blue"；

// GET /pets/42;q=11;r=22

@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET)

public void findPet(@PathVariable String petId, @MatrixVariable int q) {

// petId == 42

// q == 11

}

用注解指定这种变量之间值得映射关系：

// GET /owners/42;q=11/pets/21;q=22

@RequestMapping(value = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)

public void findPet(

@MatrixVariable(value="q", pathVar="ownerId") int q1,

@MatrixVariable(value="q", pathVar="petId") int q2) {

// q1 == 11

// q2 == 22

}

可以指定默认值代替路径中的变量值

// GET /pets/42

@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET)

public void findPet(@MatrixVariable(required=false, defaultValue="1") int q) {

// q == 1

}

将值传入Map类型的参数中

// GET /owners/42;q=11;r=12/pets/21;q=22;s=23

@RequestMapping(value = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)

public void findPet(

@MatrixVariable Map<String, String> matrixVars,

@MatrixVariable(pathVar="petId"") Map<String, String> petMatrixVars) {

// matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]

// petMatrixVars: ["q" : 11, "s" : 23]

}

默认配置中<mvc:annotation-driven>有一个属性enable-matrix-variables 为false,如果要使用这种变量需要设置为true:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:mvc="http://www.springframework.org/schema/mvc"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<mvc:annotation-driven enable-matrix-variables="true"/>

</beans>

@RequestMapping中参数consumes指定媒体类型,来匹配请求头中content-Type中相同的媒体类型

@Controller

@RequestMapping(value = "/pets", method = RequestMethod.POST, consumes="application/json")

public void addPet(@RequestBody Pet pet, Model model) {

// implementation omitted

}

又如Content-Type :text/plain

@RequestMapping中produces属性指定相应请求响应头中content-type类型

@Controller

@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, produces="application/json")

@ResponseBody

public Pet getPet(@PathVariable String petId, Model model) {

// implementation omitted

}

请求参数和请求头值

@RequestMapping params "myParam", "!myParam", or "myParam=myValue"

指定参数，非指定参数，指定参数值

@Controller

@RequestMapping("/owners/{ownerId}")

public class RelativePathUriTemplateController {

@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, params="myParam=myValue")

public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {

// implementation omitted

}

@Controller

@RequestMapping("/owners/{ownerId}")

public class RelativePathUriTemplateController {

@RequestMapping(value = "/pets", method = RequestMethod.GET, headers="myHeader=myValue")

public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {

// implementation omitted

}

@RequestMapping匹配的处理方法参数类型

支持的方法参数类型

请求或相应对象（servlet API）veg: ServletRequest, HttpServletRequest;

Session 对象（servlet API）httpSesion类型，展现session,这样的参数永远不会为空（session可能非线程安全，尤其在servlet环境中，如果多个请求同时操作一个会话，可以设置RequestMappingHandlerAdapter's "synchronizeOnSession" flag to "true"）;

org.springframework.web.context.request.WebRequest or org.springframework.web.context.request.NativeWebRequest请求参数或属性通过，与本地Servlet/Portlet API无关;

java.util.Locale 当前请求的现场，由配置环境中的LocaleResolver / LocaleContextResolver决定;

java.util.TimeZone当前请求，由LocaleContextResolver决定;

java.io.InputStream / java.io.Reader 请求内容，由Servlet API暴露原始值;

java.io.OutputStream / java.io.Writer，响应内容，由Servlet API暴露原始值;

org.springframework.http.HttpMethod 请求动作,get,post,delete,head,opitions…..;

java.security.Principal包含目前已授权的用户;

@PathVariable URL模板中变量对应参数;

@MatrixVariable URL路径片段中的name-value对对应的参数类型;

@RequestParam 访问特殊的servlet请求参数，参数值自动转化为方法参数类型;

@RequestHeader 访问特殊的servlet请求头，参数值自动转化为方法参数类型;

@RequestBody 访问http请求体参数注解，参数值转换为参数定义类型通过httpMessageConverter;

@RequestPart访问"multipart/form-data"请求部分的注解;

HttpEntity<?> 访问servlet请求http的请求头和内容，请求流转化为实体通过HttpMessageConverter;

java.util.Map / org.springframework.ui.Model / org.springframework.ui.ModelMap 充实model暴露给web视图;

org.springframework.web.servlet.mvc.support.RedirectAttributes 明确重定向的属性集合，在server端缓存属性方便重定向后二次请求的需要;

RedirectAttributes 不通过model如果方法返回带有 “redirect:”前缀的视图名或RedirectView;

org.springframework.validation.Errors / org.springframework.validation.BindingResult 校验结果为前处理或form对象;

org.springframework.web.bind.support.SessionStatus处理表单过程完成状态的标志，如果成功就清理会话属性（@SessionAttributes指定）;

org.springframework.web.util.UriComponentsBuilder准备当前请求的url生成器。;

无效的参数顺序(@ModelAttribute("pet") Pet pet, Model model, BindingRes

有效的参数顺序 (@ModelAttribute("pet") Pet pet, BindingResult result, Model model)

支持的方法返回类型

ModelAndView 对象，包含数据模型和@ModelAttribute注解访问的方法结果

Model 包含视图对象名（RequestToViewNameTranslator决定），命令对象充实的数据，结果（ModelAttribute标注方法返回相关数据）

Map 放弃数据模型的对象，包含视图名（RequestToViewNameTranslator）和充实后的数据模型；

View 命令对象返回的数据模型和@ModelAttribute涉及的数据访问方法，处理方法可以通过Model参数来充实数据模型

String 逻辑视图名的值，命令对象决定的数据模型和@ModelAttribute涉及的数据访问方法，a Model参数标记的处理方法；

Void 如果自己处理响应（直接返回数据，定义参数ServletResponse/HttpServletResponse）或者由RequestToViewNameTranslator决定，（不是定义响应参数在处理方法签名中）

如果方法是由@ResponseBody标记的，返回方式写入响应http身体，返回值转变为定义的参数类型（通过HttpMessageConverters）

HttpEntity<?>or ResponseEntity<?> 访问servlet响应http头或内容，实体将转化为响应流（HttpMessageConverters）

HttpHeaders 作为返回响应没有身体

Callable<?>返回，Spring mvc管理线程，应用异步处理返回结果

DeferredResult<?>自己选择线程处理返回结果值

ListenableFuture<?> 同上

任何其他返回类型都是被当作数据模型的一个属性暴露给视图，@ModelAttribute在方法级上做标记

请求参数到方法参数的绑定 @RequestParam

@Controller

@RequestMapping("/pets")

@SessionAttributes("pet")

public class EditPetForm {

// ...

@RequestMapping(method = RequestMethod.GET)

public String setupForm(@RequestParam("petId") int petId, ModelMap model) {

Pet pet = this.clinic.loadPet(petId);

model.addAttribute("pet", pet);

return "petForm";

}

// ...

}

自动转化参数非string类型，可以设置默认参数值

请求体和@RequestBody注解的对象相映射

方法参数和http请求体的值绑定

@RequestMapping(value = "/something", method = RequestMethod.PUT)

public void handle(@RequestBody String body, Writer writer) throws IOException {

writer.write(body);

}

转化通过HttpMessageConverter将请求消息转化为对象并且将对象转化为响应体，RequestMappingHandlerAdapter支持@RequestBody，HttpMessageConverters支持对象的转化

如果要进行xml的转化，需要MarshallingHttpMessageConverter通过确定的org.springframework.oxm下的 Marshaller和Unmarshaller实现

<util:list id="beanList">

</util:list>

</property

</bean>

<bean id="stringHttpMessageConverter"

class="org.springframework.http.converter.StringHttpMessageConverter"/>

<bean id="marshallingHttpMessageConverter"

class="org.springframework.http.converter.xml.MarshallingHttpMessageConverter">

</bean>

一个@RequestBody注解的方法参数可以用@Valid，表示用确定的Validator实例来验证

将响应体和对应的方法相关联@ResponseBody

标记方法表示返回的对象将直接写入http响应体（不会被方法模型代替，或视图名打断）

@RequestMapping(value = "/something", method = RequestMethod.PUT)

@ResponseBody

public String helloWorld() {

return "Hello World";

}

上例中文本会写入响应流中

与@RequestBody,相同，HttpMessageConverter转换返回对象为响应体。

@RestController在映射的方法上，，将@ResponseBody和@Controller联合起来。

使用HttpEntity

和@RequestBody and @ResponseBody用来访问请求体和响应体，而且可以访问请求和响应头(httpEntity and ResponseEntity)

@RequestMapping("/something")

public ResponseEntity<String> handle(HttpEntity<byte[]> requestEntity) throws UnsupportedEncodingException {

//请求头值

String requestHeader = requestEntity.getHeaders().getFirst("MyRequestHeader"));

//读取请求体作为字节数组

byte[] requestBody = requestEntity.getBody();

// do something with request header and body

//返回创建的响应头

HttpHeaders responseHeaders = new HttpHeaders();

responseHeaders.set("MyResponseHeader", "MyValue");

return new ResponseEntity<String>("Hello World", responseHeaders, HttpStatus.CREATED);

}

@ModelAttribute 在方法上和方法参数上

添加一个或多个model属性，不是直接与请求相关联，而是在关联之前调用。

/ Add one attribute

// The return value of the method is added to the model under the name "account"

// You can customize the name via @ModelAttribute("myAccount")

@ModelAttribute

public Account addAccount(@RequestParam String number) {

return accountManager.findAccount(number);

}

// Add multiple attributes

@ModelAttribute

public void populateModel(@RequestParam String number, Model model) {

model.addAttribute(accountManager.findAccount(number));

// add more ...

}

@ModelAttribute注解的方法用来构成哪些下拉框值得属性，或者构成一个对象用来在html表单中展示

在方法上使用@ModelAttribute有两种方式，第一种，增加一个参数并且返回。第二种，接收一个Model,加入多个属性。

一个controller可以有多个@ModelAttribute标记的方法，这些方法都在映射url之前被调用

@ModelAttribute可以用在@RequestMapping注解的方法上，RequestMapping注解方法的返回时一个model的属性而不是一个视图名。

在方法参数中使用@ModelAttribute 注解

参数由model而来，如果不在model中，则先实例化后加入model.在model中后，参数fields由所有请求匹配的名字中获得。者叫做数据绑定，一个有用的机制使你避免从field中一个个解析

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)

public String processSubmit(@ModelAttribute Pet pet) { }

Pet的实例从哪来：

已在model中（使用了SessionAttributes ）

已在model中由于使用了（@ModelAttribute）在同一个controller 上

基于URI template变量和类型转换

实例化使用自己默认的构造器

@ModelAttribute标记的方法是一种普遍的方法来传递数据库中的值，可以选择性的存储在请求或者使用@SessionAttributes。一些情况中使用URI template variable and a type converter.恢复属性更方便

@RequestMapping(value="/accounts/{account}", method = RequestMethod.PUT)

public String save(@ModelAttribute("account") Account account) {

}

上例中model属性account匹配uri template同名变量，如果你注册Converter<String, Account>可以将string型的account值转为account实例

数据绑定中可能有没有匹配的错误，检查这种错误加上BindingResult参数

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)

public String processSubmit(@ModelAttribute("pet") Pet pet, BindingResult result) {

if (result.hasErrors()) {

return "petForm";

}

// ...

}

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)

public String processSubmit(@ModelAttribute("pet") Pet pet, BindingResult result) {

new PetValidator().validate(pet, result);

if (result.hasErrors()) {

return "petForm";

}

// ...

}

@Valid校验参数绑定

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)

public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) {

if (result.hasErrors()) {

return "petForm";

}

// ...

}

@SessionAttributes在请求之中存储model属性在http会话中

特定的处理器处理SessionAttributes定义的session。列出model属性名或属性类型（显示的存储在session或一些会话的存储）当作随后请求的支持者

@Controller

@RequestMapping("/editPet.do")

@SessionAttributes("pet")

public class EditPetForm {

// ...

}

指定重请求和短时间存储的属性

默认的一些model属性被暴露在uri template的重请求url的变量中，这些参数被保存下来在集合或队列中。

@CookieValue 来映射cookie values

可以将方法参数与http cookie绑定

JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84

http请求获得的cookie值

@RequestMapping("/displayHeaderInfo.do")

public void displayHeaderInfo(@CookieValue("JSESSIONID") String cookie) {

//...

}

由名字来映射

请求头属性和@RequestHeader注解的参数绑定

Host localhost:8080

Accept text/html,application/xhtml+xml,application/xml;q=0.9

Accept-Language fr,en-gb;q=0.7,en;q=0.3

Accept-Encoding gzip,deflate

Accept-Charset ISO-8859-1,utf-8;q=0.7,*;q=0.7

Keep-Alive 300

@RequestMapping("/displayHeaderInfo.do")

public void displayHeaderInfo(@RequestHeader("Accept-Encoding") String encoding,

@RequestHeader("Keep-Alive") long keepAlive) {

//...

}

上例中通过映射将相同名字对应的值映射到方法参数中

@RequestHeader 用在Map<String, String>, MultiValueMap<String, String>, or HttpHeaders 中会获得所有的头中的值。

请求中的值包括请求参数，路径变量，请求头，cookie值转化为对应的方法参数类型

最近修改的响应内容的缓存

一个@RequestMapping标注的方法可能要去支持最近修改的请求去促进内容的缓存

一个应用就是请求通过计算最近修改时间查看web资源是否发生了变化，状态304没有发生变化

@RequestMapping

public String myHandleMethod(WebRequest webRequest, Model model) {

long lastModified = // 1. application-specific calculation

if (request.checkNotModified(lastModified)) {

// 2. shortcut exit - no further processing necessary

return null;

}

// 3. or otherwise further request processing, actually preparing content

model.addAttribute(...);

return "myViewName";

}

@ControllerAdvice通知controllers

方法级别的注解使用，通知实现的类通过路径扫描自动检测相关的实现类；当使用MVC namespace 或 mvc java config

@ControllerAdvice注解的classes能包含@ExceptionHandler, @InitBinder, and @ModelAttribute 注解的方法

// Target all Controllers annotated with @RestController

@ControllerAdvice(annotations = RestController.class)

public class AnnotationAdvice {}

// Target all Controllers within specific packages

@ControllerAdvice("org.example.controllers")

public class BasePackageAdvice {}

// Target all Controllers assignable to specific classes

@ControllerAdvice(assignableTypes = {ControllerInterface.class, AbstractController.class})

public class AssignableTypesAdvice {}

Jackson Serialization View Support

有时能够过滤对象上下文序列化到http响应体中。为了使用这种功能通过springmvc提供的Jackson’s Serialization Views.

在@ResponseBody controller方法上使用或者控制方法返回ResponseEntity，简单的在类参数上使用注解@JsonView，指定具体的view类或者要使用的接口

@RestController

public class UserController {

@RequestMapping(value = "/user", method = RequestMethod.GET)

@JsonView(User.WithoutPasswordView.class)

public User getUser() {

return new User("eric", "7!jd#h23");

}

public class User {

public interface WithoutPasswordView {};

public interface WithPasswordView extends WithoutPasswordView {};

private String username;

private String password;

public User() {

}

public User(String username, String password) {

this.username = username;

this.password = password;

}

@JsonView(WithoutPasswordView.class)

public String getUsername() {

return this.username;

}

@JsonView(WithPasswordView.class)

public String getPassword() {

return this.password;

}

控制器依赖视图解析，简单的添加序列化的视图类到model

@Controller

public class UserController extends AbstractController {

@RequestMapping(value = "/user", method = RequestMethod.GET)

public String getUser(Model model) {

model.addAttribute("user", new User("eric", "7!jd#h23"));

model.addAttribute(JsonView.class.getName(), User.WithoutPasswordView.class);

return "userView";

}

Jackson JSONP Support

为了使jsonp支持@responseBody标记的或者返回 ResponseEntity的方法，定义一个@ControllerAdvice bean 继承AbstractJsonpResponseBodyAdvice 类。

@ControllerAdvice

public class JsonpAdvice extends AbstractJsonpResponseBodyAdvice {

public JsonpAdvice() {

super("callback");

}

JSONP自动使得请求有参数（名字为jsoup或callback）,这些名字能够自定义通过jsonpParameterNames属性

Asynchronous Request Processing

Spring MVC 3.2 介绍 Servlet 3的异步请求过程，不是返回一个值，一个controller返回java.util.concurrent.Callable，并且产生一个返回结果通过另一线程，同时主要的servlet容器线程被释放，并允许处理其他请求。Spring mvc调用 the callable在另一个线程中（TaskExecutor的帮助），当callable返回时，将请求分派给Servlet容器简单处理callable返回的值，以下是一个例子

@RequestMapping(method=RequestMethod.POST)

public Callable<String> processUpload(final MultipartFile file) {

return new Callable<String>() {

public String call() throws Exception {

// ...

return "someView";

}

};

}

第二种选择是返回一个DeferredResult的实例。这种情况下返回值也会被一个线程处理，spring mvc并不知道这个线程，比如返回可能是对一个JMS信息事件的响应，一个定时任务等：

@RequestMapping("/quotes")

@ResponseBody

public DeferredResult<String> quotes() {

DeferredResult<String> deferredResult = new DeferredResult<String>();

// Save the deferredResult in in-memory queue ...

return deferredResult;

}

// In some other thread...

deferredResult.setResult(data);

}

没有servlet3异步处理特性的了解是很难明白这一点，了解一下基础的事实

ServletRequest通过request.startAsync()的调用使得进入异步的模式。做事的是servlet和一些filters,可以退出，响应依然打开，允许其他线程完成处理

调用后返回异步的上下文，可以供以后异步的处理，例如提供dispatch方法，可以调用来分发请求返回servlet 容器。异步分发类似forward跳转，只是从应用的一个线程到container的另一个线程，然而forward是同步发生在同一个线程中。

ServletRequest可以访问DispatcherType,,可以用来区分servlet和filter(在最初的请求处理线程中)

Callable异常请求处理:Controller返回Callable对象;spring mvc开始异常处理提交callable到taskExecutor(不同的线程处理);DispatcherServlet和所有Filter退出请求处理现场,响应依然打开；calalble产生结果，spring 分发请求回到servlet容器；DispatcherServlet再次被调用处理异步产生的结果（处理callable）

Exception Handling for Async Requests

当返回callable时引起异常怎么处理?由@ExceptionHandler注解的方法在同一个控制器中或者一个配置的实例HandlerExceptionResolver

当使用DeferredResult时选择它的setErrorResult(Object)方法，提供一个异常或其他对象。用@ExceptionHandler标记的方法在同一个controller或者一个HandlerExceotionResolver实例处理异常

拦截异步请求(Intercept)

一个存在的HandlerInterceptor实现AsyncHandlerInterceptor，提供另外的方法afterConcurrentHandlingStarted。这个方法被调用在异常处理开始之后，初始的请求处理线程退出。可以参考AsyncHandlerInterceptor javadocs

DeferredResult提供其他异步请求生命周期的调用，有方法onTimeout(Runnable)，onCompletion(Runnable)，分别是在超时或者完成后调用。超时事件可以设置DeferredResult为一些其他值，完成调用是final型，它的结果不能再设置

处理映射handler mappings

下例示例如何配置一个拦截器

<beans>

</property>

</bean>

<beans>

HandlerInterceptor拦截请求

<beans>

<bean id="handlerMapping"

class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping">

<list>

</list>

</property>

</bean>

<bean id="officeHoursInterceptor"

class="samples.TimeBasedAccessInterceptor">

</bean>

<beans>

package samples;

public class TimeBasedAccessInterceptor extends HandlerInterceptorAdapter {

private int openingTime;

private int closingTime;

public void setOpeningTime(int openingTime) {

this.openingTime = openingTime;

}

public void setClosingTime(int closingTime) {

this.closingTime = closingTime;

}

public boolean preHandle(HttpServletRequest request, HttpServletResponse response,

Object handler) throws Exception {

Calendar cal = Calendar.getInstance();

int hour = cal.get(HOUR_OF_DAY);

if (openingTime <= hour && hour < closingTime) {

return true;

}

response.sendRedirect("http://host.com/outsideOfficeHours.html");

return false;

}

任何请求处理被拦截TimeBasedAccessInterceptor，如果当前日期是工作时间之外，用户重定向到静态html页面，只有在规定时间内才能访问

解析视图，

两个接口ViewResolver提供视图名和视图的映射，View将请求交给对应的视图技术

Resolving views with the ViewResolver interface

</bean>

</bean>

<beans>

</beans>

重定向view

@RequestMapping(value = "/files/{path}", method = RequestMethod.POST)

public String upload(...) {

// ...

return "redirect:files/{path}";

}

创建urls

提供创建加密的URI使用UriComponentsBuilder and UriComponents.

UriComponents uriComponents = UriComponentsBuilder.fromUriString(

"http://example.com/hotels/{hotel}/bookings/{booking}").build();

URI uri = uriComponents.expand("42", "21").encode().toUri();

Note that UriComponents is immutable and the expand() and encode() operations return new instances if necessary.

You can also expand and encode using individual URI components:

UriComponents uriComponents = UriComponentsBuilder.newInstance()

.scheme("http").host("example.com").path("/hotels/{hotel}/bookings/{booking}").build()

.expand("42", "21")

.encode();

在servlet环境中ServletUriComponentsBuilder提供静态工厂方法从servlet 请求中获得可用的url信息

HttpServletRequest request = ...

// Re-use host, scheme, port, path and query string

// Replace the "accountId" query param

ServletUriComponentsBuilder ucb = ServletUriComponentsBuilder.fromRequest(request)

.replaceQueryParam("accountId", "{id}").build()

.expand("123")

.encode();

转载于:https://my.oschina.net/iioschina/blog/670595

weixin_34361881

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫