Mybatis-MyBatis简介 / 搭建Mybatis

MyBatis，作为当今广泛使用的Java持久层框架，其起源可以追溯到名为iBatis的开源项目。iBatis最初是由Apache Software Foundation托管的一个开源项目，旨在简化Java应用程序中的数据库交互，尤其是通过减少直接使用JDBC时所需的大量样板代码来提升开发效率。持久层框架是软件开发中的一种工具，用于方便、高效且安全地让应用程序与数据库（或其他持久化存储）进行交互。

文章共8,553字 · 阅读需要大约29分钟

一键AI生成摘要，助你高效阅读

问答

程序员雨空集

1030人浏览 · 2024-03-23 19:06:16

程序员雨空集 · 2024-03-23 19:06:16 发布

1. MyBatis简介

1.1. MyBatis历史

MyBatis，作为当今广泛使用的Java持久层框架，其起源可以追溯到名为iBatis的开源项目。iBatis最初是由Apache Software Foundation托管的一个开源项目，旨在简化Java应用程序中的数据库交互，尤其是通过减少直接使用JDBC时所需的大量样板代码来提升开发效率。

持久层框架：

持久层框架是软件开发中的一种工具，用于方便、高效且安全地让应用程序与数据库（或其他持久化存储）进行交互。它主要做两件事：

抽象化数据访问：隐藏复杂的数据库操作细节（如连接管理、SQL语句编写、结果处理等），提供简洁的API供程序员使用，减少与特定数据库技术的直接依赖，使代码更易于维护和移植。
简化常见任务：内置对象关系映射（ORM）、事务管理、查询构建、缓存等功能，自动化处理数据持久化过程中的繁琐工作，大幅减轻开发者负担，提高开发效率。

通过使用持久层框架，开发者可以专注编写业务逻辑，而无需过分关注如何与数据库进行低级别的交互，从而提升了软件的整体质量和开发速度。例如，Hibernate、MyBatis、JPA（及其各种实现）和Spring Data等都是广泛使用的Java持久层框架。

在2010年6月，iBatis项目经历了一次重要的迁移，开发团队将其从Apache迁移到了Google Code平台。伴随着这次平台变更，项目名称也随之更新，iBatis的3.x版本正式更名为了MyBatis。这一变化不仅反映了项目的新归属，也标志着其发展进入了一个新的阶段。

随着时间推移，MyBatis的源代码进一步迁移至GitHub，这一举措发生在2013年11月，顺应了开源社区日益倾向于使用GitHub进行代码托管和协作的趋势。

关于名称的由来，“iBatis”结合了“internet”和“abatis”两个词。其中，“internet”暗示了该项目在互联网时代背景下为应用程序提供数据访问能力的定位，而“abatis”原指一种用倒置树枝构成的防御工事，这里隐喻框架为应用程序提供了稳固的数据防护屏障。

作为一款持久层框架，MyBatis的核心功能集中在以下两方面：

SQL Maps：MyBatis允许开发者以XML或注解的方式定义SQL语句，并将这些语句与Java方法进行映射。这样，当调用相应的方法时，框架会自动执行对应的SQL查询或更新操作。这种方式将SQL逻辑与业务逻辑分离，使得代码更加清晰且易于维护。
Data Access Objects (DAOs)：MyBatis支持构建数据访问对象接口及其实现类，这些对象封装了对数据库的底层交互细节。通过使用MyBatis生成的代理对象或者手动编写实现类，开发者可以编写面向接口的代码，专注于定义数据访问的契约，而具体的SQL执行和结果处理则交由MyBatis框架处理。

总结来说，MyBatis起源于iBatis项目，经历了从Apache到Google Code再到GitHub的平台变迁，并在更名后继续发展成为一款深受Java开发者喜爱的持久层框架。它通过提供SQL Maps和DAO支持，有效地简化了Java应用程序中的数据库访问，促进了代码的模块化和可维护性。

