教你学会SSM框架第十步，MyBatis和Spring的整合开发

10.1 整合环境搭建

MyBatis和Spring的整合开发环境主要涉及的jar包和编写的配置文件

10.1.1 准备的jar包

1. Spring框架所需的jar包
   Spring框架所需要准备的JAR包共10个，其中包括4个核心模块JAR、AOP开发使用的JAR、JDBC和事务的JAR（其中核心容器依赖的commons-logging的JAR在MyBatis框架的lib包中已经包含）

• aopalliance-1.0.jar
• aspectjweaver-1.8.10.jar
• spring-aop-4.3.6.RELEASE.jar
• spring-aspects-4.3.6.RELEASE.jar
• spring-beans-4.3.6.RELEASE.jar
• spring-context-4,3.6.RELEASE.jar
• spring-core-4.3.6.RELEASE.jar
• spring-expression-4.3.6.RELEASE.jar
• spring-jdbc-4.3.6.RELEASE.jar
• spring-tx-4.3.6.RELEASE.jar

2. MyBatis框架的JAR包
   MyBatis框架需要准备的JAR包共13个，其中包括核心包mybatis-3.4.2.jar及其解压文件夹中lib目录中的所有JAR

• ant-1.9.6.jar
• ant-launcher-1.9.6.jar
• asm-5.1.jar
• cglib-3.2.4.jar
• commons-logging-1.2.jar
• javassist-3.21.0-GA.jar
• log4j-1.2.17.jar
• log4j-api-2.3ar
• log4j-core-2.3.jar
• mybatis-3.4.2.jar
• ognl-3.1.12.jar
• slf4j-api-1.7.22.jar
• slf4j-log4j12-1.7.22.jar

3. MyBatis与Spring整合所需的中间JAR包
   为了满足MyBatis用户对Spring框架的需求，MyBatis社区开发了一个用于整合MyBatis和Spring两个框架的中间件——MyBatis-Spring。
   这里使用的中间件是mybatis-spring-1.3.1jar。此版本的JAR包可以通过链接获取戳这里
4. 数据库驱动JAR包

• mysql-connector-java-5.1.7-bin.jar。

5. 数据源所需JAR包
   整合时所使用的是DBCP数据源，所以需要准备DBCP和连接池的JAR包

• commons-dbcp2-2.1.1.jar
• commons-pool2-2.4.2.jar

10.1.2 编写配置文件

步骤一

创建项目（名字自取），并将上述所有的jar包添加到项目的lib包中并发布到类路径去。

步骤二

在项目的src目录下分别创建db_properties,Spring的配置文件applicationContext.xml，以及MyBatis的核心配置文件mybatis-config.xml。

db_properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_mybatis
jdbc.username=root
jdbc.password=root
jdbc.maxTotal=30
jdbc.maxIdle=10
jdbc.initialSize=5

applicationContext.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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	<!--读取db.properties-->
	<context:property-placeholder location="classpath:db.properties"/>
	<!--配置数据源 -->
	<bean id="dataSource"
		class="org.apache.commons.dbcp2.BasicDataSource">
		<!--数据库驱动 -->
		<property name="driverClassName" value="${jdbc.driver}" />
		<!--连接数据库的ur1 -->
		<property name="url" value="${jdbc.url}" />
		<!--连接数据库的用户名 -->
		<property name="username" value="${jdbc.username}" />
		<!--连接数据库的密码-->
		<property name="password" value="${jdbc.password}" />
		<!--最大连接数-->
		<property name="maxTotal" value="${jdbc.maxTotal}" />
		<!--最大空闲连接-->
		<property name="maxIdle" value="${jdbc.maxIdle}" />
		<!--初始化连接数-->
		<property name="initialSize" value="${jdbc.initialSize}" />
	</bean>
	<!--事务管理器，依赖于数据源 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	<!--注册事务管理器驱动，开启事务注解 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	<!--配置MyBatis工厂 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!--注入数据源 -->
		<property name="dataSource" ref="dataSource" />
		<!--指定核心配置文件位置 -->
		<property name="configLocation" value="classpath:mybatis-config.xml" />
	</bean>
	<bean id="userDao" class="com.ssm.dao.impl.UserDaoImpl">
		<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
	</bean>
</beans>

首先定义了读取properties文件的配置，然后配置了数据源，接下来配置了事务管理器并开启了事务注解，最后配置了MyBatis工厂来与Spring整合。其中，MyBatis工厂的作用是构建SqlSessionFactory，它是通过MyBatis-Spring包中提供的org.mybatis.Spring.SqlSessionFactoryBean类来配置的。通常在配置时需要提供两个参数：一个是数据源；另一个是MyBatis的配置文件路径。这样Spring的IoC容器就会在初始化id为sqlSessionFactory的Bean时解析MyBatis的配置文件，并与数据源一同保存到Spring的Bean中。

mybatis-config.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>
	<!--配置别名 -->
	<typeAliases>
		<package name="com.ssm.po"/>
	</typeAliases>
	<!--配置Mapper的位置 -->
	<mappers>
		.....
	</mappers>
