第9章 MyBatis的关系映射

在实际开发中，对数据库的操作通常涉及多张表，涉及了对象和对象之间的关联关系。针对多表之间的操作，MyBatis提供了关联映射，通过关联映射就可以很好的处理对象与对象之间的关联关系

9.1 关联关系概述

一对一：在任意一方引入对方主键作为外键。

一对多：在“多”的一方，添加“一“的一方的主键作为外键。（连着多条线的一方是“多”）

多对多：产生中间关系表，引入两张表的主键作为外键，两个主键成为联合主键或使用新的字段作为主键。

用Java对象描述

class A{
    B b;
}
class B{
    A a;
}
//一对一：在本类中定义对方类型的对象，如A类中定义B类类型的属性b，B类中定义A类类型的属性a

class A{
    List<B>b;
}
class B{
    A a;
}
//一对多：就是一个A类类型中对应多个B类类型的情况，需要在A类中以集合的方式引入B类类型的对象，在B类中定义A类类型的属性a

class A{
    List<B> b;
}
class B{
    List<A> a;
}
//多对多：在A类中定义B类类型的集合，在B类中定义A类类型的集合

一对一：用<association>元素处理

a)、property：指定映射到的实体类对象中的属性，与表字段一一对应。

b)、column：指定数据库表中对应的字段。

c)、javaType：指定映射到实体对象属性的类型。

d)、select：指定引入嵌套查询的子SQL语句，该属性用于关联映射中的嵌套查询。

e)、fetchType：指定在关联查询时是否启用延迟加载。该属性有lazy和eager两个属性值，默认值为lazy（即默认关联映射延迟加载）。

MyBatis加载关联关系对象主要通过两种方式:嵌套查询和嵌套结果。

问题：虽然使用嵌套查询的方式比较简单，但是嵌套查询的方式要执行多条SQL语句，这对于大型数据集合和列表展示不是很好，因为这样可能会导致成百上千条关联的SQL语句被执行，从而极大的消耗数据库性能并且会降低查询效率。类似暴力for循环吧。

解决：MyBatis延迟加载的配置。使用MyBatis的延迟加载在一定程度上可以降低运行消耗并提高查询效率。MyBatis默认没有开启延迟加载，需要在核心配置文件中的<settings>元素内进行配置，具体配置方式如下：

<settings>
       <setting name="lazyLoadingEnabled" value="true" />
       <setting name="aggressiveLazyLoading" value="false"/>
</settings>

在映射文件中，<association>元素和<collection>元素中都已默认配置了延迟加载属性，即默认属性fetchType="lazy"（属性fetchType="eager"表示立即加载），所以在配置文件中开启延迟加载后，无需在映射文件中再做配置。

举例：以个人和身份证之间的一对一关联关系

创建两个表tb_idcard和tb_person

USE mybatis;
CREATE TABLE tb_idcard(
    id INT PRIMARY KEY AUTO_INCREMENT,
    CODE VARCHAR(18)
);
INSERT INTO tb_idcard(CODE) VALUE('');
INSERT INTO tb_idcard(CODE) VALUE('');

CREATE TABLE tb_person(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(32),
    age INT,
    sex VARCHAR(8),
    card_id INT UNIQUE,
    FOREIGN KEY(card_id) REFERENCES tb_idcard(id)
);
INSERT INTO tb_person(NAME,age,sex,card_id) VALUE('Rose',29,'女',1);
INSERT INTO tb_person(NAME,age,sex,card_id) VALUE('tom',27,'男',2);

此时表内数据：

创建持久化类IdCard和Person

package com.itheima.po;
/**
 * 证件持久化类
 */
public class IdCard {
    private Integer id;
    private String code;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    @Override
    public String toString() {
        return "IdCard [id=" + id + ", code=" + code + "]";
    }
}

IdCard

package com.itheima.po;
/**
 * 个人持久化类
 */
public class Person {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private IdCard card;  //个人关联的证件
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public IdCard getCard() {
        return card;
    }
    public void setCard(IdCard card) {
        this.card = card;
    }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", "
                + "age=" + age + ", sex=" + sex + ", card=" + card + "]";
    }
}

Person

嵌套查询：

IdCardMapper.xml映射文件：

