MyBatis使用嵌套查询collection和association的实现_Java

1、目标

本文的主要目标是mybatis使用collection标签完成一对多的嵌套查询，使用association标签完成一对一的嵌套查询

2、一对多的嵌套查询用collection标签

2.1 多表查询并且resultmap是数据库的class表

create table `class` (
    `id` int primary key auto_increment,
    `name` varchar(100) not null,
    `create_time` date not null
);

create table `stu` (
    `id` int primary key auto_increment,
    `name` varchar(100) not null,
    `age` int not null,
    `class_id` int not null
);

先在数据库创建表class和stu，class是班级表，stu是学生表，stu学生表中包含class_id字段表示这个学生在哪个班级中

insert into `class`(`name`, `create_time`) values ('1班', now()), ('2班', now()), ('3班', now());

然后在class表中插入记录

insert into `stu`(`name`, `age`, `class_id`) values ('张三1', 20, 1), ('李四1', 18, 1), ('王五1', 21, 1),
                                                    ('张三2', 15, 2), ('李四2', 19, 2), ('王五2', 16, 2),
                                                    ('张三3', 22, 3), ('李四3', 29, 3), ('王五3', 26, 3);

然后在stu表中插入记录

@data
public class class {

    private string id;

    private string name;

    private string createtime;

    private list<stu> stulist;

  @override
  public string tostring() {
    return "class{" +
      "id='" + id + '\'' +
      ", name='" + name + '\'' +
      ", createtime='" + createtime + '\'' +
      ", stulist=" + stulist +
      '}';
  }
}

创建class实体类，对应class表的字段，其中多了一个字段是stulist这个list集合，因为一个班级包含了多个学生，这里是一对多的嵌套查询因此用collection标签

@data
public class stu {

  private integer id;

  private string name;

  private integer age;

  private integer classid;

  @override
  public string tostring() {
    return "stu{" +
      "id=" + id +
      ", name='" + name + '\'' +
      ", age=" + age +
      ", classid=" + classid +
      '}';
  }

}

创建stu实体类，对应stu表的字段

@mapper
public interface classmapper {

    class getclass(@param("classname") string classname);

}

创建classmapper的接口方法getclass，入参是classname，出参是一个class班级对象，这个班级对象会封装多个学生对象

<?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.apache.mybatisdemo.classmapper">

    <resultmap id="classmap" type="org.apache.mybatisdemo.class">
        <id property="id" column="classid"/>
        <result property="name" column="classname"/>
        <result property="createtime" column="create_time"/>
        <collection property="stulist" javatype="java.util.list" oftype="org.apache.mybatisdemo.stu">
            <result property="id" column="stuid"/>
            <result property="name" column="stuname"/>
            <result property="age" column="age"/>
            <result property="classid" column="class_id"/>
        </collection>
    </resultmap>

    <select id="getclass" resultmap="classmap">
        select c.id classid, c.name classname, c.create_time, s.id stuid, s.name stuname, s.age, s.class_id
        from `class` c inner join `stu` s on c.id = s.class_id
        where c.`name` = #{classname}
    </select>

</mapper>

sql使用多表查询，resultmap是返回值的类型，使用collection标签封装多个stu学生对象，collection标签中javatype指定是list集合类型，oftype指定list集合的泛型类型

注意：

（1）

<id property="id" column="classid"/>
<result property="name" column="classname"/>
<result property="createtime" column="create_time"/>

resultmap中除了collection的更新字段至少有1个，比如这里我更新了3个字段
如果除了collection没有更新字段，会抛出异常，具体参考我写的博客：mybatis嵌套查询collection报错：org.apache.ibatis.exceptions.toomanyresultsexception

（2）sql查询的字段如果重复名字的要取别名，如果不取别名resultmap直接用c.id，mybatis底层不会将这个字段作为查询字段，因为它识别不了c是哪张表

<mappers>
    <mapper resource="mybatis/classmapper.xml"/>
</mappers>

mybatis-config.xml文件中设置mapper标签是classmapper.xml，因此可以扫描到这个xml文件

@test
  public void f1() throws ioexception {
    string resource = "mybatis-config.xml";
    inputstream inputstream = resources.getresourceasstream(resource);
    sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
    try (sqlsession sqlsession = sqlsessionfactory.opensession()) {
      classmapper mapper = sqlsession.getmapper(classmapper.class);
      class cls = mapper.getclass("2班");
      system.out.println(cls.tostring());
    }
  }

测试这个接口方法

在这里插入图片描述

测试结果返回一个class班级对象，这个对象包含id=2，name=2班，createtime，stulist是一个list集合，它封装了多个stu学生对象

2.2 多表查询并且resultmap是自定义vo类classvo

那resultmap返回值类型必须是数据库表对应的实体类吗？不一定，返回值类型可以是自定义类比如vo

@data
public class classvo {

  private string id;

  private list<stu> stulist;

  @override
  public string tostring() {
    return "classvo{" +
      "id='" + id + '\'' +
      ", stulist=" + stulist +
      '}';
  }

}

