使用配置类方式整合 MyBatis

在本教程中，我们将展示如何通过配置类的方式来整合 MyBatis，而不使用 mybatis.xml 配置文件。我们将一步步解释每个部分的原理和原因，以帮助读者理解为什么要这样做。

整合 mybatis

一、添加依赖

首先，在项目的 pom.xml 文件中添加以下依赖：

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <java.version>1.8</java.version>
  <maven.compiler.source>${java.version}</maven.compiler.source>
  <maven.compiler.target>${java.version}</maven.compiler.target>
  <graalvm.version>23.1.1</graalvm.version>
  <tio-boot.version>2.1.4</tio-boot.version>
  <lombok-version>1.18.44</lombok-version>
  <jfinal-aop.version>1.3.3</jfinal-aop.version>
  <hotswap-classloader.version>1.2.9</hotswap-classloader.version>
  <final.name>web-hello</final.name>
  <main.class>demo.mybatis.MybatisApp</main.class>
</properties>

<dependencies>
  <!-- 日志框架 -->
  <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.3.3</version>
  </dependency>

  <!-- Tio Boot 框架 -->
  <dependency>
    <groupId>nexus.io</groupId>
    <artifactId>tio-boot</artifactId>
    <version>${tio-boot.version}</version>
  </dependency>

  <!-- 热加载类加载器 -->
  <dependency>
    <groupId>nexus.io</groupId>
    <artifactId>hotswap-classloader</artifactId>
    <version>${hotswap-classloader.version}</version>
  </dependency>

  <!-- JFinal AOP -->
  <dependency>
    <groupId>nexus.io</groupId>
    <artifactId>jfinal-aop</artifactId>
    <version>${jfinal-aop.version}</version>
  </dependency>

  <!-- Lombok -->
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>${lombok-version}</version>
    <optional>true</optional>
    <scope>provided</scope>
  </dependency>

  <!-- MyBatis -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.4</version>
  </dependency>

  <!-- Druid 连接池 -->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
  </dependency>

  <!-- PostgreSQL 驱动 -->
  <dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.5.0</version>>
  </dependency>

  <!-- JUnit 用于测试 -->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
  </dependency>
</dependencies>

说明：

MyBatis：对象关系映射框架，用于与数据库交互。
Druid：阿里巴巴提供的高性能数据库连接池。
PostgreSQL 驱动：连接 PostgreSQL 数据库所需的 JDBC 驱动。
其他依赖：包括日志框架、Tio Boot 框架、热加载、AOP 等，支持应用的运行和开发。

二、启动类

创建应用的启动类 MybatisApp：

package demo.mybatis;

import nexus.io.annotation.AComponentScan;
import nexus.io.tio.boot.TioApplication;

@AComponentScan
public class MybatisApp {
  public static void main(String[] args) {
    TioApplication.run(MybatisApp.class, args);
  }
}

说明：

@AComponentScan：注解用于扫描组件（如控制器、配置类等）。
TioApplication.run(...)：启动 Tio Boot 应用。

三、模型类

定义实体类 SystemAdmin：

package demo.mybatis.model;

import lombok.Data;

@Data
public class SystemAdmin {
  private int id;
  private String loginName;
  private String password;
}

说明：

使用 Lombok 的 @Data 注解，自动生成 getter、setter、toString() 等方法。
该类映射到数据库中的 system_admin 表。

四、Mapper 接口

创建 Mapper 接口 SystemAdminMapper：

package demo.mybatis.mapper;

import demo.mybatis.model.SystemAdmin;

public interface SystemAdminMapper {
  public SystemAdmin getSystemAdmin(SystemAdmin systemAdmin);
}

说明：

定义数据库操作方法 getSystemAdmin。
MyBatis 将为该接口生成实现，具体 SQL 由 XML 文件或注解提供。

五、SqlSessionManager 管理类

创建 MySqlSessionManager，用于管理 SqlSessionManager：

package demo.mybatis.config;

import org.apache.ibatis.session.SqlSessionManager;