</configuration>

由于在Spring中已经配置了数据源信息，因此在MyBatis的配置文件中不再需要配置数源信息。这里只需要使用< typeAliases>和< mappers>元素来配置文件别名以及指定mapper文件位置即可。
此外，还需在项目的src目录下创建log4j.properties文件，

代码如下

# Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
log4j.logger.com.ssm=DEBUG
Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

10.2 整合

上述已经完成对MyBatis和Spring整合开发环境的搭建工作，这些配置基本完成了这两大框架大部分的整合工作。

下面是对传统DAO方式和Mapper接口方式的开发整合的介绍

10.2.1 传统DAO方式的开发整合

采用传统DAO开发方式进行MyBatis与Spring框架的整合时，我们需要编写DAO接口以及接口的实现类，并且需要向DAO实现类中注入SqlSessionFactory，然后在方法体内通过SqlSessionFactory创建SqlSession。为此，我们可以使用Mybatis-Spring包中所提供的SqlSessionTemplate类或SqlSessionDaoSupport类来实现此功能。这两个类的描述如下。

• SqlSessionTemplate：Mybatis-Spring的核心类，它负责管理MyBatis的SqlSession，调用MyBatis的SQL方法。当调用SQL方法时，SqlSessionTemplate将会保证使用的SqlSession和当前Spring的事务是相关的。它还管理SqlSession的生命周期，包含必要的关闭、提交和回滚操作。
• SqlSessionDaoSupport：一个抽象支持类，它继承了DaoSupport类，主要是作为DAO的基类来使用。可以通SqlSessionDaoSupport类的getSqlSession()方法来获取所需的SqlSession。

1.实现持久层

在包中创建持久化类用户类User，并定义相关方法，属性，

package com.ssm.po;
public class User {
	private Integer id;
	private String username;
	private String jobs;
	private String phone;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getJobs() {
		return jobs;
	}
	public void setJobs(String jobs) {
		this.jobs = jobs;
	}
	public String getPhone() {
		return phone;
	}
	public void setPhone(String phone) {
		this.phone = phone;
	}
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", jobs=" + jobs + ", phone=" + phone + "]";
	}
}

1.1

创建映射文件UserMapper.xml，编写根据id查询用户信息的映射语句

<?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 namespace="com.ssm.po.UserMapper">
	<!--根据用户编号获取用户信息 -->
	<select id="findUserById" parameterType="Integer" resultType="User">
		select * from t_user where id=#{id}
	</select>
</mapper>

1.2

在MyBatis核心配置文件中配置映射文件UserMapper.xml的位置

<mappers>
		<mapper resource="com/ssm/po/UserMapper.xml" />
		<!--<mapper resource="com/ssm/mapper/UserMapper.xml" />-->
	</mappers>

2.实现Dao层

2.1

创建接口UserDao，并在接口中编写通过id查询用户的方法

package com.ssm.dao;

import com.ssm.po.User;

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

2.2

创建UserDAO接口的实现类，UserDaoImpl.java

package com.ssm.dao.impl;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import com.ssm.dao.UserDao;
import com.ssm.po.User;
public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
	public User findUserById(Integer id) {
		return this.getSqlSession().selectOne("com.ssm.po.UserMapper.findUserById", id);
	}
}

• UserDaoImpl类继承了SqlSessionDaoSupport并实现了UserDao接口。其中，SqlSessionDaoSupport类在使用时需要一个SqlSessionFactory或一个SqlSessionTemplate对象，所以需要通过Spring给SqlSessionDaoSupport类的子类对象注入一个SqlSessionFactory或SqlSessionTemplate。这样，子类中就能通过调用SqlSessionDaoSupport类的getSqlSession()方法来获取SqlSession对象，并使用SqlSession对象中的方法了。

2.3

在Spring的配置文件中编写UserDaoImpl的配置

<bean id="userDao" class="com.ssm.dao.impl.UserDaoImpl">
		<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
	</bean>

上述代码创建了一个id为userDao的Bean，并将SqlSessionFactory对象注入该Bean的实例化对象中。

3.整合测试

创建测试类，并编写测试方法

package com.ssm.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ssm.dao.UserDao;
import com.ssm.po.User;
public class UserDaoTest {
	@Test
	public void findUserByIdDaotest(){
		//1.初始化Spring容器，加载配置文件
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.通过容器获取userDao实例
		UserDao userDao=(UserDao)applicationContext.getBean("userDao");
		//UserDao userDao=applicationContext.getBean(UserDao.class);
		User user=userDao.findUserById(1);
		System.out.println(user);
	}
}

在上述方法中，我们采用的是根据容器中Bean的id来获取指定Bean的方式。执行上述方法后，控制台的输出结果

从中可以看出，通过UserDao实例的findUserById()方法已经查询出了id为1的用户信息，这就说明MyBatis与Spring整合成功。

10.2.2 Mapper接口方式的开发整合

