Spring mvc 初探

Spring mvc：

HelloWorld：

1.在 web.xml 文档中配置 DispatcherServlet：

<!--配置 DispatcherServlet-->
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>


        <!--配置一个初始化参数-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--也可以使用默认的-->
        <!--默认的配置文件为 /WEB-INF/<servlet-name>-servlet.xml-->

        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

（在 IDEA 中可以直接代码提示找 DispatcherServlet）
对于 init-param 初始化配置，可以用默认的路径：/WEB-INF/<servlet-name>-servlet.xml

url 中的 / 表示全部匹配

2.声明控制类：

@Controller
public class HelloWorld {

    /**
     * 使用 RequestMapping 注解来映射请求的 URL
     * 返回值会通过视图解析器解析为实际的物理视图，对于 InternalResourceViewResolver 视图解析器，会做如下解析：
     * 通过 perfix + returnVal + 后缀 这样的方式得到实际的物理视图，然后做转发操作
     * @return
     */
    @RequestMapping("/helloworld")
    public String Hello() {
        System.out.println("Hello world!");
        return "success";
    }

}

@RequestMapping 用来作为映射请求的 URL
（对于路径的传输匹配）
返回的 “success” 经过视图解析器解析为实际的路径：前缀(prefix) + returnVal + 后缀(suffix)
最终路径：/WEB-INF/views/success.jsp

3.写 springmvc 配置文件：

<!--配置自动扫描的包-->
    <context:component-scan base-package="com.springmvc.handlers"></context:component-scan>

    <!--配置视图解析器，如何把 Handler 方法解析为实际的物理视图-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

自动扫描包扫描注解
视图解析器：InternalResourceViewResolver 中设置两个值：前缀和后缀

4.对于主界面的跳转：
<a href="helloworld">Hello world!</a>
helloworld 经过 @RequestMapping(“/helloworld”) 解析跳转过来执行 Hello() 方法
返回的 “success” 经过视图解析器跳转到目标路径下的 jsp 页面

RequestMapping：

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

在控制器类定义及方法定义处都可标注

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

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

修饰类：

@Controller
@RequestMapping("/springmvc")
public class HelloWorld {

    @RequestMapping("/helloworld")
    public String Hello() {
        System.out.println("Hello world!");
        return "success";
    }

}

URL：
<a href="springmvc/helloworld">Hello world!</a>

指定请求方式：

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

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

params 和 headers 支持简单的表达式
param1: 表示请求必须包含名为 param1 请求参数
!param1: 表示请求不能包含名为 param1 请求参数
param1 != value1: 表示请求包含名为 param1 请求参数，但其值不能为 value1
{“param1=value1”, “param2”}: 请求必须包含名为 param1 和 param2 两个请求参数
且 param1 参数的值必须为 value1

Method ：

@RequestMapping(value = "/testMethod", method = RequestMethod.POST)
    public String testMethod() {
        System.out.println("testMethod");
        return "success";
    }

则必须用表单设置 method 为 post：

<form method="post" action="/springmvc/testMethod">
      <input type="submit" value="submit"/>
    </form>

params & headers：

@RequestMapping(value = "/testPH", params={"username", "age!=10"}, headers = {"Accept-Language=zh-CN,zh;q=0.8"})
    public String ParamAndHeads() {
        System.out.println("ParamAndHeads");
        return "success";
    }

params 中所指定的属性必须一致才能跳转执行：
<a href="/springmvc/testPH?username=haha&age=11">TestPH</a>
路径 + ? + 属性=value + & + 属性=value

对于 headers ，和网页有关，若指定，则必须跟网页的 headers 一样才能跳转

（二者应用均不多，作了解）

路径简化：

Ant 风格资源地址支持 3 种匹配符：
? ：匹配文件名中的一个字符
* ：匹配文件名中的任意字符
** ：匹配多层路径

@RequestMapping 还支持 Ant 风格的 URL：
/user/*/createUser : 匹配
/user/aaa/createUser、/user/bbb/createUser 等 URL

/user/**/createUser : 匹配
/user/createUser、/user/aaa/bbb/createUser 等 URL

/user/createUser?? : 匹配
/user/createUseraa、/user/createUserbb 等 URL

如：
@RequestMapping("/helloworld/*/hahaha")
则超链接中路径可写成：
<a href="/helloworld/sdsfesfdsfdsf/hahaha">helloworld</a>

PathVariable：

（可以来映射 URL 中的占位符到目标方法的参数中）

带占位符的 URL 是 Spring3.0 新增的功能
该功能在 SpringMVC 向 REST 目标挺进发展过程中具有里程碑的意义