public class MySqlSessionManager {

  private static SqlSessionManager sqlSessionManager;

  public static void setSqlSessionManager(SqlSessionManager manager) {
    sqlSessionManager = manager;
  }

  public static SqlSessionManager getSqlSessionManager() {
    return sqlSessionManager;
  }

  public static <T> T getMapper(Class<T> clazz) {
    return sqlSessionManager.getMapper(clazz);
  }
}

说明：

SqlSessionManager 是 MyBatis 提供的线程安全的 SqlSession 管理器。
提供静态方法获取 Mapper，以便在应用的任何地方都可以方便地访问数据库操作。

六、Mapper XML 配置

创建 SystemAdminMapper.xml 文件，定义 SQL 语句：

<?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="demo.mybatis.mapper.SystemAdminMapper">

  <resultMap type="SystemAdmin" autoMapping="true" id="SystemAdminResult">
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="login_name" jdbcType="VARCHAR" property="loginName" />
    <result column="password" jdbcType="VARCHAR" property="password" />
  </resultMap>

  <select id="getSystemAdmin" resultMap="SystemAdminResult">
    select * from system_admin where 1=1
    <if test="loginName != null and loginName !=''">
      and login_name=#{loginName}
    </if>
  </select>
</mapper>

说明：

<mapper>：指定命名空间，与 Mapper 接口的全限定类名一致。
<resultMap>：定义结果映射，将数据库字段映射到实体类属性。
<select>：定义查询语句，支持动态 SQL。

七、MyBatis 配置类

创建配置类 MybatisConfig，通过代码方式配置 MyBatis：

package demo.mybatis.config;

import java.io.InputStream;
import java.util.Map;

import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.parsing.XNode;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.session.SqlSessionManager;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;

import nexus.io.annotation.AConfiguration;
import nexus.io.annotation.AInitialization;
import nexus.io.tio.boot.server.TioBootServer;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@AConfiguration
public class MybatisConfig {

  @Initialization
  public void sqlSessionFactory() {
    // 配置数据源
    PooledDataSource dataSource = new PooledDataSource();
    dataSource.setDriver("org.postgresql.Driver");
    dataSource.setUrl("jdbc:postgresql://192.168.3.9/defaultdb");
    dataSource.setUsername("postgres");
    dataSource.setPassword("123456");

    // 创建 MyBatis 配置对象
    Configuration configuration = new Configuration();
    configuration.setLogImpl(StdOutImpl.class); // 设置日志输出到控制台

    // 注册类型别名（添加这部分代码）
    configuration.getTypeAliasRegistry().registerAliases("demo.mybatis.model");

    // 配置环境，包括事务管理器和数据源
    Environment environment = new Environment("development", new JdbcTransactionFactory(), dataSource);
    configuration.setEnvironment(environment);

    addMapper(configuration, "SystemAdminMapper.xml");

    try {
      // 构建 SqlSessionFactory
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
      // 使用 SqlSessionManager
      SqlSessionManager sqlSessionManager = SqlSessionManager.newInstance(sqlSessionFactory);
      MySqlSessionManager.setSqlSessionManager(sqlSessionManager);

      HookCan.me().addDestroyMethod(()->{
        sqlSessionManager.close();
      });
    } catch (Exception e) {
      log.error("无法创建 SqlSessionFactory", e);
      throw new RuntimeException(e);
    }
  }

  private void addMapper(Configuration configuration, String resource) {
    // 注册 Mapper 接口
    // configuration.addMapper(demo.mybatis.mapper.SystemAdminMapper.class);

    // 加载并解析 Mapper XML 文件
    InputStream inputStream = getClass().getClassLoader().getResourceAsStream(resource);
    if (inputStream == null) {
      throw new RuntimeException("无法找到资源文件：" + resource);
    }
    Map<String, XNode> sqlFragments = configuration.getSqlFragments();
    XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(inputStream, configuration, resource, sqlFragments);
    xmlMapperBuilder.parse();
  }
}

解释原理：

