1. 核心配置文件

1.1. 概述

核心配置文件是MyBatis框架中用于集中定义全局配置信息的XML文件，其内部包含了一系列预设标签，用于设置数据库连接、对象映射、类型处理等关键参数。这些标签遵循特定的排列顺序，尽管并非所有标签都是强制性的，但按照推荐顺序编写有助于保持配置文件的清晰性和一致性。

1. properties（可选）：
   用于导入外部属性文件，便于在核心配置文件中引用其中的变量。通常用于存储数据库连接信息、环境切换标志等敏感或可变数据。
2. settings（可选）：
   设置MyBatis全局行为的配置项集合。如开启驼峰命名自动映射、设置默认的执行器、指定是否延迟加载等。每个设置项以<setting>标签进行定义。
3. typeAliases（可选）：
   定义类型别名，为Java类提供简短易记的名字，以便在Mapper XML文件中更简洁地引用。可以为单个类定义别名，也可以批量定义包下的所有类。
4. typeHandlers（可选）：
   注册自定义类型处理器，用于处理JDBC无法直接识别的数据类型（如枚举、日期等）。可以为单个类型处理器定义，也可以批量定义包下的所有处理器。
5. objectFactory（可选）：
   指定自定义对象工厂，用于创建结果对象（如查询结果映射到的实体类）。当需要对对象创建过程进行特殊控制时使用。
6. objectWrapperFactory（可选）：
   指定自定义对象包装器工厂，用于创建对象包装器，控制对象属性的读写操作。在处理深层次嵌套属性或复杂对象结构时可能用到。
7. reflectorFactory（可选）：
   指定反射器工厂，用于创建反射器，影响对象属性的读取和设置。通常情况下无需定制，但在某些特定优化场景下可能需要。
8. plugins（可选）：
   配置MyBatis插件，用于拦截核心接口方法执行，实现诸如性能监控、日志记录、动态SQL修改等功能。每个插件需指定对应的拦截器类。
9. environments：
   定义多个环境配置，如开发环境、生产环境等。每个环境包含一个默认的transactionManager（事务管理器）和至少一个dataSource（数据源）。根据实际运行时的环境标识符选择对应的环境配置。
10. databaseIdProvider（可选）：
    提供数据库供应商ID识别功能，用于在XML映射文件中根据不同的数据库执行特定的SQL语句。通常与<if>、<choose>等动态SQL元素配合使用。
11. mappers：
    引入Mapper XML文件或接口类，定义SQL映射语句和结果映射。可以通过相对于配置文件的路径、类路径下的绝对路径、包扫描等方式进行引入。

比如下面这个代码示例：

<?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">
<!-- MyBatis 配置文件 -->
<configuration>
    <!-- 引入外部属性文件 -->
    <!-- 将database.properties文件中的属性值注入到MyBatis配置中 -->
    <properties resource="database.properties"/>

    <!-- 全局配置 -->
    <settings>
        <!-- 设置日志实现方式为LOG4J -->
        <setting name="logImpl" value="LOG4J"/>
        <!-- 开启驼峰命名与下划线命名之间的自动转换 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <!-- 类型别名 -->
    <!-- 定义类型别名，简化SQL语句中的全限定类名书写 -->
    <typeAliases>
        <!-- 为User类定义别名为User -->
        <typeAlias alias="User" type="com.example.model.User"/>
        <!-- 扫描com.example.model包下的所有类，自动生成类型别名 -->
        <package name="com.example.model"/>
    </typeAliases>

    <!-- 类型处理器 -->
    <!-- 定义自定义类型处理器，处理特殊数据类型的SQL映射 -->
    <typeHandlers>
        <!-- 注册自定义类型处理器 -->
        <typeHandler handler="com.example.handler.MyCustomTypeHandler"/>
        <!-- 扫描com.example.handler包下的所有类，自动注册类型处理器 -->
        <package name="com.example.handler"/>
    </typeHandlers>

    <!-- 对象工厂、对象包装器工厂、反射器工厂（此处省略，通常使用默认即可） -->

    <!-- 插件配置 -->
    <!-- 注册MyBatis插件，用于增强或拦截MyBatis行为 -->
    <plugins>
        <!-- 注册LoggingInterceptor插件 -->
        <plugin interceptor="com.example.plugin.LoggingInterceptor"/>
    </plugins>

    <!-- 环境配置 -->
    <!-- 配置多个数据库连接环境，可按需切换 -->
    <environments default="development">
        <!-- 配置开发环境 -->
        <environment id="development">
            <!-- 事务管理器配置，此处使用JDBC原生事务管理 -->
            <transactionManager type="JDBC"/>
            <!-- 数据源配置，使用连接池（POOLED） -->
            <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>

        <!-- 可以添加更多环境，如 production 环境 -->
    </environments>

    <!-- 数据库厂商识别 -->
    <!-- 根据数据库类型自动选择对应的SQL方言 -->
    <databaseIdProvider type="DB_VENDOR">
        <!-- 定义MySQL和Oracle的标识符 -->
        <property name="MySQL" value="mysql"/>
        <property name="Oracle" value="oracle"/>
    </databaseIdProvider>

    <!-- SQL 映射文件 -->
    <!-- 配置SQL映射文件或接口，用于编写SQL语句和结果映射 -->
    <mappers>
        <!-- 引入XML形式的SQL映射文件 -->
        <mapper resource="com/example/mapper/UserMapper.xml"/>
        <!-- 引入注解形式的SQL映射接口 -->
        <mapper class="com.example.mapper.UserMapper"/>
        <!-- 可以通过包扫描方式引入 -->
        <!-- <package name="com.example.mapper"/> -->
    </mappers>
