目录

一、核心API

二、全局与映射配置文件

1.全局配置文件

2.映射配置文件

三、事务管理

1. JDBC 事务管理

2. Spring 事务管理

四、Sqlsession

1.SqlSession 的主要功能和用途：

2.如何使用 SqlSession：

五、Mapper动态代理

1.Mapper 动态代理的工作原理：

2.示例：

六、动态SQL

1.  标签

2. , , 和  标签

3. , , 和  标签

4.  标签

七、缓存使用

1. 一级缓存

2. 二级缓存

3.自定义缓存

八、多表关联查询

九、注解开发

1. @Select

2. @Insert

3. @Update

4. @Delete

5. @Results 和 @Result

6. @Param

7. @SelectProvider、@InsertProvider、@UpdateProvider 和 @DeleteProvider

---

一、核心API

MyBatis 是一个优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通的 Java 对象）为数据库中的记录。

MyBatis 的核心 API 主要包括以下几个部分：

1. SqlSessionFactoryBuilder：

   • 这个类用于构建 SqlSessionFactory。
   • 它通过读取 MyBatis 的配置文件（如 mybatis-config.xml）或者通过编程方式配置，然后构建 SqlSessionFactory 对象。

2. SqlSessionFactory：

   • 这是一个工厂接口，用于创建 SqlSession 对象。
   • SqlSession 是 MyBatis 的核心接口，用于执行 SQL 语句、获取映射器实例和管理事务。

3. SqlSession：

   • SqlSession 提供了执行 SQL 语句、获取映射器实例和管理事务的方法。
   • 它代表了一个和数据库交互的会话，完成一次数据库操作后，通常需要关闭 SqlSession 来释放资源。

4. Mapper：

   • Mapper 接口是 MyBatis 的另一个核心组件，它对应于 SQL 映射文件（如 UserMapper.xml）。
   • 通过 Mapper 接口，我们可以直接调用 SQL 语句，而无需编写 JDBC 代码。
   • MyBatis 通过动态代理技术，为 Mapper 接口生成实现类，实现类会调用相应的 SQL 语句。

5. RowBounds 和 ResultMap：

   • RowBounds 用于设置查询结果的分页信息。
   • ResultMap 用于定义 SQL 查询结果的映射规则，它可以将查询结果映射到 Java 对象中。

这些核心 API 共同构成了 MyBatis 的基础架构，使得我们可以方便地执行 SQL 语句、管理数据库连接和事务，并将查询结果映射到 Java 对象中。通过合理地使用这些 API，我们可以编写出高效、易维护的数据库访问代码。

二、全局与映射配置文件

MyBatis 中的全局配置文件和映射配置文件是 MyBatis 框架的重要组成部分，它们共同定义了 MyBatis 的运行环境和 SQL 映射规则。

1.全局配置文件

全局配置文件通常命名为 mybatis-config.xml，它包含了 MyBatis 的核心配置信息。这个文件主要用于配置 MyBatis 的运行环境，如数据源、事务管理、别名、类型处理器、插件等。

以下是一个简单的全局配置文件的示例：

<?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>  
    <!-- 配置环境 -->  
    <environments default="development">  
        <environment id="development">  
            <!-- 配置事务管理器 -->  
            <transactionManager type="JDBC"/>  
            <!-- 配置数据源 -->  
            <dataSource type="POOLED">  
                <property name="driver" value="com.mysql.jdbc.Driver"/>  
                <property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>  
                <property name="username" value="root"/>  
                <property name="password" value="password"/>  
            </dataSource>  
        </environment>  
    </environments>  
  
    <!-- 配置类型别名 -->  
    <typeAliases>  
        <typeAlias alias="User" type="com.example.User"/>  
    </typeAliases>  
  
    <!-- 配置插件 -->  
    <plugins>  
        <!-- 插件配置 -->  
    </plugins>  
  
    <!-- 配置映射文件 -->  
    <mappers>  
        <mapper resource="com/example/UserMapper.xml"/>  
    </mappers>  
