使用配置类方式整合 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>1.9.5</tio-boot.version>
  <lombok-version>1.18.30</lombok-version>
  <jfinal-aop.version>1.3.3</jfinal-aop.version>
  <hotswap-classloader.version>1.2.6</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.2.3</version>
  </dependency>

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

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

  <!-- JFinal AOP -->
  <dependency>
    <groupId>com.litongjava</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.2.24</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 com.litongjava.annotation.AComponentScan;
import com.litongjava.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 com.litongjava.annotation.AConfiguration;
import com.litongjava.annotation.AInitialization;
import com.litongjava.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();
  }
}

解释原理：

1. 配置数据源：

   • 使用 PooledDataSource 配置数据库连接池，设置驱动、URL、用户名和密码。

2. 创建 MyBatis 配置对象：

   • 创建 Configuration 实例，设置日志实现为 StdOutImpl，日志将输出到控制台。

3. 注册类型别名：

   • 通过 configuration.getTypeAliasRegistry().registerAliases("demo.mybatis.model") 注册指定包下的所有类为类型别名。
   • 这样在映射文件中，可以直接使用类名，而无需全限定名。

4. 配置环境：

   • 创建 Environment，包含事务管理器 JdbcTransactionFactory 和数据源。
   • 设置环境到配置对象中。

5. 添加 Mapper：

   • 调用 addMapper 方法，手动加载并解析 Mapper XML 文件。
   • 使用 XMLMapperBuilder 解析 XML，并注册映射关系到配置对象。

6. 构建 SqlSessionManager：

   • 使用 SqlSessionManager.newInstance(configuration) 创建 SqlSessionManager，这是 MyBatis 提供的线程安全的 SqlSession 管理器。
   • 将 SqlSessionManager 设置到 MySqlSessionManager 中，以供全局使用。

7. 资源管理：

   • 通过 HookCan.me().addDestroyMethod 方法，在应用关闭时，自动关闭 SqlSessionManager，释放资源。

为什么要这样做？

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

八、控制器

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

package demo.mybatis.controller;

import com.jfinal.kit.Kv;
import com.litongjava.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 com.litongjava.annotation.AConfiguration;
import com.litongjava.annotation.AInitialization;
import com.litongjava.jfinal.aop.AopManager;
import com.litongjava.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 com.litongjava.annotation.Inject;
import com.litongjava.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