MyBatis 关联配置详解

原创 于 2025-08-20 05:19:51 发布 · 890 阅读 · 16 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#MyBatis # Association Mapping # Entity Relationships

📕我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。

📘拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、SpringBoot、SpringMVC、SpringCloud、Mybatis、Dubbo、Zookeeper)，消息中间件底层架构原理(RabbitMQ、RocketMQ、Kafka)、Redis缓存、MySQL关系型数据库、 ElasticSearch全文搜索、MongoDB非关系型数据库、Apache ShardingSphere分库分表读写分离、设计模式、领域驱动DDD、Kubernetes容器编排等。

📙不定期分享高并发、高可用、高性能、微服务、分布式、海量数据、性能调优、云原生、项目管理、产品思维、技术选型、架构设计、求职面试、副业思维、个人成长等内容。

Java程序员廖志伟

💡在这个美好的时刻，笔者不再啰嗦废话，现在毫不拖延地进入文章所要讨论的主题。接下来，我将为大家呈现正文内容。

CSDN

🍊 MyBatis核心知识点之association：概念与作用

在开发复杂的数据模型时，我们常常会遇到一个实体类与另一个实体类之间存在一对多或多对多的关系。例如，一个订单实体（Order）可能包含多个订单详情实体（OrderDetail），而一个用户实体（User）可能拥有多个角色实体（Role）。在这种情况下，如何有效地在MyBatis中映射这种关系，是保证数据模型完整性和查询效率的关键。

场景问题：假设我们正在开发一个在线购物平台，其中订单详情需要记录每个商品的具体信息，包括商品名称、数量和价格等。如果直接在订单实体中存储这些信息，会导致数据冗余，且在查询订单详情时效率低下。为了解决这个问题，我们需要在MyBatis中利用关联关系（association）来映射订单与订单详情之间的关系。

介绍MyBatis核心知识点之association：概念与作用的重要性在于，它能够帮助我们以清晰、高效的方式处理实体之间的复杂关系。通过合理地使用association，我们可以避免数据冗余，简化数据模型，同时提高数据库查询的性能。

接下来，我们将深入探讨association的概念，解释其如何在MyBatis中实现，以及它如何帮助我们更好地管理实体之间的关系。随后，我们将进一步阐述association的作用，包括如何通过它来优化查询性能，以及如何处理一对多和多对多的关联关系。通过这些内容，读者将能够全面理解association在MyBatis中的重要性，并在实际项目中灵活运用这一知识点。

🎉 MyBatis 关联关系概述

在 MyBatis 中，关联关系是处理实体之间复杂关系的重要机制。它允许我们在查询时获取到关联的实体信息，从而简化了数据访问层的操作。下面，我们将详细探讨 MyBatis 中的关联关系，包括一对一、一对多、多对一和多对多关联，以及级联属性、嵌套查询、自定义关联映射和关联关系配置等内容。

🎉 一对一关联

一对一关联是指一个实体对应另一个实体。例如，一个用户可能只有一个地址。下面是一个一对一关联的示例：

```mermaid
graph LR
A[User] --> B[Address]

在这个例子中，一个用户（User）关联到一个地址（Address）。

🎉 一对多关联

一对多关联是指一个实体可以关联到多个实体。例如，一个班级可以有多个学生。下面是一对多关联的示例：

```mermaid
graph LR
A[Class] --> B{Student}
B --> C[Student]

在这个例子中，一个班级（Class）关联到多个学生（Student）。

🎉 多对一关联

多对一关联是指多个实体关联到一个实体。例如，多个订单可能属于同一个客户。下面是多对一关联的示例：

```mermaid
graph LR
A{Order} --> B[Customer]

在这个例子中，多个订单（Order）关联到一个客户（Customer）。

🎉 多对多关联

多对多关联是指多个实体之间相互关联。例如，多个学生可以选修多个课程。下面是多对多关联的示例：

```mermaid
graph LR
A{Student} --> B{Course}
B --> C{Student}

在这个例子中，多个学生（Student）可以选修多个课程（Course）。

🎉 级联属性

级联属性是指在关联查询中，除了主键之外，还可以查询关联实体的其他属性。例如，查询用户时，同时获取用户的地址信息。

<select id="selectUser" resultMap="userMap">
  SELECT * FROM user WHERE id = #{id}
</select>
<resultMap id="userMap" type="User">
  <id property="id" column="id" />
  <result property="name" column="name" />
  <association property="address" column="address_id" select="selectAddress" />
</resultMap>
<select id="selectAddress" resultType="Address">
  SELECT * FROM address WHERE id = #{id}
</select>

🎉 嵌套查询

嵌套查询是指在查询结果中包含另一个查询的结果。例如，查询用户时，同时获取用户的订单列表。

<select id="selectUser" resultMap="userMap">
  SELECT * FROM user WHERE id = #{id}
</select>
<resultMap id="userMap" type="User">
  <id property="id" column="id" />
  <result property="name" column="name" />
  <collection property="orders" column="id" select="selectOrders" />
</resultMap>
<select id="selectOrders" resultType="Order">
  SELECT * FROM order WHERE user_id = #{id}
</select>

🎉 自定义关联映射

自定义关联映射允许我们自定义关联查询的 SQL 语句。例如，查询用户时，使用自定义的 SQL 语句获取用户的订单列表。

<select id="selectUser" resultMap="userMap">
  SELECT * FROM user WHERE id = #{id}
</select>
<resultMap id="userMap" type="User">
  <id property="id" column="id" />
  <result property="name" column="name" />
  <collection property="orders" column="id" select="selectOrdersByUserId" />
</resultMap>
<select id="selectOrdersByUserId" resultType="Order">
  SELECT * FROM order WHERE user_id = #{id}
</select>

🎉 关联关系配置

关联关系配置包括在 MyBatis 配置文件中定义关联关系，以及使用注解方式定义关联关系。

📝 配置文件方式
<resultMap id="userMap" type="User">
  <id property="id" column="id" />
  <result property="name" column="name" />
  <association property="address" column="address_id" select="selectAddress" />
</resultMap>
📝 注解方式
@Results({
  @Result(property = "id", column = "id"),
  @Result(property = "name", column = "name"),
  @Result(property = "address", column = "address_id", javaType = Address.class, one = @One(select = "selectAddress"))
})

🎉 关联关系性能优化

关联关系性能优化主要包括以下几个方面：

  1. 合理使用缓存：通过缓存关联查询结果，减少数据库访问次数。
  2. 优化 SQL 语句：使用合适的 SQL 语句，减少查询时间和资源消耗。
  3. 分页查询：对于关联查询结果较多的情况，使用分页查询可以减少内存消耗。

通过以上方法，我们可以有效地优化 MyBatis 中的关联关系性能。

🎉 关联关系定义

在 MyBatis 中，关联关系指的是实体之间的相互关系。例如，一个学生实体可能有一个班级实体与之关联，这种关系就是关联关系。关联关系可以是简单的，也可以是复杂的。

🎉 映射文件配置

在 MyBatis 的映射文件中，通过 <association> 标签来配置关联关系。这个标签可以用来指定关联实体的映射信息，包括关联实体的类名、映射的属性名等。

🎉 一对一关联

一对一关联是指一个实体只与另一个实体有一个关联。例如，一个用户实体可能只有一个角色实体与之关联。

<resultMap id="userMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="role" column="role_id" select="selectRoleById" />
</resultMap>

🎉 一对多关联

一对多关联是指一个实体可以与多个实体关联。例如，一个班级实体可以与多个学生实体关联。

<resultMap id="classMap" type="Class">
    <id property="id" column="class_id" />
    <result property="className" column="class_name" />
    <collection property="students" column="class_id" select="selectStudentsByClassId" />
</resultMap>

🎉 多对多关联

多对多关联是指多个实体之间相互关联。例如，一个学生可以选修多个课程，一个课程可以被多个学生选修。

<resultMap id="studentCourseMap" type="StudentCourse">
    <id property="id" column="id" />
    <result property="studentId" column="student_id" />
    <result property="courseId" column="course_id" />
    <association property="student" column="student_id" select="selectStudentById" />
    <association property="course" column="course_id" select="selectCourseById" />
</resultMap>

🎉 关联加载策略

关联加载策略决定了何时加载关联实体。MyBatis 提供了三种加载策略：lazy（懒加载）、eager（立即加载）和select（选择加载）。

🎉 关联懒加载

懒加载是指在查询主实体时，不立即加载关联实体，而是在需要时才加载。这可以减少数据库的查询次数，提高性能。

<association property="role" column="role_id" select="selectRoleById" fetchType="lazy" />

🎉 关联嵌套查询

嵌套查询是指在查询关联实体时，使用另一个 SQL 查询语句。这可以用来实现复杂的关联关系。

<association property="role" column="role_id" select="selectRoleById" />

🎉 关联缓存处理

MyBatis 支持关联缓存，可以用来提高性能。通过配置 <cache> 标签，可以开启关联缓存。

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true" />

🎉 关联性能优化

为了优化关联性能，可以采取以下措施：

  • 使用合适的关联加载策略。
  • 使用索引来提高查询效率。
  • 避免在关联查询中使用复杂的 SQL 语句。
  • 使用缓存来减少数据库的查询次数。

通过以上措施，可以有效地提高 MyBatis 中关联关系的性能。

🍊 MyBatis核心知识点之association：配置方式