</configuration>

在上面的示例中，<environments> 标签用于配置数据库环境，<typeAliases> 用于配置类型别名，<mappers> 用于配置映射文件的位置。

2.映射配置文件

映射配置文件（通常命名为 Mapper.xml）用于定义 SQL 语句、输入参数类型和输出结果映射规则。这些文件通常与 Mapper 接口一一对应，用于实现具体的数据库操作。

以下是一个简单的映射配置文件的示例：

<?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="com.example.UserMapper">  
  
    <!-- 插入用户 -->  
    <insert id="insertUser" parameterType="com.example.User">  
        INSERT INTO user (id, name, age) VALUES (#{id}, #{name}, #{age})  
    </insert>  
  
    <!-- 查询用户 -->  
    <select id="findUserById" parameterType="int" resultType="com.example.User">  
        SELECT * FROM user WHERE id = #{id}  
    </select>  
  
    <!-- 更新用户 -->  
    <update id="updateUser" parameterType="com.example.User">  
        UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id}  
    </update>  
  
    <!-- 删除用户 -->  
    <delete id="deleteUser" parameterType="int">  
        DELETE FROM user WHERE id = #{id}  
    </delete>  
  
</mapper>

在上面的示例中，<mapper> 标签的 namespace 属性需要与对应的 Mapper 接口的全限定名一致。<insert>、<select>、<update> 和 <delete> 标签分别用于定义插入、查询、更新和删除操作的 SQL 语句。parameterType 属性指定输入参数的类型，resultType 或 resultMap 属性指定输出结果的映射规则。

全局配置文件和映射配置文件共同构成了 MyBatis 的核心配置，它们一起定义了 MyBatis 如何与数据库进行交互，以及如何映射查询结果到 Java 对象中。

三、事务管理

MyBatis 的事务管理是其核心功能之一，它允许用户执行数据库操作时能够在一个事务的上下文中进行，从而确保数据的一致性和完整性。MyBatis 支持两种类型的事务管理：一种是使用 JDBC 的事务管理，另一种是与 Spring 集成，利用 Spring 的事务管理功能。

1. JDBC 事务管理

在 MyBatis 的全局配置文件中，你可以指定使用 JDBC 的事务管理器。以下是如何配置的示例：

<configuration>  
    <!-- ... 其他配置 ... -->  
  
    <environments default="development">  
        <environment id="development">  
            <!-- 使用 JDBC 的事务管理 -->  
            <transactionManager type="JDBC"/>  
            <!-- 配置数据源 -->  
            <dataSource type="POOLED">  
                <!-- ... 数据源配置 ... -->  
            </dataSource>  
        </environment>  
    </environments>  
  
    <!-- ... 映射器配置 ... -->  
</configuration>

在 JDBC 事务管理模式下，MyBatis 会使用 Java 的 java.sql.Connection 对象来管理事务。当你打开一个 SqlSession 时，MyBatis 会从数据源中获取一个 Connection 对象，并在执行 SQL 语句时使用这个 Connection。如果你调用 SqlSession 的 commit() 方法，MyBatis 会提交事务；如果你调用 rollback() 方法，则会回滚事务。当 SqlSession 关闭时，如果它关联的事务没有被显式提交或回滚，MyBatis 会根据配置（默认为自动提交）来决定是否提交事务。

2. Spring 事务管理

当 MyBatis 与 Spring 集成时，通常使用 Spring 的声明式事务管理来管理 MyBatis 的事务。Spring 提供了强大的事务管理功能，包括事务的传播行为、隔离级别、只读设置等。

要在 Spring 中配置 MyBatis 的事务管理，你需要在 Spring 的配置文件中定义事务管理器，并将其与数据源和 MyBatis 的 SqlSessionFactory 关联起来。通常使用 DataSourceTransactionManager 作为事务管理器。

以下是一个 Spring 配置文件的示例，展示了如何配置 MyBatis 与 Spring 的事务管理集成：

