初始SpringMVC 完整版

初始SpringMVC
1.SpringMVC
也叫Spring Web mvc，属于表现层的框架。Spring MVC是Spring框架的一部分，是在Spring3.0后发布的。

2.Java EE的13种核心技术如下：
01、JDBC。
02、JNDI。
03、EJB。
04、RMI。 √ √ √ √ √
05、JSP。
06、Java Servlet。
07、XML。
08、JMS。 √ √ √ √ √
09、Java IDL。
010、JTS。
011、JTA。
012、JavaMail。 √ √ √ √ √

3.配置步骤
01.在web.xml中配置前端控制器
02.处理器映射器（HandlerMapping）
03.处理器适配器（HandlerAdaptor）
04.处理器
05.视图解析器（ViewResolver）
*01/04是必须配置的，其他应用程序有默认配置
4.关于请求方式
Post 添加
get 查询单个对象
Put 修改
Delete 删除
5.配置
01.web.xml文件中配置
<!--Spring MVC 中央调度器就是一个Servlet节点 -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<!--Spring配置文件的路径-->
<param-name>contextConfigLocation</param-name>
<!--配置文件-->
<param-value>classpath:Spring配置文件</param-value>
</init-param>
<!--web启动时加载Servlet时机-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
01.1
load-on-startup
值为负数或者没有设置，则容器会当Servlet被请求时再加载。如果值为正整数或者0时，表示容器在应用启动时就加载并初始化这个servlet，值越小，servlet的优先级越高，就越先被加载。值相同时，容器就会自己选择顺序来加载。
01.2小结
servlet节点中配置了<init-param>子节点。可以保障应用程序中单个Servlet对象
02.处理器（普通）
02.1
实现接口Controller
02.2
方法中实现ModelAndView对象，并返回。
6.Springmvc执行流程
01.客户端 request----------------》中央调度器 （本质就是一个Servlet DispatcherServlet）

02.HandlerMapping 处理器 映射器 --------》寻址Hanlder ，但是不具备Handler执行权 ，返回处理器执行链(HandlerChain)

03.将返回的处理器执行链转交给 中央调度器

04.中央调度器 ------------> HandlerAdaptor( 处理器适配器 ) -------具备调度的Handler的权限

05.执行Hanlder ，Handler返回的结果类型ModelAndView(视图和模型)，并将结果交给 中央调度器