<?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.itheima.mapper.IdCardMapper">

  <!-- 根据id查询证件信息，最普通的配置信息 -->
  <select id="findCodeById" parameterType="Integer" resultType="IdCard">
      SELECT * from tb_idcard where id=#{id}
  </select>

</mapper>

PersonMapper.xml映射文件：

<!-- 嵌套查询：通过执行另外一条SQL映射语句来返回预期的特殊类型 -->
    <select id="findPersonById" parameterType="Integer"
                                      resultMap="IdCardWithPersonResult123">
        SELECT * from tb_person where id=#{id}
    </select>

     <!-- resultMap最终还是要将结果映射到pojo上，type就是指定映射到哪一个pojo -->
    <resultMap type="Person" id="IdCardWithPersonResult123">
        <id property="id" column="id" />
        <result property="name" column="name" />
        <result property="age" column="age" />
        <result property="sex" column="sex" />

        <!-- 一对一：association使用select属性引入另外一条SQL语句，是另一个映射文件的select元素id -->
        <association property="card" column="card_id" javaType="IdCard"
            select="com.itheima.mapper.IdCardMapper.findCodeById" />
    </resultMap>

测试方法：

    /**
     * 嵌套查询
     */
    @Test
    public void findPersonByIdTest() {
        // 1、通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        // 2.使用MyBatis嵌套查询的方式查询id为1的人的信息
        Person person = session.selectOne("com.itheima.mapper."
                                   + "PersonMapper.findPersonById", 1);
        // 3、输出查询结果信息
        System.out.println(person);
        // 4、关闭SqlSession
        session.close();
    }

findPersonByIdTest()

运行结果：执行了多条简单的SQL语句

嵌套结果：

<!-- 嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集 -->
    <select id="findPersonById2" parameterType="Integer"
                                       resultMap="IdCardWithPersonResult2">
        SELECT p.*,idcard.code
        from tb_person p,tb_idcard idcard
        where p.card_id=idcard.id
        and p.id= #{id}
    </select>

    <resultMap type="Person" id="IdCardWithPersonResult2">
        <id property="id" column="id" /><!-- 声明主键，id是关联查询对象的唯一标识符 -->
        <result property="name" column="name" />
        <result property="age" column="age" />
        <result property="sex" column="sex" />
        <association property="card" javaType="IdCard">
            <id property="id" column="card_id" />
            <result property="code" column="code" />
        </association>
    </resultMap>

PersonMapper.xml映射文件

    /**
     * 嵌套结果
     */
    @Test
    public void findPersonByIdTest2() {
        // 1、通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        // 2.使用MyBatis嵌套结果的方法查询id为1的人的信息
        Person person = session.selectOne("com.itheima.mapper."
                                   + "PersonMapper.findPersonById2", 1);
        // 3、输出查询结果信息
        System.out.println(person);
        // 4、关闭SqlSession
        session.close();
    }

测试方法

测试结果：只执行了一条复杂的SQL语句。

DEBUG [main] - ==> Preparing: SELECT p.*,idcard.code from tb_person p,tb_idcard idcard where p.card_id=idcard.id and p.id= ?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <== Total: 1
Person [id=1, name=Rose, age=29, sex=女, card=IdCard [id=1, code=152221198711020624]]

select p.*,idcard.code from tb_person p,tb_idcard idcard where p.card_id=idcard.id and p.id = #{id}

这里的p是tb_person的别名，因为别名容易写，第二个tb_person后接空格再加p是格式，如果不用别名就是:

select tb_person.*,tb_idcard.code from tb_person,tb_idcard where tb_person.card_id=tb_idcard.id and tb_person.id = #{id}

一对一关系配置模板：

9.3 一对多

<resultMap>元素中，包含一个子元素<collection>元素，属性大部分和<association>元素相同，但有一个特殊属性ofType，这个属性和javaType属性对应，用于指定实体对象中集合类属性所包含的元素类型。

<collection>元素的使用模板：

1.在MySQL中建表tb_user和tb_orders,并插入几条数据

USE mybatis;

CREATE TABLE tb_user(
    id INT(32) PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(32),
    address VARCHAR(256)
);
INSERT INTO tb_user VALUES('','詹姆斯','克利夫兰');
INSERT INTO tb_user VALUES('','科比','洛杉矶');
INSERT INTO tb_user VALUES('','保罗','洛杉矶');