<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xmlns:tx="http://www.springframework.org/schema/tx"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
       http://www.springframework.org/schema/beans/spring-beans.xsd  
       http://www.springframework.org/schema/tx  
       http://www.springframework.org/schema/tx/spring-tx.xsd">  
  
    <!-- 配置数据源 -->  
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
        <!-- ... 数据源属性配置 ... -->  
    </bean>  
  
    <!-- 配置 SqlSessionFactory -->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource"/>  
        <!-- ... 其他配置 ... -->  
    </bean>  
  
    <!-- 配置事务管理器 -->  
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource"/>  
    </bean>  
  
    <!-- 启用事务注解 -->  
    <tx:annotation-driven transaction-manager="transactionManager"/>  
  
    <!-- 配置 Mapper -->  
    <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">  
        <property name="mapperInterface" value="com.example.UserMapper"/>  
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>  
    </bean>  
  
    <!-- ... 其他 Bean 配置 ... -->  
  
</beans>

在上面的配置中，<tx:annotation-driven> 标签启用了 Spring 的基于注解的事务管理。你可以在服务层的方法上使用 @Transactional 注解来声明该方法需要在事务的上下文中执行。Spring 会根据该注解来创建、提交或回滚事务。

例如：

@Service  
public class UserService {  
  
    @Autowired  
    private UserMapper userMapper;  
  
    @Transactional  
    public void addUser(User user) {  
        userMapper.insertUser(user);  
        // 其他数据库操作...  
    }  
}

在上面的 UserService 类中，addUser 方法使用了 @Transactional 注解，这意味着当该方法被调用时，Spring 会自动为它创建一个事务，并在方法执行完毕后提交事务（如果方法正常结束）或回滚事务（如果方法抛出异常）。

四、Sqlsession

在 MyBatis 中，SqlSession 是应用程序与数据库之间交互的核心接口。它代表了一个与数据库会话的上下文，提供了执行 SQL 语句、获取映射器（Mapper）以及管理事务的方法。

1.SqlSession 的主要功能和用途：

1. 执行 SQL 语句：SqlSession 提供了执行 SQL 语句的方法，如 selectOne(), selectList(), insert(), update(), 和 delete()。这些方法允许你执行各种数据库操作。

2. 获取 Mapper：SqlSession 可以用来获取 Mapper 接口的实例，这些 Mapper 接口通常用于定义与数据库表对应的 CRUD 操作。通过 Mapper，你可以以面向对象的方式执行 SQL 语句，而不是直接编写 SQL 字符串。

3. 管理事务：SqlSession 提供了管理事务的方法，如 commit() 和 rollback()。当你使用 MyBatis 的 JDBC 事务管理器时，你可以通过 SqlSession 来控制事务的边界。

4. 缓存：SqlSession 还可以用于缓存查询结果，从而提高性能。

5. 关闭会话：完成数据库操作后，应该关闭 SqlSession 以释放资源。

2.如何使用 SqlSession：

通常，你不会直接创建 SqlSession 实例。相反，你会通过 SqlSessionFactory 来获取 SqlSession。SqlSessionFactory 是 MyBatis 的核心，它负责创建 SqlSession 实例。

下面是一个简单的示例，展示了如何使用 SqlSession：

// 获取 SqlSessionFactory（通常通过 MyBatis 的配置文件或注解配置）  
SqlSessionFactory sqlSessionFactory = ...;  
  
try (SqlSession session = sqlSessionFactory.openSession()) {  
    // 获取 Mapper 接口的实例  
    UserMapper userMapper = session.getMapper(UserMapper.class);  
      
    // 使用 Mapper 执行查询  
    User user = userMapper.selectUserById(1);  
      
    // 提交事务（如果使用的是非自动提交模式）  
    session.commit();  
}

在上面的代码中，我们首先通过 SqlSessionFactory 打开一个 SqlSession。然后，我们使用 session.getMapper() 方法获取 UserMapper 的实例，并通过该 Mapper 执行查询操作。最后，我们提交事务并关闭 SqlSession。

