Tio-Boot 整合 MyBatis

简介

Tio-Boot：Tio-Boot 是一个高性能的 Java 网络编程框架，用于快速构建 Web、WebSocket、TCP 等网络应用。在本教程中，我们将使用 Tio-Boot 启动一个简单的 Web 服务，以演示如何与 MyBatis 整合。

MyBatis：MyBatis 是一个持久层框架，简化了 Java 对象与关系型数据库之间的映射。在本教程中，我们将使用 MyBatis 配置数据源、映射文件和 Mapper 接口，以实现与数据库的交互。

使用工具类和配置文件整合 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.8.7</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：mybatis 依赖用于使用 MyBatis 框架进行对象关系映射。
• Druid：druid 依赖提供了高效的数据库连接池。
• PostgreSQL 驱动：postgresql 依赖使您的应用能够连接到 PostgreSQL 数据库。

**注意：**如果您使用的是 MySQL 而非 PostgreSQL，请将 PostgreSQL 依赖替换为 MySQL 连接器：

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.46</version>
</dependency>

准备模拟数据

在您的数据库中创建表并插入示例数据。

SQL 脚本：

CREATE TABLE system_admin (
  id SERIAL PRIMARY KEY,
  login_name VARCHAR(32),
  password VARCHAR(32)
);

INSERT INTO system_admin (login_name, password) VALUES ('litong', '00000000');

说明：

1. 创建表：

   • 创建一个名为 system_admin 的表，包含以下字段：
     • id：自增主键。
     • login_name：最大长度为 32 的字符串。
     • password：最大长度为 32 的字符串。

2. 插入数据：

   • 向 system_admin 表中插入一条记录，login_name 为 'litong'，password 为 '00000000'。

验证：

运行以下查询以确保数据已正确插入：

SELECT * FROM system_admin;

启动 Tio-Boot

创建 IndexController

创建一个控制器类来处理传入的 HTTP 请求。

package demo.mybatis.controller;

import com.litongjava.annotation.RequestPath;

@RequestPath("/")
public class IndexController {

  @RequestPath()
  public String index() {
    return "index";
  }

}

说明：

• @RequestPath("/") 注解将控制器映射到根 URL（/）。
• index() 方法响应根 URL 的 HTTP GET 请求，返回简单的字符串 "index"。

创建主应用程序类

创建主应用程序类以引导您的 Tio-Boot 应用。

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 注解启用了组件扫描，使 Tio-Boot 能够检测并注册控制器等组件。
• main 方法通过调用 TioApplication.run() 启动应用程序。

运行应用程序

启动 MybatisApp 类。如果应用程序成功启动，您应该能够在浏览器中访问 http://localhost 并看到来自 IndexController 的响应。

整合 MyBatis

创建模型类

创建与 system_admin 表对应的模型类。

package demo.mybatis.model;

import lombok.Data;

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

说明：

• @Data 注解来自 Lombok，自动生成 getter、setter 和其他实用方法。
• 类字段 id、loginName 和 password 直接映射到 system_admin 表的列。

创建 Mapper 接口

为 SystemAdmin 模型创建一个 Mapper 接口。

package demo.mybatis.mapper;

import demo.mybatis.model.SystemAdmin;

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

说明：

• SystemAdminMapper 接口定义了一个方法 getSystemAdmin，用于从数据库中检索 SystemAdmin 对象。

创建 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>

说明：

• 命名空间： namespace 属性应与 SystemAdminMapper 接口的全限定名匹配。
• ResultMap：
  • <resultMap> 元素定义了数据库列如何映射到 SystemAdmin 类的字段。
  • autoMapping="true" 启用了基于字段名的自动映射。
• Select 语句：
  • <select> 元素为 getSystemAdmin 方法定义了 SQL 查询。
  • <if> 元素在提供 loginName 时向查询添加条件。

创建 MyBatis 配置文件

在您的资源目录中创建 mybatis.xml。

<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
  <!-- 启用 SQL 语句的日志记录 -->
  <settings>
    <setting name="logImpl" value="STDOUT_LOGGING" />
  </settings>

  <!-- 类型别名 -->
  <typeAliases>
    <package name="demo.mybatis.model" />
  </typeAliases>

  <!-- 环境配置 -->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC" />

      <dataSource type="UNPOOLED">
        <property name="driver" value="org.postgresql.Driver" />
        <property name="url" value="jdbc:postgresql://192.168.3.9/defaultdb" />
        <property name="username" value="postgres" />
        <property name="password" value="123456" />
      </dataSource>
    </environment>
  </environments>

  <!-- 映射器 -->
  <mappers>
    <mapper resource="SystemAdminMapper.xml" />
  </mappers>