配置数据源：
- 使用 PooledDataSource 配置数据库连接池，设置驱动、URL、用户名和密码。
创建 MyBatis 配置对象：
- 创建 Configuration 实例，设置日志实现为 StdOutImpl，日志将输出到控制台。
注册类型别名：
- 通过 configuration.getTypeAliasRegistry().registerAliases("demo.mybatis.model") 注册指定包下的所有类为类型别名。
- 这样在映射文件中，可以直接使用类名，而无需全限定名。
配置环境：
- 创建 Environment，包含事务管理器 JdbcTransactionFactory 和数据源。
- 设置环境到配置对象中。
添加 Mapper：
- 调用 addMapper 方法，手动加载并解析 Mapper XML 文件。
- 使用 XMLMapperBuilder 解析 XML，并注册映射关系到配置对象。
构建 SqlSessionManager：
- 使用 SqlSessionManager.newInstance(configuration) 创建 SqlSessionManager，这是 MyBatis 提供的线程安全的 SqlSession 管理器。
- 将 SqlSessionManager 设置到 MySqlSessionManager 中，以供全局使用。
资源管理：
- 通过 HookCan.me().addDestroyMethod 方法，在应用关闭时，自动关闭 SqlSessionManager，释放资源。

为什么要这样做？

完全通过代码配置：不再依赖 mybatis.xml，使配置更加灵活和可控。
类型安全：代码配置比 XML 更加类型安全，避免了拼写错误等问题。
动态性：可以根据运行环境或条件，动态调整配置。
简化管理：集中管理 Mapper 的加载和注册，减少配置文件的分散。

八、控制器

创建 SystemAdminController，处理请求并返回数据：

package demo.mybatis.controller;

import com.jfinal.kit.Kv;
import nexus.io.annotation.RequestPath;

import demo.mybatis.config.MySqlSessionManager;
import demo.mybatis.mapper.SystemAdminMapper;
import demo.mybatis.model.SystemAdmin;
import lombok.extern.slf4j.Slf4j;

@RequestPath("/SystemAdmin")
@Slf4j
public class SystemAdminController {

  public Kv getSystemAdmin() {
    SystemAdminMapper mapper = MySqlSessionManager.getMapper(SystemAdminMapper.class);
    SystemAdmin systemAdmin = mapper.getSystemAdmin(null);
    log.info("mapper:{}", mapper);
    Kv kv = Kv.by("data", systemAdmin);
    return kv;
  }
}

说明：

@RequestPath("/SystemAdmin")：映射请求路径到控制器。
使用 MySqlSessionManager.getMapper() 获取 Mapper，直接调用数据库操作方法。
返回的数据使用 Kv（键值对）封装，便于序列化为 JSON。

九、测试整合

启动应用，访问以下地址：

http://localhost/SystemAdmin/getSystemAdmin

预期结果：

{ "data": { "id": 1, "password": "00000000", "loginName": "litong" } }

日志输出示例：

2024-10-07 15:33:16.458 [Thread-18] INFO  d.m.c.SystemAdminController.getSystemAdmin:20 - mapper:org.apache.ibatis.binding.MapperProxy@77d5465f
Opening JDBC Connection
Setting autocommit to false on JDBC Connection [org.postgresql.jdbc.PgConnection@1a85f8a1]
==>  Preparing: select * from system_admin where 1=1
==> Parameters:
<==    Columns: id, login_name, password
<==        Row: 1, litong, 00000000
<==      Total: 1
Resetting autocommit to true on JDBC Connection [org.postgresql.jdbc.PgConnection@1a85f8a1]
Closing JDBC Connection [org.postgresql.jdbc.PgConnection@1a85f8a1]
2024-10-07 15:33:17.495 [Thread-18] INFO  d.m.c.SystemAdminController.getSystemAdmin:20 - mapper:org.apache.ibatis.binding.MapperProxy@166328a6

解释：