注意：在实际应用中，通常不会在每个数据库操作中都手动打开和关闭 SqlSession。相反，你可能会使用 Spring 框架来管理 SqlSession 的生命周期，这样可以在方法执行完毕后自动关闭 SqlSession。这通过 Spring 的声明式事务管理和 MyBatis 的 Spring 集成实现。

五、Mapper动态代理

在 MyBatis 中，Mapper 动态代理是 MyBatis 框架提供的一种方便的方式来自动创建 Mapper 接口的代理实现类，从而允许你以面向接口编程的方式与数据库进行交互。

当你定义了一个 Mapper 接口，并且配置了相应的 SQL 映射文件（XML）后，MyBatis 会在运行时为你生成这个接口的动态代理实现类。这样，你就可以直接注入这个接口到你的服务层或其他组件中，并通过它来执行 SQL 语句，而无需关心底层的实现细节。

1.Mapper 动态代理的工作原理：

1. 定义 Mapper 接口：首先，你需要定义一个 Mapper 接口，这个接口中声明了与数据库操作相关的方法。

2. 编写 SQL 映射文件：接着，你需要编写与 Mapper 接口对应的 SQL 映射文件（通常是 XML 文件），在这个文件中定义具体的 SQL 语句以及参数和结果的映射关系。

3. 配置 MyBatis：在 MyBatis 的配置文件中，你需要告诉 MyBatis 哪些接口需要创建动态代理实现类，以及这些接口对应的 SQL 映射文件的位置。

4. MyBatis 创建动态代理：当 MyBatis 初始化时，它会扫描配置文件中指定的 Mapper 接口，并为每个接口创建一个动态代理实现类。这个代理实现类会拦截接口方法的调用，并根据 SQL 映射文件中的配置来执行相应的 SQL 语句。

5. 使用 Mapper 接口：在你的应用程序中，你可以直接注入 Mapper 接口的实例，并通过这个接口来执行数据库操作。由于动态代理的存在，你实际上是在调用代理实现类的方法，而这个代理实现类会负责执行相应的 SQL 语句并返回结果。

2.示例：

假设你有一个 UserMapper 接口，它声明了一个 selectUserById 方法来根据 ID 查询用户信息。

public interface UserMapper {  
    User selectUserById(int id);  
}

对应的 SQL 映射文件 UserMapper.xml 如下：

<mapper namespace="com.example.mapper.UserMapper">  
    <select id="selectUserById" resultType="com.example.model.User">  
        SELECT * FROM user WHERE id = #{id}  
    </select>  
</mapper>

在 MyBatis 的配置文件中，你需要注册这个 Mapper 接口：

<configuration>  
    <!-- ... 其他配置 ... -->  
    <mappers>  
        <mapper resource="com/example/mapper/UserMapper.xml"/>  
    </mappers>  
</configuration>

然后，在你的服务层或其他组件中，你可以这样使用 UserMapper 接口：

@Service  
public class UserService {  
    private final UserMapper userMapper;  
  
    @Autowired  
    public UserService(UserMapper userMapper) {  
        this.userMapper = userMapper; // MyBatis 会自动注入动态代理实现类的实例  
    }  
  
    public User getUserById(int id) {  
        return userMapper.selectUserById(id); // 调用动态代理实现类的方法执行 SQL 语句  
    }  
}

这样，你就可以通过 UserMapper 接口以面向接口编程的方式与数据库进行交互，而无需关心底层的 SQL 语句执行和结果映射等细节。MyBatis 的 Mapper 动态代理功能极大地简化了数据库操作的编码工作，提高了开发效率。

六、动态SQL

在 MyBatis 中，动态 SQL 是一种非常强大的功能，它允许你根据不同的条件生成不同的 SQL 语句。这使得编写复杂和灵活的 SQL 查询变得更加容易和直观。

