SSM的各层执行原理以及三种整合方式和执行流程（Intellij IDE+Maven+SpringMVC+Spring+Mybatis）

1、前言

（1）随着web技术的发展，从原始的Servlet+JDBC的技术，到SSH框架（有想了解的可以阅读小编该文章），再到SSM框架的发展，现在已经有了SpringBoot高效开发的技术，持久层也出现了JPA技术，到了现在分布式和微服务的出现。有想继续了解关于SpringBoot微服务的技术的可以关注小编阅读该文章。
（2）虽然现在SpringBoot技术的发展日盛一日，使用者也越来越多，但是你真的了解SpringBoot的原理嘛。SpringBoot底层封装了SpringMVC，如果你不了解SpringMVC的执行流程，虽然效果可以做出来，但是在使用SpringBoot的过程中会一脸懵逼。而且当你会SpringMVC的原理的时候，再使用SpringBoot会特别的爽！！（知其然，亦知其所以然）废话不多说，接下来小编会带大家结合SSM框架，深入了解SpringMVC和mybatis的执行流程！

2、S：SpringMVC的执行原理

（1）Spring MVC是web层的MVC的框架，和Struts有点类似，处理用户的过程也不复杂。
（2）springMVC里有三大组件处理器映射器（HandlerMapping），处理器适配器（HandlerAdapter）和视图解析器（ViewResolver）。
（3）
①（体系架构）用户发送请求到DispatchServlet（前端控制器），它不会处理请求，而是委托给HandlerMapping。
②（处理器映射器）绑定用户请求，返回一个处理器执行链，包含拦截器和Handler处理器（页面控制器），
③然后处理器适配器（HandlerAdapter）执行Handler返回一个ModelAndView对象（包含模型数据、逻辑视图名），
④然后ViewResolver视图解析器将ModelAndView解析为View对象，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构；返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

3、M:Mybatis的执行流程

（1）Mybatis是DAO持久层的面向sql的半ORM框架，他封装了jdbc访问数据库增删改查的过程，我们开发只需专注于sql语句本身的拼装，其它复杂的过程全部可以交给mybatis去完成。
（2）
①Mybatis体系架构也比较简单，Mybatis要操作数据库，跟所有的框架一样，首先要有配置文件（核心配置文件和关系映射文件由核心配置文件来加载），
②然后配置文件由一个Resources工具类来加载的，加载之后会创建SQLSessionFactoryBuild对象。
③该对象会读取核心配置文件创建SQLSessionFactory，得到之后打开会话得到SqlSession，
④SqlSession会有各种各样的API在上面去操作的，如果深入研究的话，源码里面执行的不是sqlSession,它只是接口调用，真正干活的在Mybatis底层它有一个叫execute的东西，它给我们包装一个自己的MapperStatement,做输入输出映射，最后去访问数据库。

4、SSM框架整合

1）maven idea项目建立可以参考小编之前一篇文章

2）SSM整合的目录结构如下

3）首先pom文件加入以下配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.wdyin.learning</groupId>
<artifactId>base</artifactId>
<version>1.0-SNAPSHOT</version>

<properties>
    <!-- 设置项目编码编码 -->
    <!--<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>-->
    <!-- spring版本号 -->
    <spring.version>4.3.5.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.4.1</mybatis.version>
    <fastjson.version>1.2.47</fastjson.version>
</properties>

<dependencies>
    <!--dependency>
      <groupId>com.wander</groupId>
      <artifactId>[the artifact id of the block to be mounted]</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency-->
    <!-- java ee -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.xml</groupId>
        <artifactId>jaxrpc</artifactId>
        <version>1.1</version>
    </dependency>
    <dependency>
        <groupId>jstl</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <!-- 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!-- 实现slf4j接口并整合 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.2</version>
    </dependency>

    <!-- JSON -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.8.7</version>
    </dependency>


    <!-- 数据库 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.41</version>
        <scope>runtime</scope>
    </dependency>

    <!-- 数据库连接池 -->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>

    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>${mybatis.version}</version>
    </dependency>

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

    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.18</version>
    </dependency>

    <!--json-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>${fastjson.version}</version>
    </dependency>
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.18</version>
    </dependency>