MapperProxy：MyBatis 动态生成的 Mapper 接口实现，用于执行 SQL 语句。
数据库连接：显示了数据库连接的打开、SQL 准备和执行、结果集处理、连接关闭等过程。
日志信息：帮助开发者了解 SQL 执行的细节，便于调试和优化。

十、解释原理

1. 使用配置类方式整合 MyBatis

避免使用 XML 配置文件：通过 Java 代码配置 MyBatis，减少对 XML 配置的依赖，提高配置的灵活性和可维护性。
类型安全和可读性：Java 代码配置具有类型检查，减少配置错误，提高可读性。
集中管理：所有配置都在代码中完成，便于管理和版本控制。

2. 使用 `SqlSessionManager`

线程安全：SqlSessionManager 内部使用 ThreadLocal，保证了多线程环境下的安全性。
简化开发：开发者无需手动管理 SqlSession 的生命周期，SqlSessionManager 自动处理打开和关闭。
自动事务管理：在需要事务的情况下，可以方便地开启和提交事务。

3. 手动加载 Mapper XML 文件

灵活性：手动加载和解析 Mapper XML 文件，开发者可以精确控制加载的过程和时机。
无需 mybatis.xml：不使用全局配置文件，而是直接在代码中加载 Mapper，减少配置的分散。

4. 注册类型别名

提高可读性：在映射文件中使用简短的类型别名，避免冗长的全限定类名。
便于维护：类型别名集中管理，修改包名或类名时，方便更新。

5. 资源管理

应用关闭时释放资源：通过在应用关闭时关闭 SqlSessionManager，确保数据库连接等资源被正确释放，防止资源泄漏。

十一、总结

通过本教程，我们实现了使用配置类的方式整合 MyBatis，并深入理解了每个步骤的原理和原因。这样的配置方式具有以下优势：

灵活性高：完全通过代码配置，便于动态调整和扩展。
减少配置文件：避免了大量的 XML 配置文件，代码更集中，更易于管理。
简化开发：使用 SqlSessionManager，自动管理 SqlSession，减少了手动处理的复杂性。
提高性能：由于直接使用代码配置，可以根据需要进行优化，避免不必要的配置加载。

希望通过本教程，读者能够理解为什么要使用配置类方式整合 MyBatis，以及这样做的好处。

使用 AOP 整合 MyBatis Mapper，实现自动注入

在之前的示例中，我们通过 MySqlSessionManager.getMapper() 方法手动获取 Mapper。这种方式需要在每个需要使用 Mapper 的地方调用该方法，略显繁琐。为了简化开发，我们可以利用 AOP（面向切面编程），将 Mapper 自动注入到需要的类中。

在本文中，我们将展示如何将 MyBatis 的 Mapper 添加到 AOP 中，使其能够像普通的 Bean 一样被注入，从而避免手动获取 Mapper。同时，我们会详细解释每个步骤的原理和原因，帮助您理解为什么要这样做。

1. 使用 AOP 管理 Mapper 对象

1.1. AOP 简介

AOP（Aspect-Oriented Programming），即面向切面编程，是一种编程范式，旨在将横切关注点（如日志记录、事务管理等）与业务逻辑分离。在 Java 中，AOP 通常用于拦截方法调用、在方法前后执行额外的逻辑等。

在我们的场景中，我们可以使用 AOP 容器来管理对象的创建和依赖注入。通过将 Mapper 对象添加到 AOP 容器中，我们可以在需要的地方自动注入 Mapper，而无需手动获取。

1.2. AopManager 简介

AopManager 是一个 AOP 管理器，负责管理对象的创建、拦截器的应用以及依赖的注入。通过 AopManager，我们可以：

注册单例对象：将对象以单例的形式添加到容器中，供全局使用。
依赖注入：在需要的地方自动注入已经注册的对象。
添加拦截器：在方法调用前后执行特定的逻辑。

2. 将 Mapper 添加到 AOP 容器中

2.1. 修改 MyBatis 配置类

在 MybatisConfig 中，我们需要在构建 SqlSessionManager 后，将 Mapper 接口的实例添加到 AOP 容器中。