1.2. MyBatis特性

MyBatis作为一款持久层框架，具备以下核心特性：

定制化SQL与存储过程支持：
MyBatis鼓励并方便开发者直接编写SQL语句，无论是简单查询、复杂联接还是批量操作，都可以根据实际需求精确控制。这与一些全自动ORM框架（如Hibernate）不同，后者往往通过自动生成SQL来实现对象关系映射，而可能牺牲了SQL优化的灵活性。此外，MyBatis还支持调用存储过程，这对于那些依赖特定数据库功能或需要高性能批处理的应用场景尤为有用。
JDBC操作自动化：
使用MyBatis，开发者无需编写大量的JDBC代码来建立数据库连接、创建Statement或PreparedStatement、手动设置参数、处理结果集等。框架负责这些繁琐任务的封装与管理，极大地减少了出错概率和编码工作量。开发者只需关注如何编写SQL以及如何将查询结果映射到Java对象上，大大提升了开发效率。
XML或注解配置与映射：
MyBatis提供了两种灵活的方式来配置SQL语句和映射关系。一是传统的XML文件，其中可以详细定义SQL、参数映射、结果映射等信息。这种方式结构清晰，适合复杂查询和团队协作。二是利用注解直接在Java接口或类中声明SQL与映射规则，使得代码更为紧凑，对于简单场景或偏好代码内联配置的开发者来说更为便捷。无论选择哪种方式，MyBatis都能够将接口方法与相应的SQL语句关联起来，并自动将查询结果映射到指定的Java POJO（Plain Old Java Objects）对象上，实现了对象与数据库记录之间的无缝转换。
半自动ORM特性：
虽然MyBatis能够处理对象与数据库表之间的映射，但它并非完全意义上的全自动ORM框架。相较于全自动化框架，MyBatis在对象关系映射的级别上更为轻量化，它侧重于SQL的直接操纵和结果的定制映射，而非试图完全隐藏SQL。开发者需要显式地编写SQL语句，并在某些情况下明确指定对象属性与数据库字段之间的对应关系。这种设计保留了对SQL的精细控制，有利于针对特定数据库特性和查询性能进行优化，但同时也意味着在处理复杂对象关系时可能需要更多的手动配置。

综上所述，MyBatis以其对定制化SQL的友好支持、对JDBC操作的高度自动化、灵活的配置与映射方式以及独特的半自动ORM特性，为Java开发者提供了一个强大且高效的数据库访问解决方案，尤其适用于那些重视SQL优化、需要直接控制数据访问细节或者寻求轻量级持久层框架的项目。

1.3. MyBatis下载

MyBatis下载地址：https://github.com/mybatis/mybatis-3

往下找，点Download Latest，即下载最新版

zip是windows的，gz是linux的

下载后，解压即可

1.4. 和其它持久化层技术对比

JDBC：

问题：SQL语句直接嵌入Java代码中，导致高度耦合，代码可读性和可维护性降低。一旦SQL发生变化，需要在多处修改Java代码，维护成本较高。此外，JDBC编程涉及大量样板代码（如连接管理、预编译语句、结果集遍历等），使得代码显得冗长，开发效率较低。

Hibernate与JPA：

优点：提供高级API，简化数据访问操作，提高开发效率。通过对象关系映射（ORM），可以以面向对象的方式操作数据库，避免直接编写SQL。
问题：

- 复杂SQL处理：对于一些复杂的、定制化的SQL查询，可能需要绕过框架的自动映射机制，使用原生SQL或特定API来执行，增加了复杂性。
- SQL优化受限：框架内部自动生成的SQL可能难以针对特定场景进行深度优化，特别是在需要精细控制查询性能时，可能需要额外工作来调整或扩展框架行为。
- 部分映射挑战：对于包含大量字段的实体类，如果只需要映射其中一部分到数据库，可能需要额外配置或自定义映射策略，相对于全映射场景可能更为复杂。
- 性能考虑：由于大量使用反射机制进行对象与数据库记录之间的转换，可能在某些情况下对数据库性能产生一定影响，尤其是在大规模数据处理或高并发场景下，可能需要通过调优或采用其他策略来减轻潜在性能开销。

