MyBatis的关联查询实现(一对一、一对多、多对多)

-- 用户表
CREATE TABLE `user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `age` int DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 身份证表（与用户一对一关联）
CREATE TABLE `id_card` (
  `id` int NOT NULL AUTO_INCREMENT,
  `card_no` varchar(20) NOT NULL, -- 身份证号
  `user_id` int NOT NULL, -- 关联用户ID（外键）
  PRIMARY KEY (`id`),
  UNIQUE KEY `user_id` (`user_id`) -- 一对一：user_id唯一
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

// 用户类（包含一个身份证对象）
@Data
public class User {
    private Integer id;
    private String username;
    private Integer age;
    // 一对一关联：用户包含一个身份证
    private IdCard idCard; 
}

// 身份证类
@Data
public class IdCard {
    private Integer id;
    private String cardNo;
    private Integer userId;
}

// 根据用户ID查询用户及关联的身份证
User selectUserWithIdCardById(Integer id);

<!-- 定义resultMap：映射用户及身份证 -->
<resultMap id="UserWithIdCardMap" type="User">
    <!-- 用户表字段映射 -->
    <id column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="age" property="age"/>
    
    <!-- 一对一关联：association映射IdCard对象 -->
    <association property="idCard" javaType="IdCard">
        <id column="card_id" property="id"/> <!-- 注意：避免与user.id字段冲突 -->
        <result column="card_no" property="cardNo"/>
        <result column="user_id" property="userId"/>
    </association>
</resultMap>

<!-- 连接查询：一次性查询用户和身份证 -->
<select id="selectUserWithIdCardById" resultMap="UserWithIdCardMap">
    SELECT 
        u.id, u.username, u.age,
        ic.id AS card_id, ic.card_no, ic.user_id
    FROM user u
    LEFT JOIN id_card ic ON u.id = ic.user_id
    WHERE u.id = #{id}
</select>

// IdCardMapper接口
IdCard selectById(Integer id);

<select id="selectById" resultType="IdCard">
    SELECT id, card_no, user_id FROM id_card WHERE id = #{id}
</select>

<resultMap id="UserWithIdCardNestedMap" type="User">
    <id column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="age" property="age"/>
    
    <!-- 嵌套查询：通过select属性指定查询关联对象的方法 -->
    <association 
        property="idCard" 
        javaType="IdCard"
        column="id" <!-- 将用户id作为参数传递给关联查询 -->
        select="com.example.mapper.IdCardMapper.selectByUserId"/> <!-- 关联查询的Mapper方法 -->
</resultMap>

<select id="selectUserWithIdCardNestedById" resultMap="UserWithIdCardNestedMap">
    SELECT id, username, age FROM user WHERE id = #{id}
</select>

-- 订单表（与用户一对多关联）
CREATE TABLE `order` (
  `id` int NOT NULL AUTO_INCREMENT,
  `order_no` varchar(20) NOT NULL, -- 订单号
  `total_amount` decimal(10,2) NOT NULL, -- 总金额
  `user_id` int NOT NULL, -- 关联用户ID
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

// 用户类（包含订单列表）
@Data
public class User {
    private Integer id;
    private String username;
    private Integer age;
    // 一对多关联：用户包含多个订单
    private List<Order> orders; 
}

// 订单类
@Data
public class Order {
    private Integer id;
    private String orderNo;
    private BigDecimal totalAmount;
    private Integer userId;
}

// 查询用户及关联的所有订单
User selectUserWithOrdersById(Integer id);

<!-- 定义resultMap：映射用户及订单列表 -->
<resultMap id="UserWithOrdersMap" type="User">
    <!-- 用户表字段 -->
    <id column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="age" property="age"/>
    
    <!-- 一对多关联：collection映射订单列表 -->
    <collection property="orders" ofType="Order"> <!-- ofType指定集合元素类型 -->
        <id column="order_id" property="id"/> <!-- 订单ID（别名避免冲突） -->
        <result column="order_no" property="orderNo"/>
        <result column="total_amount" property="totalAmount"/>
        <result column="user_id" property="userId"/>
    </collection>
</resultMap>

<!-- 连接查询：用户与订单 -->
<select id="selectUserWithOrdersById" resultMap="UserWithOrdersMap">
    SELECT 
        u.id, u.username, u.age,
        o.id AS order_id, o.order_no, o.total_amount, o.user_id
    FROM user u
    LEFT JOIN `order` o ON u.id = o.user_id
    WHERE u.id = #{id}
</select>

-- 学生表
CREATE TABLE `student` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 课程表
CREATE TABLE `course` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 中间表（多对多关联）
CREATE TABLE `student_course` (
  `id` int NOT NULL AUTO_INCREMENT,
  `student_id` int NOT NULL,
  `course_id` int NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_stu_course` (`student_id`,`course_id`) -- 避免重复关联
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

// 学生类（包含课程列表）
@Data
public class Student {
    private Integer id;
    private String name;
    // 多对多关联：学生包含多个课程
    private List<Course> courses;
}

// 课程类
@Data
public class Course {
    private Integer id;
    private String name;
}

// 查询学生及所选课程
Student selectStudentWithCoursesById(Integer id);

<resultMap id="StudentWithCoursesMap" type="Student">
    <id column="id" property="id"/>
    <result column="name" property="name"/>
    
    <!-- 多对多：collection映射课程列表 -->
    <collection property="courses" ofType="Course">
        <id column="course_id" property="id"/>
        <result column="course_name" property="name"/>
    </collection>
</resultMap>

<select id="selectStudentWithCoursesById" resultMap="StudentWithCoursesMap">
    SELECT 
        s.id, s.name,
        c.id AS course_id, c.name AS course_name
    FROM student s
    LEFT JOIN student_course sc ON s.id = sc.student_id
    LEFT JOIN course c ON sc.course_id = c.id
    WHERE s.id = #{id}
</select>

<!-- 1次主表查询：查询所有用户 -->
<select id="selectAllUser" resultMap="UserWithOrdersNestedMap">
    SELECT id, username, age FROM user
</select>

<!-- 每个用户触发1次订单查询（若有100个用户，触发100次） -->
<collection property="orders" select="selectOrdersByUserId" column="id"/>

-- 错误：未用别名，o.id会覆盖u.id
SELECT u.id, u.name, o.id, o.name 
FROM user u JOIN order o ON u.id = o.user_id

-- 正确：用别名区分
SELECT 
    u.id AS user_id, u.name AS user_name,
    o.id AS order_id, o.name AS order_name

<settings>
    <setting name="lazyLoadingEnabled" value="true"/> <!-- 全局开启延迟加载 -->
    <setting name="aggressiveLazyLoading" value="false"/> <!-- 按需加载（访问时才加载） -->
</settings>

<collection property="orders" ofType="Order">
    <id column="order_id" property="id"/> <!-- 关键：指定订单唯一标识 -->
    <!-- 其他字段 -->
</collection>

<!-- 主查询返回字段为user_id -->
<select id="selectUser" resultMap="UserMap">
    SELECT id AS user_id, username FROM user
</select>

<!-- 嵌套查询需用主查询的字段名作为参数 -->
<association select="selectOrder" column="user_id"/> <!-- 正确：column="user_id" -->

<association select="selectByParams" column="{id=user_id, name=user_name}"/>