javaee入门之旅之mybatis---（6）关联映射(一对一，一对多，多对多查询)

沐小辞

于 2024-04-02 13:39:07 发布

阅读量800

点赞数 24

分类专栏： javaee 文章标签： mybatis

本文链接：https://blog.csdn.net/xmuci/article/details/137153438

版权

javaee 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、前言

在实际的运用当中，除了进行单个表格的操作，还会涉及到多张表格，针对多表之间的操作，Mybatis提供了关联映射，通过关联映射可以很好的处理表与表、对象与对象之间的关联关系。此外，在实际开发中经常需要合理利用Mybatis缓存来加快数据库查询，进而有效提升数据库性能。

关联关系映射是指在数据库表之间建立关联关系，并将这种关系映射到对象之间的关系。在关系型数据库中，我们通常使用外键来建立表与表之间的关联。

2、关联概述

①一对一关系

一个数据表中的一条记录最多可以和另一个表中的一条记录相关。例，一个人只能拥有一张身份证，一张身份证只能属于一个人。

在数据库中，我们可以通过外键来建立这种关系。在MyBatis中，我们可以使用嵌套查询或嵌套结果映射来处理一对一关系。

②一对多关系

一对多关联关系是指一个表的一条记录对应多个关联表的记录。主键数据表中的一条记录可以和另外一个数据表的多条记录相关。但另外一个数据表中的记录只能与主键数据表中的某一条记录相关。例如，班级和学生的关系就属于一对多，一个班级有很多学生，但是学生只能属于一个班级。

③多对多关系

一个数据表中的一条记录可以与另外一个数据表任意数量的记录相关，另外一个数据表中的一条记录也可以与本数据表中的任意数量的记录相关。例如，学生和老师的关系就属于多对多，一个学生由多个老师教授，一个老师教多个学生。

3、Java对象如何描述事物之间的关系

通过对象属性与另一个对象属性相互关联。

①一对一关系

本类中定义与之关联的类的对象作为属性。例如，A类中定义B类对象b作为属性，在B类中定义A类对象a作为属性。

②一对多关系

一个A类对象（班级）对应多个B类对象（学生）的情况。例如，定义在A类中，定义一个B类对象的集合作为A类的属性；在B类中，定义A类对象a作为B类的属性。

③多对多关系

定义多个与之关联的类的对象。例如，在A类中定义B类对象的集合作为A类的属性，在B类中定义A类对象的集合作为B类的属性。

4、一对一查询

在Mybatis中，通过<association>元素处理一对一关联关系，是<resultMap>元素的子元素。

元素属性

属性	说明
property	指定了 Java 对象中与数据库列对应的属性名。
column	指定了数据库中的列名。
javaType	指定了属性的 Java 类型。如果未指定，则根据该属性的 setter 方法的参数类型来确定。
jdbcType	指定了 JDBC 类型，用于将数据库列的值转换为 Java 对象。
typeHandler	指定了类型处理器，用于自定义数据库列值到 Java 对象属性值的转换。
select	用于指定进入嵌套查询的子SQL语句
autoMapping	用于指定是否自动映射
fetchType	用于指定关联查询时是否启用延迟加载。lazy和leager两个属性，默认值lazy。

①嵌套查询

指通过执行另外一条SQL映射语句来返回预期的复杂类型。

步骤

目标：通过人的id去查询人的信息

Ⅰ.创建数据表

CREATE TABLE  tb_idcard( 
     id INT PRIMARY KEY AUTO_INCREMENT,
     CODE VARCHAR(18)
);
INSERT INTO tb_idcard(CODE) VALUES('152221198711020624');
INSERT INTO tb_idcard(CODE) VALUES('152201199008150317');

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)
);
# 插入2条数据
INSERT INTO tb_person(name,age,sex,card_id) VALUES('Rose',22,'女',1);
INSERT INTO tb_person(name,age,sex,card_id) VALUES('jack',23,'男',2);

Ⅱ.创建执久化类IDCard类

package org.example.pojo;

public class IDCard {
    private Integer id;                 //主键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 + "]";
    }
}

Ⅲ.执久化类Person类

package org.example.pojo;

public class Person {
    private Integer id;          //主键id
    private String name;         //姓名
    private Integer age;         //年龄
    private String sex;          //性别
    private IDCard card;        //人员关联的证件,idcard作为人的一个属性

    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 + "]";
    }
}