简而言之，JDBC虽然直接且灵活，但代码耦合度高、维护困难且开发效率低。而Hibernate与JPA通过提供高级抽象简化了开发，但处理复杂SQL、进行特殊优化以及处理部分映射场景时可能面临挑战，且过度使用反射可能对性能有一定影响。选择合适的持久化技术需权衡项目的具体需求、开发团队的熟悉程度、性能要求以及维护成本等因素。

2. 搭建MyBatis

2.1. 创建maven工程

添加依赖，根据实际情况来

<dependencies>
        <!-- Mybatis核心 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.15</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
    </dependencies>

设置打包方式

<packaging>jar</packaging>

完整pom.xml内容

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.sakurapaid.mybatis3</groupId>
    <artifactId>Mybatis3</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <packaging>jar</packaging>
    
    <dependencies>
        <!-- Mybatis核心 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.15</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

检查依赖

2.2. 创建Mybatis核心配置文件

关于MyBatis配置文件：

文件命名与灵活性：

- mybatis-config.xml 是MyBatis推荐使用的配置文件名称，这是一个习惯性的约定，而非强制规定。开发者可以根据项目实际情况和团队规范自由命名该文件，只要在实际使用时正确指向该配置文件即可。

整合Spring后的影响：

- 当将MyBatis与Spring框架集成时，许多MyBatis的配置信息（包括数据库连接信息和全局配置）可以移至Spring的配置文件（如applicationContext.xml或使用Java配置类）中进行统一管理。这种情况下，原有的MyBatis核心配置文件（如mybatis-config.xml）的部分或全部内容可以被Spring配置替代，因此在整合Spring后，这个单独的MyBatis配置文件可能不再必要，可以省略。

核心配置文件的作用：

- 连接数据库的环境配置：该文件用于定义如何连接到目标数据库，通常包括数据库驱动、URL、用户名、密码等基本信息，以及数据源（DataSource）的相关配置。这些配置确保应用程序能够正确建立与数据库的连接，执行CRUD操作。
- MyBatis全局配置信息：

- - 设置MyBatis的行为特性：如开启或关闭缓存、设置默认的执行器类型（简单/批处理）、指定是否自动映射结果集等，这些配置会影响到MyBatis的整体运行行为和性能。
  - 定义事务管理器：可以配置事务管理策略，如使用JDBC、MANAGED（由容器如Spring管理事务）或其他自定义方式。
  - 映射器（Mapper）的注册：指定映射文件（mapper XML文件或注解类）的位置，使MyBatis能够找到并加载对应的SQL映射定义。
  - 类型别名：为Java类型定义简短的别名，简化XML映射文件中的类型引用。
  - 插件配置：启用和配置MyBatis的插件（如日志插件、分页插件等），以增强或扩展MyBatis的功能。

总结：
MyBatis的核心配置文件mybatis-config.xml用于集中配置数据库连接信息及MyBatis的全局行为选项。虽然其名称非强制，但在实际使用中通常遵循这一约定。当与Spring框架集成时，许多配置项可迁移至Spring配置中，使得单独的MyBatis配置文件变得可选甚至可以省略。理解并掌握这个配置文件的内容有助于高效地管理和配置MyBatis数据访问层。

创建mybatis-config.xml核心配置文件

存放位置：

文件里面写什么呢，这就要看官方文件里面了

mybatis – MyBatis 3 | 简介

改不改中文界面，取决于你自己

复制这一段内容

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
    
</configuration>

配置连接池的属性，这就根据实际情况来咯

最后别放错位置

2.3. 创建Mapper接口

MyBatis的Mapper接口类似于传统DAO（数据访问对象），但更简洁：