自定义vo类classvo包含的字段只有id和stulist这个list集合

@mapper
public interface classmapper {

    classvo getclassvo(@param("classname") string classname);

}

创建接口方法，返回值类型是自定义classvo类

<?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.apache.mybatisdemo.classmapper">

    <resultmap id="classvomap" type="org.apache.mybatisdemo.classvo">
        <id property="id" column="classid"/>
        <collection property="stulist" javatype="java.util.list" oftype="org.apache.mybatisdemo.stu">
            <id property="id" column="stuid"/>
            <result property="name" column="stuname"/>
            <result property="age" column="age"/>
            <result property="classid" column="class_id"/>
        </collection>
    </resultmap>

    <select id="getclassvo" resultmap="classvomap">
        select c.id classid, c.name, c.create_time, s.id stuid, s.name stuname, s.age, s.class_id
        from `class` c inner join `stu` s on c.id = s.class_id
        where c.`name` = #{classname}
    </select>
</mapper>

这个接口方法的xml对应的返回值类型是type=“org.apache.mybatisdemo.classvo”

注意：
（1）resultmap中除了collection的更新字段至少有1个
（2）sql查询的字段如果重复名字的要取别名

@test
  public void f2()throws ioexception {
    string resource = "mybatis-config.xml";
    inputstream inputstream = resources.getresourceasstream(resource);
    sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
    try (sqlsession sqlsession = sqlsessionfactory.opensession()) {
      classmapper mapper = sqlsession.getmapper(classmapper.class);
      classvo classvo = mapper.getclassvo("2班");
      system.out.println(classvo.tostring());
    }
  }

测试getclassvo方法，返回值是一个classvo对象

在这里插入图片描述

测试结果是返回一个classvo对象，它包含id=2，stulist这个list集合，它包含了3个stu学生对象

结论：resultmap返回值类型不一定是数据库表对应的实体类，可以是自己定义的类

2.3 单表查询并且resultmap是自定义vo类classvo

可以单表查询stu学生表然后resultmap可以映射吗？可以，不过除了resultmap中除了collection必须至少有1个字段更新

@mapper
public interface classmapper {

    classvo getclasvobysingletable(@param("classid") integer classid);

}

创建一个mapper接口方法

<?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.apache.mybatisdemo.classmapper">

    <resultmap id="clasvobysingletablemap" type="org.apache.mybatisdemo.classvo">
        <id property="id" column="class_id"/>
        <collection property="stulist" javatype="java.util.list" oftype="org.apache.mybatisdemo.stu">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="age" column="age"/>
            <result property="classid" column="class_id"/>
        </collection>
    </resultmap>

    <select id="getclasvobysingletable" resultmap="clasvobysingletablemap">
        select * from stu where stu.class_id = #{classid}
    </select>
</mapper>

mapper.xml文件中sql是单表查询，也可以进行resultmap的字段赋值

注意：
（1）resultmap中除了collection的更新字段至少有1个
（2）sql查询的字段如果重复名字的要取别名

@test
  public void f3() throws ioexception {
    string resource = "mybatis-config.xml";
    inputstream inputstream = resources.getresourceasstream(resource);
    sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
    try (sqlsession sqlsession = sqlsessionfactory.opensession()) {
      classmapper mapper = sqlsession.getmapper(classmapper.class);
      classvo classvo = mapper.getclasvobysingletable(2);
      system.out.println(classvo.tostring());
    }
  }

调用getclasvobysingletable方法会返回classvo对象

在这里插入图片描述

测试结果是单表查询，也可以返回一个classvo对象，它包含id=2，stulist是list集合，它包含3个stu学生对象

结论：单表查询stu学生表然后resultmap可以映射

2.4 单表查询并且resultmap是自定义vo类classvo，返回值是list类型

@mapper
public interface classmapper {

    list<classvo> getclassvolist();

}

mapper接口方法的返回值是list集合

<select id="getclassvolist" resultmap="clasvobysingletablemap">
   select * from stu
</select>

mapper.xml文件中单表查询，resultmap仍然是2.3中的resultmap即clasvobysingletablemap，因为返回值类型list集合的泛型还是classvo类

@test
  public void f4() throws ioexception {
    string resource = "mybatis-config.xml";
    inputstream inputstream = resources.getresourceasstream(resource);
    sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
    try (sqlsession sqlsession = sqlsessionfactory.opensession()) {
      classmapper mapper = sqlsession.getmapper(classmapper.class);
      list<classvo> list = mapper.getclassvolist();
      list.foreach(system.out::println);
    }
  }

测试：调用getclassvolist方法

在这里插入图片描述

测试结果是单表查询返回stu学生表的所有记录，指定resultmap，封装了collection，因此会将相同class_id的多个stu学生对象封装到一个classvo对象，结果是返回3个classvo对象，每个classvo对象都封装了3个stu对象

结论：mapper接口方法的返回值是多个class_id的classvo对象用list集合，resultmap指定list集合的泛型，mybatis会自动将相同class_id的stu学生对象封装到一个classvo对象中

2.5 多表查询并且resultmap是数据库的class表，返回值是list类型