通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中 ：
URL 中的 {xxx} 占位符可以通过 @PathVariable(“xxx”) 绑定到操作方法的入参中

如：

@RequestMapping("/testPathVariable/{id}")
    public String testPathVariable(@PathVariable("id") Integer id){
        System.out.println("testPathVariable : " + id);
        return "success";
    }

{id} 表示 URL 中的 Integer 类型的数字
在传参中声明 @PathVariable(“id”) Integer id ，即可使用 URL 中的占位符（1）：
<a href="/testPathVariable/1">hhh</a>

Rest：

REST：即 Representational State Transfer。（资源）表现层状态转化。是目前
最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，
所以正得到越来越多网站的采用

资源（Resources）：网络上的一个实体，或者说是网络上的一个具体信息。
它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。
可以用一个URI（统一资源定位符）指向它，每种资源对应一个特定的 URI 。
要获取这个资源，访问它的URI就可以，因此 URI 即为每一个资源的独一无二的识
别符。

表现层（Representation）：把资源具体呈现出来的形式，叫做它的表现层（Representation）。
比如，文本可以用 txt 格式表现，也可以用 HTML 格式、XML 格式、JSON 格式表现，甚至可以采用二进制格式。

状态转化（State Transfer）：每发出一个请求，就代表了客户端和服务器的一次交互过程。HTTP协议，是一个无状态协议，即所有的状态都保存在服务器端。
因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生“状态转化”（State Transfer）。
而这种转化是建立在表现层之上的，所以就是 “表现层状态转化”。
具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。
它们分别对应四种基本操作：
GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源

在 web.xml 中用 <filter> 去配置 HiddenHttpMethodFilter ，配置方法与 servlet 类似：

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

/* 表示全部匹配

之后在表单中用 <input type="hidden" name="_method" value="PUT"> 等来更改方式：

<form action="/springmvc/testRest" method="post">
    <input type="submit" value="TestRest Post"/>
</form>

  <a href="/springmvc/testRest/1">TestRest Get</a>

  <form action="/springmvc/testRest/1" method="post">
    <input type="hidden" name="_method" value="DELETE"/>
    <input type="submit" value="TestRest Delete"/>
  </form>

  <form action="/springmvc/testRest/1" method="post">
    <input type="hidden" name="_method" value="PUT"/>
    <input type="submit" value="TestRest Put"/>
  </form>

value 后是想改的发送方式
POST 是新增所以不需要参数
方法的 RequestMapping 的 method 的属性中声明即可

传参处理（@RequestParams）：

Spring MVC 通过分析处理方法的签名，将 HTTP 请求信息绑定到处理方法的相应入参中。

Spring MVC 对控制器处理方法签名的限制是很宽松的，几乎可以按喜欢的任何方式对方法进行签名。

必要时可以对方法及方法入参标注相应的注解（@PathVariable、@RequestParam、@RequestHeader 等）
SpringMVC 框架会将 HTTP 请求的信息绑定到相应的方法入参中
并根据方法的返回值类型做出相应的后续处理。

传参：
<a href="/springmvc/testRequestParams?username=hahaha&age=10">TRP</a>

调用参数：

@RequestMapping("/testRequestParams")
    public String testRequestParams(@RequestParam(value = "username") String username, @RequestParam(value="age",required = false, defaultValue = "0") int age) {
        System.out.println(username + age);
        return "success";
    }

利用 @RequestParams 注释，用 value 属性值来获得 URL 中的参数
参数最好用类型表示，如 Integer 等
（如果用 int 的话，URL 没有此参数，则会报错，而 Integer 则显示为 null）
required 默认为 true，设置为 false 表示这个参数可以没有（不传进来）
defaultValue 表示设置参数默认值

请求头（@RequestHeader）：

请求头包含了若干个属性
服务器可据此获知客户端的信息
通过 @RequestHeader 即可将请求头中的属性值绑定到处理方法的入参中

用超链接直接跳转：
<a href="/springmvc/testRequestHeader">TRH</a>

在传参中设置请求头，可以将其显示出来：

@RequestMapping("/testRequestHeader")
    public String testRequestHeader(@RequestHeader(value = "Accept-Language") String al) {
        System.out.println("testRequestHeader : " + al);
        return "success";
    }

打印效果：
testRequestHeader : zh-CN,zh;q=0.9

@CookieValue：

可让入参绑定某个 Cookie 值：

@RequestMapping("/testCookieValue")
    public String testCookieValue(@CookieValue("JSESSIONID") String cookieValue)  {
        System.out.println("testCookieValue : " + cookieValue);
        return "success";
    }

JSESSIONID：

（也可以自己创建，这里是直接拿网站上原有的 Cookie 来用）

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

Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配
自动为该对象填充属性值。支持级联属性。
如：dept.deptId、dept.address.tel 等

用表单传参，name 要和属性名一致：

<form action="/springmvc/testPojo" method="post">
    username:<input type="text" name="username"/>
    <br/>
    password:<input type="password" name="password"/>
    <br/>
    email:<input type="text" name="email"/>
    <br/>
    age:<input type="text" name="age"/>
    <br/>
    city:<input type="text" name="address.city"/>
    <br/>
    province:<input type="text" name="address.province"/>
    <input type="submit" value="Submit"/>
  </form>

支持级联属性：address.city

新建一个类，这个类包含表单中的属性
（级联属性可包含另一个类 Address，Address 中有 city 和 province）

直接将目标类传入，即可自动进行属性名和 name 的匹配：

@RequestMapping("/testPojo")
    public String testPojo(User user) {
        System.out.println("testPojo : " + user);
        return "success";
    }

（目标类中必须有相应的 get 和 set 方法）

使用 Servlet API 作为入参：

方法可以接受以下参数：
• HttpServletRequest
• HttpServletResponse
• HttpSession
• java.security.Principal
• Locale
• InputStream
• OutputStream
• Reader
• Writer

如：

@RequestMapping("/testServletAPI")
    public void testServletAPI(HttpServletRequest request, HttpServletResponse response , Writer out) throws IOException {
        System.out.println("testServletAPI : " + request + " , " + response);

        out.write("hello springmvc");

        /*return "success";*/
    }

