springmvc基本原理

springMVC

一、springMVC体系介绍：

1、javaee体系结构：

 2、为什么要使用MVC开发模式？

主要就是为了：解耦和

很多应用程序的问题在于处理业务数据和显示业务数据的视图的对象之间存在紧密耦合。通常，更新业务对象的命令都是从视图本身发起的，使视图对任何业务对象更改都有高度敏感性。而且，当多个视图依赖于同一个业务对象时是没有灵活性的。

Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。

 

3、springMVC的强大之处：

①.Spring MVC 实现了即用的 MVC 的核心概念。它为控制器和处理程序提供了大量与此模式相关的功能。并且当向 MVC 添加反转控制（Inversion of Control，IoC）时，它使应用程序高度解耦，提供了通过简单的配置更改即可动态更改组件的灵活性。Spring MVC 为您提供了完全控制应用程序的各个方面的力量。

②.Spring 的 Web MVC 模块是围绕 DispatcherServlet 而设计的。DispatcherServlet 给处理程序分派请求，执行视图解析，并且处理语言环境和主题解析，此外还为上传文件提供支持。

③.DispatcherServlet 通过使用处理程序映射来决定哪一个处理程序应当处理传入的请求。处理程序映射只是用于标识使用哪一个处理程序来处理特定 URL 模式的映射。处理程序是只有一种方法 ModelAndView handleRequest(request,response) 的控制器接口的实现。Spring 还有一些可用的高级处理程序实现；其中一个重要的高级处理程序实现是 SimpleFormController，它提供了将命令对象绑定到表单、对其执行验证等功能。

④.您已经在本系列教程的先前教程中使用了 DispatcherServlet 和简单的处理程序。在下一个部分中，将使用 SimpleFormController 并说明 Spring MVC 提供的各种即用功能。

4、springMVC的优势

①、清晰的角色划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（ Validator）、命令对象（Command  请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。

②、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要；

③、由于命令对象就是一个POJO，无需继承框架特定API，可以使用命令对象直接作为业务对象；

④、和Spring 其他框架无缝集成，是其它Web框架所不具备的；

⑤、可适配，通过HandlerAdapter可以支持任意的类作为处理器；

⑥、可定制性，HandlerMapping、ViewResolver等能够非常简单的定制；

⑦、功能强大的数据验证、格式化、绑定机制；

⑧、利用Spring提供的Mock对象能够非常简单的进行Web层单元测试；

⑨、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。

⑩、强大的JSP标签库，使JSP编写更容易。

………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配置支持等等。

5、springMVC的架构

6、 MVC（Model-View-Controller）三元组的概念：

①、Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或 JavaBean 组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据） 和 服务层（行为）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

领域模型

javaBean组件等价于 域模型层 + 业务逻辑层 + 持久层

②、View(视图):负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

③、Controller(控制器):接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。 也就是说控制器做了个调度员的工作

7、struts2的MVC流程

 

8、springMVC的运行流程

 

①、  首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

②、DispatcherServlet——>HandlerMapping,HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；

③、  DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

④、  HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；

⑤、  ModelAndView的逻辑视图名——> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；

⑥、  View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；

⑦、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

9、组件说明：

u DispatcherServlet：前端控制器

用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

u HandlerMapping：处理器映射器

HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

u Handler：处理器

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。

由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

 

u HandlAdapter：处理器适配器

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

u View Resolver：视图解析器

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。

u View：视图

springmvc框架提供了很多的View视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是jsp。

一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

 

说明：在springmvc的各个组件中，处理器映射器、处理器适配器、视图解析器称为springmvc的三大组件。

需要用户开放的组件有handler、view

 

二、springMVC基本配置

1、组件扫描器（打开spring的注解开关）

使用组件扫描器省去在spring容器配置每个controller类的繁琐。使用<context:component-scan>自动扫描标记@controller的控制器类，配置如下：

 

<!-- 扫描controller注解,多个包中间使用半角逗号分隔 -->

<context:component-scan base-package="cn.itcast.springmvc.controller"/>

2、RequestMappingHandlerMapping

注解式处理器映射器，对类中标记@ResquestMapping的方法进行映射，根据ResquestMapping定义的url匹配ResquestMapping标记的方法，匹配成功返回HandlerMethod对象给前端控制器，HandlerMethod对象中封装url对应的方法Method。

 

从spring3.1版本开始，废除了DefaultAnnotationHandlerMapping的使用，推荐使用RequestMappingHandlerMapping完成注解式处理器映射。

 

配置如下：

 

<!--注解映射器 -->

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