</dependencies>
<packaging>pom</packaging>

4）Spring整合SpringMVC

大家都知道，一个web项目，浏览器通过URL访问项目的入口是web.xml。因此spring在整合SpringMVC的时候。首先在Web.xml中配置DispatcherServlet前段控制器，并配置SpringMVC需要加载的配置文件。这里没有写service，自己可以加上。

①开发步骤

（1）配置web.xml
①配置 SpringMVC的前端控制器
②配置初始化参数加载spring文件
③如果要使用RestFul风格，还需要配置HiddenHttpMethodFilter（可选）
（2）配置spring文件spring-web.xml
①开启包扫描
②配置视图解析器
③配置注解驱动会自动注册RequestMappingHandlerMapping与RequestMappingHandlerAdapter两个Bean

①web.xml配置如下

	<?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">
	
	  <!-- 编码过滤器 -->
	  <filter>
	    <filter-name>encodingFilter</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>encodingFilter</filter-name>
	    <url-pattern>/*</url-pattern>
	  </filter-mapping>
	
	  <!-- 配置DispatcherServlet -->
	  <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:spring/spring-*.xml</param-value>
	    </init-param>
	    <load-on-startup>1</load-on-startup>
	    <async-supported>true</async-supported>
	  </servlet>
	  <servlet-mapping>
	    <servlet-name>SpringMVC</servlet-name>
	    <!-- 匹配所有请求 -->
	    <url-pattern>/</url-pattern>
	  </servlet-mapping>
	
	<!--  <servlet-mapping>
	    <servlet-name>default</servlet-name>
	    <url-pattern>*.png</url-pattern>
	  </servlet-mapping>
	  <servlet-mapping>
	    <servlet-name>default</servlet-name>
	    <url-pattern>*.js</url-pattern>
	  </servlet-mapping>
	  <servlet-mapping>
	    <servlet-name>default</servlet-name>
	    <url-pattern>*.css</url-pattern>
	  </servlet-mapping>-->
	</web-app>

②spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <context:component-scan base-package="com.wander.controller" />
    <!-- 配置SpringMVC -->
    <!-- 1.开启SpringMVC注解模式 -->
    <!-- 简化配置：
        (1)自动注册DefaultAnootationHandlerMapping,AnotationMethodHandlerAdapter
        (2)提供一些列：数据绑定，数字和日期的format @NumberFormat, @DateTimeFormat, xml,json默认读写支持
    -->
    <mvc:annotation-driven />

    <!-- 2.静态资源默认servlet配置
        (1)加入对静态资源的处理：js,gif,png
        (2)允许使用"/"做整体映射
     -->
    <mvc:default-servlet-handler/>

    <!--<mvc:resources location="/static/" mapping="/static/**"  />-->
    <!--
    当SpringMVC的DispatcherServlet配置的映射路径是/时，所有的请求都将被SpringMVC拦截，
    如果我们想访问某个路径下的静态资源其实是不能直接访问的。基于这种情况，SpringMVC提供了
    <mvc:resources/>配置来告诉SpringMVC，哪些请求是针对静态资源的。它需要指定两个参数，
    location用来指定静态资源对应的实际路径，可以通过classpath:META-INF/static/这种方式指定类路径下的资源，
    如果有多个路径，可以通过英文逗号分隔。mapping用来指定哪些请求会被认为是在请求静态资源。
    下面的配置就指定了格式满足/static/**的请求路径被认为是在请求静态资源，会相应的到/static/路径下寻找对应文件。
    所以当请求路径是/static/css/default.css时会响应/static/css目录下的default.css文件。
    <mvc:resources location="/static/" mapping="/static/**" />
    -->

    <!-- 3.配置jsp 显示ViewResolver -->
    <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>

    <!-- 4.扫描web相关的bean -->

</beans>

③UserController

package com.wander.controller.college;

import com.wander.controller.base.BaseController;
import com.wander.entity.College;
import com.wander.service.CollegeService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.Resource;

@Controller
@RequestMapping("wander")
public class UserController{

    @Resource
    private UserService userService;

    @RequestMapping("getById")
    public String getById(Integer id, Model model){
        User user= userService.getById(id);
        model.addAttribute(user);
        return "index";
    }
}

④UserService

package com.wander.service;

import com.wander.mapper.UserDao;
import com.wander.model.User;

import javax.annotation.Resource;

public class UserService {
    @Resource
    private UserDao userDao;

    public User getById(Integer id){
        return userDao.getById(id);
    }

}

5）Spring整合Mybatis第一种方式传统Dao开发方式

注：

该方式是需要些dao的实现类，其他两种方式不需要写dao的实现类，只需要一个接口，mybatis会动态代理该接口的实现类，这是该方式和其他两种方式的区别。

①开发步骤

（1）配置web.xml（如果已整合Spring+SpringMVC则不需要该步骤）
①配置contextConfigLocation加载spring配置文件
②配置参数contextConfigLocation启动Spring的容器
（2）配置spring文件spring-dao.xml
①配置property-placeholder，加载jdbc配置文件
②配置bean:DataSource数据源
③配置bean：sqlSessionFactory
1)注入DataSource
2)注入configLocation加载mybatis核心配置文件SqlMapConfig.xml
3)注入typeAliasesPackage别名包扫描实体类所在的包
（3）配置dao的实现类
①注入sqlSessionFactory
（4）编写jdbc.properties
（5）dao实现类继承SqlSessionDaoSupport

②直接上代码，因为在Spring和SpringMVC整合时已经在web.xml加载了Spring配置文件所以，配置web.xml该步骤不需要了，直接配置spring-dao.xml

1.spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- SqlSessionFactory配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 加载mybatis核心配置文件（） -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml" />
        <!--mapper文件交给mybatis加载有两种方式，第一种是在SqlMapConfig.xml加载Mapper文件，然后spring加载核心配置文件。第二种方式是，spring直接加载mapper配置文件如下-->
        <property name="mapperLocations" value="classpath:mapper/user.xml"/>
        <!-- 别名包扫描 -->
        <property name="typeAliasesPackage" value="com.wander.model" />
    </bean>

    <!-- 传统Dao配置 -->
    <bean class="com.wander.mapper.impl.UserDaoImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
</beans>

2.jdbc.properties

	jdbc.driver=com.mysql.jdbc.Driver
	#数据库地址
	jdbc.url=jdbc:mysql://localhost:3306/mybatis_jxmb?useUnicode=true&characterEncoding=utf-8
	#用户名
	jdbc.username=root
	#密码
	jdbc.password=root
	#最大连接数
	c3p0.maxPoolSize=30
	#最小连接数
	c3p0.minPoolSize=10
	#关闭连接后不自动commit
	c3p0.autoCommitOnClose=false
	#获取连接超时时间
	c3p0.checkoutTimeout=10000
	#当获取连接失败重试次数
	c3p0.acquireRetryAttempts=2

3.SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 配置全局属性 -->
    <settings>
        <!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->
        <setting name="useGeneratedKeys" value="true" />

        <!-- 使用列别名替换列名 默认:true -->
        <setting name="useColumnLabel" value="true" />

        <!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
</configuration>

4.mapper文件sql映射：User.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">

<!-- 设置为IUserDao接口方法提供sql语句配置 -->
<!--<mapper namespace="com.wander.mapperper.CollegeDao">-->
<mapper namespace="user">

    <select id="getById" resultType="com.wander.model.User" parameterType="int">
        SELECT * FROM user WHERE id = #{id}
    </select>

</mapper>

4.接口：UserDao
package com.wander.mapper;

import com.wander.model.User;

public interface UserDao {
    User getById(Integer id);
}

5.实现类：UserDaoImpl

package com.wander.mapper.impl;

import com.wander.mapper.UserDao;
import com.wander.model.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {

    @Override
    public User getById(Integer id) {
        SqlSession sqlSession= super.getSqlSession();
        User user = sqlSession.selectOne("user.getById", id);
        //这里不能关闭SqlSession
        //sqlSession.close();
        return user;
    }
}

6.实体类：User

package com.wander.model;

public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

6）Spring整合Mybatis第二种动态代理Dao开发方式

注：第二种和第三种方式只需要改spring-dao.xml配置文件，其他的jdbc.properties和SqlMapConfig.xml配置文件和第一种配置相同，而且dao的实现类不需要写。，只需要一个接口，mybatis会动态代理该接口的实现类.

spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
    <!-- SqlSessionFactory配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 加载mybatis核心配置文件 -->
        <!--<property name="configLocation" value="classpath:SqlMapConfig.xml"/>-->

        <!-- 别名包扫描 -->
        <property name="typeAliasesPackage" value="com.wander.model"/>
		<!--mapper文件交给mybatis加载有两种方式，第一种是在SqlMapConfig.xml加载Mapper文件，然后spring加载核心配置文件。第二种方式是，spring直接加载mapper配置文件如下-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

	    <!-- 动态代理Dao开发方式 -MapperFactoryBean -->
    <bean id="baseMapper" class="org.mybatis.spring.mapper.MapperFactoryBean" abstract="true" lazy-init="true">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
    <!-- 用户动态代理扫描 -->
    <bean parent="baseMapper">
        <property name="mapperInterface" value="com.wander.mapper.UserMapper"/>
    </bean>
</beans>

7）Spring整合Mybatis第三种动态代理Dao开发包扫描方式

注：第二种和第三种方式只需要改spring-dao.xml配置文件，其他的jdbc.properties和SqlMapConfig.xml配置文件和第一种配置相同，**而且dao的实现类不需要写。**只需要一个接口，mybatis会动态代理该接口的实现类.
spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
    <!-- SqlSessionFactory配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 加载mybatis核心配置文件 -->
        <!--<property name="configLocation" value="classpath:SqlMapConfig.xml"/>-->

        <!-- 别名包扫描 -->
        <property name="typeAliasesPackage" value="com.wander.model"/>
		<!--mapper文件交给mybatis加载有两种方式，第一种是在SqlMapConfig.xml加载Mapper文件，然后spring加载核心配置文件。第二种方式是，spring直接加载mapper配置文件如下-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 动态代理，包扫描（推荐）： -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- basePackage多个包用","分隔 不是类 -->
        <!-- <property name="basePackage" value="com.itheima.mybatis.mapper" /> -->
        <property name="basePackage" value="com.wander.mapper" />
    </bean>
</beans>

spring事物的管理需要配置
spring-service
<?xml version="1.0" encoding="UTF-8"?>

    <!-- 扫描service包下所有使用注解的类型 -->
   <!-- <context:component-scan base-package="com.wander">
        <context:exclude-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>-->

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 控制数据源，注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 开启基于注解的声明式事务，使用xml配置形式的事务（必要主要的都是使用配置式）  -->
    <context:component-scan base-package="com.wander.service"/>
    <aop:config>
        <!-- 切入点表达式 -->
        <aop:pointcut expression="execution(* com.wander.service..*(..))" id="txPoint"/>
        <!-- 配置事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
    </aop:config>

    <!--配置事务增强，事务如何切入，transactionManager默认值  -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 所有方法都是事务方法 -->
            <tx:method name="*"/>
            <!--以get开始的所有方法,都是查询，read-only="true"可以调优  -->
            <tx:method name="get*" read-only="true"/>
            <tx:method name="list*" read-only="true"/>
        </tx:attributes>
    </tx:advice>
</beans>

8）总结：

1.ssm框架整合后，大家都知道web入口是web.xml.因此，在web.xml中配置前端控制器dispatchSerlet并配置spring*.xml文件提供给web服务器读取。
2.spring-web.xml配置SpringMVC相关的配置
3.spring-daoxml配置mybatis相关的配置
4.spring-service配置spring的事物

如果小伙伴们在使用时，出现问题，可随时找加群找我~
欢迎加入少年与java交流群5号，群聊号码：106643434