阶段六模块三 SpringMVC

MVC模式

MVC是软件工程中的一种软件架构模式，它是一种分离业务逻辑与显示界面的开发思想。

* M（model）模型：处理业务逻辑，封装实体
* V（view） 视图：展示内容
* C（controller）控制器：负责调度分发（1.接收请求、2.调用模型、3.转发到视图）

SpringMVC概述

• SpringMVC 是一种基于 Java 的实现 MVC 设计模式的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 中。
• SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。

总结

SpringMVC的框架就是封装了原来Servlet中的共有行为；例如：参数封装，视图转发等。

SpringMVC快速入门

1）创建web项目，导入SpringMVC相关坐标

<!-- 设置为web工程 --> 
<packaging>war</packaging> 
<dependencies> 
    <!--springMVC坐标--> 
    <dependency> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-webmvc</artifactId> 
        <version>5.1.5.RELEASE</version> 
    </dependency> 
    <!--servlet坐标--> 
    <dependency> 
        <groupId>javax.servlet</groupId> 
        <artifactId>javax.servlet-api</artifactId> 
        <version>3.1.0</version>
    </dependency> 
    <!--jsp坐标--> 
    <dependency> 
        <groupId>javax.servlet.jsp</groupId> 
        <artifactId>jsp-api</artifactId> 
        <version>2.2</version> 
        <scope>provided</scope> 
    </dependency> 
</dependencies>

2）配置SpringMVC前端控制器DispathcerServlet

<?xml version="1.0" encoding="UTF-8"?> 
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
    http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
        version="3.1"> 
    <!--前端控制器--> 
    <servlet> 
        <servlet-name>dispatcherServlet</servlet-name> 
        <servlet- class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
        <init-param> 
            <param-name>contextConfigLocation</param-name> 
            <param-value>classpath:spring-mvc.xml</param-value> 
        </init-param> 
        <load-on-startup>2</load-on-startup> 
    </servlet> 
    <servlet-mapping> 
        <servlet-name>dispatcherServlet</servlet-name> 
        <url-pattern>/</url-pattern> 
    </servlet-mapping> 
</web-app>

3）编写Controller类和视图页面

public class UserController { 
    public String quick() { 
        System.out.println("quick running....."); 
        return "/WEB-INF/pages/success.jsp"; 
    } 
}        

4）使用注解配置Controller类中业务方法的映射地址

@Controller 
public class UserController { 
    @RequestMapping("/quick") 
    public String quick() { 
    System.out.println("quick running....."); 
    return "/WEB-INF/pages/success.jsp"; 
    } 
}

5）配置SpringMVC核心文件spring-mvc.xml

<!--配置注解扫描--> 
<context:component-scan base-package="com.lagou.controller"/>

web工程执行流程

SpringMVC的执行流程

 

1. 用户发送请求至前端控制器DispatcherServlet。
2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3. 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如 果有则生成)一并返回给DispatcherServlet。
4. DispatcherServlet调用HandlerAdapter处理器适配器。
5. HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
6. Controller执行完成返回ModelAndView。
7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9. ViewReslover解析后返回具体View。
10. DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
11. DispatcherServlet将渲染后的视图响应响应用户。

 

SpringMVC组件解析

1. 前端控制器：
　　DispatcherServlet 用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的 中心，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。
2. 处理器映射器：HandlerMapping
　　HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器 实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
3. 处理器适配器：HandlerAdapter
　　通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型 的处理器进行执行。
4. 处理器：Handler【**开发者编写**】
　　它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由Handler 对具体的用户请求进行处理。
5. 视图解析器：ViewResolver
　　View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物 理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给 用户。
6. 视图：View 【**开发者编写**】
　　SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、 pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展 示给用户，需要由程序员根据业务需求开发具体的页面。

基本配置：

<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xmlns:context="http://www.springframework.org/schema/context" 
    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 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--配置注解扫描--> 
    <context:component-scan base-package="com.lagou.controller"/> 
    
    <!--处理器映射器和处理器适配器功能增强--> 
    <mvc:annotation-driven></mvc:annotation-driven> 
    <!--视图解析器--> 
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
        <property name="prefix" value="/WEB-INF/pages/"></property> 
        <property name="suffix" value=".jsp"></property> 
    </bean> 
</beans>

SpringMVC注解解析

@Controller

SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用：

<!--配置注解扫描--> 
<context:component-scan base-package="com.lagou.controller"/>

 @RequestMapping

* 作用：
　　用于建立请求 URL 和处理请求方法之间的对应关系
* 位置：
　　1.类上：请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以/开头。
　　　　它出现的目的是为了使我们的URL可以按照模块化管理:
　　　　　　用户模块
　　　　　　　　/user/add
　　　　　　　　/user/update
　　　　　　　　/user/delete
　　　　　　　　...
　　　　　　账户模块
　　　　　　　　/account/add
　　　　　　　　/account/update
　　　　　　　　/account/delete
　　2.方法上：请求URL的第二级访问目录，和一级目录组成一个完整的 URL 路径。

 