</configuration>

说明：

• 设置：
  • <setting name="logImpl" value="STDOUT_LOGGING" /> 将 SQL 语句的日志输出到控制台。
• 类型别名：
  • <package name="demo.mybatis.model" /> 允许您在映射文件中使用简化的类名。
• 环境配置：
  • 定义数据库连接设置。
  • 事务管理器： 设置为 JDBC 以使用 JDBC 事务。
  • 数据源： 指定数据库驱动、URL、用户名和密码。
• 映射器：
  • 注册 SystemAdminMapper.xml 文件到 MyBatis。

**注意：**请根据您的环境替换数据库连接属性。

创建 MyBatis 的工具类

创建 MybatisUtils，以管理 SqlSessionFactory 并提供打开 SqlSession 的方法。

package demo.mybatis.utils;

import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MybatisUtils {

  private static final String RESOURCE = "mybatis.xml";
  private static SqlSessionFactory factory;

  static {
    try (InputStream inputStream = Resources.getResourceAsStream(RESOURCE)) {
      factory = new SqlSessionFactoryBuilder().build(inputStream);
    } catch (IOException e) {
      e.printStackTrace();
      throw new RuntimeException("Error initializing SqlSessionFactory", e);
    }
  }

  /**
   * 返回 SqlSessionFactory。
   */
  public static SqlSessionFactory getFactory() {
    return factory;
  }

  /**
   * 打开新的 SqlSession。
   *
   * @param autoCommit 是否自动提交事务
   * @return 新的 SqlSession
   */
  public static SqlSession openSession(boolean autoCommit) {
    return factory.openSession(autoCommit);
  }

  /**
   * 打开自动提交的 SqlSession。
   *
   * @return 新的 SqlSession
   */
  public static SqlSession openSession() {
    return factory.openSession(true);
  }

}

说明：

• 静态初始化块：
  • 在类加载时初始化 SqlSessionFactory。
  • 从 mybatis.xml 加载 MyBatis 配置。
• 方法：
  • getFactory()：返回 SqlSessionFactory。
  • openSession(boolean autoCommit)：使用指定的 autoCommit 设置打开新的 SqlSession。
  • openSession()：打开 autoCommit 设置为 true 的新 SqlSession。

在控制器中使用 Mapper

创建 MybatisController，使用 SystemAdminMapper 并检索数据。

package demo.mybatis.controller;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import com.jfinal.kit.Kv;
import com.litongjava.annotation.RequestPath;

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

@Slf4j
@RequestPath("/mybatis")
public class MybatisController {

  @RequestPath("/getMapper")
  public Kv getMapper() {
    SqlSessionFactory factory = MybatisUtils.getFactory();
    log.info("factory: {}", factory);

    try (SqlSession sqlSession = MybatisUtils.openSession()) {
      log.info("sqlSession: {}", sqlSession);

      SystemAdminMapper mapper = sqlSession.getMapper(SystemAdminMapper.class);
      log.info("mapper: {}", mapper);

      SystemAdmin systemAdmin = mapper.getSystemAdmin(null);
      log.info("systemAdmin: {}", systemAdmin);

      Kv kv = Kv.by("data", systemAdmin);
      return kv;
    } catch (Exception e) {
      log.error("Error fetching SystemAdmin", e);
      return Kv.by("error", e.getMessage());
    }
  }
}

说明：

• 日志记录：
  • @Slf4j 注解为类提供了一个日志记录器。
  • 添加日志以跟踪执行流程并捕获重要信息。
• 接口：
  • @RequestPath("/getMapper") 注解将 getMapper 方法映射到 /mybatis/getMapper URL。
• 数据库交互：
  • 获取 SqlSessionFactory 并打开新的 SqlSession。
  • 从 SqlSession 获取 SystemAdminMapper。
  • 调用 getSystemAdmin 从数据库中检索数据。
• 响应：
  • 返回包含检索到的数据的 Kv 对象。

错误处理：

• 捕获并记录异常。
• 如果发生异常，在响应中返回错误消息。

测试整合

访问端点以测试 MyBatis 的整合。

URL：

http://localhost/mybatis/getMapper

预期的 JSON 响应：

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

说明：