MyBatis 提供了几种标签来帮助你构建动态 SQL，包括 <if>、<choose>、<when>、<otherwise>、<trim>、<where>、<set> 和 <foreach> 等。

下面是一些使用动态 SQL 的常见场景和示例：

1. <if> 标签

<if> 标签用于根据条件包含或排除某些 SQL 片段。

<select id="findUsersByCondition" resultType="User">  
    SELECT * FROM user  
    WHERE 1=1  
    <if test="name != null">  
        AND name = #{name}  
    </if>  
    <if test="age != null">  
        AND age = #{age}  
    </if>  
</select>

在这个例子中，如果 name 不为 null，则包含 name = #{name} 这个条件；如果 age 不为 null，则包含 age = #{age} 这个条件。

2. <choose>, <when>, 和 <otherwise> 标签

这些标签类似于 Java 中的 switch-case-default 语句，用于根据多个条件生成不同的 SQL 片段。

<select id="findUsersByType" resultType="User">  
    SELECT * FROM user  
    <choose>  
        <when test="type == 'admin'">  
            WHERE role = 'ADMIN'  
        </when>  
        <when test="type == 'user'">  
            WHERE role = 'USER'  
        </when>  
        <otherwise>  
            WHERE status = 'ACTIVE'  
        </otherwise>  
    </choose>  
</select>

3. <trim>, <where>, 和 <set> 标签

这些标签用于处理 SQL 语句中的前缀和后缀，以及动态地添加 WHERE 和 SET 子句。

<update id="updateUser" parameterType="User">  
    UPDATE user  
    <set>  
        <if test="name != null">  
            name = #{name},  
        </if>  
        <if test="age != null">  
            age = #{age},  
        </if>  
    </set>  
    WHERE id = #{id}  
</update>

在这个更新操作中，<set> 标签会自动处理逗号和 WHERE 子句的前缀，避免在生成的 SQL 语句中出现多余的逗号或前缀。

4. <foreach> 标签

<foreach> 标签用于遍历集合，通常用于构建 IN 子句或批量插入/更新操作。

<select id="findUsersByIds" resultType="User">  
    SELECT * FROM user  
    WHERE id IN  
    <foreach item="id" index="index" collection="ids" open="(" separator="," close=")">  
        #{id}  
    </foreach>  
</select>

在这个例子中，ids 是一个包含多个 ID 的集合，<foreach> 标签会遍历这个集合，并生成一个由逗号分隔的 ID 列表，用于构建 IN 子句。

动态 SQL 是 MyBatis 中非常强大的一个特性，它允许你根据业务需求构建灵活多变的 SQL 语句，而无需在 Java 代码中拼接字符串或编写大量的条件逻辑。通过使用 MyBatis 提供的动态 SQL 标签，你可以编写更加清晰、可维护和易读的代码。

七、缓存使用

MyBatis 提供了两种类型的缓存：一级缓存（SqlSession 级别的缓存）和二级缓存（Mapper 级别的缓存）。这两种缓存都可以帮助提高数据库查询的性能，减少不必要的数据库访问。

1. 一级缓存

一级缓存是默认开启的，它基于 SqlSession，只要 SqlSession 没有关闭，一级缓存就有效。对于同一个 SqlSession 执行的相同的 SQL 语句，MyBatis 会从一级缓存中直接获取结果，而不会去数据库查询。

一级缓存的特点：

• 生命周期与 SqlSession 一致。
• 缓存的数据范围是针对同一个 SqlSession 的所有查询操作。
• 当执行增删改操作时，一级缓存会被清空。

2. 二级缓存

二级缓存是 Mapper 级别的缓存，多个 SqlSession 可以共享同一个二级缓存。当执行相同的 SQL 语句时，如果二级缓存中有数据，MyBatis 就会从二级缓存中获取结果，而不是去数据库查询。

启用二级缓存：

• 在 MyBatis 的全局配置文件中启用二级缓存（通常默认已启用）。
• 在需要使用二级缓存的 Mapper XML 文件中添加 <cache/> 标签。
• 也可以为 <cache/> 标签配置属性，以定制缓存的行为，例如设置缓存的过期时间、大小等。