注解描述：

@RequestMapping：定义请求url到处理器功能方法的映射

3、RequestMappingHandlerAdapter

注解式处理器适配器，对标记@ResquestMapping的方法进行适配。

 

从spring3.1版本开始，废除了AnnotationMethodHandlerAdapter的使用，推荐使用RequestMappingHandlerAdapter完成注解式处理器适配。

 

配置如下：

<!--注解适配器 -->

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

4、<mvc:annotation-driven>

springmvc使用<mvc:annotation-driven>自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter，可用在springmvc.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。

5、视图解析器

在springmvc.xml文件配置如下：

 

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">

<property name="viewClass"

value="org.springframework.web.servlet.view.JstlView" />

<property name="prefix" value="/WEB-INF/jsp/" />

<property name="suffix" value=".jsp" />

</bean>

 

InternalResourceViewResolver：支持JSP视图解析

viewClass：JstlView表示JSP模板页面需要使用JSTL标签库，所以classpath中必须包含jstl的相关jar 包。此属性可以不设置，默认为JstlView。

prefix 和suffix：查找视图页面的前缀和后缀，最终视图的址为：

前缀+逻辑视图名+后缀，逻辑视图名需要在controller中返回ModelAndView指定，比如逻辑视图名为hello，则最终返回的jsp视图地址 “WEB-INF/jsp/hello.jsp”

6、DispatcherServlet核心代码分析、

//前端控制器分派方法  

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  

        HttpServletRequest processedRequest = request;  

        HandlerExecutionChain mappedHandler = null;  

        int interceptorIndex = -1;

        try {  

            ModelAndView mv;  

            boolean errorView = false;    

            try {  

        //检查是否是请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析  

                processedRequest = checkMultipart(request);  

         //步骤2、请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射  

                mappedHandler = getHandler(processedRequest, false);  

                if (mappedHandler == null || mappedHandler.getHandler() == null) {  

                    noHandlerFound(processedRequest, response);  

                    return;  

                }  

 //步骤3、处理器适配，即将我们的处理器包装成相应的适配器（从而支持多种类型的处理器）  

                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());    

                // 304 Not Modified缓存支持  

                //此处省略具体代码    

                // 执行处理器相关的拦截器的预处理（HandlerInterceptor.preHandle）  

                //此处省略具体代码    

                // 步骤4、由适配器执行处理器（调用处理器相应功能处理方法）  

                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());    

                // Do we need view name translation?  

                if (mv != null && !mv.hasView()) {  

                    mv.setViewName(getDefaultViewName(request));  

                }    

                // 执行处理器相关的拦截器的后处理（HandlerInterceptor.postHandle）  

                //此处省略具体代码  

            }  

            catch (ModelAndViewDefiningException ex) {  

                logger.debug("ModelAndViewDefiningException encountered", ex);  

                mv = ex.getModelAndView();  

            }  

            catch (Exception ex) {  

                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  

                mv = processHandlerException(processedRequest, response, handler, ex);  

                errorView = (mv != null);  

            }    

//步骤5 步骤6、解析视图并进行视图的渲染  

//步骤5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)）  

步骤6 视图在渲染时会把Model传入（view.render(mv.getModelInternal(), request, response);）  

            if (mv != null && !mv.wasCleared()) {  

                render(mv, processedRequest, response);  

                if (errorView) {  

                    WebUtils.clearErrorRequestAttributes(request);  

                }  

            }  

            else {  

                if (logger.isDebugEnabled()) {  

                    logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +  

                            "': assuming HandlerAdapter completed request handling");  

                }  

            }    

            // 执行处理器相关的拦截器的完成后处理（HandlerInterceptor.afterCompletion）  

            //此处省略具体代码    

        catch (Exception ex) {  

            // Trigger after-completion for thrown exception.  

            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex)            throw ex;  

        }  

        catch (Error err) {  

            ServletException ex = new NestedServletException("Handler processing failed", err);  

            // Trigger after-completion for thrown exception.  

            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  

            throw ex;  

        }    

        finally {  

            // Clean up any resources used by a multipart request.  

            if (processedRequest != request) {

                cleanupMultipart(processedRequest);  

            }  

        }  

    }  

三、入门程序：

创建一个web工程，加入spring的jar包和springmvc的jar包

1、首先在web.xml里面配置springmvc的加载

<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 初始化加载springmvc配置文件 -->
<!-- 方法一：
  命名规范：<servlet-name>-servlet.xml=========>springmvc-servlet.xml
  路径规范：/WEB-INF/springmvc-servlet.xml(必须把配置文件放在WEB-INF路径下)
   -->
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

