SpringMVC（上）——未完，暂时搁置

https://www.bilibili.com/video/BV1mW411M7YA

内容概要：

• 概述
• HelloWorld
• @RequestMapping
• 映射请求参数和请求头
• 处理模型数据
• 视图和视图解析器
• RESTful CRUD
• SpringMVC 表单标签和处理静态资源
• 数据转换、数据格式化、数据校验
• 处理JSON
• 国际化
• 文件的上传
• 使用拦截器
• 异常处理
• SpringMVC运行环境
• 在Spring的环境下使用SpringMVC
• 对比Structs2

SpringMVC 概述

• SpringMVC 为展现层提供的基于MVC设计理论的优秀的Web框架，是目前最主流的MVC框架之一
• Spring3.0后全面超越Structs2
• 通过一套MVC注解，让POJO成为处理请求的控制器，而无须实现任何接口
• 支持REST风格的URL请求
• 采用了松散耦合可插拔组件结构，比其它MVC框架更具扩展性和灵活性

编写一个SpringMVC项目

• 加入jar包（略）
  除了core content那四个还有web和webmvx

配置方式一

• 在web.xml中配置

<servlet>
    <servlet-name>dispatcherservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springmvc.xmlparam-value>
        init-param>

        <load-on-startup>1load-on-startup>
servlet>

• 编写Controller

@Controller
public class HelloWorld {
    /**
     * 1. 使用@RequestMapping注解来映射请求的URL
     * 2. 返回值会通过视图解析器解析成实际的物理视图
     * 通过prefix + returnVal + 后缀的方式得到物理视图，并作转发操作
     * @return
     */
    @RequestMapping("helloWorld")
    public String hello(){
        System.out.println("hello world");
        return "success";
    }
}

• 在src中配置springdemo.xml

<context:component-scan base-package="com.springlmvc.handlers"/>
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/views/"/>
        <property name="suffix" value=".jsp"/>
    bean>

异常

• 直接用路径访问资源是访问不到的，会报异常，没有添加映射

org.springframework.web.servlet.PageNotFound.noHandlerFound No mapping found for HTTP request with URI [/mvc/a.jpg] in DispatcherServlet with name 'dispatcher'

配置方式二

• web.xml配置如下

<servlet>
        <servlet-name>dispatcherservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        
        




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

• 把springdemo.xml按照默认的命名方式放到默认的路径下。
  

@RequestMapping

• SpringMVC使用@RequestMapping注解为控制器指定可以处理哪些URL请求

• 在 控制器的类定义及方法定义处都可标注@RequestMapping

  • 类定义处：提供初步的请求映射信息。相对于WEB应用的根目录
  • 方法处：提供进一步的细分映射信息。相对于类定义处的URL。若类定义处未标注@RequestMapping，则方法处标记的URL相对于WEB应用的根目录

• DispatcherServlet截获请求后，就通过控制器上@RequestMapping提供的映射信息确定请求所对应的处理方法。

• @RequestMapping除了可以使用请求URL映射请求外，还可以使用请求方法、请求参数、及请求头映射请求

• @RequestMapping的value、method、params及heads分别表示请求URL、请求方法、请求参数及请求头的映射条件，它们之间是与的关系，联合使用多个条件可以让请求映射更加精确化。

• params和headers支持简单的表达式

  • ！param1：表示请求不能包含名为param1的参数

/**
     * 只映射POST方法，那么GET方法并不会触发该方法
     * @return
     */
    @RequestMapping(value = "/testMethod" ,method = RequestMethod.POST)
    public String testMethod(){
        System.out.println("testMethod");
        return SUCCESS;
    }

    /**
     * 筛选参数
     * http://localhost:8080/mvc/sprvc/testParam?username=username&age=11可以访问
     * http://localhost:8080/mvc/sprvc/testParam?name=username&age=11不可以访问
     * http://localhost:8080/mvc/sprvc/testParam?username=username&age=10不可以访问
     * 筛选头部
     *
     */
    @RequestMapping(value = "/testParam" ,params = {"username","age!=10"},
                    headers = {"Content-Language=zh-CN"})
    public String testParamAndHeaders(){
        System.out.println("testParamAndHeaders");
        return SUCCESS;
    }