Ⅳ.编写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="org.example.mapper.idCardMapper">
    <!-- 根据id查询证件信息 -->
    <select id="findCodeById" parameterType="Integer" resultType="org.example.pojo.IDCard">
         SELECT * from tb_idcard where id=#{id}
    </select>
</mapper>

Ⅴ.编写PersonMapper.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="org.example.mapper.PersonMapper">
    <select id="findPersonById" parameterType="Integer"
            resultMap="IdCardWithPersonResult">
    SELECT * from tb_person where id=#{id}
    </select>

    <resultMap type="org.example.pojo.Person" id="IdCardWithPersonResult">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <!-- 一对一：association使用select属性引入另外一条SQL语句 -->
        <association property="card" column="card_id" javaType="org.example.pojo.IDCard"
                     select="org.example.mapper.idCardMapper.findCodeById"/>
    </resultMap>

</mapper>

Ⅵ.引入映射文件

<mapper resource="org.example.mapper/idCardMapper.xml"/>
<mapper resource="org.example.mapper/PersonMapper.xml"/>

Ⅶ.编写测试类

在src/main/java下创建一个utils工具类，sqlsession的相关操作。

package utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.Reader;

public class MyBatisUtils {

        private static SqlSessionFactory sqlSessionFactory = null;

        // 初始化SqlSessionFactory对象
        static {
            try {
                // 使用MyBatis提供的Resources类加载MyBatis的配置文件
                Reader reader =
                        Resources.getResourceAsReader("mybatis-config.xml");
                // 构建SqlSessionFactory工厂
                sqlSessionFactory =
                        new SqlSessionFactoryBuilder().build(reader);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 获取SqlSession对象的静态方法
        public static SqlSession getSession() {
            return sqlSessionFactory.openSession();
        }
}

package Test;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import utils.MyBatisUtils;
import org.example.pojo.Person;
public class PersonTest {
    @Test
    public void findPersonByIdTest() {
        // 1、通过工具类获取SqlSession对象
        SqlSession session = MyBatisUtils.getSession();
        // 2.使用MyBatis嵌套查询的方式查询id为1的人的信息
        Person person = session.selectOne("org.example.mapper."
                + "PersonMapper.findPersonById", 1);
        // 3、输出查询结果信息
        System.out.println(person);
        // 4、关闭SqlSession
        session.close();
    }

}

②嵌套结果

使用嵌套结果映射来处理重复的联合结果的子集

与上诉相似，唯独.personmapper中的配置不同

    <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"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <association property="card" javaType="org.example.pojo.IDCard">
            <id property="id" column="card_id"/>
            <result property="code" column="code"/>
        </association>
    </resultMap>

5.一对多查询

在Mybatis中，通过<collection>元素来处理一对多关联关系。<collection>元素属性大部分与<association>元素相同，但其还包含一个特殊属性-----ofType。ofType属性与javaType属性对应。用于指定实体类对象中集合类属性所包含的元素类型。

①嵌套查询

步骤

Ⅰ.创建数据表

CREATE TABLE tb_user (
  id int(32) PRIMARY KEY AUTO_INCREMENT,
  username varchar(32),
  address varchar(256)
 );
# 插入3条数据
INSERT INTO tb_user VALUES ('1', '小明', '北京');
INSERT INTO tb_user VALUES ('2', '李华', '上海');
INSERT INTO tb_user VALUES ('3', '李刚', '上海');


# 创建一个名称为tb_orders的表
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)
);
# 插入3条数据
INSERT INTO tb_orders VALUES ('1', '1000011', '1');
INSERT INTO tb_orders VALUES ('2', '1000012', '1');
INSERT INTO tb_orders VALUES ('3', '1000013', '2');

Ⅱ.创建执久化类Orders

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 + '\'' +
                ", productList=" + productList +
                '}';
    }
}

Ⅲ.执久化类Users

public class Users {
    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 + "]";
    }
}

Ⅳ.编写users.xml文件

<select id="findUserWithOrdersByNest" parameterType="Integer"
            resultMap="UserWithOrderResultNest">
        select * from tb_user where id=#{id}
    </select>
    <resultMap type="Users" id="UserWithOrderResultNest">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="address" column="address"/>
        <collection property="ordersList" ofType="Orders" column="id" select="com.itheima.mapper.OrdersMapper.selectOrdersByUserId"/>
    </resultMap>