2、springmvc-servlet.xml的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="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"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx"xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
<!-- 开启spring注解扫描 -->
<context:component-scanbase-package="com.itcast"></context:component-scan>
<!-- 处理器映射器：寻找执行类controller，返回controller对象 -->
<beanclass="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>
<!-- 处理器适配器 :执行controller对象方法，返回执行结果-->
<beanclass="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>
<!-- 返回物理视图就不用配置视图解析器 -->
<!-- 逻辑视图使用视图解析器 -->
<beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver">
<propertyname="prefix"value="WEB-INF/jsp/"></property>
<propertyname="suffix"value=".jsp"></property>
</bean>
</beans>

注意：如果使用的是物理视图就不用配置视图解析器

           如返回的是逻辑视图，需要使用视图解析器

3、测试程序：

@Controller
publicclassUserController{
/**
 * 需求：springmvc入门案例
 *  组件:
 * 1.web.xml : 控制层  DispatherServlet
 * 2,处理器映射器: RequestMappingHandlerMapping
 * 3,处理器适配器:RequestMappingHandlerAdapter
 * 4,创建controller执行类
 * 5,@RequestMapping:请求映射  根据浏览器请求进行匹配映射
 */
@RequestMapping("hello")
publicModelAndView showHello(){
//创建模型和视图对象
ModelAndView mv =newModelAndView();
//设置数据
mv.addObject("hello","张三丰好帅");
//指定返回试图页面，直接设计物理视图
//mv.setViewName("/WEB-INF/jsp/hello.jsp");
mv.setViewName("hello");//逻辑视图，用视图解析器
return mv;
}
}

4、扩展：

①、自定义配置文件的文件名和路径

springmvc的配置文件的默认路径为WEB-INF目录下，文件名格式是：<servlet-name>-servlet.xml

怎么自定义呢？

  <servlet>

      <servlet-name>springmvc</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>

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

  </servlet>

②、返回字符串视图

/**
 * 需求：返回string类型的逻辑视图
 * springmvc：封装参数方法：所有参数都放置方法中，这些参数将会自动被创建对象
 * model：model其实是request域
 */
@RequestMapping("hello2")
publicString showHello2(Model model){
//放入数值
model.addAttribute("hello","峨嵋派周芷若");
//返回逻辑视图
return"hello";
}

③、注解驱动使用

用注解驱动代替处理映射器和处理适配器的配置，支持json格式和对象进行相互转换

<mvc:annotation-driven></mvc:annotation-driven>

5、参数的接收

封装参数方法：所有参数都放置方法中，这些参数将会自动被创建对象

①、跳转参数页面

/**
 * 需求：跳转参数封装页面
 */
@RequestMapping("param")
publicString showParam(){
//返回逻辑视图：页面名称
return"param";
}

②、int类型参数的传递

<form action="${pageContext.request.contextPath}/receiveInt.do">
<input type="text" name="id" id="id">
<input type="submit" value="提交表单">
</form>

/**
 * 需求:接受int类型参数
 * springmvc参数封装方法:
 * 基于方法进行封装,参数变量都写在方法中,参数将会自动被创建对象,接受页面 参数
 */
@RequestMapping("receiveInt")
publicString receiveInt(int id){
System.out.println(id);
//封装成功
return"success/success";
}

③、boolean类型参数的传递

<form action="${pageContext.request.contextPath}/receiveBoolean.do">
trueFlag:<input type="radio" name="flag" value="true">
<br>falseFlag:<input type="radio" name="flag" value="false">
<br><input type="submit" value="提交表单">
</form>

/**
 * 需求:接受boolean类型参数
 */
@RequestMapping("receiveBoolean")
publicString receiveBoolean(boolean flag){
System.out.println(flag);
//封装成功
return"success/success";
}

④、接收String类型参数（中文乱码的解决）

<form action="${pageContext.request.contextPath}/receiveStr.do">
姓名：<input type="text" name="username" id="username">
<br><input type="submit" value="提交表单">
</form>

没有解决中文乱码问题的基本代码：

@RequestMapping("receiveStr")
publicString receiveStr(String username){
System.out.println(username);
//封装成功
return"success/success";
}

此程序有中文乱码问题，怎么解决？

    u   get请求传来的数据

                1、第一种方案：