USER mybatis;
CREATE TABLE tb_orders(
    id INT(32) PRIMARY KEY AUTO_INCREMENT,
    number VARCHAR(32) NOT NULL,
    user_id INT(32) NOT NULL,
    FOREIGN KEY(user_id) REFERENCES tb_user(id)
);
INSERT INTO tb_orders VALUES('','','');
INSERT INTO tb_orders VALUES('','','');
INSERT INTO tb_orders VALUES('','','');

结果：

2.创建持久化类Orders和User

package com.itheima.po;
import java.util.List;
/**
 * 用户持久化类
 */
public class User {
    private Integer id;                 // 用户编号
    private String username;           // 用户姓名
    private String address;            // 用户地址
    private List<Orders> ordersList; //用户关联的订单...................................
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public List<Orders> getOrdersList() {
        return ordersList;
    }
    public void setOrdersList(List<Orders> ordersList) {
        this.ordersList = ordersList;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", address="
                + address + ", ordersList=" + ordersList + "]";
    }
}

User.java

package com.itheima.po;

import java.util.List;

/**
 * 订单持久化类
 */
public class Orders {
    private Integer id;    //订单id
    private String number;//订单编号
    //关联商品集合信息
    private List<Product> productList;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
//    @Override
//    public String toString() {
//        return "Orders [id=" + id + ", number=" + number + "]";
//    }
    public List<Product> getProductList() {
        return productList;
    }
    public void setProductList(List<Product> productList) {
        this.productList = productList;
    }
    @Override
    public String toString() {
        return "Orders [id=" + id + ", number=" + number + ", productList=" + productList + "]";
    }

}

Orders.java

3.创建映射文件UserMapper.xml

<?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">

<!-- namespace表示命名空间 -->
<mapper namespace="com.itheima.mapper.UserMapper">

    <!-- 一对多：查看某一用户及其关联的订单信息
          注意：当关联查询出的列名相同，则需要使用别名区分 -->
    <select id="findUserWithOrders123" parameterType="Integer"
                           resultMap="UserWithOrdersResult123">
        SELECT u.*,o.id as orders_id,o.number
        from tb_user u,tb_orders o
        WHERE u.id=o.user_id
         and u.id=#{id}
    </select>

    <resultMap type="User" id="UserWithOrdersResult123">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="address" column="address"/>

        <!-- 一对多关联映射：collection
            ofType表示属性集合中元素的类型，List<Orders>属性即Orders类 -->
        <collection property="ordersList" ofType="Orders">
            <id property="id" column="orders_id"/>
            <result property="number" column="number"/>
        </collection>

    </resultMap>
</mapper>

4.测试方法：

/**
     * 一对多
     */
    @Test
    public void findUserTest() {
        // 1、通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        // 2、查询id为1的用户信息
        User user = session.selectOne("com.itheima.mapper."
                                + "UserMapper.findUserWithOrders123", 1);
        // 3、输出查询结果信息
        System.out.println(user);
        // 4、关闭SqlSession
        session.close();
    }

findUserTest

5.查询结果：

DEBUG [main] - ==> Preparing: SELECT u.*,o.id as orders_id,o.number from tb_user u,tb_orders o WHERE u.id=o.user_id and u.id=?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <== Total: 2
User [id=1, username=詹姆斯, address=克利夫兰, ordersList=[Orders [id=1, number=1000011, productList=null], Orders [id=2, number=1000012, productList=null]]]

9.4 多对多

以商品和订单为例，一个订单可以包含多个商品，一个商品可以属于多个订单，数据库中的多对多联系通常使用一个中间表来维护，中间表中的订单id作为外键参照订单表的id，商品id作为外键参照商品表的id。

（外键：这个表的某一属性是别的表的主键，可以有重复，可以有多个，可以为空）

1.建表：tb_product和tb_ordersitem

USE mybatis;

CREATE TABLE tb_product(
    id INT(32) PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(32),
    price DOUBLE
);
INSERT INTO tb_product VALUES('','Java基础入门','44.5');
INSERT INTO tb_product VALUES('','Java Web程序开发入门','38.5');
INSERT INTO tb_product VALUES('','SSM框架整合实战','');