06.中央调度器 寻址视图解析器(//////////// .jsp .ftl .xxx)

07.使用物理视图渲染页面 ，html标签 浏览器只能认识html标签 Data+View
7.Spring MVC 核心组件
01.中央调度器（DispatcherServlet）
02.视图解析器（ViewResolver）
03.处理器映射器（HandlerMapping）
04.处理器（Handler）
05.处理器适配器（HandlerAdaptor）
06.视图（View）
8.视图解析器
01.语法
<!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>
02.小结
02.1
InternalResourceViewResolver一个非常重要的特性，我们都知道存放在/WEB-INF/下面的内容是不能直接通过request请求的方式请求到的，为了安全性考虑，我们通常会把jsp文件放在WEB-INF目录下，而InternalResourceView在服务器端跳转的方式可以很好的解决这个问题。

02.2
处理器中一个InternalResourceViewResolver的定义，根据该定义当返回的逻辑视图名称是test的时候，InternalResourceViewResolver会给它加定上义好的前缀和后缀，组成“/WEB-INF/test.jsp”的形式，然后把它当做一个InternalResourceView的url新建一个InternalResourceView对象返回。
9.解决静态资源无法访问
拦截器：控制器/静态资源
01.Spring默认解决方式
一切源于Restful编程rest
01.2.web.xml文件中
语法
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>不需要拦截的内容</url-pattern>
</servlet-mapping>

02.使用MVC的default-servlet-handler
02.1
会将对静态资源的访问请求通过HandlerMapping映射到默认Servlet请求处处理DefaultServletRequestHandler对象。而该处理器调度了Tomcat的DefaultServlet来处理静态资源的访问请求

02.2ApplicationContext文件中
语法
<mvc:default-servlet-handler></mvc:default-servlet-handler>
*当然需要引入mvc约束
03.使用MVC的resource节点解决
03.1
在Spring3.0.4之后，Spring定义了专门用于处理静态资源请求的处理器ResourceHTTPRequestHandler。并且添加了<mvc:resources/>标签，专门用于解决静态资源无法访问问题
03.2
语法
<mvc:resources location="/image/" mapping="/image/**" ></mvc:resources>
location：静态资源所在目录
mapping:对资源的请求
*需要Tomcat7支持
10.处理器映射器
01.Map方式配置（方式1）
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="urlMap">
<map>
<entry key="访问名称">
<value>处理器配置文件</value>
</entry>
</map>
</property>
</bean>
02.Properties方式配置（方式2）
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="访问名称">处理器配置文件</prop>
</props>
</property>
</bean>
03.防止客户端直接访问，只能通过别名访问
11.AbstractController（限定请求方式）
01.说明
若处理器继承自AbstractController类，那么该控制器就具有了一些功能。因为AbstractController类还继承自一个父类WebContentGenerator，WebContentGenerator具有supportMethods属性，可以设置支持HTTP数据提交方式。默认支持GET/POST/HEAD
02.配置方式
02.1
继承AbstractController
02.2
方法中实现ModelAndView对象，并返回。
02.3
在ApplicationContext配置文件bean节点中，通过设置supportedMethods属性限定请求方式
12.方法名解析器，多动作解析器（默认）
MultiActionController
01.说明
客户端通过处理器类中方法名，访问响应的方法
02.配置
02.1
处理器映射器的配置
访问修改为“/*”（因为访问多个页面）
02.2
处理器
01.继承MultiActionController
02.自定义响应的方法
如：
public String doshow1(HttpServletRequest request, HttpServletResponse response) throws Exception {
return "index";
}
03.操作
url访问处理器类中的方法名，获取到方法的返回，通过视图解析器展示
13.属性方法名称解析器
PropertiesMethodNameResolver
01.说明
可以通过客户端访问的属性名称，访问到对应方法。可以避免直接引用
02.步骤
02.1
bean指定PropertiesMethodNameResolver，properties属性指向mappings，mapping中指定
语法
<!--方法名称解析器-->
<bean id="propertiesMethodNameResolver" class="org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver">
<property name="mappings">
<props>
<prop key="/index">doshow1</prop>
<prop key="/index1">doshow2</prop>
<prop key="客户端访问地址">处理器类方法</prop>
</props>
</property>
</bean>
02.2
处理器节点中通过methodNameResolver属性，引入方法名称解析器。
语法
<bean id="xxx" class="mvc.Day02_PropertiesMethodNameResolver.Day02PropertiesMethodNameResolver">
<property name="methodNameResolver" ref="propertiesMethodNameResolver"></property>
</bean>
*绑定方法名称解析器
*处理器映射器的配置
访问修改为“/*”（因为需要访问多个）
14.参数方法名称解析器
ParameterMethodNameResolver
01.说明
客户端通过参数访问响应的处理器方法
02.步骤
02.1
bean节点指定ParameterMethodNameResolver，properties属性指向paramName。可以理解为固定参数名称，用于就收参数
语法
<bean id="parameterMethodNameResolver" class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
<property name="paramName" value="action"></property>
</bean>
02.2
处理器节点中通过methodNameResolver属性，引入参数方法名称解析器。
语法
<bean id="xxx" class="mvc.Day02_PropertiesMethodNameResolver.Day02PropertiesMethodNameResolver">
<property name="methodNameResolver" ref="parameterMethodNameResolver"></property>
</bean>
03.小结
03.1
处理器映射器，拦截地址修改为固定名称
03.2
客户端访问时，URL
语法
http://localhost:8080/处理器映射器名?定义的接收参数变量=处理器类中方法名
15.HTTP请求方式
01.
GET
请求指定的页面信息，并返回实体主体。
02.
POST
向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
03.
PUT
从客户端向服务器传送的数据取代指定的文档的内容。
04.
DELETE
请求服务器删除指定的页面。
05.
CONNECT
HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
06.
OPTIONS
允许客户端查看服务器的性能。
07.
TRACE
回显服务器收到的请求，主要用于测试或诊断。
08.
HEAD
类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头
16.视图解析器
BeanNameViewResolver
01.视图对象
定义外部资源视图对象
RedirectView
定义内部资源视图对象
JstlView
02.语法
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver"></bean>
<!--外部视图解析器-->
<bean id="redirectView" class="org.springframework.web.servlet.view.RedirectView">
<property name="url" value="https://sale.jd.com"></property>
</bean>
<!--内部视图解析器-->
<bean id="jstlView" class="org.springframework.web.servlet.view.JstlView">
<property name="url" value="/index2.jsp"></property>
</bean>
*在处理器中使用解析器的id，定义响应的方法
03.1
外部视图解析器/内部视图解析器区别
01.外部视图解析器
可以访问外网
02.内部视图解析器
只能访问工程内部
17.分离配置信息
XmlViewResolver
01.说明
在使用BeanNameViewResolver（视图解析器）时可以创建多个外部/内部视图解析器，为了避免代码的零散，提取到单独的Spring容器进行管理。
02.语法
<bean class="org.springframework.web.servlet.view.XmlViewResolver">
<property name="location" value="classpath:单独提取的视图解析器"></property>
</bean>
*视图解析器根节点（BeanNameViewResolver），可以在提取的Spring容器，也可以在原Spring容器。

--------------------------------------配置式开发结束，注解式开发开始-------------------------------------------

1.注解
01.1概念
一种可以在类、方法、参数上进行标注的一种技术，被标注的对象可以受到JVM的特殊礼遇多一些特殊的信息
01.2常用注解
01.在ApplicationContext文件中导入命名空间
01.1
xmlns:context="http://www.springframework.org/schema/context"
01.2在xsi:schemaLocation下添加
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
01.3 注意
也可以使用快捷方式进行导入Alt+Enter
01.4 在beans节点中添加（添加扫描器）
<context:component-scan base-package="扫描注解配合路径"></context:component-scan>
*base-package指定的是使用注解的类包名
02.在实体类中
02.1
类上方
@Component 不按照上面三个注解分类,就用此注解
@Repository 持久层
@Service 业务逻辑层
@Controller 控制器
如：@Component("use")
use表示bean节点的id
*如注解中没有定义值，默认是类的小写
属性注入值
@Value("")
03.域属性注入值
03.1
使用jdk提供的注解
@Resource(name = "")
name指定的是bean节点的id
03.2
使用spring提供的注解
@Autowired //表示自动连接
@Qualifier(value = "")
value指定的是bean节点的id
03.3小结
01.
@Resource默认安装byName的方式进行装配。byName的含义：拥有该属性字段名称必须和Spring容器中现有bean的id相同。@Resource比较只能，当根据byName方法装配失败后，它会继续尝试使用byType的方式进行装配，即使类型相同也可以完成装配。
02.
@Autowired默认安装byType的方式进行装配，拥有该注解的字段类型必须和Spring容器中现有类型相同。如果发现与字段想用的bean会导致异常。
03.
@Qualifier将此注解跟@Autowired混合使用时，含义是强制使用byName的方式进行装配，不匹配直接导致异常
2.配置案例
01.Spring容器中配置视图解析器/包扫描器
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/"></property>
<!--后缀-->
<property name="suffix" value=".jsp"></property>
</bean>
<!--包扫描器-->
<context:component-scan base-package="直接配置类包级路径"></context:component-scan>
02.类的配置
@Controller //标记，成为Spring容器管理的的对象
@RequestMapping("/Logger")//映射请求参数，请求方法或请求头
public class Day04AnnotationDevelopment01 {
@RequestMapping("/show1")
public String doshow1(HttpServletRequest request, HttpServletResponse response){
return "index1";
}
@RequestMapping("/show2")
public String doshow2(HttpServletRequest request, HttpServletResponse response){
return "index2";
}
}
3.通配符
*XXX 以XXX结尾

XXX* 以XXX开头

/**/XXX XXX之前可以有0到N级目录

/*/XXX XXX之必须有一级目录

XXX*X XXX~X之间可以包含0到N个字符
4.@RequestMapping属性
01.
有一个属性method,用于对被注解方法所处理请求的提交方式进行限制，只有满足该method属性指定的提交方式，才会执行被注解方法。
method属性的取值为RequestMethod，是一个枚举常量。常用值为
RequestMethod.GET 或 RequestMethod.POST.
02.案例
@RequestMapping(value="请求Url地址",method=RequestMethod.POST或GET)
*如果在两个方法上都添加了一样的value，不一样的请求方式的RequestMapping。Spring容器会通过响应的请求方式访问方法
5.处理器方法参数
处理器方法中常用的参数有五类，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用
01.HttpServletRequest
02.HttpServletResponse
03.HttpSession
04.用于承载数据的Model
05.请求中携带的请求参数
6.零散参数自动装配
01.客户端请求Controller
只要参数一致，就可以达到参数的自动装配
02.Controller携带参数到客户端
@RequestMapping("/show1")
public String doshow1(HttpServletRequest request, HttpServletResponse response, Model model){
model.addAttribute("key值","value值");
return "index1";
}
*在Controller层直接通过Model对象传入参数
*客户端通过EL表达式获取（${key值}）。通过key获取Model对象中的value值
03.@RequestParam()
校正参数，在客户端请求的参数与Controller层不一致时使用
通过Controller方法入参前@RequestParam("别名")，校正参数
7.对象参数装配
01.客户端请求Controller
页面中name的参数与实体类对象名称一致即可
02.Controller携带参数到客户端
@RequestMapping("/show1")
public String doshow1(Book book, Model model){
model.addAttribute("key值","value值");
System.out.println(book.getName())
return "index1";
}
*在Controller层直接通过Model对象传入参数
*客户端通过EL表达式获取（${key值}）。通过key获取Model对象中的value值
8.域属性装配
01.客户端请求Controller
页面中name的参数（域属性名.实体类常量）与实体类对象名称一致即可
02.Controller携带参数到客户端
@RequestMapping("/show1")
public String doshow1(Book book, Model model){
model.addAttribute("key值","value值");
System.out.println(book.type.getName())
return "index1";
}
*在Controller层直接通过Model对象传入参数
*客户端通过EL表达式获取（${key值}）。通过key获取Model对象中的value值
8.集合属性装配
01.客户端请求Controller
页面中name的参数（属性名[index].实体类常量）与实体类对象名称一致即可
02.Controller携带参数到客户端
@RequestMapping("/show1")
public String doshow1(Book book, Model model){
model.addAttribute("key值","value值");
System.out.println(book.type[0].getName())
return "index1";
}
*在Controller层直接通过Model对象传入参数
*客户端通过EL表达式获取（${key值}）。通过key获取Model对象中的value值
9.编码过滤器
<!--编码过滤器-->
<filter>
<filter-name>encodeFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!--请求-->
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
<!--响应-->
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<!--拦截对象-->
<filter-mapping>
<filter-name>encodeFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
10.路径变量
@PathVariable
01.对于处理器方法中所接收的请求参数，可以来自于请求中所携带的参数，也可以来自于请求的URI中所携带的变量，即路径变量。不过，此时，需要借助@PathVariable注解。
02.@PathVariable在不指定参数的情况下，默认其参数名，即路径变量名与用于接收其值的属性名相同。若路径变量与用于接收其值的属性名不同，则@PathVariable可通过参数指出路径变量名称。
03.使用
在方法入参前使用注解
11.处理器方法的返回值
01.ModelAndView
若处理器方法处理完后，需要跳转到其它资源，而又要在跳转的资源间传递数据，此时选择ModelAndView作为处理器方法的返回值
02.String 内部资源视图名
02.1
通过ApplicationContext中配置的视图解析器

03.void（不常用）
通过ServletAPI完成数据和视图功能
03.1转发（Spring容器默认）
03.2重定向
04.void Ajax
使用fastjson
04.1步骤
01.依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.1.15</version>
</dependency>
02.在Controller层把数据转换为json格式，后发送给客户端
String data = JSON.toJSONString(数据);//把普通数据转换为JSON格式
response.getWriter().write(data);//放入响应对象
03.客户端使用ajax操作
05.Object json
01.客户端访问Controller层方法时直接返回json数据
02.配置
02.1 依赖
<!--jackson为了生成json对象-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.8.1</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.5.1</version>
</dependency>
02.2 ApplicationContext文件
<mvc:annotation-driven></mvc:annotation-driven>
02.3 直接Controller配置使用
@ResponseBody
06.Object 字符串型
01.解决上方服务器响应json对象中，中文乱码
02.配置
@RequestMapping(value = "/doshow",produces = "text/html;charset=utf-8")
*使用RequestMapping中produces属性
07.Object 自定义对象类型
01.客户端请求服务器时返回对象类型（json对象）
02.返回结果（格式）
02.1返回单个对象
{"对象属性":"对象属性值","对象属性":对象属性值}
*直接大括号包裹对象
02.2返回集合对象
[{"对象属性":"对象属性值","对象属性":对象属性值},{"对象属性":"对象属性值","对象属性":对象属性值}]
*中括号包裹
03.对象属性值
引用类型值会被双引号包裹，值类型直接
08.Object Map
01.服务器返回结果（json格式）
{"map集合key":Map集合Value,"map集合key":Map集合Value}
如：
{"友情岁月":{"username":"友情岁月","password":"123456"},"明天会更好":{"username":"明天会更好","password":"密码2"}}
12.$function和window.onload区别
01.单页面书写：$function多次 window.onload一次
02.执行顺序： $function先执行 window.onload后执行
13.转发和重定向
当处理器对请求处理完毕后，向其他资源进行跳转时，有两种跳转方式：请求转发与重定向。而根据要跳转的资源类型，又可分为两类：跳转到页面与跳转到其他处理器。

01.重定向为
redirect
*默认不会通过视图解析器，直接当做服务器内部对象查找（物理视图）
02.转发为（默认）
forward
03.案例
/*
* 转发
* */
@RequestMapping("doshow5")
public String doRequest(){
return "forward:doshow";
}
/*
* 重定向
* */
@RequestMapping("doshow6")
public String doResponse(){
return "redirect:doshow";
}

14.异常处理
01.系统异常处理
SimpleMappingExceptionResolver
01.1.配置
直接在ApplicationContext配置文件中添加SimpleMappingExceptionResolver节点
01.2.示例
<!--系统处理异常-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<!--出现异常后跳转的位置（默认错误视图）-->
<property name="defaultErrorView" value="/Second.jsp"></property>
<!--捕捉异常信息-->
<property name="exceptionAttribute" value="ex"></property>
</bean>
01.3.缺点
404错误，无法处理
02.高级系统异常处理器
02.1示例
<!--系统处理异常-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<!--出现异常后跳转的位置（默认错误视图）-->
<property name="defaultErrorView" value="/Second.jsp"></property>
<!--捕捉异常信息-->
<property name="exceptionAttribute" value="ex"></property>
<!--定义需要特殊处理的异常，用类名或完全路径名作为key，异常页文件名作为值（错误页面），
　　　　将不同的异常映射到不同的页面上-->
<property name="exceptionMappings">
<props>
<prop key=""></prop>
</props>
</property>
</bean>
02.2配置
使用属性exceptionMappings，手动指定异常类型
02.3缺点
404错误，无法处理
03.自定义异常处理器
03.1概念
使用Springmvc定义好的SimpleMappingExceptionResolver异常处理器，可以实现发生指定异常后的跳转。但是若要实现在捕获到指定异常时，执行一些操作的目的，它是完成不了的。此时，就需要自定义异常处理器。自定义异常处理器，需要实现HandlerExceptionResolver接口，并且该类需要在Springmvc配置文件中进行注册
03.2配置
01.Controller层照常写
02.自定义异常处理器实现接口（HandlerExceptionResolver），并实现方法
03.ApplicationContext文件中引入自定义异常处理器，关联
04.页面使用EL表达式，读取ModeAndView中异常信息
03.3配置（示例）
Controller层
@RequestMapping("/doshow1")
public String doCustomExceptions(String name,Integer age) throws Exception {
if (!name.equals("admin"))
throw new UNameException("用户名错误");//自定义异常类中放入信息
else if (age>50)
throw new UAgeException("年龄不合法");
return "index";
}
自定义异常处理器
public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("e",e);//异常信息放入ModelAndView对象
if (e instanceof UNameException){//判断异常类型
modelAndView.setViewName("Second");//错误视图---》出现错误时跳转的页面
}
}else if(e instanceof UAgeException){
modelAndView.setViewName("Second");
}
return modelAndView;
}
ApplicationContext
<!--指定已定义异常类 class指定自定义异常类-->
<bean class="cn.happy.day08CustomExceptions.CustomExceptions"></bean>
04.异常处理注解
01.概念：
使用注解@ExceptionHandler可以将一个方法指定为异常处理方法。该注解只有一个可选属性value，为一个Class<?>数组，用于指定该注解的方法所要处理的异常类，即所要匹配的异常。
02.配置
02.1直接在Controller层完成
01.Controller层

