JavaEE简单实例——MyBatis的一对一映射的嵌套查询的简单介绍和基础配置

最新推荐文章于 2024-04-26 16:01:44 发布

Error_exception_worn

最新推荐文章于 2024-04-26 16:01:44 发布

阅读量1.9k

点赞数 2

文章标签： mysql 数据库

本文链接：https://blog.csdn.net/hssjsh/article/details/129192012

版权

简单介绍：

在前一章我们介绍了关于MyBatis的多表查询的时候的对应关系，其中有三种对应关系，分别是一对一，一对多，多对多的关系。如果忘记了这三种方式的对应形式可以去前面看看，一定要记住这三种映射关系的图表形式，以及在Java中的以类的形式存在的嵌套关系。这次我们来详细的讲解一对一关系的详细使用方法。

在一对一映射关系的查询中，需要使用到<assciaition>元素，它提供了一系列的用于维护表与表之间关系的属性：

property：用于指定映射关系到实体类对象的属性，与表字段一一对应

column：用于指定表中与对象的属性对应的字段。使用column和property可以完成数据表字段和实体类属性的映射关系。

javaType：用于指定映射到实体类属性值的数据类型

jdbcType：用于指定数据表中对应字段的类型

fetchType：用于指定在关联查询时是否启动延迟加载，fatchType有属性有两个值，lazy和eager两个属性值，默认为lazy。

select：用于指定引入嵌套查询的子SQL语句。

typeHandler：用于指定一个类处理器

<assciaition>是resultMap的子元素，也就是说要使用这个元素需要手动的指定自定义映射规则，并且在我们做多表查询的时候有两种配置方法，嵌套查询和嵌套结果集，我们先讲解嵌套查询

嵌套查询的方式进行多表查询：

嵌套查询的核心理念：将一条查询语句的结果当作另一条查询语句的查询条件。比如在我们想要查询学生的学生卡的时候，需要首先查询学生的信息，得到这个学生的所有信息之后找出学籍号这一列，然后用这个数据再去查询学生卡，在SQL语句中就是这样的：

查询结果就是这样的：

而我们要做就是将子查询的查询结果分离出我们要的列的信息之后，再把这个信息传递给父查询作为查询参数进行进一步查询，最终得出我们想要的结果

前期准备：

首先我们需要两个数据库，一个用来存储学生的相关信息，一个用来存储学生卡的相关信息：

SQL语句：

show databases ;
use mybatis;
show tables ;
create table user(
    id int COMMENT 'id信息',
    name varchar(10) COMMENT '姓名',
    sex varbinary(3) COMMENT '性别',
    id_card int COMMENT 'id号码'
);
# 这两张表使用id_card字段形成一对一的关系
insert into user values (1,'张三','男',1),
                        (2,'李四','女',2),
                        (3,'王五','男',3);
create table id_card(
    id_card int COMMENT 'id号码',
    Information varchar(30) COMMENT '信息'
);
insert into id_card values (1,'我是张三的信息'),
                           (2,'我是李四的信息'),
                           (3,'我是王五的信息');
select * from user;
select * from id_card;

然后就是与之对应的Java实体类，我们需要两个类，一个学生类用来存储学生的相关信息，一个学生卡类用来存储学生的相关信息：

首先是学生卡类：

package com.mybatis.POJO;

public class IdCard {
    private int id_card;
    private String Information;

    public IdCard() {
    }

    public IdCard(int id_card, String information) {
        this.id_card = id_card;
        Information = information;
    }

    public int getId_card() {
        return id_card;
    }

    public void setId_card(int id_card) {
        this.id_card = id_card;
    }

    public String getInformation() {
        return Information;
    }

    public void setInformation(String information) {
        Information = information;
    }

    @Override
    public String toString() {
        return "IdCard{" +
                "id_card=" + id_card +
                ", Information='" + Information + '\'' +
                '}';
    }
}

然后是学生类：

package com.mybatis.POJO;

public class User{
    private int id;
    private String name;
    private String sex;
    private IdCard id_card;

    public User() {
    }