CREATE TABLE tb_ordersitem(
    id INT(32) PRIMARY KEY AUTO_INCREMENT,
    orders_id INT(32),
    product_id INT(32),
    FOREIGN KEY(orders_id) REFERENCES tb_orders(id),
    FOREIGN KEY(product_id) REFERENCES tb_product(id)
);
INSERT INTO tb_ordersitem VALUES('','','');
INSERT INTO tb_ordersitem VALUES('','','');
INSERT INTO tb_ordersitem VALUES('','','');

建表后：

2.创建持久化类Product表示商品，订单用以前的Order

package com.itheima.po;
import java.util.List;
/**
 * 商品持久化类
 */
public class Product {
    private Integer id;  //商品id
    private String name; //商品名称
    private Double price;//商品单价
    private List<Orders> orders; //与订单的关联属性...........................
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public List<Orders> getOrders() {
        return orders;
    }
    public void setOrders(List<Orders> orders) {
        this.orders = orders;
    }
    @Override
    public String toString() {
        return "Product [id=" + id + ", name=" + name
                           + ", price=" + price + "]";
    }
}

Product.java

3.创建订单实体映射文件OrdersMapper.xml和ProductMapper.xml

<?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.itheima.mapper.OrdersMapper">

    <!-- 多对多嵌套查询：通过执行另外一条SQL映射语句来返回预期的特殊类型
    定义了一个id为findOrdersWithPorduct的select语句来查询订单及其关联的商品信息-->
    <select id="findOrdersWithPorduct" parameterType="Integer"
              resultMap="OrdersWithProductResult">
        select * from tb_orders WHERE id=#{id}
    </select>

    <resultMap type="Orders" id="OrdersWithProductResult">
        <id property="id" column="id" />
        <result property="number" column="number" />

        <!-- property属性表示订单持久化类中的商品属性，ofType属性表示集合中的数据为Product类型，而column的
        属性值会作为参数执行ProductMapper中定义的id为findProductById的执行语句来查询订单中的商品信息-->
        <collection property="productList" column="id" ofType="Product"
             select="com.itheima.mapper.ProductMapper.findProductById">
        </collection>

    </resultMap>

    <!-- 多对多嵌套结果查询：查询某订单及其关联的商品详情 -->
    <select id="findOrdersWithPorduct2" parameterType="Integer"
             resultMap="OrdersWithPorductResult2">
        select o.*,p.id as pid,p.name,p.price
        from tb_orders o,tb_product p,tb_ordersitem  oi
        WHERE oi.orders_id=o.id
        and oi.product_id=p.id
        and o.id=#{id}
    </select>

    <!-- 自定义手动映射类型 -->
    <resultMap type="Orders" id="OrdersWithPorductResult2">
        <id property="id" column="id" />
        <result property="number" column="number" />
        <!-- 多对多关联映射：collection -->
        <collection property="productList" ofType="Product">
            <id property="id" column="pid" />
            <result property="name" column="name" />
            <result property="price" column="price" />
        </collection>
    </resultMap>

</mapper>

OrdersMapper.xml

<?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.itheima.mapper.ProductMapper">
    <select id="findProductById" parameterType="Integer"
                                       resultType="Product">
        SELECT * from tb_product where id IN(
           SELECT product_id FROM tb_ordersitem  WHERE orders_id = #{id}
        )
    </select>
</mapper>

ProductMapper.xml

4.测试方法：

    /**
     * 多对多
     */
    @Test
    public void findOrdersTest(){
        // 1、通过工具类生成SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        // 2、查询id为1的订单中的商品信息
        Orders orders = session.selectOne("com.itheima.mapper."
                               + "OrdersMapper.findOrdersWithPorduct", 1);
        // 3、输出查询结果信息
        System.out.println(orders);
        // 4、关闭SqlSession
        session.close();
    }

findOrdersTest()

5.测试结果：

DEBUG [main] - ==> Preparing: select * from tb_orders WHERE id=?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <== Total: 1
DEBUG [main] - ==> Preparing: SELECT * from tb_product where id IN( SELECT product_id FROM tb_ordersitem WHERE orders_id = ? )
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <== Total: 2
Orders [id=1, number=1000011, productList=[Product [id=1, name=Java基础入门, price=44.5], Product [id=3, name=SSM框架整合实战, price=50.0]]]