在开发过程中，我们经常会遇到需要将多个实体之间的关系映射到数据库中的情况。例如，一个用户可以拥有多个订单，这种关系在数据库中通常表现为一对多。MyBatis作为一个强大的持久层框架，提供了关联（association）的配置方式来处理实体之间的关系。下面，我们将通过一个具体的场景来引出MyBatis核心知识点之association：配置方式的重要性。

场景描述： 假设我们正在开发一个在线书店项目，其中有一个Book实体和一个Author实体。每个Book实体都关联了一个Author实体，而一个Author实体可以写多本书。在这种情况下，如果我们直接在数据库中查询Book实体，我们需要手动处理与Author实体的关联关系，这无疑会增加代码的复杂度和出错的可能性。

为什么需要介绍MyBatis核心知识点之association：配置方式？ 在MyBatis中，通过配置association可以简化实体之间的关系映射，使得开发者无需手动编写繁琐的关联查询代码。这种方式不仅提高了代码的可读性和可维护性，而且能够有效减少因手动处理关联关系而引入的错误。在大型项目中，这种配置方式尤其重要，因为它有助于构建一个健壮且易于扩展的持久层架构。

接下来，我们将对以下三级标题内容进行概述，帮助读者建立整体认知：

  • MyBatis核心知识点之association：一对一配置、一对一配置步骤、一对一配置示例：这部分内容将详细介绍如何在一对一的关系中配置association，包括如何设置关联的映射关系、如何编写相应的SQL语句以及如何处理查询结果。
  • MyBatis核心知识点之association：一对多配置、一对多配置步骤、一对多配置示例：这部分内容将深入探讨在一对多的关系中使用association的配置方法，包括如何处理多个子实体的加载、如何优化查询性能等。
  • MyBatis核心知识点之association：多对多配置、多对多配置步骤、多对多配置示例：这部分内容将介绍如何在多对多的关系中使用association，包括如何创建中间表、如何配置关联关系以及如何处理复杂的查询需求。

通过这些内容的介绍，读者将能够全面理解MyBatis中association的配置方式，并能够在实际项目中灵活运用，从而提高开发效率和项目质量。

🎉 MyBatis 一对一关系配置

在 MyBatis 中，一对一关系通常指的是两个实体类之间存在一种“属于”的关系，即一个实体类中的某个属性是另一个实体类的实例。例如，一个 User 实体类可能包含一个 Address 实体类的属性，表示该用户有一个地址。

📝 配置方式对比
配置方式优点缺点
关联查询简单易用，易于理解性能较低，需要多次查询数据库
嵌套查询性能较好，减少数据库访问次数配置复杂，代码冗余

关联查询：通过在查询时直接关联另一个表，获取关联数据。这种方式简单易用，但性能较低，因为每次查询都需要访问两个表。

嵌套查询：通过在映射文件中定义一个查询，然后在结果映射中调用这个查询。这种方式性能较好，因为它减少了数据库访问次数，但配置复杂，代码冗余。

📝 映射文件

在 MyBatis 的映射文件中，使用 <association> 标签来配置一对一关系。

<resultMap id="userAddressMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" javaType="Address">
        <id property="id" column="address_id" />
        <result property="street" column="street" />
        <result property="city" column="city" />
    </association>
</resultMap>
📝 属性配置

在实体类中，定义属性来表示一对一关系。

public class User {
    private Integer id;
    private String username;
    private Address address;
    // getters and setters
}

public class Address {
    private Integer id;
    private String street;
    private String city;
    // getters and setters
}
📝 结果映射

在 <resultMap> 中，使用 <association> 标签来配置一对一关系。

<resultMap id="userAddressMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" javaType="Address">
        <id property="id" column="address_id" />
        <result property="street" column="street" />
        <result property="city" column="city" />
    </association>
</resultMap>
📝 关联查询

在查询时，使用 <select> 标签来获取关联数据。

<select id="selectUserById" resultMap="userAddressMap">
    SELECT u.id, u.username, a.id AS address_id, a.street, a.city
    FROM users u
    LEFT JOIN addresses a ON u.address_id = a.id
    WHERE u.id = #{id}
</select>
📝 嵌套查询

在 <resultMap> 中，使用 <association> 标签来配置嵌套查询。

<resultMap id="userAddressMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" select="selectAddressById" />
</resultMap>

<select id="selectAddressById" resultType="Address">
    SELECT id, street, city
    FROM addresses
    WHERE id = #{id}
</select>
📝 SQL语句编写

在 SQL 语句中，使用 JOIN 或子查询来获取关联数据。

SELECT u.id, u.username, a.id AS address_id, a.street, a.city
FROM users u
LEFT JOIN addresses a ON u.address_id = a.id
WHERE u.id = #{id}
📝 实体类设计

在实体类中，定义属性来表示一对一关系，并使用 getter 和 setter 方法。

public class User {
    private Integer id;
    private String username;
    private Address address;
    // getters and setters
}

public class Address {
    private Integer id;
    private String street;
    private String city;
    // getters and setters
}
📝 关联关系定义

在实体类中，定义属性来表示一对一关系，并使用 getter 和 setter 方法。

public class User {
    private Integer id;
    private String username;
    private Address address;
    // getters and setters
}

public class Address {
    private Integer id;
    private String street;
    private String city;
    // getters and setters
}
📝 配置示例

以下是一个完整的配置示例，包括实体类、映射文件和 SQL 语句。

public class User {
    private Integer id;
    private String username;
    private Address address;
    // getters and setters
}

public class Address {
    private Integer id;
    private String street;
    private String city;
    // getters and setters
}

<resultMap id="userAddressMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" javaType="Address">
        <id property="id" column="address_id" />
        <result property="street" column="street" />
        <result property="city" column="city" />
    </association>
</resultMap>

<select id="selectUserById" resultMap="userAddressMap">
    SELECT u.id, u.username, a.id AS address_id, a.street, a.city
    FROM users u
    LEFT JOIN addresses a ON u.address_id = a.id
    WHERE u.id = #{id}
</select>
📝 性能优化

为了提高性能，可以考虑以下优化措施：

  • 使用缓存来减少数据库访问次数。
  • 使用合适的索引来提高查询效率。
  • 选择合适的数据库连接池。
📝 应用场景

一对一关系在以下场景中非常有用：

  • 用户与地址的关系。
  • 商品与分类的关系。
  • 部门与员工的关系。

通过以上内容，我们可以了解到 MyBatis 中一对一关系的配置方法、属性配置、结果映射、关联查询、嵌套查询、SQL语句编写、实体类设计、关联关系定义、配置示例、性能优化和应用场景。希望这些内容能帮助您更好地理解和应用 MyBatis 的一对一关系配置。

🎉 MyBatis 之 association：一对一配置步骤详解

在 MyBatis 中，association 标签用于配置一对一的关联关系。这种配置允许我们在查询一个实体时，同时获取与之关联的另一个实体。下面，我将详细讲解如何进行一对一配置。

📝 一对一配置步骤

在进行一对一配置之前，我们需要明确以下几点：

  1. 实体类：定义两个实体类，分别代表两个关联的表。
  2. 映射文件：在 MyBatis 的映射文件中配置一对一的关联关系。
  3. 配置文件：确保 MyBatis 配置文件正确配置。

下面，我将通过一个具体的例子来讲解一对一配置的步骤。

📝 实体类

假设我们有两个实体类：Student 和 Classroom。Student 类代表学生表，Classroom 类代表教室表。它们之间存在一对一的关系，即一个学生属于一个教室。

public class Student {
    private Integer id;
    private String name;
    private Classroom classroom;

    // 省略 getter 和 setter 方法
}

public class Classroom {
    private Integer id;
    private String name;

    // 省略 getter 和 setter 方法
}
📝 映射文件

在 MyBatis 的映射文件中，我们需要配置 association 标签来表示一对一的关系。

<mapper namespace="com.example.mapper.StudentMapper">
    <!-- 查询学生信息及其所属教室信息 -->
    <select id="selectStudentAndClassroom" resultType="com.example.entity.Student">
        SELECT s.id, s.name, c.id AS classroom_id, c.name AS classroom_name
        FROM student s
        LEFT JOIN classroom c ON s.classroom_id = c.id
    </select>

    <!-- 配置一对一关联关系 -->
    <resultMap id="studentResultMap" type="com.example.entity.Student">
        <id property="id" column="id" />
        <result property="name" column="name" />
        <!-- 使用 association 标签配置一对一关联关系 -->
        <association property="classroom" javaType="com.example.entity.Classroom">
            <id property="id" column="classroom_id" />
            <result property="name" column="classroom_name" />
        </association>
    </resultMap>
</mapper>
📝 配置文件

确保 MyBatis 配置文件正确配置，以便 MyBatis 能够找到映射文件。

<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/mydb" />
                <property name="username" value="root" />
                <property name="password" value="password" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/mapper/StudentMapper.xml" />
    </mappers>
</configuration>
📝 总结

通过以上步骤，我们成功配置了 MyBatis 的一对一关联关系。在实际项目中，我们可以根据需要调整实体类、映射文件和配置文件，以满足不同的业务需求。

🎉 MyBatis 中的 association：一对一配置示例

在 MyBatis 中，association 元素用于配置一对一的关联关系。这种配置允许我们在查询一个实体时，同时获取与之关联的另一个实体。下面，我们将详细探讨如何使用 association 元素进行一对一配置。

📝 实体类设计