out.write 直接在页面上打印一句话

处理模型数据：

• Spring MVC 提供了以下几种途径输出模型数据：
– ModelAndView:
处理方法返回值类型为 ModelAndView时
方法体即可通过该对象添加模型数据

– Map 及 Model:
入参为 org.springframework.ui.Model、org.springframework.ui.ModelMap 或 java.uti.Map 时
处理方法返回时，Map中的数据会自动添加到模型中。

– @SessionAttributes:
将模型中的某个属性暂存到 HttpSession 中
以便多个请求之间可以共享这个属性

– @ModelAttribute:
方法入参标注该注解后, 入参的对象就会放到数据模型中

ModelAndView：

• 控制器处理方法的返回值如果为 ModelAndView, 则其既包含视图信息，也包含模型数据信息。

• 添加模型数据:
– MoelAndView addObject(String attributeName, Object
attributeValue)
– ModelAndView addAllObject(Map

@RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView() {
        String viewName = "success";
        ModelAndView modelAndView = new ModelAndView(viewName);

        modelAndView.addObject("time", new Date());

        return modelAndView;
    }

返回一个 ModelAndView ，可以传参（String）指定其页面
可以用 addObject 方法设置 键值对
在跳转页面中用 ${requestScope.time} 即可调用显示其 time 的值

（易错点：
应该引入 import org.springframework.web.servlet.ModelAndView;
而不是 import org.springframework.web.portlet.ModelAndView;
若引入后者，则返回跳转会跳转到 URL 的路径
）

关于 ${requestScope.time} ：
requestscope主要用于数据的展示，从request隐藏对象中取出对象或者变量来显示。而request中的对象或变量是通过request.setAttribute方法放入request对象中的。
ModelAndView.addObject 类似于 request.setAttribute

Map 及 Model：

Spring MVC 在内部使用了一个 org.springframework.ui.Model 接口存
储模型数据

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

@RequestMapping("/testMap")
    public String testMap(Map<String, Object> map) {
        map.put("names", Arrays.asList("Tom", "Jerry", "Mike"));
        return "success";
    }

直接传进去一个 Map<String, Object> ，put 一个键值对进去
在页面中就可以直接 ${requestScope.names} 来显示这个键对应的值
（也可以是 Model 或者 ModelMap，但是用的少，Map 用的多）

@SessionAttributes：

• 若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注一个 @SessionAttributes,
Spring MVC 将在模型中对应的属性暂存到 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})

@RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Map<String, Object> map) {
        User user = new User("Tom", "123456", "Tom@163.com", 10);
        map.put("user", user);
        map.put("school", "daxue");

        return "success";
    }

map 储存的是 request，但是如果在类头标明：
@SessionAttributes(value = {"user"}, types = {String.class})
value 相对于 map 的键，types 相对于 map 的值的类型
类头加入 @SessionAttributes 注解，则可以将 map 所存储的数值复制一份到 session 中