    public User(int id, String name, String sex, IdCard id_card) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.id_card = id_card;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public IdCard getId_card() {
        return id_card;
    }

    public void setId_card(IdCard id_card) {
        this.id_card = id_card;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", id_card=" + id_card +
                '}';
    }
}

在创建学生类的时候就需要注意了，在我们之前介绍一对一查询的Java类实现的时候曾经说过，在Java中体现一对一的查询就是在本类中定义与之关联的类的对象做为属性。比如在A类中定义B类对象作为属性，在B类中定义A类为属性。形成一种互相包含的属性

关键点在这里：

在学生类里面有一个属性，它的类型是学生卡类，也就是达成了我们之前说过一个类里面包含与之关联的对象作为属性，这里是第一个需要注意的点。

使用方法：

在我们创建完之前的数据库和实体类之后，接下来就是进行我们SQL映射语句的编写了：

在我们的嵌套查询的形式中，需要将子查询和父查询分开来写，也就是需要两条SQL映射语句：

<!--    首先是子查询-->
    <select id="selectIdCard" parameterType="int" resultType="IdCard">
        select * from id_card where id_card = #{id};
    </select>
<!--    然后是父查询-->
    <select id="selectUser" resultMap="MapperIdCard" parameterType="int">
        select * from user where id = #{id};
    </select>
    <resultMap id="MapperIdCard" type="User">
        <result column="name" property="name"/>
        <result column="id" property="id"/>
        <result column="sex" property="sex"/>
        <association property="id_card"
                     column="id_card"
                     javaType="IdCard"
                     select="mappers.NestedSelect.selectIdCard"/>
    </resultMap>

我们来解释一下上面的SQL映射文件的片段：

最上面的SQL映射语句是子查询，也就是对应了我们完整的SQL语句中的这个位置：

传递的参数就是int类型，就是要根据这个值查询，返回的类型是IdCard也就是是这个值：

子查询就是由这些组成的，然后关键在于夫查询：

父查询的SQL语句对应完整的SQL语句如下：

SQL语句的传入参数的属性是int类型，也就是要根据这个值去查询学生信息，然后从学生信息中获取到学生卡号信息，再用学生卡号信息去查询学生卡信息，具体的参数的流向如下图所示：

红色的箭头指向的是参数的传递，蓝色的箭头指向的是结果集的封装。那么最后的SQL语句运行结果就是这样的：

其中由两个比较重要的问题，是我们在之后编写自定义映射规则的时候需要解决的：

1.如何从所有的参数中单独拿出id_card列的数据进行传递？

2.如何将结果集封装成IdCard属性并传递给学生类？

然后我们就要开始对我们之前编写的SQL映射文件中的内容进行详细的解释：

<?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">
<!--        接口式开发有两个规范: -->
<!--1.接口中方法的名称必须与SQL语句的唯一标识,也就是id的值保持一致,resultType就是接口中返回值的类型,parameterType就是接口中方法的参数的类型-->
<!-- 2.mapper标签的namespace属性必须是接口的全路径,否则在运行的时候会无法找到接口对象的SQL映射文件 -->
<mapper namespace="mappers.NestedSelect">
    <!--    根据id查询单条数据-->
    <select id="selectOne" resultType="User" parameterType="int">
        select *
        from user
        where id = #{id};
    </select>
    <!--    查询所有的数据-->
    <select id="selectAll" resultType="User">
        select *
        from user;
    </select>
<!--    开始编写关于嵌套查询的内容-->
<!--    首先是子查询-->
    <select id="selectIdCard" parameterType="int" resultType="IdCard">
        select * from id_card where id_card = #{id};
    </select>
<!--    然后是父查询-->
    <select id="selectUser" resultMap="MapperIdCard" parameterType="int">
        select * from user where id = #{id};
    </select>
    <resultMap id="MapperIdCard" type="User">
        <result column="name" property="name"/>
        <result column="id" property="id"/>
        <result column="sex" property="sex"/>
        <association property="id_card"
                     column="id_card"
                     javaType="IdCard"
                     select="mappers.NestedSelect.selectIdCard"/>
    </resultMap>
</mapper>

首先我们来看父查询中的resultMap部分：