首先，我们需要设计两个实体类，假设我们有一个 User 类和一个 Address 类，其中 User 和 Address 之间存在一对一的关系。

public class User {
    private Integer id;
    private String name;
    private Address address; // 一对一关联

    // 省略 getter 和 setter 方法
}

public class Address {
    private Integer id;
    private String street;
    private String city;

    // 省略 getter 和 setter 方法
}
📝 属性映射

在 XML 映射文件中，我们需要配置 User 类的 address 属性的映射。这里使用 association 元素来指定一对一的关联关系。

<resultMap id="userAddressMap" type="User">
    <id property="id" column="user_id"/>
    <result property="name" column="user_name"/>
    <association property="address" column="user_id" javaType="Address" select="selectAddressByUserId"/>
</resultMap>

在上面的 XML 配置中，association 元素指定了 address 属性的映射。property 属性指定了在 User 实体类中对应的属性名，column 属性指定了数据库中用于关联的字段名，javaType 属性指定了关联实体的类型，select 属性指定了用于加载关联实体的查询语句的 ID。

📝 关联查询

接下来，我们需要在 XML 映射文件中定义用于加载 Address 实体的查询语句。

<select id="selectAddressByUserId" resultType="Address">
    SELECT id, street, city FROM address WHERE user_id = #{id}
</select>

这个查询语句根据 User 实体的 id 查询对应的 Address 实体。

📝 结果集处理

当 MyBatis 执行查询时，它会根据 resultMap 中的配置来处理结果集。对于 association 配置，MyBatis 会执行指定的查询语句来加载关联的实体。

📝 示例代码

下面是一个使用 MyBatis 进行一对一查询的示例代码。

public class UserMapper {
    @Select("SELECT * FROM user WHERE id = #{id}")
    @ResultMap("userAddressMap")
    User getUserById(Integer id);
}

在这个示例中，getUserById 方法会返回一个 User 对象，其中包含了与该用户关联的 Address 对象。

📝 配置细节

在配置一对一关联时，需要注意以下几点：

  • 确保关联的字段在数据库中存在。
  • column 属性应与数据库中的关联字段匹配。
  • select 属性应指向正确的查询语句。
📝 性能优化

为了优化性能，可以考虑以下策略：

  • 使用缓存来减少数据库查询次数。
  • 选择合适的索引来提高查询效率。
📝 应用场景

一对一配置在以下场景中非常有用：

  • 当一个实体与另一个实体之间存在一对一的关系时。
  • 当需要同时获取关联实体的信息时。

通过以上内容，我们详细介绍了 MyBatis 中 association 元素的使用方法，包括实体类设计、属性映射、关联查询、结果集处理、示例代码、配置细节、性能优化以及应用场景。希望这些信息能帮助您更好地理解和应用 MyBatis 的一对一关联配置。

🎉 关联关系配置原理

在 MyBatis 中，association 标签用于配置一对多关联关系。这种关系通常存在于实体类之间，其中一方可以包含另一方的多个实例。配置原理基于 Java 的反射机制，MyBatis 会根据映射文件中的配置，动态地构建出相应的关联对象。

🎉 一对多映射配置方法

一对多映射配置通常涉及以下几个步骤：

  1. 在主实体类中定义一个集合属性，用于存放关联的实体对象。
  2. 在映射文件中，使用 association 标签配置一对多关系。
  3. 在 association 标签中，指定关联实体的类名、映射的属性名以及关联查询的 SQL 语句。

以下是一个简单的示例：

<resultMap id="UserResultMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="orders" javaType="List<Order>" column="user_id" select="selectOrdersByUserId" />
</resultMap>

🎉 关联查询语句编写

关联查询语句通常在映射文件中通过 select 属性指定。以下是一个示例：

<select id="selectOrdersByUserId" resultType="Order">
    SELECT * FROM orders WHERE user_id = #{id}
</select>

🎉 关联结果集处理

在执行查询后，MyBatis 会根据 association 标签的配置，将查询结果映射到主实体类的关联属性中。处理关联结果集时，需要注意以下几点：

  1. 确保关联查询返回的结果集与映射文件中的 resultMap 配置一致。
  2. 如果关联查询返回的结果集包含多个实体对象，需要使用集合类型配置。

🎉 集合类型配置

在 MyBatis 中，集合类型配置通常使用 <collection> 标签。以下是一个示例：

<collection property="orders" javaType="List<Order>" column="user_id" select="selectOrdersByUserId" />

🎉 级联属性配置

级联属性配置允许在关联查询中包含额外的属性。以下是一个示例：

<association property="orders" javaType="List<Order>" column="user_id" select="selectOrdersByUserId">
    <result property="orderDate" column="order_date" />
</association>

🎉 集合属性映射

集合属性映射与普通属性映射类似，只是需要使用 <collection> 标签。以下是一个示例：

<collection property="orders" javaType="List<Order>" column="user_id" select="selectOrdersByUserId">
    <resultMap id="OrderResultMap" type="Order">
        <id property="id" column="order_id" />
        <result property="orderDate" column="order_date" />
        <!-- 其他属性映射 -->
    </resultMap>
</collection>

🎉 关联查询优化

为了优化关联查询，可以考虑以下策略：

  1. 使用索引：确保关联查询中的列上有索引，以提高查询效率。
  2. 选择合适的查询策略：例如，使用 fetchType="lazy" 实现延迟加载，减少数据库访问次数。

🎉 与其他配置元素结合使用

association 标签可以与其他配置元素结合使用，例如：

  • resultMap：用于定义复杂的映射关系。
  • cache：用于配置二级缓存。

🎉 实际应用案例

在实际项目中，一对多关联关系配置广泛应用于用户与订单、商品与评论等场景。以下是一个简单的用户与订单关联关系的示例：

public class User {
    private Integer id;
    private String username;
    private List<Order> orders;
    // getters and setters
}

public class Order {
    private Integer id;
    private Date orderDate;
    // getters and setters
}

在 MyBatis 映射文件中，配置一对多关联关系如下：

<resultMap id="UserOrderResultMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <collection property="orders" javaType="List<Order>" column="user_id" select="selectOrdersByUserId" />
</resultMap>

通过以上配置，可以方便地查询用户及其订单信息。

🎉 关联关系配置原理

在 MyBatis 中，关联关系配置主要是指如何将一个实体类与另一个实体类进行关联。以一对多为例，假设我们有一个 User 实体类和一个 Order 实体类，其中每个 User 可以有多个 Order。在 MyBatis 中，我们通过配置文件来定义这种关联关系。

关联关系配置的原理是基于 XML 配置文件中的 <association> 标签。这个标签允许我们在查询一个实体时，同时加载与之关联的实体集合。在内部，MyBatis 会根据 <association> 标签的配置，执行一个额外的查询来获取关联的实体集合。

🎉 一对多映射配置步骤

📝 步骤 1：定义实体类

首先，我们需要定义 User 和 Order 两个实体类，并确保它们之间有一对多的关系。

public class User {
    private Integer id;
    private String name;
    private List<Order> orders;
    // getters and setters
}

public class Order {
    private Integer id;
    private String orderNumber;
    private User user;
    // getters and setters
}
📝 步骤 2：配置映射文件

在 MyBatis 的映射文件中，我们需要为 User 实体类配置一个查询语句，并使用 <association> 标签来指定与 Order 的关联关系。

<select id="selectUser" resultType="User">
    SELECT * FROM user WHERE id = #{id}
    <association property="orders" column="id" select="selectOrdersByUserId"/>
</select>

<select id="selectOrdersByUserId" resultType="Order">
    SELECT * FROM order WHERE user_id = #{id}
</select>

🎉 关联查询语句编写

在上面的配置中，selectUser 查询会返回一个 User 对象，而 <association> 标签中的 select 属性指定了一个额外的查询 selectOrdersByUserId，它会返回与当前 User 关联的所有 Order 对象。

🎉 配置文件属性设置

在 <association> 标签中，我们可以设置一些属性来进一步控制关联查询的行为：

  • property：指定关联的属性名，即 User 中的 orders。
  • column：指定用于关联查询的列名，即 User 表中的 id。
  • select：指定用于加载关联实体的查询语句的 ID。

🎉 关联映射标签使用

在 MyBatis 中，除了 <association> 标签，还可以使用 <collection> 标签来配置一对多关系。<collection> 标签与 <association> 标签类似，但用于处理集合类型的关联。

<collection property="orders" column="id" select="selectOrdersByUserId"/>

🎉 集成示例代码

以下是一个简单的集成示例，展示了如何在 MyBatis 中使用关联关系：

public class UserMapper {
    @Select("selectUser")
    User selectUser(@Param("id") Integer id);
}

public class OrderMapper {
    @Select("selectOrdersByUserId")
    List<Order> selectOrdersByUserId(@Param("id") Integer id);
}

🎉 性能优化建议

为了优化性能，可以考虑以下建议：

  • 只加载必要的关联数据。
  • 使用缓存来减少数据库查询次数。
  • 考虑使用延迟加载（懒加载）来减少初始加载时间。

🎉 异常处理与调试

在处理关联关系时，可能会遇到各种异常，如 SQL 异常、数据转换异常等。为了调试这些问题，可以使用以下方法：

  • 查看详细的 SQL 日志。
  • 使用日志记录查询语句和参数。
  • 检查实体类和映射文件中的配置是否正确。

🎉 与其他配置标签的配合使用