</configuration>

---

1.2. 分离数据库连接属性

使用外部 .properties文件简化MyBatis配置

---

在实际项目开发中，数据库连接信息（如驱动、URL、用户名、密码等）通常需要根据不同的环境（如开发、测试、生产）灵活调整。直接在MyBatis的核心配置文件中硬编码这些数据源信息，虽然简单直接，但不利于配置的管理和维护，特别是在需要频繁切换数据库连接时，每次手动修改配置文件会显得繁琐且易出错。

为解决这一问题，我们可以将数据库连接相关的属性提取到一个单独的db.properties文件中，并通过MyBatis的<properties>标签将其引入到核心配置文件中。这样，当需要切换数据库连接时，只需修改db.properties文件，而无需改动核心配置文件，大大提高了配置的灵活性和可维护性。

以下是具体的操作步骤和代码示例：

步骤1：创建db.properties文件

创建一个名为db.properties的文件，名字可根据实际情况来

其中包含数据库连接所需的各项属性：

db.driver = com.mysql.cj.jdbc.Driver
db.url = jdbc:mysql://localhost:3306/mybatis3?characterEncoding=utf-8
db.username = root
db.password = 2076805863

步骤2：在MyBatis核心配置文件中引入db.properties

在MyBatis的mybatis-config.xml核心配置文件中添加<properties>标签，指定resource属性为db.properties文件的路径，以便MyBatis加载该文件：

<?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>
    <!-- 引入外部文件 -->
    <properties resource="db.properties"/>

    <!-- ... 其他配置 ... -->
</configuration>

步骤3：使用属性占位符替换数据源配置

接下来，在配置数据源时，使用${}语法引用db.properties文件中定义的属性，替换原本硬编码的值：

<dataSource type="POOLED">
    <property name="driver" value="${db.driver}"/>
    <property name="url" value="${db.url}"/>
    <property name="username" value="${db.username}"/>
    <property name="password" value="${db.password}"/>
</dataSource>

---

2. Mybatis增删改查

2.1. 准备操作

创建表并添加数据

创建相关Javabean类

package com.sakurapaid.mybatis3.demo01.bean;

public class User {
    private int id;
    private String name;
    private int age;
    private String sex;

    public User() {
    }

    public User(int id, String name, int age, String sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    /**
     * 获取
     * @return id
     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return sex
     */
    public String getSex() {
        return sex;
    }

    /**
     * 设置
     * @param sex
     */
    public void setSex(String sex) {
        this.sex = sex;
    }

    public String toString() {
        return "User{id = " + id + ", name = " + name + ", age = " + age + ", sex = " + sex + "}";
    }
}

配置 mybatis-config.xml 文件

记得在最下面写映射配置

<?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>
    