其中在我们的自定义结果集映射的部分，前几个部分都是和之前是一样的，在最后的<association>元素中，property指向的就是我们的一个类里面包含与之关联的对象作为属性，column就是与其他表建立联系的字段，这个值也就是我们传递给子查询的参数的来源，JavaType的值就是一个类里面包含与之关联的对象作为属性的这个与之关联的对象的类，也就是我们的IdCard的类名，最后的select指向的就是子查询的SQL语句的唯一标识：

具体的参数的传递如下面的图式所示：

最终的运行结果就是如下所示：

在数据库中的查询语句如下：

查询结果如下：

代码实现：

最后总结一下完整的代码：

SQL映射文件：

<?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">
<!--        接口式开发有两个规范: -->
<!--1.接口中方法的名称必须与SQL语句的唯一标识,也就是id的值保持一致,resultType就是接口中返回值的类型,parameterType就是接口中方法的参数的类型-->
<!-- 2.mapper标签的namespace属性必须是接口的全路径,否则在运行的时候会无法找到接口对象的SQL映射文件 -->
<mapper namespace="mappers.NestedSelect">
    <!--    根据id查询单条数据-->
    <select id="selectOne" resultType="User" parameterType="int">
        select *
        from user
        where id = #{id};
    </select>
    <!--    查询所有的数据-->
    <select id="selectAll" resultType="User">
        select *
        from user;
    </select>
<!--    开始编写关于嵌套查询的内容-->
<!--    首先是子查询-->
    <select id="selectIdCard" parameterType="int" resultType="IdCard">
        select * from id_card where id_card = #{id};
    </select>
<!--    然后是父查询-->
    <select id="selectUser" resultMap="MapperIdCard" parameterType="int">
        select * from user where id = #{id};
    </select>
    <resultMap id="MapperIdCard" type="User">
        <result column="name" property="name"/>
        <result column="id" property="id"/>
        <result column="sex" property="sex"/>
        <association property="id_card"
                     column="id_card"
                     javaType="IdCard"
                     select="mappers.NestedSelect.selectIdCard"/>
    </resultMap>
</mapper>

接口文件：

package mappers;

import com.mybatis.POJO.IdCard;
import com.mybatis.POJO.User;

import java.util.List;

public interface NestedSelect {
    public User selectOne(int i);
    public List<User> selectAll();
    public List<User> selectUser(int i);
    public List<IdCard> selectIdCard(int i);
}

测试类：

package mappers;

import Tools.create;
import com.mybatis.POJO.IdCard;
import com.mybatis.POJO.User;
import org.apache.ibatis.session.SqlSession;
import org.junit.Before;
import org.junit.Test;

public class NestedSelectTest {
    NestedSelect mapper = null;
    SqlSession session = null;

    @Before
    public void setUp() throws Exception {
        session = create.createSqlSession();
        mapper = create.createNestedSelectMappers();
    }
    @Test
    public void testSelectOne() {
        User user = mapper.selectOne(1);
        System.out.println(user.toString());
    }

    @Test
    public void testSelectAll() {
        for (User user : mapper.selectAll()) {
            System.out.println(user.toString());
        }
    }
//    测试嵌套查询的运行语句
    @Test
    public void selectUser(){
        for (User user : mapper.selectUser(2)) {
            System.out.println(user.toString());
        }
    }
    @Test
    public void selectIdCard(){
        for (IdCard idCard : mapper.selectIdCard(1)) {
            System.out.println(idCard.toString());
        }
    }
}

运行结果：

注意点：

在这一章节中所需要的注意点就是我们在配置SQL映射文件的时候一定要清晰的理解这些配置项之间的嵌套关系，以及类与类，表与表之间的关系，或者如果不理解的话，至少知道怎么写能出现什么效果。常见的报错就是SQL语句的嵌套关系错误导致的查询结果不正确，如果出现了查询结果不正确，首先去检查映射关系的部分。如果出现了查询不到数据，可以去看看有没有配置之前的驼峰映射，这个配置会影响后续的我们的自定义映射关系的数据，有可能会导致最终的结果查询不到数据。