在 MyBatis 中，关联关系可以与其他配置标签配合使用，如 <resultMap>、<sql> 等。例如，可以使用 <resultMap> 来定义复杂的关联关系映射，或者使用 <sql> 来重用 SQL 代码片段。

通过以上内容，我们可以看到 MyBatis 中一对多关联关系的配置和使用方法。在实际项目中，合理配置和使用关联关系可以简化代码，提高开发效率。

🎉 MyBatis 中的 association：一对多关系配置示例

在 MyBatis 中，association 标签用于配置一对多关系。所谓一对多，指的是一个实体类可以与多个另一个实体类相关联。下面，我将通过一个示例来详细解释如何配置一对多关系。

📝 对比与列举：一对多关系与多对一关系的区别
特征一对多关系多对一关系
关系描述一个实体类可以与多个另一个实体类相关联多个实体类可以与一个另一个实体类相关联
关联方式使用 association 标签使用 collection 标签
示例一个班级有多个学生一个学生属于一个班级
📝 配置示例

假设我们有两个实体类：Class 和 Student。一个班级可以有多个学生，因此这是一个典型的一对多关系。

public class Class {
    private Integer id;
    private String name;
    private List<Student> students;
}

public class Student {
    private Integer id;
    private String name;
    private Class clazz;
}

接下来，我们来看如何在 MyBatis 的映射文件中配置这个一对多关系。

📝 映射文件
<mapper namespace="com.example.mapper.ClassMapper">
    <!-- 查询班级信息及其学生信息 -->
    <select id="selectClassAndStudents" resultType="Class">
        SELECT c.id, c.name, s.id AS student_id, s.name AS student_name
        FROM class c
        LEFT JOIN student s ON c.id = s.clazz_id
    </select>
    
    <!-- 配置一对多关系 -->
    <resultMap id="classResultMap" type="Class">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!-- 使用 association 标签配置一对多关系 -->
        <association property="students" javaType="List<Student">
            <id property="id" column="student_id"/>
            <result property="name" column="student_name"/>
        </association>
    </resultMap>
</mapper>
📝 结果集处理

在上面的映射文件中，我们使用了 resultMap 来定义结果集的处理方式。在 resultMap 中，我们使用 association 标签来配置一对多关系。property 属性指定了关联的集合属性名，javaType 属性指定了集合中元素的类型。

📝 关联查询

在执行查询时，MyBatis 会根据 resultMap 中的配置来处理结果集。对于一对多关系，MyBatis 会将关联的集合数据填充到对应的实体类属性中。

public List<Class> selectClassAndStudents() {
    // ... 执行查询 ...
}
📝 性能优化

在处理一对多关系时，需要注意性能优化。如果数据量较大，可以考虑以下优化措施：

  • 使用懒加载（Lazy Loading）：在查询班级信息时，暂时不加载学生信息，直到真正需要时才加载。
  • 使用分页查询：对关联的集合数据进行分页查询，减少一次性加载的数据量。
📝 应用场景

一对多关系在许多实际场景中都有应用，例如：

  • 学校与课程：一个学校可以开设多个课程。
  • 公司与部门：一个公司可以拥有多个部门。
  • 图书馆与书籍：一个图书馆可以存放多本书籍。

通过以上示例，我们可以看到如何在 MyBatis 中配置一对多关系。在实际项目中，根据具体需求，我们可以灵活运用这些配置技巧。

🎉 MyBatis 多对多关系配置

在 MyBatis 中，处理多对多关系是一种常见的需求。多对多关系意味着两个表中的记录可以相互关联，每个表中的记录都可以与另一个表中的多个记录相关联。下面，我们将详细探讨 MyBatis 中如何配置多对多关系。

📝 关联配置

在 MyBatis 中，多对多关系通常通过关联配置来实现。关联配置允许我们在一个映射文件中定义两个表之间的关系。

配置项说明
<resultMap>定义了如何将数据库中的结果集映射到 Java 对象。
association用于配置多对多关系。
collection用于配置一对多关系。
📝 映射文件

在 MyBatis 的映射文件中，我们需要定义两个实体类，分别对应数据库中的两个表。以下是一个简单的示例：

<resultMap id="UserOrderMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <collection property="orders" ofType="Order">
        <id property="id" column="order_id" />
        <result property="orderName" column="order_name" />
    </collection>
</resultMap>

在这个映射文件中，我们定义了一个 User 实体类和一个 Order 实体类。User 实体类有一个 orders 属性，它是一个 Order 实体类的集合，表示用户和订单之间的多对多关系。

📝 一对一配置

在多对多关系中，我们通常需要使用一对一配置来关联两个实体类。以下是一个一对一配置的示例：

<resultMap id="OrderDetailMap" type="Order">
    <id property="id" column="order_id" />
    <result property="orderName" column="order_name" />
    <association property="orderDetail" javaType="OrderDetail">
        <id property="id" column="detail_id" />
        <result property="detailName" column="detail_name" />
    </association>
</resultMap>

在这个示例中，我们定义了一个 Order 实体类和一个 OrderDetail 实体类。Order 实体类有一个 orderDetail 属性，它是一个 OrderDetail 实体类，表示订单和订单详情之间的一对一关系。

📝 级联关系

在 MyBatis 中，我们可以使用级联关系来简化关联配置。以下是一个级联关系的示例：

<resultMap id="UserOrderMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <collection property="orders" ofType="Order" column="user_id" select="selectOrdersByUserId" />
</resultMap>

在这个示例中，我们使用了一个子查询来获取用户的所有订单。selectOrdersByUserId 是一个 MyBatis 映射语句，它返回用户的所有订单。

📝 嵌套查询

在 MyBatis 中，我们还可以使用嵌套查询来处理多对多关系。以下是一个嵌套查询的示例：

<select id="selectUsersByOrder" resultMap="UserOrderMap">
    SELECT u.*, o.*
    FROM users u
    JOIN orders o ON u.id = o.user_id
    WHERE o.order_id = #{orderId}
</select>

在这个示例中，我们使用了一个嵌套查询来获取与特定订单相关的所有用户。

📝 自定义SQL

在处理多对多关系时，我们可能需要自定义 SQL 语句。以下是一个自定义 SQL 语句的示例：

<select id="selectUsersByOrder" resultMap="UserOrderMap">
    SELECT u.*, o.*
    FROM users u
    LEFT JOIN orders o ON u.id = o.user_id
    WHERE o.order_id = #{orderId}
</select>

在这个示例中，我们使用了一个左连接来获取与特定订单相关的所有用户。

📝 动态SQL

在 MyBatis 中，我们可以使用动态 SQL 来处理多对多关系。以下是一个动态 SQL 的示例：

<select id="selectUsersByOrder" resultMap="UserOrderMap">
    SELECT u.*, o.*
    FROM users u
    <where>
        <if test="orderId != null">
            AND o.order_id = #{orderId}
        </if>
    </where>
</select>

在这个示例中，我们使用了一个 if 标签来动态地添加条件。

📝 结果集处理

在 MyBatis 中，我们可以使用结果集处理来处理多对多关系。以下是一个结果集处理的示例：

<select id="selectUsersByOrder" resultMap="UserOrderMap">
    SELECT u.*, o.*
    FROM users u
    JOIN orders o ON u.id = o.user_id
    WHERE o.order_id = #{orderId}
</select>

在这个示例中，我们使用了一个 resultMap 来定义如何将数据库中的结果集映射到 Java 对象。

📝 实体类设计

在 MyBatis 中，我们需要设计实体类来表示数据库中的表。以下是一个实体类的示例：

public class User {
    private Integer id;
    private String username;
    private List<Order> orders;
    // getters and setters
}

public class Order {
    private Integer id;
    private String orderName;
    // getters and setters
}

在这个示例中，我们定义了两个实体类 User 和 Order，分别对应数据库中的两个表。

📝 数据库表结构

在数据库中，我们需要创建两个表来表示多对多关系。以下是一个数据库表结构的示例：

CREATE TABLE users (
    id INT PRIMARY KEY,
    username VARCHAR(50)
);

CREATE TABLE orders (
    id INT PRIMARY KEY,
    user_id INT,
    order_name VARCHAR(50),
    FOREIGN KEY (user_id) REFERENCES users(id)
);

在这个示例中，我们创建了两个表 users 和 orders，其中 orders 表中的 user_id 字段是外键，它引用了 users 表中的 id 字段。

📝 示例代码

以下是一个使用 MyBatis 处理多对多关系的示例代码：

public List<User> getUsersByOrder(Integer orderId) {
    SqlSession sqlSession = sqlSessionFactory.openSession();
    try {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        return userMapper.selectUsersByOrder(orderId);
    } finally {
        sqlSession.close();
    }
}

在这个示例中，我们使用了一个 MyBatis 映射器 UserMapper 来获取与特定订单相关的所有用户。

📝 配置示例

以下是一个 MyBatis 配置文件的示例：

<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/mydb" />
                <property name="username" value="root" />
                <property name="password" value="password" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/mapper/UserMapper.xml" />
    </mappers>
</configuration>

在这个示例中，我们配置了 MyBatis 的环境、数据源和映射文件。

📝 性能优化

在处理多对多关系时，性能优化是一个重要的考虑因素。以下是一些性能优化的建议：

  • 使用索引：确保数据库表中的外键字段上有索引。
  • 缓存：使用缓存来减少数据库访问次数。
  • 分页：使用分页来减少一次性加载的数据量。
📝 最佳实践