package demo.mybatis.config;

import java.io.InputStream;
import java.util.Map;

import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.parsing.XNode;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.session.SqlSessionManager;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;

import nexus.io.annotation.AConfiguration;
import nexus.io.annotation.AInitialization;
import nexus.io.jfinal.aop.AopManager;
import nexus.io.tio.boot.server.TioBootServer;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@AConfiguration
public class MybatisConfig {

  @Initialization
  public void sqlSessionFactory() {
    // 配置数据源
    PooledDataSource dataSource = new PooledDataSource();
    dataSource.setDriver("org.postgresql.Driver");
    dataSource.setUrl("jdbc:postgresql://192.168.3.9/defaultdb");
    dataSource.setUsername("postgres");
    dataSource.setPassword("123456");

    // 创建 MyBatis 配置对象
    Configuration configuration = new Configuration();
    configuration.setLogImpl(StdOutImpl.class); // 设置日志输出到控制台

    // 注册类型别名
    configuration.getTypeAliasRegistry().registerAliases("demo.mybatis.model");

    // 配置环境，包括事务管理器和数据源
    Environment environment = new Environment("development", new JdbcTransactionFactory(), dataSource);
    configuration.setEnvironment(environment);

    // 添加 Mapper
    addMapper(configuration, "SystemAdminMapper.xml");

    try {
      // 构建 SqlSessionFactory
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
      // 构建 SqlSessionManager
      SqlSessionManager sqlSessionManager = SqlSessionManager.newInstance(sqlSessionFactory);
      MySqlSessionManager.setSqlSessionManager(sqlSessionManager);

      // 将 Mapper 添加到 AOP 容器中
      addMapperToAop(sqlSessionManager);

      // 在应用关闭时，关闭 SqlSessionManager
      HookCan.me().addDestroyMethod(() -> {
        sqlSessionManager.close();
      });
    } catch (Exception e) {
      log.error("无法创建 SqlSessionManager", e);
      throw new RuntimeException(e);
    }
  }

  private void addMapper(Configuration configuration, String resource) {
    // 加载并解析 Mapper XML 文件
    InputStream inputStream = getClass().getClassLoader().getResourceAsStream(resource);
    if (inputStream == null) {
      throw new RuntimeException("无法找到资源文件：" + resource);
    }
    Map<String, XNode> sqlFragments = configuration.getSqlFragments();
    XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(inputStream, configuration, resource, sqlFragments);
    xmlMapperBuilder.parse();
  }

  private void addMapperToAop(SqlSessionManager sqlSessionManager) {
    // 获取所有注册的 Mapper 接口
    Configuration configuration = sqlSessionManager.getConfiguration();
    for (Class<?> mapperClass : configuration.getMapperRegistry().getMappers()) {
      // 获取 Mapper 实例
      Object mapperInstance = sqlSessionManager.getMapper(mapperClass);
      // 将 Mapper 实例添加到 AOP 容器中
      AopManager.me().addSingletonObject(mapperClass, mapperInstance);
      log.info("Mapper [{}] added to AOP", mapperClass.getName());
    }
  }
}

解释：

addMapperToAop 方法：
- 获取 SqlSessionManager 中注册的所有 Mapper 接口。
- 对于每个 Mapper 接口，获取其实例（代理对象）。
- 使用 AopManager.me().addSingletonObject(mapperClass, mapperInstance) 将 Mapper 实例添加到 AOP 容器中。
- 日志输出，便于调试和确认。
为什么要这样做？
- 将 Mapper 添加到 AOP 容器后，可以在需要的地方通过依赖注入的方式获取 Mapper，无需手动调用 getMapper 方法。

2.2. 修改 `MySqlSessionManager`

由于我们现在通过 AOP 容器来获取 Mapper，MySqlSessionManager 中的 getMapper 方法可以不再使用，或者保留以备特殊情况下使用。

package demo.mybatis.config;

import org.apache.ibatis.session.SqlSessionManager;