在页面中直接调用：${sessionScope.user}

@ModelAttribute：

• 在方法定义上使用 @ModelAttribute 注解：
Spring MVC在调用目标处理方法前，会先逐个调用在方法级上标注了 @ModelAttribute 的方法。

• 在方法的入参前使用 @ModelAttribute 注解：
– 可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数绑定到对象中，再传入入参
– 将方法入参对象添加到模型中

/**
     * 用 @ModelAttribute 标记的方法，会在每个目标方法执行之前被 Spring mvc 调用！
     */
    @ModelAttribute
    public void getUser(@RequestParam(value="id", required = false) Integer id, Map<String, Object> map) {
        if(id != null) {
            // 模拟从数据库中获取一个对象
            User user = new User(1, "Tom", "123456", "tg@sg.com", 12);
            System.out.println("从数据库中获取一个对象 ：" + user);

            map.put("user", user);
        }
    }

获取数据库对象之后，再在页面上对其进行修改：

<form action="/springmvc/testModelAttribute" method="post">
    <input type="hidden" name="id" value="1"/>
    username:<input type="text" name="username" value="Tom"/><br/>
    email:<input type="text" name="email" value="tom@sg.com"/><br/>
    age:<input type="text" name="age" value="12"/><br/>
    <input type="submit" value="Submit"/>
  </form>

注意：在 @ModelAttribute 修饰的方法中，map 的 键名 要和入参的类型名的第一个字母小写的字符串一致！（只能是 user ， 不能是 user1）

但是可以用 @ModelAttribute 来修饰，使 value 等于 map 的键名，如：
map.put("abc", user)

则传参为：
public String testModelAttribute(@ModelAttribute("abc") User user){}

关于 @SessionAttributes 引发的异常：

可以用传参 @ModelAttribute(“abc”) 标识与 SessionAttributes 不同的 value 名
或者无 MA 标识，那么必须要有前置的 MA 方法

视图和视图解析器：

• 请求处理方法执行完成后，最终返回一个 ModelAndView对象。
对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个 ModelAndView 对象，它包含了逻辑名和模型对象的视图

• Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View）
最终的视图可以是 JSP ，也可能是 Excel、JFreeChart 等各种表现形式的视图

• 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心
处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦

JSTL：

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

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

1.加入 jar 包依赖：jakarta-taglibs-standard-1.1.2

2.配置资源文件 i18n.properties ：

i18n.username=Username
i18n.password=Password

这里可以将 i18n 复制两份
一份用英文，与原 i18n 相同，名字为：i18n_en_US
一份用中文，名字为：i18n_zh_CN，内容为：

i18n.username=\u7528\u6237\u540D
i18n.password=\u5BC6\u7801

（这里的 \u 是中文转换的 u 编码 ，其意义分别为：用户名，密码）

3.配置 springmvc.xml：

<!--配置国际化资源文件-->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basename" value="i18n"></property>
    </bean>

因为 JSTL 代替了 InternalResource，在引入 jar 包的一刻 JSTL 已经完成替代
所以这里引入的 bean 为 ResourceBundleMessageSource
配置 basename 为 i18n

4.使用 JSTL 视图：
首先在目标页面中引入 JSTL：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

之后在目标页面使用 fmt 标签显示：

<fmt:message key="i18n.username"></fmt:message>
<fmt:message key="i18n.password"></fmt:message>

JSTL 直接转发到目标页面：

可以用 mvc:view-controller 使其不经过 handle 直接转发到目标页面：

<!--配置直接转发的页面-->
<mvc:view-controller path="/success" view-name="success" />

path 是路径，view-name 是目标文件名

（进入 Tomcat 后在地址栏直接输入 /success ，就可以进入目标界面）

问题：以前的 handle 转发到 success 页面失效
解决：加入 mvc:annotation-driven 标签：

<!--实际开发中通常都需配置 mvc:annotation-driven 标签-->
<mvc:annotation-driven></mvc:annotation-driven>

这样两种方法就都可行了

BeanNameViewResolver 视图解析器：

除了 InternalResourceViewResolver 视图解析器外（路径）
还可以用 BeanNameViewResolver 视图解析器直接靠名字建立页面视图

配置：

<!--配置视图 BeanNameViewResolver 解析器 : 使用视图的名字来解析视图-->
<!--可以用 order 属性配置优先级-->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
    <property name="order" value="1"></property>
</bean>

order 表明视图解析器的优先级

只要有一个实现 View 接口的方法：

@Component
public class HelloView implements View {

    @Override
    public String getContentType() {
        return "text/html";
    }