以下是一些处理多对多关系的最佳实践：

  • 使用关联配置来简化映射文件。
  • 使用级联关系来简化关联配置。
  • 使用嵌套查询来处理复杂的多对多关系。
  • 使用自定义 SQL 来处理特殊的多对多关系。
  • 使用动态 SQL 来处理动态的多对多关系。
  • 使用结果集处理来处理复杂的多对多关系。
  • 设计合理的实体类和数据库表结构。
  • 使用缓存和分页来优化性能。

通过以上内容，我们可以看到 MyBatis 在处理多对多关系方面提供了丰富的配置选项和最佳实践。希望这些信息能帮助您更好地理解和应用 MyBatis 的多对多关系配置。

🎉 MyBatis 多对多关系配置步骤详解

在 MyBatis 中，处理多对多关系是一种常见的需求。多对多关系意味着两个实体类之间存在多个实例之间的关系。下面，我们将详细探讨 MyBatis 中如何配置多对多关系。

📝 配置步骤对比与列举
步骤描述代码示例
1. 实体类设计设计两个实体类，分别代表多对多关系中的两个实体。```java

public class Student { private Integer id; private String name; // 省略其他属性和getter/setter方法 }

public class Course { private Integer id; private String name; // 省略其他属性和getter/setter方法 }

| 2. 关联表设计 | 在数据库中设计一个关联表，用于存储多对多关系的数据。 | ```sql
CREATE TABLE student_course (
    student_id INT,
    course_id INT,
    PRIMARY KEY (student_id, course_id),
    FOREIGN KEY (student_id) REFERENCES student(id),
    FOREIGN KEY (course_id) REFERENCES course(id)
);
``` |
| 3. 配置文件编写 | 在 MyBatis 的配置文件中，配置实体类与数据库表的映射关系。 | ```xml
<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/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/mapper/StudentMapper.xml"/>
        <mapper resource="com/example/mapper/CourseMapper.xml"/>
    </mappers>
</configuration>
``` |
| 4. XML映射文件 | 在 XML 映射文件中，配置多对多关系的映射。 | ```xml
<mapper namespace="com.example.mapper.StudentMapper">
    <resultMap id="studentResultMap" type="Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <collection property="courses" ofType="Course">
            <id property="id" column="course_id"/>
            <result property="name" column="course_name"/>
        </collection>
    </resultMap>
    <select id="selectStudents" resultMap="studentResultMap">
        SELECT s.id, s.name, c.id AS course_id, c.name AS course_name
        FROM student s
        JOIN student_course sc ON s.id = sc.student_id
        JOIN course c ON sc.course_id = c.id
    </select>
</mapper>
``` |
| 5. 注解配置 | 使用注解代替 XML 映射文件进行配置。 | ```java
@Mapper
public interface StudentMapper {
    @Select("SELECT s.id, s.name, c.id AS course_id, c.name AS course_name " +
            "FROM student s " +
            "JOIN student_course sc ON s.id = sc.student_id " +
            "JOIN course c ON sc.course_id = c.id")
    List<Student> selectStudents();
}
``` |
| 6. 示例代码 | 编写示例代码，展示如何使用 MyBatis 查询多对多关系的数据。 | ```java
public class Main {
    public static void main(String[] args) {
        SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory();
        try (SqlSession session = sqlSessionFactory.openSession()) {
            StudentMapper mapper = session.getMapper(StudentMapper.class);
            List<Student> students = mapper.selectStudents();
            for (Student student : students) {
                System.out.println("Student: " + student.getName());
                for (Course course : student.getCourses()) {
                    System.out.println("Course: " + course.getName());
                }
            }
        }
    }
}
``` |
| 7. 调试与优化 | 调试查询结果，确保多对多关系正确映射。根据需要优化查询语句和配置。 | 无 |

#### 📝 关联关系映射

在 MyBatis 中，关联关系映射主要分为两种：一对一和一对多。对于多对多关系，我们需要使用关联表来实现。

1. **一对一配置**：一对一关系意味着一个实体类中的一个实例与另一个实体类中的一个实例相关联。在 MyBatis 中，可以使用 `<association>` 标签来配置一对一关系。

2. **一对多配置**：一对多关系意味着一个实体类中的一个实例可以与多个另一个实体类的实例相关联。同样，使用 `<association>` 标签来配置一对多关系。

#### 📝 级联关系

在多对多关系中，级联关系指的是在查询一个实体时，自动查询与之关联的另一个实体。在 MyBatis 中，可以通过配置 `<collection>` 标签来实现级联关系。

#### 📝 嵌套查询

在 MyBatis 中，嵌套查询是指在一个查询中执行另一个查询。对于多对多关系，可以使用嵌套查询来获取关联数据。

#### 📝 总结

通过以上步骤，我们可以配置 MyBatis 中的多对多关系。在实际项目中，根据具体需求选择合适的配置方式，以达到最佳的性能和可维护性。

### 🎉 MyBatis 中的 association：多对多关系配置示例

在 MyBatis 中，`association` 元素用于配置复杂关联关系，特别是多对多关系。多对多关系指的是两个表中的多个记录可以相互关联。下面，我们将通过一个示例来详细讲解如何配置多对多关系。

#### 📝 配置示例

首先，我们假设有两个实体类：`User` 和 `Role`，它们之间存在多对多关系。`User` 表有多个用户，每个用户可以拥有多个角色；`Role` 表有多个角色，每个角色也可以被多个用户拥有。

**实体类设计**

```java
public class User {
    private Integer id;
    private String username;
    private List<Role> roles; // 用户与角色的多对多关系

    // 省略getter和setter方法
}

public class Role {
    private Integer id;
    private String roleName;

    // 省略getter和setter方法
}

映射文件

在 MyBatis 的映射文件中，我们需要配置多对多关系。以下是配置示例：

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户及其角色信息 -->
    <select id="selectUserAndRoles" resultType="com.example.entity.User">
        SELECT u.*, r.*
        FROM user u
        LEFT JOIN user_role ur ON u.id = ur.user_id
        LEFT JOIN role r ON ur.role_id = r.id
        WHERE u.id = #{id}
    </select>

    <!-- 查询用户角色信息 -->
    <select id="selectUserRoles" resultType="com.example.entity.Role">
        SELECT r.*
        FROM user u
        LEFT JOIN user_role ur ON u.id = ur.user_id
        LEFT JOIN role r ON ur.role_id = r.id
        WHERE u.id = #{id}
    </select>
</mapper>
📝 关联查询与结果集处理

在执行查询时，MyBatis 会根据映射文件中的配置，将查询结果映射到对应的实体类中。在上面的示例中，selectUserAndRoles 查询会返回用户及其所有角色的信息，而 selectUserRoles 查询只会返回用户的所有角色信息。

public List<Role> getUserRoles(Integer userId) {
    // 调用MyBatis的SqlSession来执行查询
    List<Role> roles = sqlSession.selectList("com.example.mapper.UserMapper.selectUserRoles", userId);
    return roles;
}
📝 自定义结果映射

如果需要自定义结果映射，可以使用 <resultMap> 元素。以下是一个自定义结果映射的示例：

<resultMap id="userRoleMap" type="com.example.entity.User">
    <id property="id" column="id" />
    <result property="username" column="username" />
    <collection property="roles" ofType="com.example.entity.Role">
        <id property="id" column="role_id" />
        <result property="roleName" column="role_name" />
    </collection>
</resultMap>
📝 一对多配置对比

与多对多关系相比，一对多关系通常指的是一个表中的多个记录与另一个表中的一个记录相关联。在 MyBatis 中，一对多关系可以使用 <collection> 元素配置。

<resultMap id="userMap" type="com.example.entity.User">
    <id property="id" column="id" />
    <result property="username" column="username" />
    <collection property="orders" ofType="com.example.entity.Order">
        <id property="id" column="order_id" />
        <result property="orderName" column="order_name" />
    </collection>
</resultMap>
📝 级联属性、延迟加载、缓存策略

在多对多关系中，我们可以使用级联属性来简化关联查询。级联属性允许我们在查询一个实体时，自动加载其关联的实体。

<resultMap id="userRoleMap" type="com.example.entity.User">
    <id property="id" column="id" />
    <result property="username" column="username" />
    <collection property="roles" ofType="com.example.entity.Role" column="id" select="selectRolesByUserId" />
</resultMap>

延迟加载和缓存策略是提高 MyBatis 性能的关键。延迟加载可以在需要时才加载关联实体，而缓存策略可以缓存查询结果，避免重复查询。

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true" />
📝 示例代码

以下是一个使用 MyBatis 查询用户及其角色的示例代码：

public List<User> getUsers() {
    // 调用MyBatis的SqlSession来执行查询
    List<User> users = sqlSession.selectList("com.example.mapper.UserMapper.selectUserAndRoles");
    return users;
}
📝 性能优化

为了提高性能，我们可以采取以下措施：

  • 使用合适的缓存策略。
  • 避免在查询中使用过多的关联。
  • 使用索引优化查询。
  • 优化实体类设计，减少不必要的字段。

通过以上内容，我们可以了解到 MyBatis 中 association 元素在配置多对多关系时的应用。在实际项目中，合理配置关联关系，可以有效提高代码的可读性和可维护性。

🍊 MyBatis核心知识点之association：属性配置

在开发复杂的数据模型时，我们常常会遇到需要将多个实体关联起来的情况。例如，一个订单实体可能包含多个订单明细，而每个订单明细又关联着具体的商品信息。在这种情况下，如何有效地在MyBatis中配置这些关联关系，是保证数据模型正确映射到数据库表结构的关键。