Ⅴ.编写order.xml文件

<select id="selectOrdersByUserId" parameterType="Integer" resultType="Orders">
        select * from tb_orders where user_id=#{id};
    </select>

Ⅵ.引入映射文件

<mapper resource="com/itheima/mapper/UsersMapper.xml"/>
<mapper resource="com/itheima/mapper/OrdersMapper.xml"/>

Ⅶ.编写测试类

    @Test
    public void findUserTest() {
        // 1.通过工具类生成SqlSession对象
        SqlSession session = MyBatisUtils.getSession();
        // 2.查询id为1的用户信息
        Users users = session.selectOne("com.itheima.mapper."
                + "UsersMapper.findUserWithOrdersByNest", 1);
        // 3.输出查询结果信息
        System.out.println(users);
        // 4.关闭SqlSession
        session.close();
    }

②嵌套结果

同上

    <select id="findUserWithOrders" parameterType="Integer"
            resultMap="UserWithOrdersResult">
              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="Users" id="UserWithOrdersResult">
        <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>

6.多对多查询

多对多关联关系通常需要一个中间表来维护（使用collection），中间表需要添加另外两个表的主键来进行关联，我们看成是双向的一对多关系。例如下图，

Ⅰ.数据库数据准备

CREATE TABLE tb_orders (
  id int(32) PRIMARY KEY AUTO_INCREMENT,
  number varchar(32) NOT NULL,
  user_id int(32) NOT NULL
);
# 插入3条数据
INSERT INTO tb_orders VALUES ('1', '1000011', '1');
INSERT INTO tb_orders VALUES ('2', '1000012', '1');
INSERT INTO tb_orders VALUES ('3', '1000013', '2');

create table tb_product(
    id int(32) primary key auto_increment,
    name varchar(32),
    price double
);

insert into tb_product values('1','Java基础','44.5');
insert into tb_product values('2','python基础','30.5');
insert into tb_product values('3','ssm框架整合实战','50.5');

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('1','1','1');
insert into tb_ordersitem values('2','1','1');
insert into tb_ordersitem values('3','3','3');

Ⅱ.创建执久化类

//同上订单类
public class Orders {
    private Integer id;                //订单id
    private String number;            //订单编号
    //关联商品集合属性
    private List<Product> productList;
}

public class Product{
    private int id;
    private String name;
    private double price;

    private List<Orders> ordersLIst;

    //略
}

Ⅲ.xml文件配置

创建一个productmapper的映射文件

<select id="findProducctById" parameterType="Integer" resultType="product">
    select * from tb_product where id in(select product_id from tb_ordersitem where orders_id=#{id})
</select>

创建一个orders的映射文件

<select id="findOrdersById" parameter="Integer" resultMap="orderWithProductResult">
    select * from tb_orders where id =#{id}
</select>

<resultMap type="Orders" id="OrdersWithPorductResult">
        <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配置

Ⅴ.测试文件

    @Test
    public void findUserTest() {
        // 1.通过工具类生成SqlSession对象
        SqlSession session = MyBatisUtils.getSession();
        // 2.查询id为1的用户信息
        Object order = session.selectOne("com.itheima.mapper."
                + "OrdersMapper.findOrdersById", 1);
        // 3.输出查询结果信息
        System.out.println(order);
        // 4.关闭SqlSession
        session.close();
    }

多对多可参考Mybatis从入门到精通系列 10 —— Mybatis多表查询之多对多查询_mybatis 多对多-CSDNbf

沐小辞

关注

24
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
javaee入门之旅之mybatis---（6）关联映射(一对一，一对多，多对多查询)

在实际的运用当中，除了进行单个表格的操作，还会涉及到多张表格，针对多表之间的操作，Mybatis提供了关联映射，通过关联映射可以很好的处理表与表、对象与对象之间的关联关系。此外，在实际开发中经常需要合理利用Mybatis缓存来加快数据库查询，进而有效提升数据库性能。关联关系映射是指在数据库表之间建立关联关系，并将这种关系映射到对象之间的关系。在关系型数据库中，我们通常使用外键来建立表与表之间的关联。一个数据表中的一条记录最多可以和另一个表中的一条记录相关。
复制链接

扫一扫