mybatis resultMap collection嵌套collection mybatis collection多层嵌套

1. 什么是多层嵌套查询？

多层嵌套查询指的是在进行数据库查询时，需要查询多个关联表才能获取最终的结果。这种情况下，我们需要在 SQL 语句中使用多个子查询，把不同层级的查询进行组合，才能得到最终的结果。

2. Mybatis 多层嵌套查询的实现方式

Mybatis 多层嵌套查询的实现方式一般有两种，一种是使用嵌套 Select 语句，一种是使用 Mybatis 的 Association 和 Collection 功能。

2.1 使用嵌套 Select 语句

使用嵌套 Select 语句需要写 SQL 语句，如下所示：

SELECT
    a.name,
    b.book_name,
    c.chapter_name
FROM
    author a
    JOIN book b ON a.author_id = b.author_id
    JOIN chapter c ON b.book_id = c.book_id
WHERE
    a.name = '张三';

在这个 SQL 语句中，我们使用了 JOIN 操作来关联多个表，然后使用 WHERE 子句来筛选出指定作者的信息。这个 SQL 语句可以返回指定作者和他所写的书籍和书籍的章节信息。

然后，我们可以将这个 SQL 语句写入 Mybatis 的 Mapper 文件中，使用 #{} 语法来传递参数，如下所示：

<select id="getAuthorBookChapterByName" resultType="Author">
    SELECT
        a.name,
        b.book_name,
        c.chapter_name
    FROM
        author a
        JOIN book b ON a.author_id = b.author_id
        JOIN chapter c ON b.book_id = c.book_id
    WHERE
        a.name = #{name}
</select>

在 Mapper 文件中，我们可以使用 resultType 属性来指定查询结果的类型，这里我们指定为 Author。然后我们可以使用 #{} 语法来传递参数，这里我们传入了 name 参数来指定查询的作者名称。

2.2 使用 Association 和 Collection 功能

使用 Mybatis 的 Association 和 Collection 功能可以通过配置文件来实现多表查询，如下所示：

<resultMap id="authorMap" type="Author">
    <id property="authorId" column="author_id"/>
    <result property="name" column="name"/>
    <association property="book" javaType="Book" columnPrefix="book_">
        <id property="bookId" column="book_id"/>
        <result property="bookName" column="book_name"/>
        <collection property="chapters" ofType="Chapter" columnPrefix="chapter_">
            <id property="chapterId" column="chapter_id"/>
            <result property="chapterName" column="chapter_name"/>
        </collection>
    </association>
</resultMap>

在这个配置文件中，我们首先定义了一个 resultMap，指定了结果集的类型为 Author，并定义了 Author 类的属性映射关系。

然后，我们定义了一个 association，用来关联 Author 和 Book 两个表，定义了 Book 类的属性映射关系。

最后，我们定义了一个 collection，用来关联 Book 和 Chapter 两个表，定义了 Chapter 类的属性映射关系。

然后我们可以在 Mapper 文件中使用这个 resultMap，如下所示：

<select id="getAuthorByName" resultMap="authorMap">
    SELECT
        a.author_id,
        a.name,
        b.book_id AS book_book_id,
        b.book_name AS book_book_name,
        c.chapter_id AS chapter_chapter_id,
        c.chapter_name AS chapter_chapter_name
    FROM
        author a
        JOIN book b ON a.author_id = b.author_id
        JOIN chapter c ON b.book_id = c.book_id
    WHERE
        a.name = #{name}
</select>

在 Mapper 文件中，我们可以使用 resultMap 属性来指定查询结果的映射方式为上面定义的 resultMap，并使用 #{} 语法来传递参数，例如这里我们传入了 name 参数来指定查询的作者名称。

3. 示例

下面我们将使用上面两种方式来完成多层嵌套查询，并展示示例代码。

3.1 使用嵌套 Select 语句

我们将定义一个 Author 类来保存查询结果，然后在 Mapper 文件中添加如下代码：

public class Author {
    private int authorId;
    private String name;
    private String bookName;
    private String chapterName;
    // 省略 getter 和 setter 方法
}

<select id="getAuthorByNestSelect" resultType="Author">
    SELECT
        a.author_id,
        a.name,
        b.book_name,
        c.chapter_name
    FROM
        author a
        JOIN book b ON a.author_id = b.author_id
        JOIN chapter c ON b.book_id = c.book_id
    WHERE
        a.name = #{name}
</select>

然后我们可以在代码中使用上述定义的 Mapper 来查询结果：

try(SqlSession sqlSession = sqlSessionFactory.openSession()) {
    AuthorMapper authorMapper = sqlSession.getMapper(AuthorMapper.class);
    List<Author> authors = authorMapper.getAuthorByNestSelect("张三");
    for(Author author : authors) {
        System.out.println(author.getName() + "-" + author.getBookName() + "-" + author.getChapterName());
    }
}

3.2 使用 Association 和 Collection 功能

我们将定义一个 Author、Book 和 Chapter 三个类来保存查询结果，然后在 Mapper 文件中添加如下代码：

public class Author {
    private int authorId;
    private String name;
    private List<Book> bookList;
    // 省略 getter 和 setter 方法
}

public class Book {
    private int bookId;
    private String bookName;
    private List<Chapter> chapterList;
    // 省略 getter 和 setter 方法
}

public class Chapter {
    private int chapterId;
    private String chapterName;
    // 省略 getter 和 setter 方法
}

<resultMap id="authorMap" type="Author">
    <id property="authorId" column="author_id"/>
    <result property="name" column="name"/>
    <collection property="bookList" javaType="ArrayList" ofType="Book" columnPrefix="book_">
        <id property="bookId" column="book_id"/>
        <result property="bookName" column="book_name"/>
        <collection property="chapterList" javaType="ArrayList" ofType="Chapter" columnPrefix="chapter_">
            <id property="chapterId" column="chapter_id"/>
            <result property="chapterName" column="chapter_name"/>
        </collection>
    </collection>
</resultMap>

<select id="getAuthorByName" resultMap="authorMap">
    SELECT
        a.author_id,
        a.name,
        b.book_id AS book_book_id,
        b.book_name AS book_book_name,
        c.chapter_id AS chapter_chapter_id,
        c.chapter_name AS chapter_chapter_name
    FROM
        author a
        JOIN book b ON a.author_id = b.author_id
        JOIN chapter c ON b.book_id = c.book_id
    WHERE
        a.name = #{name}
</select>

然后我们可以在代码中使用上述定义的 Mapper 来查询结果：

try(SqlSession sqlSession = sqlSessionFactory.openSession()) {
    AuthorMapper authorMapper = sqlSession.getMapper(AuthorMapper.class);
    List<Author> authors = authorMapper.getAuthorByName("张三");
    for(Author author : authors) {
        System.out.println(author.getName());
        List<Book> books = author.getBookList();
        for(Book book : books) {
            System.out.println(book.getBookName());
            List<Chapter> chapters = book.getChapterList();
            for(Chapter chapter : chapters) {
                System.out.println(chapter.getChapterName());
            }
        }
    }
}

4. 总结

本文主要介绍了 Mybatis 多层嵌套查询的实现方式，包括使用嵌套 Select 语句和使用 Mybatis 的 Association 和 Collection 功能。同时，本文还提供了两个示例代码供读者参考。希望本文能够帮助读者更好地了解和使用 Mybatis。