无实现类：
Mapper接口仅定义方法签名，无需编写实现类。具体数据库操作由MyBatis框架自动完成。
直接映射SQL：
每个接口方法对应一个SQL语句（查询、更新等）。SQL与方法的映射关系在XML文件或注解中配置。
简化开发：
开发者专注于定义方法，无需处理JDBC细节。修改SQL不影响接口或业务代码，利于维护。
框架自动生成代理执行：
MyBatis利用动态代理为Mapper接口创建代理对象，实际数据库操作由框架在背后处理。

简而言之，Mapper接口是MyBatis提供的轻量级DAO，仅声明方法，无需实现。框架依据映射规则执行SQL，简化开发，提升代码清晰度和维护性。

在这之前我先建表添加数据(￣▽￣)／

建表添加数据

create table user
(
    id   int         not null,
    name varchar(20) null comment '姓名',
    age  int         null comment '年龄',
    sex  varchar(20) null comment '性别',
    constraint user_pk
        primary key (id)
)
    comment '用户表';

创建相关类

package com.sakurapaid.mybatis3.demo01.bean;

public class User {
    private int id;
    private String name;
    private int age;
    private String sex;
    
    //构造函数、getter、setter方法...
}

创建Mapper结构

package com.sakurapaid.mybatis3.demo01.mapper;

import java.util.List;

public interface UserMapper {
    List<User> selectAll();
}

2.4. 创建MyBatis的映射文件

创建MyBatis的映射文件是为了实现ORM（Object-Relational Mapping，对象关系映射）这一概念，它是一种编程技术，用于将面向对象的程序设计语言（如Java）中的实体类对象与关系型数据库中的表结构及数据建立一种对应关系。

对象（Objects）：
这些是Java应用程序中的实体类对象，代表业务模型中的对象实例。比如，一个User类可能包含属性如id、username、password等，以及相应的getter和setter方法。它们封装了业务逻辑和数据，构成了程序的领域模型。

关系（Relationships）：
这里指关系型数据库（如MySQL、PostgreSQL等）中的表、字段以及表间的关系（如外键关联）。数据库表用来存储数据，每个表有若干列（字段）来描述不同的数据项，行（记录）则代表具体的数据实例。表之间可以通过外键约束来表达一对多、一对一或多对多的关系。

映射（Mapping）：
映射是将上述对象世界与关系世界连接起来的过程，它定义了如何将实体类的对象属性与数据库表的字段对应起来，如何将对象间的操作（如创建、读取、更新、删除）转换为对应的SQL操作，以及如何处理复杂的表关系。映射还涵盖了对象集合与数据库查询结果集的转换规则。

在MyBatis中，创建映射文件就是编写一个XML文件，它包含了这些映射关系的具体定义。这个XML文件通常遵循以下要点：

命名规则：
映射文件通常以对应的Java Mapper接口名为基础命名，后缀为.xml。例如，对于名为UserMapper的接口，映射文件应命名为UserMapper.xml。
文件结构：
文件以<mapper>元素作为根节点，其namespace属性设置为Mapper接口的全限定名，以便框架识别。
SQL映射：
在<mapper>内部，定义各种SQL语句（如<select>, <insert>, <update>, <delete>等）作为子元素。每个SQL元素都有一个id属性，作为接口方法与SQL语句的唯一标识符。
参数绑定与结果映射：
SQL语句可以使用${}或#{}占位符来动态绑定接口方法传入的参数。结果映射（如<resultMap>）定义了查询结果如何与实体类的属性一一对应，包括复杂的嵌套关系和自动类型转换。

通过这样的映射文件，MyBatis能够在运行时根据调用的Mapper接口方法找到对应的SQL语句，执行数据库操作，然后自动将查询结果转化为Java对象返回给应用程序，反之亦然。这样，开发者无需手动编写大量的JDBC代码，专注于业务逻辑，同时保持了对象模型与数据库结构的解耦，提高了开发效率和代码可维护性。