    <!-- 配置MyBatis的运行环境，默认使用development环境 -->
    <environments default="development">
        <!-- 定义development环境 -->
        <environment id="development">
            <!-- 使用JDBC事务管理器 -->
            <transactionManager type="JDBC"/>
            <!-- 配置数据源，使用连接池类型 -->
            <dataSource type="POOLED">
                <!-- 配置数据库连接池的属性 -->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis3?characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    
    <!-- 映射器配置，指定Mapper XML文件的位置 -->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
    
</configuration>

创建 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">
    
</mapper>

namespace对应下面创建的Dao层接口的全类名位置

namespace="com.sakurapaid.mybatis3.demo01.mapper.UserMapper"

创建UserMapper的dao层接口

package com.sakurapaid.mybatis3.demo01.mapper;

import com.sakurapaid.mybatis3.demo01.bean.User;

import java.util.List;

public interface UserMapper {
    
}

项目结构

---

2.2. 添加数据

UserMapper.java

package com.sakurapaid.mybatis3.demo01.mapper;

import com.sakurapaid.mybatis3.demo01.bean.User;

public interface UserMapper {
    // 1.添加用户
    public int addUser(User user);
}

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">
    <!--1.添加用户-->
    <insert id="addUser" parameterType="User">
        insert into user(name,age,sex) values(#{name},#{age},#{sex})
    </insert>
</mapper>

可能到这里就需要一步步解释每个标签是什么意思了：

<mapper> 标签：

<mapper namespace="com.sakurapaid.mybatis3.demo01.mapper.UserMapper">

<mapper> 标签代表一个独立的 SQL 映射文件，用于定义与数据库交互的各种操作（如增删改查）。每个 <mapper> 必须有一个唯一的 namespace 属性，它类似于 Java 中的包名，用于唯一标识该映射文件。这里的 namespace 值为 "com.sakurapaid.mybatis3.demo01.mapper.UserMapper"，表示这个映射文件对应于名为 UserMapper 的 Java 接口（通常位于 com.sakurapaid.mybatis3.demo01.mapper 包下），该接口中定义了与 <mapper> 文件中 SQL 语句相对应的方法。

<insert> 标签：

<!--1.添加用户-->
<insert id="addUser" parameterType="User">
    insert into user(name,age,sex) values(#{name},#{age},#{sex})
</insert>

<insert> 标签用于定义插入数据到数据库表的操作。具体说明如下：

id 属性：id="addUser" 表示这个 <insert> 标签对应于 UserMapper 接口中一个名为 addUser 的方法。当调用该接口方法时，MyBatis 将执行此 <insert> 标签内的 SQL 语句。

parameterType 属性：parameterType="User" 指定执行 SQL 语句时使用的输入参数类型。这里为 User 类，通常是一个与数据库表结构对应的 Java 实体类。这意味着调用 addUser 方法时，需要传入一个 User 对象作为参数。

parameterType 的值一般要写全类名才可以，这里只写User是因为我核心配置文件做了取别名操作，

一般上要写右边com开头的一大堆东西

SQL 语句：insert into user(name,age,sex) values(#{name},#{age},#{sex}) 是具体的 SQL 插入语句，用于向名为 user 的数据库表中插入一条新记录。name, age, sex 分别对应表中的字段名，而 #{name}, #{age}, #{sex} 是占位符，它们会被传入的 User 对象的相应属性值替换。例如，如果传入的 User 对象有属性 name="John", age=25, sex="Male"，那么实际执行的 SQL 语句将会是：

insert into user(name,age,sex) values('John',25,'Male')

总结来说，这段 <mapper> 标签定义了一个与 com.sakurapaid.mybatis3.demo01.mapper.UserMapper 接口对应的 SQL 映射文件，其中的 <insert> 标签定义了向 user 表中插入用户数据的操作。当在代码中通过 UserMapper 接口调用 addUser 方法并传入一个 User 对象时，MyBatis 会自动执行相应的 SQL 插入语句，将用户数据写入数据库。

---

测试输出

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 {
    @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会话
        // true的作用：自动提交事务，默认为false
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        
        // 获取UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        // 1.添加用户
        User user = new User(0, "小明", 18, "男");
        int i = userMapper.addUser(user);
        if (i > 0) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }
    }
}

---

2.3. 修改数据

UserMapper.java

package com.sakurapaid.mybatis3.demo01.mapper;

import com.sakurapaid.mybatis3.demo01.bean.User;

public interface UserMapper {
    // 1.添加用户
    public int addUser(User user);
    
    // 2.修改用户
    public int updateUser(User user);   
}

UserMapper.xml

这里的 <update>标签就不用我多说了吧(ノ￣▽￣)

<?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">
    <!--1.添加用户-->
    <insert id="addUser" parameterType="User">
        insert into user(name,age,sex) values(#{name},#{age},#{sex})
    </insert>
    
    <!--2.修改用户-->
    <update id="updateUser" parameterType="User">
        update user set name=#{name},age=#{age},sex=#{sex} where id=#{id}
    </update>
</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 {
    @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会话
        // true的作用：自动提交事务，默认为false
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        // 获取UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        // 1.添加用户
        /*User user = new User(0, "小明", 18, "男");
        int i = userMapper.addUser(user);
        if (i > 0) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }*/
        
        // 2.修改用户
        User user = new User(1, "萨达姆", 26, "男");
        int i = userMapper.updateUser(user);
        if (i > 0) {
            System.out.println("修改成功");
        } else {
            System.out.println("修改失败");
        }
    }

}

---

2.4. 查询数据

UserMapper.java

package com.sakurapaid.mybatis3.demo01.mapper;

import com.sakurapaid.mybatis3.demo01.bean.User;

import java.util.List;

public interface UserMapper {
    // 1.添加用户
    public int addUser(User user);

    // 2.修改用户
    public int updateUser(User user);

    // 3.查询所有用户
    public List<User> findAllUser();
}

UserMapper.xml

这里的 <select>标签就不用我多说了吧ヽ(￣▽￣)ﾉ

<?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">
    <!--1.添加用户-->
    <insert id="addUser" parameterType="User">
        insert into user(name,age,sex) values(#{name},#{age},#{sex})
    </insert>
    
    <!--2.修改用户-->
    <update id="updateUser" parameterType="User">
        update user set name=#{name},age=#{age},sex=#{sex} where id=#{id}
    </update>
    
    <!--3.查询所有用户-->
    <select id="findAllUser" resultType="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 {
    @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会话
        // true的作用：自动提交事务，默认为false
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        // 获取UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        // 1.添加用户
        /*User user1 = new User(0, "小明", 18, "男");
        int i = userMapper.addUser(user1);
        if (i > 0) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }*/

        // 2.修改用户
        /*User user2 = new User(1, "萨达姆", 26, "男");
        int i = userMapper.updateUser(user2);
        if (i > 0) {
            System.out.println("修改成功");
        } else {
            System.out.println("修改失败");
        }*/
        
        // 3.查询所有用户
        List<User> users = userMapper.findAllUser();
        if (!users.isEmpty()) {
            for (User user : users) {
                System.out.println(user);
            }
        } else {
            System.out.println("没有数据");
        }
    }

}

---

2.5. 删除数据

UserMapper.java

package com.sakurapaid.mybatis3.demo01.mapper;

import com.sakurapaid.mybatis3.demo01.bean.User;

import java.util.List;

public interface UserMapper {
    // 1.添加用户
    public int addUser(User user);