• 响应包含从数据库检索到的 SystemAdmin 数据。
• 如果数据与先前插入的示例数据匹配，则整合成功。

示例日志输出：

INFO  [main] MybatisController - factory: org.apache.ibatis.session.defaults.DefaultSqlSessionFactory@23e97c4d
INFO  [main] MybatisController - sqlSession: org.apache.ibatis.session.defaults.DefaultSqlSession@303eef5f
INFO  [main] MybatisController - mapper: org.apache.ibatis.binding.MapperProxy@7a1b8606
INFO  [main] MybatisController - systemAdmin: SystemAdmin(id=1, loginName=litong, password=00000000)

其他注意事项

• 配置管理：
  • 考虑使用属性文件或环境变量将数据库 URL、用户名和密码等配置属性外部化。
• 异常处理：
  • 增强错误处理，提供更友好的用户消息或错误代码。
• 日志级别：
  • 适当调整日志级别，以避免在生产环境中产生过多的日志。
• 安全考虑：
  • 在日志中记录敏感信息（如密码）时要谨慎。
• 依赖版本：
  • 保持依赖项的更新，以利用安全补丁和新功能。
• 资源管理：
  • 始终关闭 SqlSession 和其他资源，以防止资源泄漏。

结论

通过本教程，您已经成功地将 MyBatis 与 Tio-Boot 整合，并使用 MyBatis 的 Mapper 执行了数据库操作。此设置为构建具有高效数据库交互的可扩展 Web 应用程序提供了坚实的基础。

使用配置类和配置文件整合 MyBatis

使用配置类整合 MyBatis

在本节中，我们将通过使用配置类来整合 MyBatis，并演示如何在代码中配置 MyBatis，同时仍然使用 mybatis.xml 配置文件。

添加依赖

在 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.8.7</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 驱动。

创建 MySqlSessionManager

MySqlSessionManager 用于管理 SqlSession，以便在应用程序中共享 SqlSession 实例。

package demo.mybatis.config;

import org.apache.ibatis.session.SqlSession;

public class MySqlSessionManager {

  private static SqlSession sqlSession;

  public static SqlSession getSqlSession() {
    return sqlSession;
  }

  public static void setSqlSession(SqlSession sqlSession) {
    MySqlSessionManager.sqlSession = sqlSession;
  }

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

说明：

• getSqlSession()：获取当前的 SqlSession 实例。
• setSqlSession(SqlSession sqlSession)：设置当前的 SqlSession 实例。
• getMapper(Class<T> clazz)：从 SqlSession 获取指定类型的 Mapper。

创建 MybatisConfig 配置类

MybatisConfig 使用 MyBatis 框架来配置数据库会话，并通过配置类的方式管理 SqlSession 的创建。

package demo.mybatis.config;

import java.io.IOException;
import java.io.Reader;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.litongjava.annotation.ABean;
import com.litongjava.annotation.AConfiguration;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@AConfiguration
public class MybatisConfig {

  // 配置文件名称
  private String mybatisConfigXml = "mybatis.xml";

  /**
   * 获取 SqlSession，并将其注册为 Bean，应用关闭时自动销毁。
   *
   * @return SqlSession 实例
   */
  @ABean(destroyMethod = "close")
  public SqlSession getSqlSession() {
    Reader reader = null;
    try {
      reader = Resources.getResourceAsReader(mybatisConfigXml);
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
      // 打开一个新的数据库会话
      SqlSession sqlSession = sqlSessionFactory.openSession();
      MySqlSessionManager.setSqlSession(sqlSession);
      return sqlSession;
    } catch (IOException e) {
      log.error("无法获取 SqlSession", e);
      return null;
    }
  }
}

说明：

• 加载配置文件：通过 Resources.getResourceAsReader(mybatisConfigXml) 加载 mybatis.xml 配置文件。
• 创建 SqlSessionFactory：使用 SqlSessionFactoryBuilder 构建 SqlSessionFactory。
• 获取 SqlSession：从 SqlSessionFactory 打开一个新的 SqlSession。
• 注册 SqlSession：将 SqlSession 设置到 MySqlSessionManager 中，方便全局使用。

配置文件

在上述配置中，mybatis.xml 文件依然被使用，因此需要确保该文件存在并正确配置。

mybatis.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>
    <setting name="logImpl" value="STDOUT_LOGGING" />
  </settings>

  <!-- 类型别名 -->
  <typeAliases>
    <package name="demo.mybatis.model" />
  </typeAliases>