场景问题：假设我们正在开发一个电子商务平台，其中订单实体（Order）与订单明细实体（OrderDetail）之间存在一对多关系，而订单明细实体又与商品实体（Product）存在多对一关系。如果我们直接在订单实体中映射订单明细，而不使用关联配置，那么在查询订单时，可能无法正确地加载关联的订单明细和商品信息，导致数据不完整。

需要介绍MyBatis核心知识点之association：属性配置的原因在于，这是实现实体间复杂关联关系的关键配置方式。通过正确配置association属性，我们可以确保在查询实体时，能够同时加载其关联的实体数据，从而避免数据不一致的问题。这对于提高数据访问效率和保证数据完整性具有重要意义。

接下来，我们将对MyBatis中association属性的配置进行概述，并给出一个具体的配置示例。首先，概述将介绍association属性的基本概念、配置方式和注意事项，帮助读者理解如何正确地使用这一特性。随后，示例将展示如何在实际项目中配置一个包含关联关系的实体映射，以便读者能够将理论知识应用到实际开发中。通过这些内容，读者将能够更好地掌握MyBatis的关联配置，为构建复杂的数据模型打下坚实的基础。

🎉 MyBatis 中的 association 属性配置概述

在 MyBatis 中，association 属性是用于配置复杂关联关系的关键。它允许我们在映射文件中定义实体之间的关系，如一对一、一对多、多对一和多对多。下面，我们将详细探讨 association 属性的配置概述。

📝 关联关系类型

在 MyBatis 中，关联关系主要有以下几种类型：

关联关系类型描述
一对一一个实体对应另一个实体，如用户与地址的关系。
一对多一个实体可以对应多个实体，如分类与商品的关系。
多对一多个实体对应一个实体，如订单与用户的关系。
多对多多个实体之间相互对应，如学生与课程的关系。
📝 配置方式

在 MyBatis 的映射文件中，association 属性的配置方式如下：

<resultMap id="BaseResultMap" type="com.example.User">
    <id column="id" property="id" />
    <result column="username" property="username" />
    <association property="address" javaType="com.example.Address">
        <id column="address_id" property="id" />
        <result column="street" property="street" />
        <result column="city" property="city" />
    </association>
</resultMap>

在上面的示例中，我们定义了一个 User 实体的 address 属性，它是一个 Address 实体。association 标签中的 property 属性指定了关联的属性名，javaType 属性指定了关联实体的类型。

📝 XML 标签

在配置 association 属性时，我们通常会使用以下 XML 标签：

XML 标签描述
<id>用于配置关联实体的主键映射。
<result>用于配置关联实体的非主键映射。
<association>用于配置关联关系。
📝 属性配置

在 association 属性中，我们可以配置以下属性：

属性描述
property关联实体的属性名。
javaType关联实体的类型。
select用于加载关联实体的查询语句的 ID。
column用于加载关联实体的查询语句的列名。
📝 示例代码

以下是一个一对一关联关系的示例代码：

public class User {
    private Integer id;
    private String username;
    private Address address;
    // getters and setters
}

public class Address {
    private Integer id;
    private String street;
    private String city;
    // getters and setters
}

在 MyBatis 的映射文件中，我们可以这样配置：

<resultMap id="UserResultMap" type="com.example.User">
    <id column="id" property="id" />
    <result column="username" property="username" />
    <association property="address" javaType="com.example.Address">
        <id column="address_id" property="id" />
        <result column="street" property="street" />
        <result column="city" property="city" />
    </association>
</resultMap>
📝 最佳实践

在配置 association 属性时，以下是一些最佳实践：

  • 使用 resultMap 来定义关联实体的映射，以便更好地管理关联关系。
  • 使用 select 属性来加载关联实体，以便在需要时进行延迟加载。
  • 使用 fetchType 属性来控制关联实体的加载方式，如懒加载或立即加载。

通过以上内容，我们详细介绍了 MyBatis 中 association 属性的配置概述。在实际项目中，合理配置关联关系可以简化代码，提高开发效率。

🎉 MyBatis 中的 association 属性配置示例

在 MyBatis 中，association 属性用于配置一对多、多对一、一对一关系。它允许我们在查询时关联另一个表的数据。下面，我们将通过对比与列举的方式，详细解释 association 属性的配置示例。

📝 一对多关系

在一对多关系中，一个实体类可以关联多个另一个实体类。以下是一个示例：

关系类型实体类A实体类B关联方式
一对多用户角色用户有多个角色
<!-- UserMapper.xml -->
<select id="selectUsers" resultType="User">
  SELECT * FROM users
</select>

<select id="selectRolesByUserId" resultType="Role" parameterType="int">
  SELECT * FROM roles WHERE user_id = #{userId}
</select>

在上述示例中，selectUsers 查询返回所有用户，而 selectRolesByUserId 查询返回指定用户的角色列表。

📝 多对一关系

在多对一关系中，多个实体类可以关联到一个实体类。以下是一个示例：

关系类型实体类A实体类B关联方式
多对一角色用户多个角色对应一个用户
<!-- RoleMapper.xml -->
<select id="selectRoles" resultType="Role">
  SELECT * FROM roles
</select>

<select id="selectUsersByRoleId" resultType="User" parameterType="int">
  SELECT * FROM users WHERE role_id = #{roleId}
</select>

在上述示例中，selectRoles 查询返回所有角色，而 selectUsersByRoleId 查询返回指定角色的用户列表。

📝 一对一关系

在一对一关系中，一个实体类只能关联另一个实体类的一个实例。以下是一个示例：

关系类型实体类A实体类B关联方式
一对一用户地址一个用户只有一个地址
<!-- UserMapper.xml -->
<select id="selectUsers" resultType="User">
  SELECT * FROM users
</select>

<select id="selectAddressesByUserId" resultType="Address" parameterType="int">
  SELECT * FROM addresses WHERE user_id = #{userId}
</select>

在上述示例中，selectUsers 查询返回所有用户，而 selectAddressesByUserId 查询返回指定用户的地址。

🎉 级联关系与嵌套关系

级联关系和嵌套关系是 MyBatis 中关联查询的高级用法。以下是一个示例：

关系类型实体类A实体类B关联方式
级联关系用户角色用户有多个角色，角色有多个权限
嵌套关系用户角色用户有多个角色，角色有多个权限，权限有多个菜单
<!-- UserMapper.xml -->
<select id="selectUsers" resultType="User">
  SELECT * FROM users
</select>

<select id="selectRolesByUserId" resultType="Role" parameterType="int">
  SELECT * FROM roles WHERE user_id = #{userId}
</select>

<select id="selectPermissionsByRoleId" resultType="Permission" parameterType="int">
  SELECT * FROM permissions WHERE role_id = #{roleId}
</select>

<select id="selectMenusByPermissionId" resultType="Menu" parameterType="int">
  SELECT * FROM menus WHERE permission_id = #{permissionId}
</select>

在上述示例中，selectUsers 查询返回所有用户，selectRolesByUserId 查询返回指定用户的角色列表，selectPermissionsByRoleId 查询返回指定角色的权限列表，而 selectMenusByPermissionId 查询返回指定权限的菜单列表。

🎉 关联查询与结果映射

关联查询和结果映射是 MyBatis 中处理关联关系的关键技术。以下是一个示例：

<!-- UserMapper.xml -->
<select id="selectUserWithRoles" resultType="User">
  SELECT u.*, r.*
  FROM users u
  LEFT JOIN user_roles ur ON u.id = ur.user_id
  LEFT JOIN roles r ON ur.role_id = r.id
  WHERE u.id = #{userId}
</select>

在上述示例中，selectUserWithRoles 查询返回指定用户的详细信息及其关联的角色信息。

通过以上示例，我们可以看到 MyBatis 中 association 属性的强大功能。在实际应用中，我们可以根据具体需求灵活运用这些关联关系，提高代码的可读性和可维护性。

🍊 MyBatis核心知识点之association：注意事项

在开发过程中，我们经常会遇到需要将多个实体之间的关系映射到数据库中。例如，一个订单实体可能包含多个订单明细，而每个订单明细又关联到一个商品实体。在这种情况下，如何有效地在MyBatis中处理这种多对一的关系，就是一个需要特别注意的问题。若处理不当，可能会导致数据不一致或查询效率低下。因此，介绍MyBatis核心知识点之association：注意事项显得尤为重要。

在传统的Java开发中，我们可能会通过编写复杂的SQL语句或使用多个查询来处理这种关联关系，这不仅增加了代码的复杂度，还可能引入错误。MyBatis的association标签正是为了解决这类问题而设计的。它允许我们在映射文件中定义实体之间的关系，从而简化了数据库操作，提高了代码的可读性和可维护性。

接下来，我们将对MyBatis核心知识点之association：注意事项进行概述，并探讨一些常见问题及解决方法。首先，我们会详细介绍如何正确使用association标签来映射实体之间的关系，包括如何配置fetchType、如何处理懒加载等。然后，我们会分析在实际应用中可能遇到的一些问题，如数据不一致、性能瓶颈等，并提供相应的解决策略。通过这些内容，读者将能够更好地理解如何利用MyBatis的association功能来优化数据库操作，提高项目开发效率。

🎉 注意事项概述

在MyBatis中，使用association标签进行关联关系配置时，需要注意以下几个方面：