请求参数不符合时报异常：

No matching handler method found for servlet request: path '/sprvc/testParam', method 'GET', parameters map['name' -> array<String>['username'], 'age' -> array<String>['11']]

匹配符

• ? ——匹配文件名中的一个字符
• *——匹配文件名中的一个字符
• ** ——匹配多层路径
• 还支持Ant风格的URL

@PathVariable 映射URL绑定的占位符

• 带占位符的URL是Spring3.0新增的功能，该功能在SpringMVC向REST目标挺进发展过程中具有里程碑的意义，
• 通过@PathVariable可以将URL中占位符参数绑定到控制器处理方法的入参中：URL中的{xxx}占位符可以通过@PathVariable(“xxx”)绑定到操作方法的入参中。

/**
     * 测试 @PathVariable
     * 访问路径： testPathVariable（id） 

     */
    @RequestMapping(value = "/testPathVariable/{id}" )
    public String testPathVariable(@PathVariable String id){
        System.out.println("testPathVariable {id ="+id+"}");
        return SUCCESS;
    }

REST

• REST：Representational State Transfer。（资源）表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。
• 资源（Resources）：网络上的一个实体，或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。可以用一个URI（统一资源定位符）指向它，每种资源对应一个特定的URI。要获取这个资源，访问它的URI就可以，因此URI即为每一个资源的独一无二的识别符。
• 表现层（Representation）：把资源具体呈现出来的形式，叫做它的表现出。比如：文本可以用txt格式，也可以用HTML格式，xml格式，JSON格式，甚至二进制格式……
• 状态转化（State Transfer）：每发出一个请求，就代表了客户端和服务器的一次交互过程。HTTP协议，是一个无状态协议，即所有的状态都保存在服务器端，因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发送“状态转化”。而这种转化是建立在表现层之上的，所以就算“表现层状态转化”。具体说，就是HTTP协议里面，四个表示操作的动词：GET、POST、PUT、DELETE，它们分别对应四种基本操作：获取资源，新建资源，更新资源，删除资源。
• 示例：
  • 得到id=1的order： /order/1 —— GET
  • 删除id=1的order：/order/1——DELETE
  • 更新id=1的order：/order/1——PUT
  • 新增order：/order/——POST
• HiddenHttpMethodFilter：浏览器form表单只支持GET与POST请求，而DELETE、PUT等method并不支持，Spring3.0添加了一个过滤器，可以将这些请求转换为标准的http方法，使得支持GET、POST、PUT与DELETE请求。

 
    <filter>
        <filter-name>hiddenHttpMethodFilterfilter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>hiddenHttpMethodFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

• 访问入口表单：

<form action="sprvc/testRest" method="post">
        <input type="submit" value="Test Rest POST"/>
      form>
      <form action="sprvc/testRest" method="post">
        <input type="hidden" name="method" value="DELETE">
        <input type="submit" value="Test Rest DELETE"/>
      form>
      <form action="sprvc/testRest" method="post">
        <input type="hidden" name="method" value="PUT">
        <input type="submit" value="Test Rest PUT"/>
      form>
      <a href="sprvc/testRest/1">Test Rest Geta>

/**
     * GET
     */
    @RequestMapping(value = "/testRest/{id}",method = RequestMethod.GET)
    public String testRest(@PathVariable("id") Integer id){
        System.out.println("GET: "+id);
        return SUCCESS;
    }
    //POST
    @RequestMapping(value = "/testRest",method = RequestMethod.POST)
    public String testRestPOST() {
        System.out.println("POST: ");
        return SUCCESS;
    }
    @RequestMapping(value = "/testRest/{id}",method = RequestMethod.DELETE)
    public String testRestDELETE(@PathVariable("id")  Integer id) {
        System.out.println("DELETE: " + id);
        return SUCCESS;
    }
    @RequestMapping(value = "/testRest/{id}",method = RequestMethod.PUT)
    public String testRestPUT(@PathVariable("id")  Integer id) {
        System.out.println("PUT: " + id);
        return SUCCESS;
    }

异常

405 - 方法不允许

HTTP状态 405 - 方法不允许
类型 状态报告

消息 JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS

描述 请求行中接收的方法由源服务器知道，但目标资源不支持