    @Override
    public void render(Map<String, ?> map, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        httpServletResponse.getWriter().print("hello view, time : " + new Date());
    }

}

重写 render 方法使其在页面上直接显示内容
在 springmvc 方法中建立返回值为其小名的方法（helloView）
之后超链接可直接调用，只要返回的小名与目标类一致，则根据 BeanName 直接转到目标类
（相应的还可以自定义其他视图，只要实现 View 接口）

关于重定向：

• 一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理

• 如果返回的字符串中带 forward: 或 redirect: 前缀时
SpringMVC 会对他们进行特殊处理：将 forward: 和redirect:
当成指示符，其后的字符串作为 URL 来处理
– redirect:success.jsp：会完成一个到 success.jsp 的重定向的操作
– forward:success.jsp：会完成一个到 success.jsp 的转发操作

@RequestMapping("/testRedirect")
    public String testRedirect() {
        System.out.println("testRedirect");
        return "redirect:/index.jsp";
    }

将请求重定向到 index.jsp
（视图解析器都是转发的）

CRUD：

显示所有员工信息：

表单标签：

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

声明：
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<form:form action="/emp" method="post" modelAttribute="employee">
        LastName : <form:input path="lastName"/>
        <br/>
        Email : <form:input path="email"/>
        <br/>
        <%
            Map<String, String> genders = new HashMap();
            genders.put("1", "Male");
            genders.put("0", "Female");

            request.setAttribute("genders", genders);
        %>
        Gender : <form:radiobuttons path="gender" items="${genders }"/>
        <br/>
        Deparment : <form:select path="department.id" items="${deparments }" itemLabel="departmentName" itemValue="id"></form:select>
        <br/>
        <input type="submit" value="Submit"/>
    </form:form>

• 一般情况下，通过 GET 请求获取表单页面，而通过POST 请求提交表单页面，因此获取表单页面和提交表单页面的 URL 是相同的。
只要满足该最佳条件的契约，<form:form>标签就无需通过 action 属性指定表单提交的 URL

• 可以通过 modelAttribute 属性指定绑定的模型属性，若没有指定该属性，则默认从 request 域对象中读取command 的表单 bean，如果该属性值也不存在，则会发生错误。

• SpringMVC 提供了多个表单组件标签，如
<form:input/>、<form:select/>等，用以绑定表单字段的
属性值，它们的共有属性如下：
– path：表单字段，对应 html 元素的 name 属性，支持级联属性
– htmlEscape：是否对表单值的 HTML 特殊字符进行转换，默认值为 true
– cssClass：表单组件对应的 CSS 样式类名
– cssErrorClass：表单组件的数据存在错误时，采取的 CSS 样式

• form:input、form:password、form:hidden、form:textarea：
对应 HTML 表单的 text、password、hidden、textarea 标签
• form:radiobutton：单选框组件标签，当表单 bean 对应的属性值和 value 值相等时，单选框被选中
• form:radiobuttons：单选框组标签，用于构造多个单选框：
– items：可以是一个 List、String[] 或 Map
– itemValue：指定 radio 的 value 值。可以是集合中 bean 的一个属性值
– itemLabel：指定 radio 的 label 值
– delimiter：多个单选框可以通过 delimiter 指定分隔符

• form:checkbox：复选框组件。用于构造单个复选框
• form:checkboxs：用于构造多个复选框。使用方式同 form:radiobuttons 标签
• form:select：用于构造下拉框组件。使用方式同 form:radiobuttons 标签
• form:option：下拉框选项组件标签。使用方式同 form:radiobuttons 标签
• form:errors：显示表单组件或数据校验所对应的错误：
– <form:errors path= “ *” />：显示表单所有的错误
– <form:errors path= “ user*” /> ：显示所有以 user 为前缀的属性对应的错误
– <form:errors path= “ username” /> ：显示特定表单对象属性的错误

处理静态资源：

• 优雅的 REST 风格的资源URL 不希望带 .html 或 .do 等后缀
• 若将 DispatcherServlet 请求映射配置为 /，则 Spring MVC 将捕获WEB 容器的所有请求，包括静态资源的请求， SpringMVC 会将他们当成一个普通请求处理，因找不到对应处理器将导致错误。
• 可以在 SpringMVC 的配置文件中配置 <mvc:default-servlet-handler/>的方式解决静态资源的问题：
– <mvc:default-servlet-handler/>将在 SpringMVC 上下文中定义一个 DefaultServletHttpRequestHandler，它会对进入 DispatcherServlet 的请求进行筛查，如果发现是没有经过映射的请求，就将该请求交由 WEB应用服务器默认的 Servlet 处理，如果不是静态资源的请求，才由 DispatcherServlet 继续处理
– 一般 WEB 应用服务器默认的 Servlet 的名称都是 default。若所使用的WEB 服务器的默认 Servlet 名称不是 default，则需要通过 default-servlet-name 属性显式指定