二级缓存的特点：

• 生命周期与 Mapper 映射文件一致。
• 缓存的数据范围是跨 SqlSession 的，不同的 SqlSession 可以共享。
• 当执行增删改操作时，MyBatis 默认会清空该 Mapper 对应的二级缓存，但可以通过配置来改变这一行为。

注意事项：

• 当使用二级缓存时，需要确保查询的 SQL 语句和参数完全一致，否则 MyBatis 会认为它们是不同的查询，从而无法从缓存中获取结果。
• 由于二级缓存是跨 SqlSession 的，因此在使用时需要注意并发问题，避免脏读、脏写等问题的发生。
• 不是所有的查询都适合使用缓存，特别是对于那些数据变化频繁或者对实时性要求很高的查询，使用缓存可能会带来问题。因此，在使用缓存时需要根据实际情况进行判断和选择。

3.自定义缓存

除了使用 MyBatis 提供的默认缓存实现外，你还可以自定义缓存实现。这通常涉及实现 MyBatis 提供的接口，如 org.apache.ibatis.cache.Cache，并在 Mapper XML 文件中通过 <cache-ref/> 或 <cache type="你的自定义缓存类型"/> 来引用或使用它。

自定义缓存可以让你根据业务需求实现更复杂的缓存逻辑，例如集成第三方缓存库（如 Redis、Memcached 等）。但请注意，自定义缓存实现需要更多的工作，并可能引入额外的复杂性和性能开销。因此，在决定使用自定义缓存之前，请仔细评估其必要性和潜在影响。

八、多表关联查询

在 MyBatis 中，多表关联查询通常通过编写复杂的 SQL 语句来实现，并结合 MyBatis 的映射文件将查询结果映射到相应的 Java 对象上。MyBatis 支持多种关联查询方式，包括内连接（INNER JOIN）、左连接（LEFT JOIN）、右连接（RIGHT JOIN）等。

下面是一个使用 MyBatis 进行多表关联查询的示例：

假设我们有两个表，一个是用户表 user，另一个是订单表 order，它们通过用户ID进行关联。

user 表

CREATE TABLE user (  
    id INT PRIMARY KEY,  
    name VARCHAR(50),  
    email VARCHAR(50)  
);

order 表

CREATE TABLE order (  
    order_id INT PRIMARY KEY,  
    user_id INT,  
    order_date DATE,  
    amount DECIMAL(10, 2),  
    FOREIGN KEY (user_id) REFERENCES user(id)  
);

现在，我们想要查询某个用户的所有订单信息，包括订单详情和用户信息。

Mapper XML 文件

首先，我们需要在 Mapper XML 文件中编写一个 SQL 查询语句，并使用 <resultMap> 标签定义结果映射。

<mapper namespace="com.example.mapper.OrderMapper">  
    <!-- 定义结果映射 -->  
    <resultMap id="orderUserResultMap" type="OrderUser">  
        <id property="orderId" column="order_id"/>  
        <result property="orderDate" column="order_date"/>  
        <result property="amount" column="amount"/>  
        <association property="user" javaType="User">  
            <id property="id" column="id"/>  
            <result property="name" column="name"/>  
            <result property="email" column="email"/>  
        </association>  
    </resultMap>  
      
    <!-- 查询用户订单 -->  
    <select id="findOrdersByUserId" resultMap="orderUserResultMap">  
        SELECT o.order_id, o.order_date, o.amount, u.id, u.name, u.email  
        FROM order o  
        INNER JOIN user u ON o.user_id = u.id  
        WHERE u.id = #{userId}  
    </select>  
</mapper>

在这个示例中，我们定义了一个名为 orderUserResultMap 的结果映射，它将查询结果映射到 OrderUser 类型的对象上。OrderUser 是一个包含 Order 和 User 属性的自定义 Java 类，用于存储订单和用户信息。