MyBatis+Spring的项目中，虽然使用传统的DAO开发方式可以实现所需功能，但是采用这种方式在实现类中会出现大量的重复代码，在方法中也需要指定映射文件中执行语句的id，并且不能保证编写时id的正确性（运行时才能知道）。为此，我们可以使用MyBatis提供的另一种编程方式，即使用Mapper接口编程。接下来将讲解如何使用 Mapper接口方式来实现MyBatis与Spring的整合。

1. 基于MapperFactoryBean的整合

MapperFactoryBean是MyBatis-Spring团队提供的一个用于根据Mapper接口生成Mapper对象的类，该类在Spring配置文件中使用时可以配置以下参数。

• mapperInterface：用于指定接口。
• SqlSessionFactory：用于指定SqlSessionFactory。
• SqlSessionTemplate：用于指定SqlSessionTemplate。若与SqlSessionFactory同时设定，则只会启用SqlsessionTemplate。

步骤一

在src目录下创建一装映射文件的包，并创建UserMapper接口以及对应的映射文件

UserMapper.java

package com.ssm.mapper;
import com.ssm.po.User;
public interface UserMapper {
	public User findUserById(Integer id);
}

UserMapper.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 namespace="com.ssm.mapper.UserMapper">
	<!--根据用户编号获取用户信息 -->
	<select id="findUserById" parameterType="Integer" resultType="User">
		select * from t_user where id=#{id}
	</select>
</mapper>

步骤二

在MyBatis中引入新的映射文件

<!--配置Mapper的位置 -->
	<mappers>
		<mapper resource="com/ssm/po/UserMapper.xml" />
		<!--<mapper resource="com/ssm/mapper/UserMapper.xml" />-->
	</mappers>

步骤三

在Spring的配置文件中创建一个id为userMapper的Bean，

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
		<property name="mapperInterface" value="com.ssm.mapper.UserMapper" />
		<property name="sqlSessionFactory" ref="sqlSessionFactory" />
	</bean>

上述配置代码为MapperFactoryBean指定了接口以及SqlSessionFactory。

步骤四

在测试类UserDaoTest中编写测试方法findUserByIdMapperTest()

@Test
	public void findUserByldMapperTest(){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserMapper userMapper=(UserMapper)applicationContext.getBean("userMapper");
		User user=userMapper.findUserById(1);
		System.out.println(user);
	}

注意

Mapper接口编程方式是，只需要程序员编写Mapper接口（相当于DAO接口），然后由MyBatis框架根据接口的定义创建接口的动态代理对象，这个代理对象的方法体等同于DAO接口的实现类方法。
虽然使用Mapper接口编程的方式很简单，但是在具体使用时还是需要遵循以下规范。

• Mapper接口的名称和对应的Mapper.xml映射文件的名称必须一致。
• Mapper.xml文件中的namespace与Mapper接口的类路径相同（即接口文件和映射文件需要放在同一个包中）。
• Mapper接口中的方法名和Mapper.xml中定义的每个执行语句的id相同。
• Mapper接口中方法的输入参数类型要和Mapper.xml中定义的每个SQL的parameterType的类型相同。
• Mapper接口方法的输出参数类型要和Mapper.xml中定义的每个SQL的resultType的类型相同。
  只要遵循了这些开发规范，MyBatis就可以自动生成Mapper接口实现类的代理对象，从而简化开发。

2. 基于MapperScannerConfigurer的整合

在实际的项目中，DAO层会包含很多接口，如果每一个接口都那样在Spring配置文件中配置，那么不但会增加工作量，还会使得Spring配置文件非常臃肿。为此，MyBatis-Spring团队提供了一种自动扫描的形式来配置MyBatis中的映射器——采用MapperScannerConfigurer类。
MapperScannerConfigurer类在Spring配置文件中使用时可以配置以下属性。

• basePackage：指定映射接口文件所在的包路径，当需要扫描多个包时可以使用分号或逗号作为分隔符。指定包路径后，会扫描该包及其子包中的所有文件。
• annotationClass：指定要扫描的注解名称，只有被注解标识的类才会被配置为映射器。
• sqlSessionFactoryBeanName：指定在Spring中定义的SqlSessionFactory的Bean名称。
• sqlSessionTemplateBeanName：指定在Spring中定义的SqlSessionTemplate的Bean名称。若定义此属性，则sqlSessionFactoryBeanName将不起作用。
• markerInterface：指定创建映射器的接口。
  MapperScannerConfigurer的使用非常简单，只需要在Spring的配置文件中编写如下代码：
  

在通常情况下，MapperScannerConfigurer在使用时只需通过basePackage属性指定需要扫描的包即可。

Spring会自动地通过包中的接口生成映射器。这使得开发人员可以在编写很少代码的情况下完成对映射器的配置，从而提高开发效率。
要验证上面的配置很容易，只需将上述配置代码写入Spring的配置文件，并将基于MapperFactoryBean的整合案例中的步骤02和步骤03的代码注释掉，再次执行findUserByIdMapperTest()方法进行测试即可。方法执行后结果一致。