数据绑定流程：

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

• Spring MVC 通过反射机制对目标处理方法进行解析，将请求消息绑定到处理方法的入参中。数据绑定的核心部件是 DataBinder，运行机制如下：

（可以在方法中传 BindingResult 参数来获取 类型转换 失败的信息）

if(result.getErrorCount() > 0){
            System.out.println("数据类型转换出错了!");

            for(FieldError error:result.getFieldErrors()){
                System.out.println(error.getField() + ":" + error.getDefaultMessage());
            }

数据转换：

• Spring MVC 上下文中内建了很多转换器，可完成大多数 Java 类型的转换工作。
• ConversionService converters =
– java.lang.Boolean -> java.lang.String :
org.springframework.core.convert.support.ObjectToStringConverter@f874ca
– java.lang.Character -> java.lang.Number : CharacterToNumberFactory@f004c9
– java.lang.Character -> java.lang.String : ObjectToStringConverter@68a961
– java.lang.Enum -> java.lang.String : EnumToStringConverter@12f060a
– java.lang.Number -> java.lang.Character : NumberToCharacterConverter@1482ac5
– java.lang.Number -> java.lang.Number : NumberToNumberConverterFactory@126c6f
– java.lang.Number -> java.lang.String : ObjectToStringConverter@14888e8
– java.lang.String -> java.lang.Boolean : StringToBooleanConverter@1ca6626
– java.lang.String -> java.lang.Character : StringToCharacterConverter@1143800
– java.lang.String -> java.lang.Enum : StringToEnumConverterFactory@1bba86e
– java.lang.String -> java.lang.Number : StringToNumberConverterFactory@18d2c12
– java.lang.String -> java.util.Locale : StringToLocaleConverter@3598e1
– java.lang.String -> java.util.Properties : StringToPropertiesConverter@c90828
– java.lang.String -> java.util.UUID : StringToUUIDConverter@a42f23
– java.util.Locale -> java.lang.String : ObjectToStringConverter@c7e20a
– java.util.Properties -> java.lang.String : PropertiesToStringConverter@367a7f
– java.util.UUID -> java.lang.String : ObjectToStringConverter@112b07f ……

mvc:annotation-driven：

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

@InitBinder：

• 由 @InitBinder 标识的方法，可以对 WebDataBinder 对象进行初始化。
WebDataBinder 是 DataBinder 的子类，用于完成由表单字段到 JavaBean 属性的绑定
• @InitBinder方法不能有返回值，它必须声明为void。
• @InitBinder方法的参数通常是 WebDataBinder
（手动在提交表单的过程中加入些操作）
（需要手工加东西，比如完成集合的映射的时候用到这个注解）

数据格式化：

（必须配置 mvc:annotation-driven）
• 对属性对象的输入/输出进行格式化，从其本质上讲依然属于 “类型转换” 的范畴。
• Spring 在格式化模块中定义了一个实现 ConversionService 接口的 FormattingConversionService 实现类，该实现类扩展了 GenericConversionService，因此它既具有类型转换的功能，又具有格式化的功能
• FormattingConversionService 拥有一个 FormattingConversionServiceFactroyBean 工厂类，后者用于在 Spring 上下文中构造前者

• FormattingConversionServiceFactroyBean 内部已经注册了 :
– NumberFormatAnnotationFormatterFactroy：支持对数字类型的属性
使用 @NumberFormat 注解
（如： @NumberFormat(pattern=”#,###,###.#”) ）
– JodaDateTimeFormatAnnotationFormatterFactroy：支持对日期类型
的属性使用 @DateTimeFormat 注解
（如 @DateTimeFormat(pattern=”yyyy-MM-dd”) ）

• 装配了 FormattingConversionServiceFactroyBean 后，就可以在 Spring MVC 入参绑定及模型数据输出时使用注解驱动了。
<mvc:annotation-driven/> 默认创建的 ConversionService 实例即为 FormattingConversionServiceFactroyBean

@DateTimeFormat：

java.util.Date、java.util.Calendar、java.long.Long 时间类型进行标注：
– pattern 属性：类型为字符串。指定解析/格式化字段数据的模式，如：”yyyy-MM-dd hh:mm:ss”
– iso 属性：类型为 DateTimeFormat.ISO。指定解析/格式化字段数据的ISO模式，包括四种：ISO.NONE（不使用） – 默认、ISO.DATE(yyyy-MM-dd) 、ISO.TIME(hh:mm:ss.SSSZ)、
ISO.DATE_TIME(yyyy-MM-dd hh:mm:ss.SSSZ)
– style 属性：字符串类型。通过样式指定日期时间的格式，由两位字符组成，第一位表示日期的格式，第二位表示时间的格式：S：短日期/时间格式、M：中日期/时间格式、L：长日期/时间格式、F：完整日期/时间格式、-：忽略日期或时间格式

@NumberFormat：

• @NumberFormat 可对类似数字类型的属性进行标注，它拥有两个互斥的属性：
– style：类型为 NumberFormat.Style。用于指定样式类型，包括三种：Style.NUMBER（正常数字类型）、Style.CURRENCY（货币类型）、 Style.PERCENT（百分数类型）
– pattern：类型为 String，自定义样式，如patter=”#,###”；

数据校验：

• JSR 303 是 Java 为 Bean 数据合法性校验提供的标准框架，它已经包含在 JavaEE 6.0 中 .
• JSR 303 通过在 Bean 属性上标注类似于 @NotNull、@Max 等标准的注解指定校验规则，并通过标准的验证接口对 Bean 进行验证

• Spring 4.0 拥有自己独立的数据校验框架，同时支持 JSR 303 标准的校验框架。
• Spring 在进行数据绑定时，可同时调用校验框架完成数据校验工作。在 Spring MVC 中，可直接通过注解驱动的方式进行数据校验
• Spring 的 LocalValidatorFactroyBean 既实现了 Spring 的 Validator 接口，也实现了 JSR 303 的 Validator 接口。只要在 Spring 容器中定义了一个 LocalValidatorFactoryBean，即可将其注入到需要数据校验的 Bean 中。
• Spring 本身并没有提供 JSR303 的实现，所以必须将 JSR303 的实现者的 jar 包放到类路径下。

• Hibernate Validator 是 JSR 303 的一个参考实现，除支持所有标准的校验注解外，它还支持以下的扩展注解

• <mvc:annotation-driven/> 会默认装配好一个 LocalValidatorFactoryBean，通过在处理方法的入参上标注 @valid 注解即可让 Spring MVC 在完成数据绑定后执行数据校验的工作
• 在已经标注了 JSR303 注解的表单/命令对象前标注一个 @Valid，Spring MVC 框架在将请求参数绑定到该入参对象后，就会调用校验框架根据注解声明的校验规则实施校验
• Spring MVC 是通过对处理方法签名的规约来保存校验结果的：前一个表单/命令对象的校验结果保存到随后的入参中，这个保存校验结果的入参必须是 BindingResult 或 Errors 类型，这两个类都位于 org.springframework.validation 包中

• 需校验的 Bean 对象和其绑定结果对象或错误对象时成对出现的，它们之间不允许声明其他的入参
• Errors 接口提供了获取错误信息的方法，如 getErrorCount() 或 getFieldErrors(String field)
• BindingResult 扩展了 Errors 接口

• 在表单/命令对象类的属性中标注校验注解，在处理方法对应的入参前添加 @Valid，Spring MVC 就会实施校验并将校验结果保存在被校验入参对象之后的 BindingResult 或
Errors 入参中。
• 常用方法：
– FieldError getFieldError(String field)
– List< FieldError > getFieldErrors()
– Object getFieldValue(String field)
– Int getErrorCount()

（在对象中添加 @Email 等限制，然后在目标方法的对象入参前加入 @Valid）

在页面中显示校验限制：

• Spring MVC 除了会将表单/命令对象的校验结果保存到对应的 BindingResult 或 Errors 对象中外，还会将所有校验结果保存到 “隐含模型”
• 即使处理方法的签名中没有对应于表单/命令对象的结果入参，校验结果也会保存在 “隐含对象” 中。
• 隐含模型中的所有数据最终将通过 HttpServletRequest 的属性列表暴露给 JSP 视图对象，因此在 JSP 中可以获取错误信息
• 在 JSP 页面上可通过 <form:errors path=“userName”>显示错误消息

提示消息国际化：

• 每个属性在数据绑定和数据校验发生错误时，都会生成一个对应的 FieldError 对象。
• 当一个属性校验失败后，校验框架会为该属性生成 4 个消息代码，这些代码以校验注解类名为前缀，结合 modleAttribute、属性名及属性类型名生成多个对应的消息代码：例如 User 类中的 password 属性标准了一个 @Pattern 注解，当该属性值不满足 @Pattern 所定义的规则时, 就会产生以下 4个错误代码：
– Pattern.user.password
– Pattern.password
– Pattern.java.lang.String
– Pattern

• 当使用 Spring MVC 标签显示错误消息时， Spring MVC 会查看 WEB 上下文是否装配了对应的国际化消息，如果没有，则显示默认的错误消息，否则使用国际化消息。

• 若数据类型转换或数据格式转换时发生错误，或该有的参数不存在，或调用处理方法时发生错误，都会在隐含模型中创建错误消息。其错误代码前缀说明如下：
– required：必要的参数不存在。如 @RequiredParam(“param1”) 标注了一个入参，但是该参数不存在
– typeMismatch：在数据绑定时，发生数据类型不匹配的问题
– methodInvocation：Spring MVC 在调用处理方法时发生了错误
• 注册国际化资源文件：

处理JSON：

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

使用 HttpMessageConverter：

• HttpMessageConverter< T > 是 Spring3.0 新添加的一个接口，负责将请求信息转换为一个对象（类型为 T），将对象（类型为 T）输出为响应信息
• HttpMessageConverter< T >接口定义的方法：
– Boolean canRead(Class< ? > clazz,MediaType mediaType): 指定转换器可以读取的对象类型，即转换器是否可将请求信息转换为 clazz 类型的对象，同时指定支持 MIME 类型(text/html,applaiction/json等)
– Boolean canWrite(Class< ? > clazz,MediaType mediaType):指定转换器是否可将 clazz 类型的对象写到响应流中，响应流支持的媒体类型在MediaType 中定义。
– LIst< MediaType > getSupportMediaTypes()：该转换器支持的媒体类型。
– T read(Class< ? extends T> clazz,HttpInputMessage inputMessage)：将请求信息流转换为 T 类型的对象。
– void write(T t,MediaType contnetType,HttpOutputMessgaeoutputMessage):将T类型的对象写到响应流中，同时指定相应的媒体类型为 contentType。

• 使用 HttpMessageConverter 将请求信息转化并绑定到处理方法的入参中或将响应结果转为对应类型的响应信息，Spring 提供了两种途径：
– 使用 @RequestBody / @ResponseBody 对处理方法进行标注
– 使用 HttpEntity< T > / ResponseEntity< T > 作为处理方法的入参或返回值
• 当控制器处理方法使用到 @RequestBody/@ResponseBody HttpEntity< T >/ResponseEntity< T > 时, Spring 首先根据请求头或响应头的 Accept 属性选择匹配的 HttpMessageConverter, 进而根据参数类型或泛型类型的过滤得到匹配的 HttpMessageConverter, 若找不到可用的 HttpMessageConverter 将报错

国际化：

• 默认情况下，SpringMVC 根据 Accept-Language 参数判断客户端的本地化类型。
• 当接受到请求时，SpringMVC 会在上下文中查找一个本地化解析器（LocalResolver），找到后使用它获取请求所对应的本地化类型信息。
• SpringMVC 还允许装配一个动态更改本地化类型的拦截器，这样通过指定一个请求参数就可以控制单个请求的本地化类型。

1.配置资源文件 i18n.properties ：

i18n.username=Username
i18n.password=Password

将 i18n 复制两份
一份用英文，与原 i18n 相同，名字为：i18n_en_US
一份用中文，名字为：i18n_zh_CN，内容为：

i18n.username=\u7528\u6237\u540D
i18n.password=\u5BC6\u7801

（这里的 \u 是中文转换的 u 编码 ，其意义分别为：用户名，密码）

2.配置 springmvc.xml：

<!--配置国际化资源文件-->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basename" value="i18n"></property>
    </bean>

3.使用 fmt 显示：
引入：

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

显示：

<fmt:message key="i18n.username"></fmt:message>
<fmt:message key="i18n.password"></fmt:message>

可以用 mvc:view-controller 使其不经过 handle 直接转发到目标页面：

<!--配置直接转发的页面-->
<mvc:view-controller path="/success" view-name="success" />

path 是路径，view-name 是目标文件名

（进入 Tomcat 后在地址栏直接输入 /success ，就可以进入目标界面）
（加入 mvc:annotation-drivern 来防止 Handle 失效）

也可以用 Handle 来跳转：

用 ResourceBundleMessageSource 对象，getMessage 方法获取信息，传入 Locale 解析器，来跳转

通过超链接的方式切换 Local：

1.配置 SessionLocalResolver 和 LocaleChanceInterceptor 的 bean：

2.两个超链接作为切换，传入 locale 对应的语言编码：

流程：