* 属性：
　　1.value：用于指定请求的URL。它和path属性的作用是一样的
　　2.method：用来限定请求的方式
　　3.params：用来限定请求参数的条件
　　　　例如：params={"accountName"} 表示请求参数中必须有accountName
    　　 pramss={"money!100"} 表示请求参数中money不能是100

中文乱码过滤器

当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤。

<!--配置全局过滤的filter-->
<filter>
  <filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

自定义类型转换器

SpringMVC 默认已经提供了一些常用的类型转换器；例如：客户端提交的字符串转换成int型进行参数设置，日期格式类型要求为：yyyy/MM/dd 不然的话会报错，对于特有的行为，SpringMVC提供了自定义类型转换器方便开发者自定义处理。

public class DateConverter implements Converter<String, Date> {
  public Date convert(String dateStr) {
    //将日期字符串转换成日期对象 返回
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    Date date = null;
    try {
      date = format.parse(dateStr);
   } catch (ParseException e) {
      e.printStackTrace();
   }
    return date;
 }
}

<!--处理器映射器和适配器增强-->
<mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-
driven>
<!--自定义转换器配置-->
<bean id="conversionService"
class="org.springframework.context.support.ConversionServiceFactoryBean">
  <property name="converters">
    <set>
      <bean class="com.lagou.converter.DateConverter"></bean>
    </set>
  </property>
</bean>

相关注解

@RequestParam

当请求的参数name名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定

@RequestMapping("/findByPage")
public String findByPage(@RequestParam(name = "pageNo", defaultValue = "1")
Integer pageNum, @RequestParam(defaultValue = "5") Integer pageSize) {
  System.out.println(pageNum);
  System.out.println(pageSize);
  return "success";
}

@RequestHeader

获取请求头的数据。

@RequestMapping("/requestHead")
public String requestHead(@RequestHeader("cookie") String cookie) {
  System.out.println(cookie);
  return "success";
}

@CookieValue

获取cookie中的数据。

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

获取Servlet相关API

SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：

@RequestMapping("/servletAPI")
public String servletAPI(HttpServletRequest request, HttpServletResponse
response, HttpSession session) {
  System.out.println(request);
  System.out.println(response);
  System.out.println(session);
  return "success";
}

SpringMVC的响应

页面跳转

1. 返回字符串逻辑视图
2. void原始ServletAPI
3. ModelAndView

返回数据

1. 直接返回字符串数据
2. 将对象或集合转为json返回（任务二演示）

返回字符串逻辑视图

直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转到指定页面

@RequestMapping("/returnString")
public String returnString() {
  return "success";
}

void原始ServletAPI

我们可以通过request、response对象实现响应

@RequestMapping("/returnVoid")
public void returnVoid(HttpServletRequest request, HttpServletResponse response)
throws Exception {
  // 1.通过response直接响应数据
  response.setContentType("text/html;charset=utf-8");
  response.getWriter().write("拉勾网");
  ----------------------------------------
  request.setAttribute("username", "拉勾教育");
  // 2.通过request实现转发
  request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,
response);
  ----------------------------------------
  // 3.通过response实现重定向
  response.sendRedirect(request.getContextPath() + "/index.jsp");
}

转发和重定向

forward转发

@RequestMapping("/forward")
public String forward(Model model) {
  model.addAttribute("username", "拉勾招聘");
  return "forward:/WEB-INF/pages/success.jsp";
}

Redirect重定向

我们可以不写虚拟目录，springMVC框架会自动拼接，并且将Model中的数据拼接到url地址上

@RequestMapping("/redirect")
public String redirect(Model model) {
  model.addAttribute("username", "拉勾教育");
  return "redirect:/index.jsp";
}

ModelAndView

方式一

在Controller中方法创建并返回ModelAndView对象，并且设置视图名称

@RequestMapping("/returnModelAndView1")
public ModelAndView returnModelAndView1() {
  /*
 Model:模型 作用封装数据
    View：视图 作用展示数据
  */
  ModelAndView modelAndView = new ModelAndView();
  //设置模型数据
  modelAndView.addObject("username", " lagou");
  //设置视图名称
  modelAndView.setViewName("success");
  return modelAndView;
}

方式二

在Controller中方法形参上直接声明ModelAndView，无需在方法中自己创建，在方法中直接使用该对象设置视图，同样可以跳转页面

@RequestMapping("/returnModelAndView2")
public ModelAndView returnModelAndView2(ModelAndView modelAndView) {
  //设置模型数据
  modelAndView.addObject("username", "itheima");
  //设置视图名称
  modelAndView.setViewName("success");
  return modelAndView;
}