Java概念	数据库概念
类	表
属性	字段 / 列
对象	记录 / 行

创建UserMapper接口的映射文件

这个同样有代码模板，也在官方文档里有

mybatis – MyBatis 3 | 入门

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.mybatis.example.BlogMapper">
  <select id="selectBlog" resultType="Blog">
    select * from Blog where id = #{id}
  </select>
</mapper>

创建完映射文件后记得在核心配置文件里添加相关映射

2.5. 通过junit测试功能

在这之前在UserMapper.xml映射文件里新增一个查询语句

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 定义mapper接口的命名空间 -->
<mapper namespace="com.sakurapaid.mybatis3.demo01.mapper.UserMapper">
    
    <select id="selectAll" resultType="com.sakurapaid.mybatis3.demo01.bean.User">
        select * from user
    </select>
    
</mapper>

创建测试类测试输出

package com.sakurapaid.mybatis3.demo01.test;

import com.sakurapaid.mybatis3.demo01.bean.User;
import com.sakurapaid.mybatis3.demo01.mapper.UserMapper;
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 org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * 用户测试类
 */
public class UserTest {
    
    /**
     * 测试方法
     * 无参数
     * 无返回值
     * 功能描述：通过MyBatis查询所有用户信息并打印
     */
    @Test
    public void test() throws IOException {
        // 加载MyBatis的核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        // 使用配置文件构建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 通过SqlSessionFactoryBuilder构建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = builder.build(is);
        // 打开一个SqlSession会话
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 获取UserMapper接口的实现对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 查询所有用户信息
        List<User> list = mapper.selectAll();
        // 遍历并打印用户信息
        for (User user : list) {
            System.out.println(user);
        }
    }
}

2.6. 加入log4j2日志功能

在MyBatis框架中使用Log4j2日志功能，目的是：

快速定位问题：
当程序遇到错误或运行缓慢时，通过查看Log4j2记录的SQL语句、输入参数和执行时间等详细日志，能迅速找出问题根源。
满足合规与审计：
Log4j2记录所有数据库操作，确保每一项数据访问均可被追溯，符合内部管理和法规对数据访问记录的要求。
灵活定制日志：
可以自由设置日志级别（如详细、普通、警告、错误），选择日志输出位置（如控制台、文件、网络服务等），便于日志的查看、分析与管理。

总之，Log4j2为MyBatis用户提供了强大的日志记录能力，助力他们轻松排查问题、确保数据访问合规、有效监控与管理数据库操作，从而提升程序稳定性、效率和合规性。

加入依赖

<!--log4j2的依赖-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.19.0</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j2-impl</artifactId>
    <version>2.19.0</version>
</dependency>

加入日志配置文件

log4j2的配置文件名为log4j2.xml，存放的位置是src/main/resources目录下

注意本地生成的日志文件位置

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <loggers>
        <!--
            level指定日志级别，从低到高的优先级：
                TRACE < DEBUG < INFO < WARN < ERROR < FATAL
                trace：追踪，是最低的日志级别，相当于追踪程序的执行
                debug：调试，一般在开发中，都将其设置为最低的日志级别
                info：信息，输出重要的信息，使用较多
                warn：警告，输出警告的信息
                error：错误，输出错误信息
                fatal：严重错误
        -->
        <root level="DEBUG">
            <appender-ref ref="spring6log"/>
            <appender-ref ref="RollingFile"/>
            <appender-ref ref="log"/>
        </root>
    </loggers>

    <appenders>
        <!--输出日志信息到控制台-->
        <console name="spring6log" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/>
        </console>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
        <File name="log" fileName="F:/Program/Mybatis3Log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

        <!-- 这个会打印出所有的信息，
            每次大小超过size，
            则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，
            作为存档-->
        <RollingFile name="RollingFile" fileName="F:/Program/Mybatis3Log/app.log"
                     filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
            <SizeBasedTriggeringPolicy size="50MB"/>
            <!-- DefaultRolloverStrategy属性如不设置，
            则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>
    </appenders>