解决办法：

有三种解决方案：

（一）将 Tomcat 8 改为 Tomcat 7，在Tomcat 7 下运行是正常的

（二）将请求转发（forward）改为请求重定向（redirect）

（三）自己手动写一个Filter来包装HttpRequest中的getMethod()方法

下面介绍一下第（三）种做法，也就是自己写一个Filter来包装从服务器发回来的HttpRequest请求：
大致说一下流程，

1. 在第1步中，客户端发送请求至服务器，这时如果发送的是POST请求且带有以_method为名的参数会被Spring的HiddenHttpMethodFilter给拦截。

2. HiddenHttpMethodFilter内有一个静态内部类通过继承HttpServletRequestWrapper类并重写getMethod()方法，将该方法返回值设为_method隐藏域的值。

3. HiddenHttpMethodFilter在包装好Request后，将请求发往服务器的控制器中对应的方法处理器，这时的请求变成了图中的
   3、WrapperRequest by SpringFilter

4. 服务器处理完请求后，产生了一个forward请求，产生相应的请求处理信息发往客户端，注意这时的request的getMethod()方法仍然是HiddenHttpMethodFilter包装过的

5. 我们需要在服务器的响应请求到达客户端前进行拦截，这也是最关键的一步，通过自定义过滤器MyHttpMethodFilter进一步包装请求，将getMethod()方法返回值改成POST或GET即可

6. 在web.xml中配置该filter，注意dispatcher结点值必须为FORWARD。由于字数超限，暂时说到这。。。

<filter-mapping> 	
<filter-name>myFilterfilter-name>
	<url-pattern>/*url-pattern> 	
<dispatcher>FORWARDdispatcher>
filter-mapping>

参照 https://blog.csdn.net/renanrenan/article/details/84654362

HTTP状态 500 - 内部服务器错误

通配符的匹配很全面, 但无法找到元素 ‘context:component-scan’ 的声明。

• 原因未知，推测是关闭启动项目的时候，没彻底关闭？
• 搜到的都是xml文件头配置不完全（没用）

tomcat commonslogging 乱码（还没解决）

还没解决
搜索的：VM options：-Dfile.encoding=UTF-8（没用）

@RequestParam

/* 筛选头部
     * RequestParam获取请求参数
     * required = false表示该参数非必需，没有也能正常运行
     * defaultValue表示默认值，请求中没有该参数时就取默认值
     */
    @RequestMapping(value = "/testParam" ,params = {"username","age!=10"},
                    headers = {"Host=localhost:8080"})
    public String testParamAndHeaders(@RequestParam(value = "username",defaultValue = "unnamed") String name,@RequestParam(value = "age",required = false) Integer age){
        System.out.println("testParamAndHeaders , username:"+name+" age:"+age);
        return SUCCESS;
    }

@CookieValue

获得cookie中的值

使用POJO对象绑定请求参数值

SpringMVC会按请求参数名和POJO属性名进行自动装配，自动为该对象填充属性值。支持级联属性，如dept.deptId,dept.address.tel等

SpringMVC的Handler可以方法接受哪些ServletAPI类型的参数

• HttpServletRequest
• HttpServletResponce
• HttpSession
• java.security.Principal
• Locale
• InputStream
• OutputStream
• Reader
• Writer

/**
     * 获取Servlet相关API，测试
     * 
     * @param request 请求
     * @param response 响应
     * @return 直接向页面写内容
     */
    @RequestMapping("/testServletAPI")
    public void testServletAPI(HttpServletRequest request, HttpServletResponse response,
                               Writer out) throws IOException {
        System.out.println("testServletAPI:");
        System.out.println(request);
        System.out.println(response);
        out.write("hello ,I'm writer.");
        out.close();
    }

处理模型数据

/**
     * 目标方法的返回值可以是ModelAndView，包括返回字符串，也是包装成了ModelAndView
     * 其中可以包含视图和模型信息
     * SpringMVC会把ModelAndView的model中数据放入到request域对象中
     * @return 视图模型
     */
    @RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView(){
        String viewName = SUCCESS;
        ModelAndView modelAndView = new ModelAndView(viewName);
        //添加模型数据到ModelAndView中
        modelAndView.addObject("time",new Date());

        return modelAndView;
    }