在 <association> 标签中，我们定义了用户信息的映射关系。property 属性指定了 OrderUser 类中的用户属性名，javaType 属性指定了用户对象的类型。然后，我们使用 <id> 和 <result> 标签将数据库列映射到用户对象的属性上。

在 <select> 标签中，我们编写了一个 SQL 查询语句，使用 INNER JOIN 将 order 表和 user 表连接起来，并根据用户ID进行过滤。查询结果将使用 orderUserResultMap 进行映射。

Java 代码

在 Java 代码中，我们可以通过注入 OrderMapper 接口的实例来调用 findOrdersByUserId 方法进行查询。

@Autowired  
private OrderMapper orderMapper;  
  
public List<OrderUser> findOrdersByUserId(int userId) {  
    return orderMapper.findOrdersByUserId(userId);  
}

这样，当我们调用 findOrdersByUserId 方法并传入用户ID时，MyBatis 会执行相应的 SQL 查询语句，并将结果映射到 OrderUser 类型的对象列表上。我们就可以在 Java 代码中处理这些对象了。

这只是一个简单的示例，实际的多表关联查询可能会涉及更复杂的 SQL 语句和结果映射。你可以根据具体的业务需求和数据表结构来编写相应的 MyBatis 代码。

九、注解开发

MyBatis 支持基于注解的开发方式，允许开发者直接在接口方法上使用注解来替代 XML 映射文件。使用注解可以减少 XML 配置的复杂性，并使代码更加简洁。下面是一些常用的 MyBatis 注解：

1. @Select

用于执行查询操作。

@Select("SELECT * FROM user WHERE id = #{id}")  
User selectUserById(@Param("id") int id);

2. @Insert

用于执行插入操作。

@Insert("INSERT INTO user(name, age) VALUES(#{name}, #{age})")  
int insertUser(User user);

3. @Update

用于执行更新操作。

@Update("UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id}")  
int updateUser(User user);

4. @Delete

用于执行删除操作。

@Delete("DELETE FROM user WHERE id = #{id}")  
int deleteUser(@Param("id") int id);

5. @Results 和 @Result

用于处理复杂的结果映射，特别是在查询返回多个字段或需要映射到自定义对象时。

@Select("SELECT id, name, email FROM user")  
@Results({  
    @Result(id = true, column = "id", property = "id"),  
    @Result(column = "name", property = "name"),  
    @Result(column = "email", property = "email")  
})  
List<User> selectAllUsers();

6. @Param

当方法参数不止一个，或者需要指定 SQL 语句中参数的名称时，使用 @Param 注解。

@Select("SELECT * FROM user WHERE name = #{name} AND age = #{age}")  
User findUserByNameAndAge(@Param("name") String name, @Param("age") int age);

7. @SelectProvider、@InsertProvider、@UpdateProvider 和 @DeleteProvider

这些注解允许你使用类和方法来动态地构建 SQL 语句。

@SelectProvider(type = UserSqlBuilder.class, method = "buildSelectUserSql")  
User selectUserDynamically(Map<String, Object> params);

在 UserSqlBuilder 类中，你需要实现一个名为 buildSelectUserSql 的方法，该方法将返回动态构建的 SQL 字符串。

注意事项：

• 使用注解时，MyBatis 会自动扫描并注册标注了 @Mapper 或 @Repository 的接口。
• 注解方式虽然简洁，但不适合处理复杂 SQL 或需要大量配置的场景。对于这类情况，XML 映射文件通常更为灵活和强大。
• 注解和 XML 映射文件可以混合使用，你可以根据项目的具体需求选择最适合的方式。

最后，要确保你的 MyBatis 配置正确设置了注解扫描的路径，这样 MyBatis 才能找到并使用这些注解。这通常通过在 MyBatis 的配置文件中设置 mapperLocations 或使用 Spring Boot 的自动配置来完成。

---

 文章制作不易，如果有帮助的话，还希望能给个点赞和关注支持一下，谢谢大家！🙏🙏🙏