</configuration>

测试一下

运行刚才那个UserTest测试类，就出现了下面一大堆的日志消息，方便以后出问题找bug时快速高效

F:\Develop\JDK8\bin\java.exe -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:F:\Develop\IDEA\IntelliJ IDEA 2023.3.3\lib\idea_rt.jar=10441:F:\Develop\IDEA\IntelliJ IDEA 2023.3.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\Users\ASUS\.m2\repository\org\junit\platform\junit-platform-launcher\1.10.2\junit-platform-launcher-1.10.2.jar;C:\Users\ASUS\.m2\repository\org\junit\platform\junit-platform-engine\1.10.2\junit-platform-engine-1.10.2.jar;C:\Users\ASUS\.m2\repository\org\opentest4j\opentest4j\1.3.0\opentest4j-1.3.0.jar;C:\Users\ASUS\.m2\repository\org\junit\platform\junit-platform-commons\1.10.2\junit-platform-commons-1.10.2.jar;C:\Users\ASUS\.m2\repository\org\apiguardian\apiguardian-api\1.1.2\apiguardian-api-1.1.2.jar;C:\Users\ASUS\.m2\repository\org\junit\vintage\junit-vintage-engine\5.10.2\junit-vintage-engine-5.10.2.jar;F:\Develop\IDEA\IntelliJ IDEA 2023.3.3\lib\idea_rt.jar;F:\Develop\IDEA\IntelliJ IDEA 2023.3.3\plugins\junit\lib\junit5-rt.jar;F:\Develop\IDEA\IntelliJ IDEA 2023.3.3\plugins\junit\lib\junit-rt.jar;F:\Develop\JDK8\jre\lib\charsets.jar;F:\Develop\JDK8\jre\lib\deploy.jar;F:\Develop\JDK8\jre\lib\ext\access-bridge-64.jar;F:\Develop\JDK8\jre\lib\ext\cldrdata.jar;F:\Develop\JDK8\jre\lib\ext\dnsns.jar;F:\Develop\JDK8\jre\lib\ext\jaccess.jar;F:\Develop\JDK8\jre\lib\ext\jfxrt.jar;F:\Develop\JDK8\jre\lib\ext\localedata.jar;F:\Develop\JDK8\jre\lib\ext\nashorn.jar;F:\Develop\JDK8\jre\lib\ext\sunec.jar;F:\Develop\JDK8\jre\lib\ext\sunjce_provider.jar;F:\Develop\JDK8\jre\lib\ext\sunmscapi.jar;F:\Develop\JDK8\jre\lib\ext\sunpkcs11.jar;F:\Develop\JDK8\jre\lib\ext\zipfs.jar;F:\Develop\JDK8\jre\lib\javaws.jar;F:\Develop\JDK8\jre\lib\jce.jar;F:\Develop\JDK8\jre\lib\jfr.jar;F:\Develop\JDK8\jre\lib\jfxswt.jar;F:\Develop\JDK8\jre\lib\jsse.jar;F:\Develop\JDK8\jre\lib\management-agent.jar;F:\Develop\JDK8\jre\lib\plugin.jar;F:\Develop\JDK8\jre\lib\resources.jar;F:\Develop\JDK8\jre\lib\rt.jar;F:\Program\Java\Mybatis3\target\classes;F:\Develop\apache\LocalMavenWarehouse\org\apache\logging\log4j\log4j-core\2.19.0\log4j-core-2.19.0.jar;F:\Develop\apache\LocalMavenWarehouse\org\apache\logging\log4j\log4j-api\2.19.0\log4j-api-2.19.0.jar;F:\Develop\apache\LocalMavenWarehouse\org\apache\logging\log4j\log4j-slf4j2-impl\2.19.0\log4j-slf4j2-impl-2.19.0.jar;F:\Develop\apache\LocalMavenWarehouse\org\slf4j\slf4j-api\2.0.0\slf4j-api-2.0.0.jar;F:\Develop\apache\LocalMavenWarehouse\org\mybatis\mybatis\3.5.15\mybatis-3.5.15.jar;F:\Develop\apache\LocalMavenWarehouse\junit\junit\4.12\junit-4.12.jar;F:\Develop\apache\LocalMavenWarehouse\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;F:\Develop\apache\LocalMavenWarehouse\mysql\mysql-connector-java\8.0.25\mysql-connector-java-8.0.25.jar;F:\Develop\apache\LocalMavenWarehouse\com\google\protobuf\protobuf-java\3.11.4\protobuf-java-3.11.4.jar;F:\Develop\apache\LocalMavenWarehouse\org\junit\jupiter\junit-jupiter\5.10.2\junit-jupiter-5.10.2.jar;F:\Develop\apache\LocalMavenWarehouse\org\junit\jupiter\junit-jupiter-api\5.10.2\junit-jupiter-api-5.10.2.jar;F:\Develop\apache\LocalMavenWarehouse\org\opentest4j\opentest4j\1.3.0\opentest4j-1.3.0.jar;F:\Develop\apache\LocalMavenWarehouse\org\junit\platform\junit-platform-commons\1.10.2\junit-platform-commons-1.10.2.jar;F:\Develop\apache\LocalMavenWarehouse\org\apiguardian\apiguardian-api\1.1.2\apiguardian-api-1.1.2.jar;F:\Develop\apache\LocalMavenWarehouse\org\junit\jupiter\junit-jupiter-params\5.10.2\junit-jupiter-params-5.10.2.jar;F:\Develop\apache\LocalMavenWarehouse\org\junit\jupiter\junit-jupiter-engine\5.10.2\junit-jupiter-engine-5.10.2.jar;F:\Develop\apache\LocalMavenWarehouse\org\junit\platform\junit-platform-engine\1.10.2\junit-platform-engine-1.10.2.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit5 com.sakurapaid.mybatis3.demo01.test.UserTest
2024-03-23 19:02:04 279 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
2024-03-23 19:02:04 289 [main] DEBUG org.apache.ibatis.datasource.pooled.PooledDataSource - PooledDataSource forcefully closed/removed all connections.
2024-03-23 19:02:04 289 [main] DEBUG org.apache.ibatis.datasource.pooled.PooledDataSource - PooledDataSource forcefully closed/removed all connections.
2024-03-23 19:02:04 290 [main] DEBUG org.apache.ibatis.datasource.pooled.PooledDataSource - PooledDataSource forcefully closed/removed all connections.
2024-03-23 19:02:04 290 [main] DEBUG org.apache.ibatis.datasource.pooled.PooledDataSource - PooledDataSource forcefully closed/removed all connections.
2024-03-23 19:02:04 389 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Opening JDBC Connection
2024-03-23 19:02:05 128 [main] DEBUG org.apache.ibatis.datasource.pooled.PooledDataSource - Created connection 1605988985.
2024-03-23 19:02:05 129 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5fb97279]
2024-03-23 19:02:05 133 [main] DEBUG com.sakurapaid.mybatis3.demo01.mapper.UserMapper.selectAll - ==>  Preparing: select * from user
2024-03-23 19:02:05 153 [main] DEBUG com.sakurapaid.mybatis3.demo01.mapper.UserMapper.selectAll - ==> Parameters: 
2024-03-23 19:02:05 171 [main] DEBUG com.sakurapaid.mybatis3.demo01.mapper.UserMapper.selectAll - <==      Total: 3
User{id = 1, name = 小明, age = 18, sex = 男}
User{id = 2, name = 小红, age = 19, sex = 女}
User{id = 3, name = 小军, age = 20, sex = 女}

进程已结束，退出代码为 0