@mapper
public interface classmapper {

    list<class> getclasslist();
    
}

返回值是list集合

<select id="getclasslist" resultmap="classmap">
        select c.id classid, c.name classname, c.create_time, s.id stuid, s.name stuname, s.age, s.class_id
        from `class` c inner join `stu` s on c.id = s.class_id
</select>

resultmap复用2.1的resultmap，因为返回值是list集合，它的泛型和2.1的返回值类型是相同的

@test
  public void f5() throws ioexception {
    string resource = "mybatis-config.xml";
    inputstream inputstream = resources.getresourceasstream(resource);
    sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
    try (sqlsession sqlsession = sqlsessionfactory.opensession()) {
      classmapper mapper = sqlsession.getmapper(classmapper.class);
      list<class> list = mapper.getclasslist();
      list.foreach(system.out::println);
    }
  }

调用getclasslist方法

在这里插入图片描述

返回值是3个class班级对象，每个class班级对象都封装了自己班的stu学生对象

结论：mapper接口方法的返回值是多个class_id的class班级对象用list集合，resultmap指定list集合的泛型，mybatis会自动将相同class_id的stu学生对象封装到一个class班级对象中

3、一对一的嵌套查询用association标签

3.1 多表查询，返回值是stu学生对象

@data
public class stu {
  private integer id;
  private string name;
  private integer age;
  private integer classid;
  private class stuclass;
  @override
  public string tostring() {
    return "stu{" +
      "id=" + id +
      ", name='" + name + '\'' +
      ", age=" + age +
      ", classid=" + classid +
      ", stuclass=" + stuclass +
      '}';
  }
}

创建stu实体类对象，多一个表中不存在的class类型的stuclass对象，它表示这个学生属于哪个班级，这里是一对一的嵌套查询因此用association标签

@mapper
public interface stumapper {
  stu getstubyid(@param("stuname") string stuname);
}

mapper接口方法是getstubyid方法，返回值是stu学生对象

<?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.apache.mybatisdemo.stumapper">

    <resultmap id="stumap" type="org.apache.mybatisdemo.stu">
        <id property="id" column="stuid"/>
        <result property="name" column="stuname"/>
        <result property="age" column="age"/>
        <result property="classid" column="class_id"/>
        <association property="stuclass" javatype="org.apache.mybatisdemo.class">
            <id property="id" column="classid"/>
            <result property="name" column="classname"/>
            <result property="createtime" column="create_time"/>
        </association>
    </resultmap>

    <select id="getstubyid" resultmap="stumap">
        select c.id classid, c.name classname, c.create_time, s.id stuid, s.name stuname, s.age, s.class_id
        from `class` c inner join `stu` s on c.id = s.class_id
        where s.`name` = #{stuname}
    </select>

</mapper>

mapper.xml文件多表查询，resultmap的type是org.apache.mybatisdemo.stu类型，其中stuclass属性是class班级类型，是一对一的嵌套查询因此用association标签，association标签用javatype表示类型是org.apache.mybatisdemo.class

<mappers>
    <mapper resource="mybatis/blogmapper.xml"/>
    <mapper resource="mybatis/classmapper.xml"/>
    <mapper resource="mybatis/stumapper.xml"/>
</mappers>

mybatis-config.xml文件中注册stumapper.xml

@test
  public void f8() throws ioexception {
    string resource = "mybatis-config.xml";
    inputstream inputstream = resources.getresourceasstream(resource);
    sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
    try (sqlsession sqlsession = sqlsessionfactory.opensession()) {
      stumapper mapper = sqlsession.getmapper(stumapper.class);
      stu stu = mapper.getstubyid("张三3");
      system.out.println(stu);
    }
  }

调用mapper的getstubyid方法

在这里插入图片描述

测试结果是返回一个stu学生对象，它包含id=7，name=张三3，age=22，classid=3，stuclass属性是一个class班级对象，使用association标签封装了这个class班级对象

结论：一对一的嵌套查询用association标签

3.2 多表查询，返回值是list集合，泛型是stu学生对象

@mapper
public interface stumapper {

  list<stu> getstulist();

}

返回值是list集合，泛型是stu学生对象

<?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.apache.mybatisdemo.stumapper">

    <select id="getstulist" resultmap="stumap">
        select c.id classid, c.name classname, c.create_time, s.id stuid, s.name stuname, s.age, s.class_id
        from `class` c inner join `stu` s on c.id = s.class_id
    </select>
    
</mapper>

mapper.xml的方法中resultmap指定stumap，还是3.1中的resultmap，只需要指定list集合的泛型即可

@test
  public void f9() throws ioexception {
    string resource = "mybatis-config.xml";
    inputstream inputstream = resources.getresourceasstream(resource);
    sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
    try (sqlsession sqlsession = sqlsessionfactory.opensession()) {
      stumapper mapper = sqlsession.getmapper(stumapper.class);
      list<stu> stulist = mapper.getstulist();
      stulist.foreach(system.out::println);
    }
  }

调用mapper的getstulist方法

在这里插入图片描述