修改tomcat服务器编码(server.xml）

<Connector URIEncoding="UTF-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

         2、第二种方案：

                           重新对参数进行解码,编码（对于post请求同样适用）

@RequestMapping("receiveStr")
publicString receiveStr(String username){
try{
username=newString(username.getBytes("iso8859-1"),"utf-8");
}catch(UnsupportedEncodingException e){
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(username);
//封装成功
return"success/success";
}

    u   post请求传来的数据

            由spring提供编码过滤器（只能解决post提交的请求）

            具体做法：在web.xml里面配置编码过滤器

            

<!-- 编码过滤器 -->
<filter>
<filter-name>characterEncoding</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>
</filter>
<filter-mapping>
<filter-name>characterEncoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

⑤、数组类型参数接收

<form action="${pageContext.request.contextPath}/receiveArray.do" method="post">
<input type="checkbox" name="ids" value="1">篮球
<br><input type="checkbox" name="ids" value="2">足球
<br><input type="checkbox" name="ids" value="3">乒乓球
<br><input type="submit" value="提交表单">
</form>

/**
 * 接收数组参数类型
 * 批量删除
 */
@RequestMapping("receiveArray")
publicString receiveArray(Integer[] ids){
System.out.println(Arrays.toString(ids));
//封装成功
return"success/success";
}

⑥、pojo类型传递（Date类型的格式）

<form action="${pageContext.request.contextPath}/receiveUser.do" method="post">
姓名:<input type="text" name="username" id="username">
<br>性别:<input type="text" name="sex" id="sex">
<br>年龄:<input type="text" name="age" id="age">
<br>生日:<input type="text" name="birthday" id="birthday">
<br>地址:<input type="text" name="address" id="address">
<br><input type="submit" value="提交表单">
</form>

/**
 * 需求:接受pojo类型参数
 */
@RequestMapping("receiveUser")
publicString receiveUser(User user){
System.out.println(user);
//封装成功
return"success/success";
}

      u默认的Date格式为1998/02/02

⑦、传递包装类型参数

<form action="${pageContext.request.contextPath}/receiveVo.do" method="post">
姓名:<input type="text" name="user.username" id="username">
<br>性别:<input type="text" name="user.sex" id="sex">
<br>年龄:<input type="text" name="user.age" id="age">
<br>生日:<input type="text" name="user.birthday" id="birthday">
<br>地址:<input type="text" name="user.address" id="address">
<br><input type="submit" value="提交表单">
</form>

/**
 * 需求:接受包装类型参数
 * 包装类型包装user对象
 */
@RequestMapping("receiveVo")
publicString receiveVo(QueryVo queryVo){
System.out.println(queryVo.getUser());
//封装成功
return"success/success";
}

⑧、集合参数的接收

要有一个包装类把集合装进去

在QueryVo类型声明一个List<User> uList;属性

<form action="${pageContext.request.contextPath}/receiveList.do" method="post">
姓名:<input type="text" name="uList[0].username" id="username">
<br>地址:<input type="text" name="uList[0].address" id="address">
<br>姓名:<input type="text" name="uList[1].username" id="username">
<br>地址:<input type="text" name="uList[1].address" id="address">
<br><input type="submit" value="提交表单">
</form>

/**
 * 需求:接受集合类型参数
 * 集合类型包装user对象
 */
@RequestMapping("receiveList")
publicString receiveList(QueryVo queryVo){
System.out.println(queryVo.getuList());
//封装成功
return"success/success";
}

⑨、自定义参数的封装

时间类型默认传入格式是1321/02/02，如果要修改成其他的格式，那么就需要另外的配置

            1、第一种方案：使用注解    @initBinder

/**
 * 需求：时间类型参数，如果和当前系统时间类型不匹配，传递不成功
 * 解决方案：使用注解
 */
@InitBinder
publicvoid dateRegister(WebDataBinder binder){//true表示可以为空
binder.registerCustomEditor(Date.class,newCustomDateEditor(newSimpleDateFormat("yyyy-MM-dd"),true));
}

这个注解会自动被调用

缺点：每个类都要配置

               2、使用代码转换器的方案

                                   ①、声明一个Converter的实现类

package com.itcast.utils;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.core.convert.converter.Converter;
publicclassDateConvertimplementsConverter<String,Date>{
publicDate convert(String source){
// TODO Auto-generated method stub
SimpleDateFormat sdf =newSimpleDateFormat("yyyy-MM-dd");
//转换
Date parse=null;
try{
parse = sdf.parse(source);
}catch(ParseException e){
// TODO Auto-generated catch block
e.printStackTrace();
}
return parse;
}
}

                           ②、把代码配置到springmvc的配置中的注解驱动中

<mvc:annotation-drivenconversion-service="conversion"></mvc:annotation-driven>
<beanid="conversion"class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<propertyname="converters">
<beanclass="com.itcast.utils.DateConvert"></bean>
</property>
</bean>

四、springmvc和mybatis整合

1、web.xml的配置

<!-- 1,编码过滤器 -->
<filter>
<filter-name>characterEncoding</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>
</filter>
<filter-mapping>
<filter-name>characterEncoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 2,加载spring配置文件 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext-*.xml</param-value>
</context-param>
<!-- 3,加载springmvc配置文件 -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 初始化加载springmvc配置文件 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

2、dao层配置：

        配置mybatis和数据层

<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="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"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- 1,数据源 -->
<!-- 整合持久层框架 -->
<context:property-placeholderlocation="classpath:jdbc.properties"/>
<beanid="dataSource"class="com.alibaba.druid.pool.DruidDataSource">
<propertyname="driverClassName"value="${jdbc.driver}"></property>
<propertyname="url"value="${jdbc.url}"></property>
<propertyname="username"value="${jdbc.username}"></property>
<propertyname="password"value="${jdbc.password}"></property>
</bean>
<!-- 2,sqlSessionFactory工厂 -->
<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean">
<propertyname="dataSource"ref="dataSource"></property>
<propertyname="typeAliasesPackage"value="com.itheima.domain"></property>
<propertyname="configLocation"value="classpath:sqlMapConfig.xml"></property>
</bean>
<!-- 3,Mapper接口代理开发扫描 -->
<beanclass="org.mybatis.spring.mapper.MapperScannerConfigurer">
<propertyname="basePackage"value="com.itheima.mapper"></property>
</bean>
</beans>

        配置映射文件    ItemMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- mapper:映射文件开始标签,标签中封装所有sql语句 namespace: 1,命名空间,唯一标识一个映射文件,名称自定义 2,如果是接口代理开发,namespace有特殊含义,不能随便定义 -->
<mappernamespace="com.itheima.mapper.ItemMapper">
<!-- 需求:查询所有商品,展示商品列表 -->
<selectid="findAllItems"resultType="item">
select * from items
</select>
</mapper>

        接口：

publicinterfaceItemMapper{
/**
 * 需求:查询所有商品,列表展示
 * 
 */
publicList<Item> findAllItems();
}

        

3、service层配置

           配置事务：

<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://code.alibabatech.com/schema/dubbo 
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- 一,把service交给spring管理 -->
<context:component-scanbase-package="com.itheima.service"></context:component-scan>
<!-- 二,事物管理 -->
<!-- 1,事物管理平台 -->
<beanid="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<propertyname="dataSource"ref="dataSource"></property>
</bean>
<!-- 2,事物管理策略,通知 -->
<tx:adviceid="txAdvice"transaction-manager="transactionManager">
<tx:attributes>
<tx:methodname="save*"propagation="REQUIRED"/>
<tx:methodname="delete*"propagation="REQUIRED"/>
<tx:methodname="update*"propagation="REQUIRED"/>
<tx:methodname="*"propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 3,事物切面 -->
<aop:config>
<aop:advisoradvice-ref="txAdvice"pointcut="execution(* com.itheima.service.*.*(..))"/>
</aop:config>
</beans>

                配置ItemService

@Service
publicclassItemServiceImplimplementsItemService{
@Autowired
privateItemMapper itemMapper;
@Override
publicList<Item> findAllItems(){
List<Item> list = itemMapper.findAllItems();
return list;
}
}

4、controller层配置

            配置ItemController

@Controller
publicclassItemController{
//注入service服务对象
@Autowired
privateItemService itemService;
/**
 * 需求:查询所有商品,列表展示
 * 请求:itemsList.do
 */
@RequestMapping("itemsList")
publicString itemsList(Model model){
//调用service服务方法,查询商品数据
List<Item> itemList = itemService.findAllItems();
//页面回显
model.addAttribute("itemsList", itemList);
return"itemsList";
}
}

               配置springmvc.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="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"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- 1,扫描,把controller交给spring管理 -->
<context:component-scanbase-package="com.itheima.controller"></context:component-scan>
<!-- 2,注解驱动 -->
<mvc:annotation-driven/>
<!-- 3,视图解析器 -->
<beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀 -->
<propertyname="prefix"value="/WEB-INF/jsp/"></property>
<!-- 后缀 -->
<propertyname="suffix"value=".jsp"></property>
</bean>
</beans>

注意：@AutoWired和@Resource(name="")都不需要set方法，直接就能注入