📝 1. 关联关系配置

在配置关联关系时，需要确保关联的属性名称与实体类中的属性名称一致。以下是一个简单的示例：

<resultMap id="UserResultMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" javaType="Address">
        <id property="id" column="address_id" />
        <result property="street" column="street" />
        <result property="city" column="city" />
    </association>
</resultMap>

在这个例子中，User 实体类有一个名为 address 的属性，它是一个 Address 类型的对象。在 association 标签中，property 属性指定了关联的属性名称，javaType 属性指定了关联对象的类型。

📝 2. 关联关系映射配置

在配置关联关系映射时，需要确保映射的 SQL 语句正确，并且能够正确地返回关联对象的数据。以下是一个示例：

<select id="selectUserById" resultMap="UserResultMap">
    SELECT u.id, u.username, a.id AS address_id, a.street, a.city
    FROM users u
    LEFT JOIN addresses a ON u.address_id = a.id
    WHERE u.id = #{id}
</select>

在这个例子中，selectUserById SQL 语句查询用户信息，并通过 LEFT JOIN 与地址表进行关联，以获取关联的地址信息。

📝 3. 多表关联查询

在处理多表关联查询时，需要注意 SQL 语句的编写，确保能够正确地返回所需的数据。以下是一个示例：

<select id="selectUserAndAddress" resultMap="UserResultMap">
    SELECT u.id, u.username, a.id AS address_id, a.street, a.city
    FROM users u
    LEFT JOIN addresses a ON u.address_id = a.id
    WHERE u.id = #{id}
</select>

在这个例子中，selectUserAndAddress SQL 语句查询用户及其关联的地址信息。

📝 4. 级联属性

在配置级联属性时，需要确保级联属性与实体类中的属性名称一致。以下是一个示例：

<resultMap id="UserResultMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" javaType="Address">
        <id property="id" column="address_id" />
        <result property="street" column="street" />
        <result property="city" column="city" />
        <association property="country" javaType="Country">
            <id property="id" column="country_id" />
            <result property="name" column="name" />
        </association>
    </association>
</resultMap>

在这个例子中，address 属性是一个 Address 类型的对象，它有一个名为 country 的属性，它是一个 Country 类型的对象。

📝 5. 级联方法

在配置级联方法时，需要确保方法名称与实体类中的方法名称一致。以下是一个示例：

public class User {
    // ...
    public Address getAddress() {
        // ...
    }
    // ...
}

在 MyBatis 映射文件中，配置级联方法如下：

<resultMap id="UserResultMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" select="com.example.mapper.AddressMapper.selectById" />
</resultMap>

在这个例子中，selectById 方法是 AddressMapper 接口中的一个方法，用于根据地址 ID 查询地址信息。

📝 6. 延迟加载

在配置延迟加载时，需要确保关联对象的数据在需要时才进行加载。以下是一个示例：

<resultMap id="UserResultMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" select="com.example.mapper.AddressMapper.selectById" fetchType="lazy" />
</resultMap>

在这个例子中，fetchType="lazy" 属性指定了关联对象的数据在需要时才进行加载。

📝 7. 嵌套查询

在配置嵌套查询时，需要确保嵌套查询的 SQL 语句正确，并且能够正确地返回所需的数据。以下是一个示例：

<select id="selectUserAndAddress" resultMap="UserResultMap">
    SELECT u.id, u.username, a.id AS address_id, a.street, a.city
    FROM users u
    LEFT JOIN addresses a ON u.address_id = a.id
    WHERE u.id = #{id}
</select>

在这个例子中，selectUserAndAddress SQL 语句查询用户及其关联的地址信息。

📝 8. 自定义关联映射

在自定义关联映射时，需要确保映射的 SQL 语句正确，并且能够正确地返回所需的数据。以下是一个示例：

<resultMap id="UserResultMap" type="User">
    <id property="id" column="user_id" />
    <result property="username" column="username" />
    <association property="address" column="address_id" select="com.example.mapper.AddressMapper.selectById" />
</resultMap>

在这个例子中，selectById 方法是 AddressMapper 接口中的一个方法，用于根据地址 ID 查询地址信息。

📝 9. 注意事项
  • 确保关联的属性名称与实体类中的属性名称一致。
  • 确保映射的 SQL 语句正确，并且能够正确地返回所需的数据。
  • 在配置延迟加载时，确保关联对象的数据在需要时才进行加载。
  • 在配置嵌套查询时，确保嵌套查询的 SQL 语句正确，并且能够正确地返回所需的数据。
  • 在自定义关联映射时，确保映射的 SQL 语句正确，并且能够正确地返回所需的数据。
📝 10. 性能优化
  • 使用合适的索引，以提高查询效率。
  • 避免在关联查询中使用过多的 JOIN 操作，以减少查询时间。
  • 使用缓存机制，以减少数据库访问次数。
📝 11. 异常处理
  • 在查询过程中，捕获并处理可能出现的异常。
  • 在配置映射文件时，确保 SQL 语句正确，以避免出现异常。
📝 12. 与缓存机制结合
  • 使用一级缓存和二级缓存，以提高查询效率。
  • 在配置缓存时，确保缓存策略合理，以避免数据不一致的问题。

通过以上内容，我们可以了解到 MyBatis 中使用 association 标签进行关联关系配置的注意事项。在实际开发过程中，我们需要根据具体需求进行配置，以确保系统的稳定性和性能。

🎉 MyBatis 关联关系配置

在 MyBatis 中，关联关系配置是处理多表关系的重要手段。它允许我们在查询时一次性获取到关联表的数据，从而简化了数据访问逻辑。

📝 对比与列举
关联关系类型描述举例
一对一一个实体对应另一个实体用户与地址
一对多一个实体对应多个实体分类与商品
多对多多个实体对应多个实体用户与角色

🎉 常见问题类型

在使用 MyBatis 关联关系配置时，可能会遇到以下常见问题：

  1. 关联查询结果为空
  2. 关联查询效率低下
  3. 关联查询结果不正确

🎉 问题原因分析

  1. 关联查询结果为空：可能是关联关系配置错误，或者关联表中的数据不存在。
  2. 关联查询效率低下：可能是 SQL 语句编写不当，或者数据库索引未建立。
  3. 关联查询结果不正确：可能是关联关系配置错误，或者数据源问题。

🎉 解决方法

  1. 关联查询结果为空：

    • 检查关联关系配置是否正确。
    • 确认关联表中的数据是否存在。

  2. 关联查询效率低下：

    • 优化 SQL 语句，使用 EXISTS 替代 IN。
    • 建立数据库索引，提高查询效率。

  3. 关联查询结果不正确：

    • 检查关联关系配置是否正确。
    • 检查数据源问题，确保数据一致性。

🎉 最佳实践

  1. 使用 resultMap 配置关联关系，避免使用 select 标签。
  2. 使用 fetchType="lazy" 进行延迟加载，提高查询效率。
  3. 使用 SQL 分页查询，避免一次性加载过多数据。

🎉 性能优化

  1. 使用缓存机制，减少数据库访问次数。
  2. 优化 SQL 语句，使用 EXISTS 替代 IN。
  3. 建立数据库索引，提高查询效率。

🎉 与 XML 配置对比

XML 配置注解配置
优点：易于阅读和维护优点：代码更简洁，易于编写和修改
缺点：配置复杂，修改困难缺点：代码可读性较差，不易维护

🎉 与注解配置对比

XML 配置注解配置
优点：易于阅读和维护优点：代码更简洁，易于编写和修改
缺点：配置复杂，修改困难缺点：代码可读性较差，不易维护

🎉 与 Hibernate 对比

MyBatisHibernate
优点：性能高，灵活优点：易于使用，功能强大
缺点：配置复杂，学习曲线陡峭缺点：性能相对较低，依赖 JPA 规范

🎉 与 Spring 集成

MyBatis 可以与 Spring 框架集成，实现自动数据源切换、事务管理等。

@Configuration
public class MyBatisConfig {
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws IOException {
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(new ClassPathResource("mybatis-config.xml"), dataSource);
        return sqlSessionFactory;
    }
}

🎉 实际应用案例

在电商项目中，可以使用 MyBatis 关联关系配置查询商品及其所属分类信息。

public interface ProductMapper {
    Product selectProductById(@Param("id") Long id);
}

<select id="selectProductById" resultMap="productMap">
    SELECT p.*, c.name AS categoryName
    FROM product p
    LEFT JOIN category c ON p.category_id = c.id
    WHERE p.id = #{id}
</select>

<resultMap id="productMap" type="Product">
    <id property="id" column="id" />
    <result property="name" column="name" />
    <result property="price" column="price" />
    <association property="category" javaType="Category">
        <id property="id" column="category_id" />
        <result property="name" column="categoryName" />
    </association>
</resultMap>

CSDN

博主分享

📥博主的人生感悟和目标

Java程序员廖志伟

📙经过多年在CSDN创作上千篇文章的经验积累，我已经拥有了不错的写作技巧。同时，我还与清华大学出版社签下了四本书籍的合约，并将陆续出版。

面试备战资料

八股文备战
场景描述链接
时间充裕（25万字）Java知识点大全（高频面试题）Java知识点大全
时间紧急（15万字）Java高级开发高频面试题Java高级开发高频面试题

理论知识专题（图文并茂，字数过万）