    // 2.修改用户
    public int updateUser(User user);

    // 3.查询所有用户
    public List<User> findAllUser();

    // 4.根据id删除指定用户
    public int deleteUserById(int id);
}

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">
    <!--1.添加用户-->
    <insert id="addUser" parameterType="User">
        insert into user(name,age,sex) values(#{name},#{age},#{sex})
    </insert>
    
    <!--2.修改用户-->
    <update id="updateUser" parameterType="User">
        update user set name=#{name},age=#{age},sex=#{sex} where id=#{id}
    </update>
    
    <!--3.查询所有用户-->
    <select id="findAllUser" resultType="User">
        select * from user
    </select>
    
    <!--4.根据id删除指定用户-->
    <delete id="deleteUserById" parameterType="int">
        delete from user where id=#{id}
    </delete>
</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 {
    @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会话
        // true的作用：自动提交事务，默认为false
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        // 获取UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        // 1.添加用户
        /*User user1 = new User(0, "小明", 18, "男");
        int i = userMapper.addUser(user1);
        if (i > 0) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }*/

        // 2.修改用户
        /*User user2 = new User(1, "萨达姆", 26, "男");
        int i = userMapper.updateUser(user2);
        if (i > 0) {
            System.out.println("修改成功");
        } else {
            System.out.println("修改失败");
        }*/

        // 3.查询所有用户
        /*List<User> users = userMapper.findAllUser();
        if (!users.isEmpty()) {
            for (User user : users) {
                System.out.println(user);
            }
        } else {
            System.out.println("没有数据");
        }*/

        // 4.根据id删除指定用户
        int i = userMapper.deleteUserById(4);
        if (i > 0) {
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败");
        }
    }

}

---