Map和Model

• Spring MVC在内部使用了一个org.springframework.ui.Model接口存储模型数据
• 具体步骤
  • SpringMVC在调用方法前会创建一个隐含的模型对象作为模型数据的存储容器。
  • 如果方法的入参为Map或Model模型，SpringMVC会将隐含模型的引用传递给这些入参。在方法体内，开发者可以通过这个入参对象访问到模型中的所有数据，也可以向模型中添加新的属性数据。

/**
     * 目标方法可以添加Map类型（实际上也可以是Model类型，或ModelMap，ExtendedModelMap）的参数，
     * public class ExtendedModelMap extends ModelMap implements Model {}
     * @param map
     * @return
     */
    @RequestMapping("/testMap")
    public String testMap(Map<String,Object> map){
        
        map.put("names", Arrays.asList("tom","jerry","jack"));
        return SUCCESS;
    }

@SessionAttributes

• 若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注一个@SessionAttributes，SpringMVC将在模型中对应的属性暂存到HttpSession中。
• @SessionAttributes除了可以通过属性名指定需要放到会话中的 属性外，还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中
  • @SessionAttributes(types=User.class)会将隐含模型中所有类型为User.class的属性添加到会话中。
  • @SessionAttributes(value={“user1”,“user2”})
  • @SessionAttributes(types={User.class,Dept.class})
  • @SessionAttributes(value={"user1,“user2”},types={Dept.class})

@SessionAttributes(value = {"user"},types = String.class)
@RequestMapping("/sprvc")
@Controller
public class SpringMVCTest {
	/**
     * @SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外（实际上使用的是value属性值），
     * 还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中（实际上使用的是types属性值）
     * 注意：这个注解只能放在类的上面，而不能修饰方法
     * @param map map中的值可以在展示页面中读取
     * @return
     */
    @RequestMapping("/testSessionAttributes")
    public  String testSessionAttributes(Map<String,Object> map){
        User user = new User("Tom","123456","[email protected]",15);
        map.put("user",user);
        map.put("School","atguigu");
        return SUCCESS;
    }
}

异常 Session attribute 'user' required - not found in session（没写）

@ModelAttribute

1. 有@ModelAttribute标记的方法，会在每个目标方法执行之前被SpringMVC调用
2. @ModelAttribute注解也可以用来修饰目标方法POJO类型的入参，其value属性值会有如下作用:
   1. SpringMVC会使用value属性值在ImplicitModel中查找对应的对象，若存在则会直接传入到目标方法的入参中
   2. SpringMVC会以 value为key，POJO类型的对象为value，存入到request中

/**
     * 测试@ModelAttribute
     * @param user 若存的时候名字不是"user"而是"abc"，则可在user前加注解： @ModelAttribute("abc")，不加的话获取不到
     *             public String testModelAttribute(@ModelAttribute("abc") User user){
     * @return
     */
	@RequestMapping("/testModelAttribute")
    public String testModelAttribute(User user){
        System.out.println("修改： "+user);
        return SUCCESS;
    }

    /**
     * 有@ModelAttribute标记的方法，会在每个目标方法执行之前被SpringMVC调用
     *   执行流程：
     *          1. 执行该注解修饰的方法：从数据库中去除对象，把读写放入了Map中。键为：user
     *          2. SpringMVC从Map中取出user对象，并把表单的请求参数赋给该user对象的对应属性
     *          3. 将上述对象传入目标方法的参数。
     *   注意：
     *          在该注解修饰的方法中，放入到Map时的键需要和目标方法入参类型的第一个字母小写的字符串一致
     * @param id 从表单得到：
     * @param map
     */
    @ModelAttribute
    public void getUser(@RequestParam(value = "id",required = false) Integer id,
                        Map<String,Object> map){
        if (id!=null){
            //模拟从数据库中获取对象
            User user = new User("Tom","123456","[email protected]",15);
            System.out.println("从数据中获取对象： "+user);
            map.put("user",user);
        }
    }

执行流程：

1. 执行该注解修饰的方法：从数据库中去除对象，把读写放入了Map中。键为：user
2. SpringMVC从Map中取出user对象，并把表单的请求参数赋给该user对象的对应属性
3. 将上述对象传入目标方法的参数。

源代码分析的流程：

1. 调用@ModelAttribute注解修饰的方法，实际上把@ModelAttribute方法中map的数据放到了ImplicitModel中。
2. 解析请求处理器的目标参数，实际上该目标参数来自与WebDataBinder 对象的target属性
   1. 创建WebDataBinder 对象。
      确定ObjectName属性：若传入的attrName属性值为空串，则objectName为类名第一个字母小写；若目标方法的POJO属性使用了@ModelAttribute修饰，则attrName值则为@ModelAttribute的value属性值
      确定target属性：在ImplicitModel查找attrName对应的属性值，若存在，ok；若不存在，则验证当前Handler是否使用了@SessionAttributes修饰，若使用了，则尝试从Session中获取attrName所对应的属性值；若没有对应的属性，则抛出异常。若没有用@SessionAttributes修饰，或@SessionAttributes中没有使用value值指定的key和attrName，则通过反射创建了POJO对象
   2. SpringMVC 把表单的请求参数赋给了WebDataBinder的target对应的属性
   3. SpringMVC会把WebDataBinder的attrName和target给到ImplicitModel
   4. 把WebDataBinder的target作为参数传递给目标方法的入参

SpringMVC确定目标方法POJO类型入参的过程

1. 确定一个key
   1. 若目标方法的POJO类型的参数没有使用@ModelAttribute，则key为POJO类名第一个字母小写
   2. 若使用了@ModelAttribute来修饰，则key作为@ModelAttribute注解的value属性值。
2. 在ImplicitModel中查找key对应的对象，若存在，则作为入参传入
   1. 若@ModelAttribute标记的方法中在Map中保存过，且key和1确定的key一致，则会获取到。
3. 若中不存在key对应的对象，则检查当前的Handler是否使用@SessionAttributes 注解修饰：若使用了该注解，且这个注解的value属性值中包含了key，则会从HttpSession中来获取key所对应的value值，若存在则直接传入到目标方法的入参中，若不存在则抛出异常。
4. 若Handler没有使用@SessionAttributes注解或@SessionAttributes 注解的value值中不包含key，则会通过反射来创建POJO类型的参数，传入为目标方法的参数
5. SpringMVC会把key和POJO类型的对象保存到ImplicitModel中，进而会保存到request中。

视图和视图解析器

• @Controller请求处理方法执行完成后，最终可能返回三种类型的返回值：
  • String
  • ModelAndView
  • View
• 这三种类型都会被SpringMVC装配成一个ModelAndView对象，它包含了逻辑和模型对象的视图
• SpringMVC借助ViewResolver得到最终的视图对象View，它可以是JSP/JSTL/PDF…各种表现形式的视图
• 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现MVC的充分解耦。

视图

• 视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。
• 为了实现视图模型和具体实现技术的解耦，Spring在org.springframework.web.Servlet包中定义了一个高度抽象的View接口
• 视图对象由视图解析器负责实例化。由于视图是无状态的，所以它们不会有线程安全的问题。

视图解析器

• 常见的视图解析器实现类

大类	视图类型	说明
解析为Bean的名字	BeanNameViewResolver	将逻辑视图名解析为一个Bean，Bean的id等于逻辑视图名
解析为URL文件	InternalResourceViewResolver JasperReportsViewResolver	将视图名解析为一个URL文件，一般使用该解析器将视图名映射为一个保存在WEB-INF目录下的程序文件（如JSP） JasperReports是一个基于Java的开源报表工具
模板文件视图	FreeMarkerViewResolver VelocityViewResolver VelocityLayoutViewResolver	FreeMarker模板 Velocity模板

• 程序员可以选择一种视图解析器或混用多种。
• 每个视图解析器都实现了Ordered接口并开放出一个order属性，可以通过order属性指定解析器的优先顺序。
• SpringMVC会按照视图解析器的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则抛出ServletException异常

InternalResourceViewResolver

• 若项目中使用了JSTL，则SpringMVC会自动把视图由InternalResourceView转为JstlView
• 若使用JSTL的fmt标签则需要在SpringMVC的配置文件中配置国际化资源文件

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
    <property name="basename" value="i18n">property>
bean>

• 若希望直接响应通过SpringMVC渲染的页面，可以使用mvc:view-controller标签实现

    
    <mvc:view-controller path="/success" view-name="success"/>
    
    <mvc:annotation-driven />

自定义视图

Excel视图

• 若希望使用Excel展示数据列表，仅需要扩展SpringMVC提供的AbstractExcelView或AbstractExcel View即可。实现buildExcelDoucument()方法，在方法中使用模型数据对象构建Excel文档就可以了。
• 视图对象需要配置IOC容器中的一个Bean，使用BeanNameViewResolver作为视图解析器即可。
• 若希望直接在浏览器中直接下载Excel文档，则可以设置响应头Content-Disposition的值为attachment;filename=xxx.xls

转发和重定向

//重定向
return "redirect:/index.jsp";
//转发
return "forward:/index.jsp";

RESTFUL SPRINGMVC CRUD

Spring的表单标签

• 可以实现将模型数据中的属性和HTML表单元素相绑定，以实现表单数据更便捷编辑和表单值的回显。

SpringMVC处理静态资源

1. 优雅的REST风格的资源URL不希望带.html等后缀，若将DispatcherServlet请求映射配置位/，则SpringMVC会捕获WEB容器的所有请求，包括静态资源的请求，SpringMVC会将它们当作一个普通请求处理，因找不到对应处理器将捕获错误。
2. 在SpringMVC的配置文件中配置

    <mvc:default-servlet-handler/>
    <!--    通常需要加上mvc:annotation-driven-->
    <mvc:annotation-driven />

数据绑定流程

1. SpringMVC主框架将ServletRequest对象及目标方法的入参实例传递给WebDataBinderFactory实例，以创建DataBinder实例对象
2. DataBinder调用装配在SpringMVC上下文中的ConversionService组件进行数据类型转换、数据格式化工作。将Servlet中的请求信息填充到入参对象中
3. 调用Validator组件对已经绑定了请求消息的入参对象进行数据合法化校验，并最终生成数据绑定结果BindingData对象
4. SpringMVC抽取BindingResult中的入参对象和校验错误对象，将它们赋给处理方法的响应入参

数据转换

SpringMVC上下文中内建了很多转换器，可完成大多数Java类型的转换工作。

	<mvc:annotation-driven conversion-service="conversionService"/>
    <bean id="conversionService" class="org.springframework.core.convert.support.DefaultConversionService">
        <property name="converters">
            <set >
                <ref bean="employeeConverter"/> set>
        property>
    bean>

class EmployeeConverter implements  ConversionService{
	//略
}

关于mvc:annotation-driven

• 会自动注册RequestMappingHandlerMapping、RequestMappingHandlerAdapter、ExceptionHandlerExceptionResolver 三个bean。
• 还将提供以下支持
  • 支持使用@ConversionService实例对表单参数进行类型转换
  • 支持使用@NumberFormatannotation @DateTimeFormat注解完成数据类型的格式化
  • 支持使用@Valid注解对JavaBean实例进行JSR 303验证
    +支持使用 @RequestBody和@ResponseBody注解

@InitBinder

• 由@InitBinder标识的方法，可以对WebDataBinder对象进行初始化。WebDataBinder是DataBinder的子类。用于完成由表单字段到JavaBean属性的绑定
• @InitBinder方法不能有返回值，必须为void
• @InitBinder方法的参数通常是WebDataBinder

获取错误信息

获取对象 BindingResult

/**
     * 打印错误信息
     * @param result
     */
    public void printErrorMessages(BindingResult result){
        int count = result.getErrorCount();
        for (int i = 0; i < count; i++) {
            FieldError error = result.getFieldErrors().get(i);
            System.out.println(error.getField()+":"+error.getDefaultMessage());
        }
    }

数据校验

JSR 303

JavaEE标准

过程

1. 使用JSR 303验证标准
2. 加入hibernate validator验证框架
3. 在SpringMVC配置文件中添加
4. 在bean的属性上添加对应的注解
5. 在目标方法bean类型的前面添加@Valid注解

处理JSON——HttpMessageConverter

1. 加入jar包（jackson）
2. 编写目标方法，使其返回JSON对应的对象或集合
3. 在方法上添加@ResponseBody注解