  <!-- 环境配置 -->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC" />
      <dataSource type="UNPOOLED">
        <property name="driver" value="org.postgresql.Driver" />
        <property name="url" value="jdbc:postgresql://localhost:5432/your_database" />
        <property name="username" value="your_username" />
        <property name="password" value="your_password" />
      </dataSource>
    </environment>
  </environments>

  <!-- 映射器 -->
  <mappers>
    <mapper resource="SystemAdminMapper.xml" />
  </mappers>
</configuration>

说明：

• 数据源配置：在 <dataSource> 节点中配置数据库连接信息，请根据实际情况修改。
• 映射器注册：在 <mappers> 节点中注册 SystemAdminMapper.xml，确保映射器文件被 MyBatis 识别。

在 Controller 中获取 Mapper

创建 MybatisController2，演示如何获取所有注册的 Mapper 并返回其信息。

package demo.mybatis.controller;

import java.util.Collection;

import org.apache.ibatis.binding.MapperRegistry;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;

import com.litongjava.annotation.RequestPath;

import demo.mybatis.config.MySqlSessionManager;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequestPath("/mybatis2")
public class MybatisController2 {

  @RequestPath("/getMappers")
  public String getMappers() {
    SqlSession sqlSession = MySqlSessionManager.getSqlSession();
    Configuration configuration = sqlSession.getConfiguration();
    MapperRegistry mapperRegistry = configuration.getMapperRegistry();
    Collection<Class<?>> mappers = mapperRegistry.getMappers();
    for (Class<?> c : mappers) {
      log.info("已注册的 Mapper：{}", c.getName());
    }
    return mappers.toString();
  }
}

说明：

• 获取 SqlSession：从 MySqlSessionManager 获取当前的 SqlSession。
• 获取配置：通过 sqlSession.getConfiguration() 获取 MyBatis 的配置对象。
• 获取 Mapper 注册表：从配置中获取 MapperRegistry。
• 遍历 Mapper：获取所有已注册的 Mapper 并输出其类名。

测试接口：

访问 http://localhost/mybatis2/getMappers，将返回所有已注册的 Mapper 的信息。

测试 SystemAdminController

创建 SystemAdminController，演示如何通过 Mapper 获取数据库中的数据。

package demo.mybatis.controller;

import com.litongjava.annotation.RequestPath;

import demo.mybatis.config.MySqlSessionManager;
import demo.mybatis.mapper.SystemAdminMapper;
import demo.mybatis.model.SystemAdmin;

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

  @RequestPath("/getSystemAdmin")
  public SystemAdmin getSystemAdmin() {
    SystemAdminMapper mapper = MySqlSessionManager.getMapper(SystemAdminMapper.class);
    SystemAdmin systemAdmin = mapper.getSystemAdmin(null);
    return systemAdmin;
  }
}

说明：

• 获取 Mapper：使用 MySqlSessionManager.getMapper(SystemAdminMapper.class) 获取 SystemAdminMapper 实例。
• 查询数据：调用 mapper.getSystemAdmin(null) 方法，从数据库中查询 SystemAdmin 数据。
• 返回结果：将查询到的 SystemAdmin 对象返回。

测试接口：

访问 http://localhost/SystemAdmin/getSystemAdmin，将返回数据库中的 SystemAdmin 数据，例如：

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

重要说明

• 仍然使用了 mybatis.xml：尽管使用了配置类 MybatisConfig，但仍然通过读取 mybatis.xml 文件来加载 MyBatis 的配置。这种方式结合了配置类和 XML 配置文件的优点。

• 配置类的作用：MybatisConfig 的主要作用是通过代码方式管理 SqlSession 的创建和生命周期，使其更符合应用程序的管理方式。

• 为什么使用 mybatis.xml：使用 XML 配置文件可以集中管理 MyBatis 的各种配置，如环境、数据源、Mapper 映射等，使配置更直观清晰。

总结

通过本节的内容，我们了解了如何使用配置类来整合 MyBatis，同时仍然使用 mybatis.xml 配置文件。我们创建了 MySqlSessionManager 来管理 SqlSession，并通过 MybatisConfig 配置类来加载 MyBatis 配置和创建 SqlSession。

在控制器中，我们展示了如何获取 Mapper 并查询数据库数据。通过这些步骤，成功地实现了 MyBatis 与 Tio-Boot 的整合。

完全使用配置类方式整合

下一篇