Spring 整合 MyBatis 全流程详解及 JUnit 单元测试

步骤 3：创建模型类（domain 包）

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Double money;
    // 构造器、getter、setter、toString 方法略
}

步骤 4：创建 Dao 接口

public interface AccountDao {
    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);

    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);

    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);

    @Select("select * from tbl_account")
    List<Account> findAll();

    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

步骤 5：创建 Service 接口和实现类

// Service 接口
public interface AccountService {
    void save(Account account);
    void delete(Integer id);
    void update(Account account);
    List<Account> findAll();
    Account findById(Integer id);
}

// Service 实现类
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Override
    public void save(Account account) {
        accountDao.save(account);
    }

    @Override
    public void update(Account account) {
        accountDao.update(account);
    }

    @Override
    public void delete(Integer id) {
        accountDao.delete(id);
    }

    @Override
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    @Override
    public List<Account> findAll() {
        return accountDao.findAll();
    }
}

步骤 6：添加 jdbc.properties 配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root

说明：useSSL=false 用于关闭 MySQL 的 SSL 连接，避免警告。

步骤 7：添加 MyBatis 核心配置文件 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.dtd">
<configuration>
    <!-- 读取外部 properties 配置文件 -->
    <properties resource="jdbc.properties"></properties>
    <!-- 别名扫描的包路径 -->
    <typeAliases>
        <package name="com.itheima.domain"/>
    </typeAliases>
    <!-- 数据源 -->
    <environments default="mysql">
        <environment>
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 映射文件扫描包路径 -->
    <mappers>
        <package name="com.itheima.dao"/>
    </mappers>
</configuration>

步骤 8：编写应用程序

public class App {
    public static void main(String[] args) throws IOException {
        // 1. 创建 SqlSessionFactoryBuilder 对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 2. 加载 SqlMapConfig.xml 配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 3. 创建 SqlSessionFactory 对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        // 4. 获取 SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 5. 执行 SqlSession 对象执行查询，获取结果
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
        Account ac = accountDao.findById(1);
        System.out.println(ac);
        // 6. 释放资源
        sqlSession.close();
    }
}

步骤 9：运行程序

Account{id=1, name='Tom', money=1000.0}
Process finished with exit code 0

1.2 MyBatis 核心对象与整合思路分析

1.2.1 MyBatis 核心对象分析

1.2.2 整合核心思路

Spring 整合 MyBatis 的核心就是两件事：

1. Spring 管理 SqlSessionFactory：将 MyBatis 的核心工厂交给 Spring IoC 容器，统一管理，避免手动创建。
2. Spring 管理 Mapper 接口的扫描：自动扫描 Dao 接口，生成代理对象，交给 Spring 容器，直接@Autowired 注入使用。

同时，原来 MyBatis 配置文件 SqlMapConfig.xml 中的所有配置，都可以通过 Spring 的配置类来实现，最终可以完全舍弃该配置文件。

二、Spring 整合 MyBatis 完整步骤

2.1 导入整合依赖

<!-- Spring 操作数据库依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<!-- MyBatis 提供的 Spring 整合包 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

说明：mybatis-spring 是 MyBatis 官方提供的 Spring 整合工具包，封装了 SqlSessionFactoryBean、MapperScannerConfigurer 等核心类。

2.2 创建 Spring 主配置类

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
public class SpringConfig {
}

• @Configuration：标记该类为 Spring 配置类
• @ComponentScan：组件扫描，扫描项目中的 Service、Dao 等 Bean
• @PropertySource：加载 jdbc.properties 配置文件

2.3 数据源配置类（Druid 连接池）

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

2.4 MyBatis 核心配置类

public class MybatisConfig {
    /**
     * 配置 SqlSessionFactoryBean，生成 SqlSessionFactory
     */
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        // 设置模型类的别名扫描包
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        // 设置数据源（自动注入 Spring 管理的 DruidDataSource）
        ssfb.setDataSource(dataSource);
        return ssfb;
    }

    /**
     * 配置 MapperScannerConfigurer，扫描 Dao 接口生成代理对象
     */
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        // 设置 Dao 接口的扫描包路径
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

重点说明：配置了 MapperScannerConfigurer 批量扫描 dao 包后，Mapper 接口上无需添加@Mapper 注解，即可被 Spring 管理并支持@Autowired 注入。

@Mapper 注解

MyBatis 提供的注解，作用是标记当前接口为 Mapper 接口，让 Spring 能为该接口生成代理对象并注入到容器中。

@MapperScan / MapperScannerConfigurer

作用是批量扫描指定包下的所有接口，自动将其识别为 Mapper 接口，统一生成代理对象，无需逐个接口加注解。