@SessionAttributes

如果在多个请求之间共用数据，则可以在控制器类上标注一个 @SessionAttributes,配置需要在session中存放的数据范围，Spring MVC将存放在model中对应的数据暂存到 HttpSession 中。

注意：@SessionAttributes只能定义在类上

@Controller
@SessionAttributes("username") //向request域存入的key为username时，同步到session域中
public class UserController {
  @RequestMapping("/forward")
  public String forward(Model model) {
    model.addAttribute("username", "子慕");
    return "forward:/WEB-INF/pages/success.jsp";
 }
  @RequestMapping("/returnString")
  public String returnString() {
    return "success";
  }
}

静态资源访问的开启

当有静态资源需要加载时，比如jquery文件，通过谷歌开发者工具抓包发现，没有加载到jquery文件，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是 /（缺省）,代表对所有的静态资源都进行处理操作，这样就不会执行Tomcat内置的DefaultServlet处理，我们可以通过以下两种方式指定放行静态资源：

方式一

<!--在springmvc配置文件中指定放行资源-->
<mvc:resources mapping="/js/**" location="/js/"/>
<mvc:resources mapping="/css/**" location="/css/"/>
<mvc:resources mapping="/img/**" location="/img/"/>

方式二

<!--在springmvc配置文件中开启DefaultServlet处理静态资源-->
<mvc:default-servlet-handler/>

ajax异步交互

Springmvc默认用MappingJackson2HttpMessageConverter对json数据进行转换，需要加入jackson的包；同时使用 <mvc:annotation-driven />

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.8</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.8</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.0</version>
</dependency>

 @RequestBody

该注解用于Controller的方法的形参声明，当使用ajax提交并指定contentType为json形式时，通过HttpMessageConverter接口转换为对应的POJO对象。

@ResponseBody

该注解用于将Controller的方法返回的对象，通过HttpMessageConverter接口转换为指定格式的数据如：json,xml等，通过Response响应给客户端。

/*
 @RequestMapping
 produces = "application/json;charset=utf-8" 响应返回数据的mime类型和编码，默认为
json
*/
@RequestMapping(value = "/ajaxRequest")
@ResponseBody
public List<User> ajaxRequest(@RequestBody List<User> list) {
  System.out.println(list);
  return list;
}

RESTful

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。
Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下：

• GET：读取（Read）
• POST：新建（Create）
• PUT：更新（Update）
• DELETE：删除（Delete）

 

 

 @PathVariable

用来接收RESTful风格请求地址中占位符的值

@RestController

RESTful风格多用于前后端分离项目开发，前端通过ajax与服务器进行异步交互，我们处理器通常返回的是json数据所以使用@RestController来替代@Controller和@ResponseBody两个注解。

// @Controller
@RestController
public class RestFulController {
  @GetMapping(value = "/user/{id}")
  // 相当于 @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
  // @ResponseBody
  public String get(@PathVariable Integer id) {
    return "get：" + id;
 }
  @PostMapping(value = "/user")
  // @ResponseBody
  public String post() {
    return "post";
 }
  @PutMapping(value = "/user")
  // @ResponseBody
  public String put() {
    return "put";
 }
  @DeleteMapping(value = "/user/{id}")
  // @ResponseBody
  public String delete(@PathVariable Integer id) {
    return "delete："+ id;
 }
}

文件上传

文件上传三要素

• 表单项 type="file"
• 表单的提交方式 method="POST"
• 表单的enctype属性是多部分表单形式 enctype=“multipart/form-data"

 

•  当form表单修改为多部分表单时，request.getParameter()将失效。
• 当form表单的enctype取值为 application/x-www-form-urlencoded 时，
  • form表单的正文内容格式是： name=value&name=value
• 当form表单的enctype取值为 mutilpart/form-data 时，请求正文内容就变成多部分形式：

 

 单文件上传

步骤分析

1. 导入fileupload和io坐标
2. 配置文件上传解析器
3. 编写文件上传代码

1）导入fileupload和io坐标

<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.3</version>
</dependency>
<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.6</version>
</dependency>

2）配置文件上传解析器

<!--文件上传解析器-->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  <!-- 设定文件上传的最大值为5MB，5*1024*1024 -->
  <property name="maxUploadSize" value="5242880"></property>
  <!-- 设定文件上传时写入内存的最大值，如果小于这个参数不会生成临时文件，默认为10240 -->
  <property name="maxInMemorySize" value="40960"></property>
</bean>

3）编写文件上传代码

<form action="${pageContext.request.contextPath}/fileUpload" method="post"
enctype="multipart/form-data">
 名称：<input type="text" name="username"> <br>
 文件：<input type="file" name="filePic"> <br>
  <input type="submit" value="单文件上传">
</form>