public class MySqlSessionManager {

  private static SqlSessionManager sqlSessionManager;

  public static void setSqlSessionManager(SqlSessionManager manager) {
    sqlSessionManager = manager;
  }

  public static SqlSessionManager getSqlSessionManager() {
    return sqlSessionManager;
  }

  // 可以保留或删除此方法
  public static <T> T getMapper(Class<T> clazz) {
    return sqlSessionManager.getMapper(clazz);
  }
}

3. 在需要的地方注入 Mapper

3.1. 修改控制器

现在，我们可以在控制器中直接注入 Mapper，而无需手动获取。

package demo.mybatis.controller;

import com.jfinal.kit.Kv;
import nexus.io.annotation.Inject;
import nexus.io.annotation.RequestPath;

import demo.mybatis.mapper.SystemAdminMapper;
import demo.mybatis.model.SystemAdmin;
import lombok.extern.slf4j.Slf4j;

@RequestPath("/SystemAdmin")
@Slf4j
public class SystemAdminController {

  @Inject
  private SystemAdminMapper systemAdminMapper;

  public Kv getSystemAdmin() {
    SystemAdmin systemAdmin = systemAdminMapper.getSystemAdmin(null);
    log.info("systemAdmin:{}", systemAdmin);
    return Kv.by("data", systemAdmin);
  }
}

说明：

@Inject 注解：用于依赖注入，将 systemAdminMapper 自动注入。
直接使用 systemAdminMapper：无需手动获取 Mapper，代码更加简洁。

3.2. 确保注入生效

组件扫描：确保您的 AOP 框架能够扫描到控制器类，以便进行依赖注入。
Mapper 已经添加到 AOP 容器：之前在 MybatisConfig 中已经将 Mapper 添加到了 AOP 容器中。

4. 运行测试

重新启动应用程序，访问以下地址：

http://localhost/SystemAdmin/getSystemAdmin

预期结果：

{ "data": { "id": 1, "password": "00000000", "loginName": "litong" } }

日志输出：

2024-10-07 16:00:00.123 [Thread-20] INFO  d.m.c.SystemAdminController.getSystemAdmin:20 - systemAdmin:SystemAdmin(id=1, loginName=litong, password=00000000)

解释：

systemAdminMapper 已经成功注入，直接调用其方法获取数据。
日志中输出了 systemAdmin 对象的信息，验证了数据的正确性。

5. 原理解释

5.1. AOP 容器管理对象

对象注册：通过 AopManager.me().addSingletonObject() 方法，将对象注册到 AOP 容器中。
依赖注入：在需要的地方使用 @Inject 注解，AOP 容器会自动将匹配的对象注入。
单例模式：注册的对象是单例的，在应用程序中共享同一个实例。

5.2. Mapper 的实例化

Mapper 实例：MyBatis 通过动态代理为 Mapper 接口生成实现（代理对象）。
代理对象：代理对象内部会处理方法调用，执行对应的 SQL 语句。
AOP 容器：将这些代理对象添加到 AOP 容器中，使其可以被自动注入。

5.3. 自动注入的优势

代码简洁：无需手动获取 Mapper，减少样板代码。
解耦合：降低了业务代码与框架代码的耦合度。
维护方便：在需要修改 Mapper 实例的获取方式时，只需修改注册的代码，不影响业务代码。

6. 总结

通过将 MyBatis 的 Mapper 添加到 AOP 容器中，我们实现了自动注入 Mapper 的功能，使得业务代码更加简洁，降低了耦合度。这种方式的优势在于：

简化代码：避免了手动获取 Mapper 的样板代码。
解耦合：业务代码与框架代码解耦，更易于维护和测试。
统一管理：通过 AOP 容器统一管理对象的创建和依赖注入。

在实际开发中，合理利用 AOP 框架的特性，可以大大提高开发效率和代码质量。

示例代码开源地址

https://github.com/litongjava/java-ee-tio-boot-study/tree/main/tio-boot-latest-study/tio-boot-mybatis-study003