两者的使用关系

只要配置了批量扫描（@MapperScan / MapperScannerConfigurer），接口上就不需要再写 @Mapper；即使写了也不会报错，但属于冗余配置，没有实际作用。

不同开发场景的使用规范

• 传统 SSM 框架：使用 MapperScannerConfigurer 配置批量扫描，接口上不写 @Mapper；
• Spring Boot（主流方案）：在启动类上添加 @MapperScan("xxx.dao") 配置扫描包，接口上不写 @Mapper；
• 唯一必须写 @Mapper 的场景：没有任何批量扫描配置，仅单独使用某个 Mapper 接口，这句话仅在 Spring Boot 中是可实现的。在 SSM 中不成立，因为 SSM 中即使给单个接口加 @Mapper，不配置扫描器也无法生效，不存在「不配置批量扫描就能单独用 @Mapper」的情况。

补充生效规则

• 纯 Spring（SSM）环境：@Mapper 必须配合 MapperScannerConfigurer 才能生效；
• Spring Boot 环境：@Mapper 可以直接生效，因为 Spring Boot 的 MyBatis 自动配置已经帮你完成了底层扫描逻辑。

2.5 完善主配置类

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MybatisConfig.class})
public class SpringConfig {
}

2.6 编写运行测试类

public class App2 {
    public static void main(String[] args) {
        // 启动 Spring 容器
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        // 获取 Service Bean
        AccountService accountService = ctx.getBean(AccountService.class);
        // 执行查询
        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}

2.7 项目结构说明

spring_15_spring_mybatis
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com.itheima
│   │   │       ├── config
│   │   │       │   ├── JdbcConfig.java
│   │   │       │   ├── MybatisConfig.java
│   │   │       │   └── SpringConfig.java
│   │   │       ├── dao
│   │   │       │   └── AccountDao.java
│   │   │       ├── domain
│   │   │       │   └── Account.java
│   │   │       ├── service
│   │   │       │   ├── AccountService.java
│   │   │       │   └── impl
│   │   │       │       └── AccountServiceImpl.java
│   │   │       ├── App.java
│   │   │       └── App2.java
│   │   └── resources
│   │       └── jdbc.properties
└── pom.xml

三、Spring 整合 Junit 单元测试

3.1 环境准备

直接使用上面整合好的 Spring+MyBatis 项目，在 test 目录下编写测试类。

3.2 整合步骤与代码实现

步骤 1：引入依赖 在 pom.xml 中添加 Junit 和 Spring 测试依赖：

<!-- Junit 依赖 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!-- Spring 测试依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

步骤 2：编写测试类 在 test/java/com/itheima 下创建 AccountServiceTest 测试类：

// 设置运行器：Spring 整合 Junit 的专用运行器
@RunWith(SpringJUnit4ClassRunner.class)
// 设置 Spring 配置类
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    // 自动注入 Service Bean
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));
    }

    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}

关键注解说明：

• @RunWith(SpringJUnit4ClassRunner.class)：必须添加，Spring 提供的专用运行器，负责自动创建 Spring 容器。
• @ContextConfiguration(classes = SpringConfig.class)：指定 Spring 配置类，加载容器。
• @Autowired：直接注入 Bean，无需手动获取。

3.3 整合 vs 手动方式对比

手动方式代码示例（不推荐）：

public class AccountServiceTest {
    @Test
    public void testFindById() {
        // 手动创建 Spring 容器
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        // 获取 Bean
        AccountService accountService = ctx.getBean(AccountService.class);
        // 执行测试
        System.out.println(accountService.findById(1));
    }
}

四、常见问题与注意事项

1. SqlSessionFactoryBean 的 dataSource 必须是 Spring 管理的，不能手动 new。
2. MapperScannerConfigurer 的 basePackage 必须准确，否则无法生成 Mapper 代理对象。
3. 配置 MapperScannerConfigurer 后，Mapper 接口不需要@Mapper 注解。
4. @PropertySource 必须加 classpath:，确保配置文件加载成功。
5. SqlSession 线程不安全，不能交给 Spring 单例管理。
6. 测试类中@RunWith 必须在@ContextConfiguration 之前。

五、总结

Spring 整合 MyBatis 的核心思想是将 MyBatis 的核心对象交给 Spring IoC 容器统一管理，实现解耦、简化开发、统一配置：

• 用 SqlSessionFactoryBean 替代 SqlMapConfig.xml，管理 SqlSessionFactory；
• 用 MapperScannerConfigurer 自动扫描 Dao 接口，生成代理对象，无需@Mapper；
• 整合 Junit 后，自动创建容器，大幅简化单元测试。