@RequestMapping("/fileUpload")
public String fileUpload(String username, MultipartFile filePic) throws
IOException {
  System.out.println(username);
  // 获取文件名
  String originalFilename = filePic.getOriginalFilename();
  //保存文件
  filePic.transferTo(new File("d:/upload/"+originalFilename));
  return "success";
}

<!--配置文件上传解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设定文件上传的最大值为5MB，5*1024*1024 -->
        <property name="maxUploadSize"  value="5242880"></property>
        <!-- 设定文件上传时写入内存的最大值，如果小于这个参数不会生成临时文件，默认为10240 -->
        <property name="maxInMemorySize" value="40960"></property>
    </bean>

异常处理

在Java中，对于异常的处理一般有两种方式:

• 一种是当前方法捕获处理（try-catch），这种处理方式会造成业务代码和异常处理代码的耦合。
• 另一种是自己不处理，而是抛给调用者处理（throws），调用者再抛给它的调用者，也就是一直向上抛。

　　在这种方法的基础上，衍生出了SpringMVC的异常处理机制。

　　系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图：

自定义异常处理器

 创建异常处理器类实现HandlerExceptionResolver

public class GlobalExceptionResolver  implements HandlerExceptionResolver {
  @Override
  public ModelAndView resolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("error", ex.getMessage());
    modelAndView.setViewName("error");
    return modelAndView;
 }
}

配置异常处理器

@Component
public class GlobalExecptionResovler implements HandlerExceptionResolver {}

web的处理异常机制

<!--处理500异常-->
<error-page>
  <error-code>500</error-code>
  <location>/500.jsp</location>
</error-page>
<!--处理404异常-->
<error-page>
  <error-code>404</error-code>
  <location>/404.jsp</location>
</error-page>

拦截器

拦截器（interceptor）的作用

Spring MVC 的拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。
将拦截器按一定的顺序联结成一条链，这条链称为拦截器链（InterceptorChain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

拦截器和过滤器区别

 1）创建拦截器类实现HandlerInterceptor接口

ublic class MyInterceptor1 implements HandlerInterceptor {


    /*
        preHandle: 在目标方法执行之前 进行拦截   return false:不放行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle1....");

        return true;
    }


    /*
        postHandle: 在目标方法执行之后，视图对象返回之前，执行的方法
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle1....");
    }

    /*
        afterCompletion：在流程都执行完成后，执行的方法
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

        System.out.println("afterCompletion1....");


    }
}

2）配置拦截器

<!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/> <!--对所有controller类里面的所有方法都进行拦截-->
            <bean class="com.lagou.interceptor.MyInterceptor1"></bean>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/**"/> <!--对所有controller类里面的所有方法都进行拦截-->
            <bean class="com.lagou.interceptor.MyInterceptor2"></bean>
        </mvc:interceptor>

    </mvc:interceptors>

 

 

 SSM整合

spring整合mybatis

1）整合思想

将mybatis接口代理对象的创建权交给spring管理，我们就可以把dao的代理对象注入到service中，此时也就完成了spring与mybatis的整合了。

2）导入整合包

<!--mybatis整合spring坐标-->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.1</version>
</dependency>

spring配置文件管理mybatis

<!--配置IOC相关操作:开启注解扫描-->
    <context:component-scan base-package="com.lagou.service"></context:component-scan>

    <!--spring整合mybatis开始...................-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--sqlSessionFactory的创建权交给了spring 生产sqlSession-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="com.lagou.domain"></property>

        <!--引入加载mybatis的核心配置文件，可以不用去加载-->
       <!-- <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>-->
    </bean>

    <!--mapper映射扫描 MapperScannerConfigurer扫描该包下所有接口，生成代理对象存到IOC容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.lagou.dao"></property>
     </bean>
    <!--spring整合mybatis结束..........-->


    <!--spring的声明式事务-->
    <!--1.事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--2.开始事务注解的支持-->
    <tx:annotation-driven/>

spring整合springMVC

spring和springMVC其实根本就不用整合，本来就是一家。
但是我们需要做到spring和web容器整合，让web容器启动的时候自动加载spring配置文件，web容器销毁的时候spring的ioc容器也销毁。

spring和web容器整合：

ContextLoaderListener加载【掌握】

可以使用spring-web包中的ContextLoaderListener监听器，可以监听servletContext容器的创建和销毁，来同时创建或销毁IOC容器。

<!--spring 与 web容器整合-->
<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>

spring配置声明式事务

spring配置文件加入声明式事务

<!--事务管理器-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启事务注解支持-->
<tx:annotation-driven/>

 

---

如果您觉得阅读本文对您有帮助，请点一下“推荐”按钮，您的“推荐”将是我最大的写作动力！欢迎各位转载，但是未经作者本人同意，转载文章之后必须在文章页面明显位置给出作者和原文连接，否则保留追究法律责任的权利。