@RequestMapping("/doshow1")
public String doCustomExceptions(String name,Integer age) throws Exception {
if (!name.equals("admin"))
throw new UNameException("用户名错误");//自定义异常类中放入信息
else if (age>50)
throw new UAgeException("年龄不合法");
return "index";
}
02.异常处理器（直接提取成方法）
@ExceptionHandler({UAgeException.class,UNameException.class})//引入异常类型
public ModelAndView resolveException(Exception e) {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("e",e);//异常信息放入ModelAndView对象
if (e instanceof UNameException){//判断异常类型
modelAndView.setViewName("Second");//错误视图---》出现错误时跳转的页面
}else if(e instanceof UAgeException){
modelAndView.setViewName("Second");
}
return modelAndView;
}

15.EL表达式
${ex.message}
底层编译时会在调度的message前加get，message编译为Message，后加()
*因为EL表达式底层调度的就是Get方法
16.索引器/属性
属性的本质是方法
索引器的本质是属性

17.类型转换器
01.概念
为什么页面上输入”12”,可以赋值给Handler方法对应的参数?
这是因为框架内部帮我们做了类型转换的工作。将String转换成int但默认类型转换器并不是可以将用户提交的String，转换为用户需要的所有类型。此时 ，就需要自定义类型转换器了
02.配置
02.1自定义格式转换类
实现接口Converter，并实现方法
02.2ApplicationContext
01.注册类型转换器
bean节点引入自定义转换器类
*命名空间：javax.faces.convert.Converter
02.注册转换服务器对象
ConversionServiceFactoryBean节点，属性converters指定注册类型转换器id
03.注册mvc注解驱动
<mvc:annotation-driven conversion-service="注册转换器id">
18.注解类型转换1
01.概念
经常会遇到页面某些数据类型是Date、Integer、Double等的数据要绑定到控制器的实体，或者控制器需要接受这些数据，如果这类数据类型不做处理的话将无法绑定。这时我们就可以在Controller层使用注解@InitBinder进行类型装配
02.配置
/*
* 下面date类型的转换
* */
@InitBinder("date")
public void initBinder(WebDataBinder binder){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//参数一：需要转换的类型，，，，，，参数二：系统属性类型编辑器
binder.registerCustomEditor(Date.class,new CustomDateEditor(sdf,true));
}
/*
*页面请求方法
*/
@RequestMapping("/doShow")
public String doshow(String name, int age, Date date){
System.out.println(name);
System.out.println(age);
System.out.println(date);
return "/Second.jsp";
03.注解使用
直接定义注解时，会通过请求方法的入参挨个走一遍。如果在注解中指定了转换的入参，那么转换器只针对指定的参数
}
-------------------------------------------------课外内容------------------------------------------------------

1.