技术栈链接
RocketMQRocketMQ详解
KafkaKafka详解
RabbitMQRabbitMQ详解
MongoDBMongoDB详解
ElasticSearchElasticSearch详解
ZookeeperZookeeper详解
RedisRedis详解
MySQLMySQL详解
JVMJVM详解

集群部署（图文并茂，字数过万）

技术栈部署架构链接
MySQL使用Docker-Compose部署MySQL一主二从半同步复制高可用MHA集群Docker-Compose部署教程
Redis三主三从集群（三种方式部署/18个节点的Redis Cluster模式）三种部署方式教程
RocketMQDLedger高可用集群（9节点）部署指南
Nacos+Nginx集群+负载均衡（9节点）Docker部署方案
Kubernetes容器编排安装最全安装教程

开源项目分享

项目名称链接地址
高并发红包雨项目https://gitee.com/java_wxid/red-packet-rain
微服务技术集成demo项目https://gitee.com/java_wxid/java_wxid

管理经验

【公司管理与研发流程优化】针对研发流程、需求管理、沟通协作、文档建设、绩效考核等问题的综合解决方案：https://download.csdn.net/download/java_wxid/91148718

希望各位读者朋友能够多多支持！

现在时代变了，信息爆炸，酒香也怕巷子深，博主真的需要大家的帮助才能在这片海洋中继续发光发热，所以，赶紧动动你的小手，点波关注❤️，点波赞👍，点波收藏⭐，甚至点波评论✍️，都是对博主最好的支持和鼓励！

🔔如果您需要转载或者搬运这篇文章的话，非常欢迎您私信我哦~

MyBatis框架-关联映射
f135917h的博客
11-30 1084
实体–数据实体，实体关系指的就是数据与数据之间的关系例如：订单和商品，用户和角色数据表关系：主键关联：用户表主键和用户详情表的主键相同时，表示是匹配的数据唯一外键关联：用户表和详情表使用外键关联，但需要将外键设置为唯一键一对多：班级对学生多对一：学生对班级数据表关系：建立第三张关系表，添加两个外键分别和两张表主键进行关联。
Mybatis的关联关系映射以及自定义resultMap三种映射关系
m0_73647713的博客
09-04 826
学习Mybatis的关联关系映射可以带来以下收获和认识：1. 数据库关系的抽象：学习MyBatis的关联关系映射可以有助于我们理解数据库中表与表之间的关系，如一对一和一对多关系。这可以提升我们对数据模型的理解和设计能力。2. 对象关系映射（ORM）的学习：MyBatis采用了ORM的思想，通过映射配置将数据库表与Java对象进行关联。学习MyBatis的关联关系映射可以帮助我们掌握ORM的基本原理和实践技巧。
Mybatis实现多条件动态查询
leo666leo的博客
07-26 4763
动态查询是各大应用常见的功能,相信大家的第一印象就是采用mybatis的动态标签来实现。那究竟是如何实现的呢？相信大部分人，包括之前的我也是一知半解的，本文将尽力解答你的所有疑惑！ 1 需求分析 要实现上图这个功能，前端传入查询条件列表，必须明确数据请求和响应的格式是怎样的。很显然，请求的数据是个列表，列表中是一个个的查询条件对象，每个查询条件对象都有三个属性（查询字段、查询规则、查询值）。 在此基础上，我们进行后续的工作。 2 实现 为了方便演示，本文使用Springboot + Mybatis来快速演
【最详细Mybatis关联映射详解】Mybatis关联映射详解
qq_46747441的博客
08-29 927
【最详细Mybatis关联映射详解】Mybatis关联映射详解
MyBatis——@Result注解column参数传递多个参数
无限迭代中......
05-30 7730
问题描述 @Result注解column参数传递多个参数。 官方文档 property description column 数据库的列名或者列标签别名。与传递给resultSet.getString(columnName)的参数名称相同。注意： 在处理组合键时，您可以使用column=“{prop1=col1,prop2=col2}”这样的语法，设置多个列名传入到嵌套查询语句。这就会把prop1和prop2设置到目标嵌套选择语句的参数对象中。 解决方案 @Mapper pub
Mybatis系列（五）之Mybatis的关系关联配置
lijie1025的博客
09-04 1109
Mybatis关系关联映射详细介绍
掌握MyBatis一对多关联映射的XML配置方法
最新发布
weixin_30674431的博客
08-05 992
MyBatis 是一款流行的 Java 持久层框架，它起源于 Apache iBatis 项目。在简化 Java 开发者与数据库交互的同时，MyBatis 提供了更加灵活的SQL映射和数据操作方式。它支持定制化SQL、存储过程以及高级映射，让开发者可以几乎以任意方式编写SQL语句，同时通过简单的XML或注解的方式将对象与数据库映射。
【转载】MyBatis一对多关联查询XMl配置写法
t194978的博客
03-10 1861
                                MyBatis一对多关联查询XMl配置写法   一、情景概述 1、有一张客户表 Client ，存储客户信息， 姓名 name ，年龄 age等。 2、有一张客户附件表 cl...
Mybatis关联查询之一对多和多对一XML配置详解
qq_24208765的博客
11-11 158
Mybatis关联查询之一对多和多对一XML配置详解 置顶 2017-12-21 10:53:05 百度搜不到… 阅读数 111376更多 分类专栏： JAVA 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/qq_33561055/article/details/78861...
Mybatis实体关联映射
bobozai86的博客
01-16 3354
原文源自：https://blog.csdn.net/Daybreak1209/article/details/51815753 一、一对一   1、resultType返回类型：使用resultType返回相对简单，查询扩展类属性时，创建扩展类。 2、resultMap返回类型：使用resultMap首先需要将1：1关联实体例如订单关联查询用户是一对一关系，所以在Order实体中添加单个U...
Mybatis步步进阶（七）——Mybatis实体关联映射
Think In JAVA—Max
07-03 8786
一、一对一   1、resultType返回类型：使用resultType返回相对简单，查询扩展类属性时，创建扩展类。 2、resultMap返回类型：使用resultMap首先需要将1：1关联实体例如订单关联查询用户是一对一关系，所以在Order实体中添加单个User对象存储关联查询的用户信息。 1）Order Pojo中添加private User user； 2）定义resultMa
Mybatis系列（七）关联映射
Chris Mao的专栏
10-02 600
Mybatis系列之多表关联映射 引言 之前的文章里有提到过使用Mybatis对数据库单表进行映射，执行增删改查操作。但是在现实的项目中进行数据库建模时，我们要遵循数据库设计范式的要求，会对现实中的业务模型进行拆分，封装在不同的数据表中，表与表之间存在着一对多或是多对多的对应关系。进而，我们对数据库的增删改查操作的主体，也就从单表变成了多表。那么Mybatis中是如何实现这种多表关系的映射...
SSM框架中mybatis传递多个参数实现联合查询的两种方法
Wall的博客
07-13 8391
①将多个参数封装成一个类1.首先创建一个类，将参数作为类的属性public class Student {private int studentId;private String studentName;private String studentClassid;public int getStudentId() {return studentId;}public void setStudentI...
结合mybatis-plus 实现实体操作多表关联查询
热门推荐
mryaj的博客
08-23 3万+
项目地址：github # multipleselect java mybatis 实现简单多表通用查询 ### 简介 实现项目中比较基本的多表通用查询。 ​ 实现简单的实体类操作多表, 首先你的项目是使用了mybatis-plus 才可以使用。 ​ 不做任何更改，也不会对项目产生任何影响，与手写XML 功能一样。 ​ 通过解析实体，调用通用的...
MyBatis级联多个对象属性赋值
weixin_43014205的博客
12-26 1181
一个客户有多个订单，   一个订单对应一个客户 需求：查询一个用户，得到对应的用户及相关订单   两个实体类 package com.bullet.domain; import lombok.Getter; import lombok.Setter; import lombok.ToString; import java.util.ArrayList; import java.uti...
MyBatis学习笔记（六）一对多的关联查询和传递多个参数
和尚
08-06 3323
首发于我的博客 和尚的博客 本文讲解一对多的关联查询，传递多个参数。 1.传递多个参数 当你的形参传递&amp;amp;amp;amp;gt;1个的时候，parameterType不写，让其自动处理 #{值}，默认为arg0，arg1…..或param1，param2，，， 若在接口中注解了@Param(相当于指明了key值)，即也可以写xxx，默认的也可以写，相当于3个值 2.结构 3.数据库...
MyBatis关联映射，一对一实例：增删改查
hjw0505521的博客
03-27 3203
在现实的项目中进行数据库建模时，我们要遵循数据库设计范式的要求，会对现实中的业务模型进行拆分，封装在不同的数据表中，表与表之间存在着一对一、一对多或是多对多的对应关系。 ...
Mybatis关联映射（关联多个对象）
荒的博客
08-25 3339
Mybatis关联映射 什么是关联映射？ 将数据库中有关系的表以实体对象引用的方式体现出来 几种关联方式？ 在Mybatis中有两种关联：关联单个对象和关联多个对象 什么时候使用？ 业务需要对数据库进行关联查询的时候（通过一条或两条SQL语句进行关联查询） ----------------------------------------------------------------...
mybatis级联查询传参（map保存多参数传参）
Xiazhiyu_whu的博客
08-25 1880
Map map = new HashMap(); long userId = 1; long  paperId = 1; map.put("userId", userId); map.put("paperId",paperId); session.update( "com.mukitech.anji.bean.UserPaperMapper.updateStatus", map);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值