详解MyBatis中的结果映射resultMap

最新推荐文章于 2024-05-10 14:07:14 发布
最新推荐文章于 2024-05-10 14:07:14 发布
阅读量1.9k 收藏 5
点赞数 1
文章标签： mybatis java sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76607156/article/details/129768890
版权

前言

查询是数据库中使用频率最高的功能，在MyBatis中想要执行查询，需要在映射文件中配置<select>标签来编写查询SQL。光有查询还不够，还得完成查询结果与实体对象的映射，MyBatis提供了<resultMap>标签来提供强大的结果映射功能。

本篇文章将结合示例对<select>和<resultMap>标签进行学习，并对N+1问题进行分析。

MyBatis版本：3.5.6

正文

一. 示例工程搭建

首先通过如下SQL语句创建表，并插入数据。

CREATE TABLE people (
    id INT(11) PRIMARY KEY AUTO_INCREMENT,
    p_name VARCHAR(255) NOT NULL,
    p_age INT(11) NOT NULL
);

INSERT INTO people(p_name, p_age) VALUES ("Lee", 20);
INSERT INTO people(p_name, p_age) VALUES ("Arm", 25);

CREATE TABLE bookstore(
    id INT(11) PRIMARY KEY AUTO_INCREMENT,
    bs_name VARCHAR(255) NOT NULL,
    p_id INT(11) NOT NULL,
    FOREIGN KEY bookstore(p_id) REFERENCES people(id)
);

INSERT INTO bookstore (bs_name, p_id) VALUES ("XinHua", 1);
INSERT INTO bookstore (bs_name, p_id) VALUES ("SanYou", 2);

CREATE TABLE book(
    id INT(11) PRIMARY KEY AUTO_INCREMENT,
    b_name VARCHAR(255) NOT NULL,
    b_price FLOAT NOT NULL,
    bs_id INT(11) NOT NULL,
    FOREIGN KEY book(bs_id) REFERENCES bookstore(id)
);

INSERT INTO book (b_name, b_price, bs_id) VALUES ("Math", 20.5, 1);
INSERT INTO book (b_name, b_price, bs_id) VALUES ("English", 21.5, 1);
INSERT INTO book (b_name, b_price, bs_id) VALUES ("Water Margin", 30.5, 2)
复制代码

工程结构如下所示。

MAVEN的pom文件内容如下所示。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lee.learn.mybatis</groupId>
    <artifactId>mybatis-select</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>
复制代码

配置文件mybatis-config.xml如下所示。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://192.168.101.7:3306/test?characterEncoding=utf-8&amp;serverTimezone=UTC&amp;useSSL=false"/>
                <property name="username" value="somdbdev"/>
                <property name="password" value="Km7HZP#aB"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <package name="com.lee.learn.mybatis.dao"/>
    </mappers>
</configuration>
复制代码

实体对象如下所示。

public class Book {

    private int id;
    private String bookName;
    private float bookPrice;
    private int bookStoreId;

    // 省略get和set

}

public class BookStore {

    private int id;
    private String bookStoreName;
    private int peopleId;

    // 省略get和set

}

public class People {

    private int id;
    private String peopleName;
    private int peopleAge;

    // 省略get和set

}

public class BsBookCombine {

    private int id;
    private String bookStoreName;

    private List<Book> books;

    // 省略get和set

}

public class BsPeopleCombine {

    private int id;
    private String bookStoreName;

    private People boss;

    // 省略get和set

}

public class BsBkPeopleCombine {

    private int id;
    private String bookStoreName;

    private People boss;

    private List<Book> books;

    // 省略get和set

}
复制代码

映射接口BookMapper如下所示。

public interface BookMapper {

    /**
     * 根据书Id查询一本书。
     *
     * @param bookId 书Id。
     * @return {@link Book}。
     */
    Book queryBookByBookId(int bookId);

    /**
     * 根据书店Id查询多本书。
     *
     * @param bsId 书店Id。
     * @return {@link Book}。
     */
    List<Book> queryBooksByBsId(int bsId);

}
复制代码

映射文件BookMapper.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.lee.learn.mybatis.dao.BookMapper">
    <resultMap id="bookResultMap" type="com.lee.learn.mybatis.entity.Book">
        <id property="id" column="id"/>
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
        <result property="bookStoreId" column="bs_id"/>
    </resultMap>

    <select id="queryBookByBookId" resultMap="bookResultMap">
        SELECT
            id,
            b_name,
            b_price,
            bs_id
        FROM book
        WHERE id=#{bookId}
    </select>

    <select id="queryBooksByBsId" resultMap="bookResultMap">
        SELECT
            id,
            b_name,
            b_price,
            bs_id
        FROM book
        WHERE bs_id=#{bsId}
    </select>

</mapper>
复制代码

映射接口PeopleMapper如下所示。

public interface PeopleMapper {

    /**
     * 根据人Id查询一个人。
     *
     * @param peopleId 人Id。
     * @return 以Map的形式返回。
     */
    Map<String, Object> simpleQueryPeopleByPeopleId(int peopleId);

    /**
     * 根据人Id查询一个人。
     *
     * @param peopleId 人id。
     * @return {@link People}。
     */
    People queryPeopleByPeopleId(int peopleId);

}
复制代码

映射文件PeopleMapper.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.lee.learn.mybatis.dao.PeopleMapper">
    <resultMap id="peopleResultMap" type="com.lee.learn.mybatis.entity.People">
        <id property="id" column="id"/>
        <result property="peopleName" column="p_name"/>
        <result property="peopleAge" column="p_age"/>
    </resultMap>

    <select id="simpleQueryPeopleByPeopleId" resultType="Map">
        SELECT
            id,
            p_name,
            p_age
        FROM people
        WHERE id=#{id}
    </select>

    <select id="queryPeopleByPeopleId" resultMap="peopleResultMap">
        SELECT
            id,
            p_name,
            p_age
        FROM people
        WHERE id=#{id}
    </select>

</mapper>
复制代码

映射接口AssociatedMapper如下所示。

public interface AssociatedMapper {

    /**
     * 根据书店Id 关联的嵌套Select 查询{@link BsPeopleCombine}。
     *
     * @param bsId 书店Id。
     * @return {@link BsPeopleCombine}。
     */
    BsPeopleCombine queryBsPeopleCombineByBsIdAssociatedNestSelect(int bsId);

    /**
     * 根据书店Id 关联的嵌套结果 查询{@link BsPeopleCombine}。
     *
     * @param bsId 书店Id。
     * @return {@link BsPeopleCombine}。
     */
    BsPeopleCombine queryBsPeopleCombineByBsIdAssociatedNestResult(int bsId);

    /**
     * 根据书店Id 集合的嵌套Select 查询{@link BsBookCombine}。
     *
     * @param bsId 书店Id。
     * @return {@link BsBookCombine}。
     */
    BsBookCombine queryBsBookCombineByBsIdCollectionNestSelect(int bsId);

    /**
     * 根据书店Id 集合的嵌套结果 查询{@link BsBookCombine}。
     *
     * @param bsId 书店Id。
     * @return {@link BsBookCombine}。
     */
    BsBookCombine queryBsBookCombineByBsIdCollectionNestResult(int bsId);

    /**
     * 根据书店Id 嵌套Select 查询{@link BsBkPeopleCombine}。
     *
     * @param bsIs 书店Id。
     * @return {@link BsBkPeopleCombine}。
     */
    BsBkPeopleCombine queryBsBkPeopleCombineByBsIdNestSelect(int bsIs);

    /**
     * 根据书店Id 嵌套结果 查询{@link BsBkPeopleCombine}。
     *
     * @param bsIs 书店Id。
     * @return {@link BsBkPeopleCombine}。
     */
    BsBkPeopleCombine queryBsBkPeopleCombineByBsIdNestResult(int bsIs);

}
复制代码

映射文件AssociatedMapper.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.lee.learn.mybatis.dao.AssociatedMapper">
    <resultMap id="bsPeopleCombineQueryMap" type="com.lee.learn.mybatis.entity.BsPeopleCombine">
        <id property="id" column="id"/>
        <result property="bookStoreName" column="bs_name"/>
        <association property="boss" column="p_id"
                     javaType="com.lee.learn.mybatis.entity.People"
                     select="com.lee.learn.mybatis.dao.PeopleMapper.queryPeopleByPeopleId"/>
    </resultMap>

    <resultMap id="bsPeopleCombineResultMap" type="com.lee.learn.mybatis.entity.BsPeopleCombine">
        <id property="id" column="bs_id"/>
        <result property="bookStoreName" column="bs_name"/>
        <association property="boss" javaType="com.lee.learn.mybatis.entity.People">
            <id property="id" column="p_id"/>
            <result property="peopleName" column="p_name"/>
            <result property="peopleAge" column="p_age"/>
        </association>
    </resultMap>

    <resultMap id="bsBookCombineQueryMap" type="com.lee.learn.mybatis.entity.BsBookCombine">
        <id property="id" column="id"/>
        <result property="bookStoreName" column="bs_name"/>
        <collection property="books" column="id"
                    javaType="ArrayList" ofType="com.lee.learn.mybatis.entity.Book"
                    select="com.lee.learn.mybatis.dao.BookMapper.queryBooksByBsId"/>
    </resultMap>

    <resultMap id="bsBookCombineResultMap" type="com.lee.learn.mybatis.entity.BsBookCombine">
        <id property="id" column="bs_Id"/>
        <result property="bookStoreName" column="bs_name"/>
        <collection property="books" ofType="com.lee.learn.mybatis.entity.Book">
            <id property="id" column="b_id"/>
            <result property="bookName" column="b_name"/>
            <result property="bookPrice" column="b_price"/>
            <result property="bookStoreId" column="bbs_id"/>
        </collection>
    </resultMap>

    <resultMap id="BsBkPeopleCombineQueryMap" type="com.lee.learn.mybatis.entity.BsBkPeopleCombine">
        <id property="id" column="id"/>
        <result property="bookStoreName" column="bs_name"/>
        <association property="boss" column="p_id"
                     javaType="com.lee.learn.mybatis.entity.People"
                     select="com.lee.learn.mybatis.dao.PeopleMapper.queryPeopleByPeopleId"/>
        <collection property="books" column="id"
                    ofType="com.lee.learn.mybatis.entity.Book"
                    select="com.lee.learn.mybatis.dao.BookMapper.queryBooksByBsId"/>
    </resultMap>
    
    <resultMap id="BsBkPeopleCombineResultMap" type="com.lee.learn.mybatis.entity.BsBkPeopleCombine">
        <id property="id" column="bs_id"/>
        <result property="bookStoreName" column="bs_name"/>
        <association property="boss" javaType="com.lee.learn.mybatis.entity.People">
            <id property="id" column="p_id"/>
            <result property="peopleName" column="p_name"/>
            <result property="peopleAge" column="p_age"/>
        </association>
        <collection property="books" ofType="com.lee.learn.mybatis.entity.Book">
            <id property="id" column="b_id"/>
            <result property="bookName" column="b_name"/>
            <result property="bookPrice" column="b_price"/>
            <result property="bookStoreId" column="bbs_id"/>
        </collection>
    </resultMap>

    <select id="queryBsPeopleCombineByBsIdAssociatedNestSelect" resultMap="bsPeopleCombineQueryMap">
        SELECT
            id,
            bs_name,
            p_id
        FROM bookstore
        WHERE id=#{bsId}
    </select>

    <select id="queryBsPeopleCombineByBsIdAssociatedNestResult" resultMap="bsPeopleCombineResultMap">
        SELECT
            bs.id AS bs_id,
            bs.bs_name AS bs_name,
            p.id AS p_id,
            p.p_name AS p_name,
            p.p_age AS p_age
        FROM bookstore bs
            LEFT OUTER JOIN people p ON bs.p_id=p.id
        WHERE bs.id=#{bsId}
    </select>

    <select id="queryBsBookCombineByBsIdCollectionNestSelect" resultMap="bsBookCombineQueryMap">
        SELECT
            id,
            bs_name
        FROM bookstore
        WHERE id=#{bsId}
    </select>

    <select id="queryBsBookCombineByBsIdCollectionNestResult" resultMap="bsBookCombineResultMap">
        SELECT
            bs.id AS bs_Id,
            bs.bs_name AS bs_name,
            b.id AS b_id,
            b.b_name AS b_name,
            b.b_price AS b_price,
            b.bs_id AS bbs_id
        FROM bookstore bs
            LEFT OUTER JOIN book b ON bs.id=b.bs_id
        WHERE bs.id=#{bsId}
    </select>

    <select id="queryBsBkPeopleCombineByBsIdNestSelect" resultMap="BsBkPeopleCombineQueryMap">
        SELECT
            id,
            bs_name,
            p_id
        FROM bookstore
        WHERE id=#{bsId}
    </select>

    <select id="queryBsBkPeopleCombineByBsIdNestResult" resultMap="BsBkPeopleCombineResultMap">
        SELECT
            bs.id AS bs_id,
            bs.bs_name AS bs_name,
            p.id AS p_id,
            p.p_name AS p_name,
            p.p_age AS p_age,
            b.id AS b_id,
            b.b_name AS b_name,
            b.b_price AS b_price,
            b.bs_id AS bbs_id
        FROM bookstore bs
            LEFT OUTER JOIN people p ON bs.p_id=p.id
            LEFT OUTER JOIN book b ON bs.id=b.bs_id
        WHERE bs.id=#{bsId}
    </select>

</mapper>
复制代码

最后就是单元测试类MybatisTest如下所示。

public class MybatisTest {

    private ObjectMapper objectMapper;

    private SqlSession sqlSession;

    @Before
    public void setUp() throws Exception {
        objectMapper = new ObjectMapper();

        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
        sqlSession = sqlSessionFactory.openSession();
    }

    @After
    public void tearDown() {
        sqlSession.close();
    }

    @Test
    public void 根据人Id查询一个人并映射成Map() throws Exception {
        PeopleMapper peopleMapper = sqlSession.getMapper(PeopleMapper.class);
        Map<String, Object> peopleMap = peopleMapper.simpleQueryPeopleByPeopleId(1);
        System.out.println(objectMapper.writeValueAsString(peopleMap));
    }

    @Test
    public void 根据书Id查询一本书() throws Exception {
        BookMapper bookMapper = sqlSession.getMapper(BookMapper.class);
        Book book = bookMapper.queryBookByBookId(1);
        System.out.println(objectMapper.writeValueAsString(book));
    }

    @Test
    public void 根据人Id查询一个人() throws Exception {
        PeopleMapper peopleMapper = sqlSession.getMapper(PeopleMapper.class);
        People people = peopleMapper.queryPeopleByPeopleId(1);
        System.out.println(objectMapper.writeValueAsString(people));
    }

    @Test
    public void 关联的嵌套SELECT查询() throws Exception {
        AssociatedMapper associatedMapper = sqlSession
                .getMapper(AssociatedMapper.class);
        BsPeopleCombine bsPeopleCombine = associatedMapper
                .queryBsPeopleCombineByBsIdAssociatedNestSelect(1);
        System.out.println(bsPeopleCombine.getBookStoreName());
        People boss = bsPeopleCombine.getBoss();
        System.out.println(objectMapper.writeValueAsString(boss));
    }

    @Test
    public void 关联的嵌套结果查询() throws Exception {
        AssociatedMapper associatedMapper = sqlSession
                .getMapper(AssociatedMapper.class);
        BsPeopleCombine bsPeopleCombine = associatedMapper
                .queryBsPeopleCombineByBsIdAssociatedNestResult(1);
        System.out.println(objectMapper.writeValueAsString(bsPeopleCombine));
    }

    @Test
    public void 集合的嵌套SELECT查询() {
        AssociatedMapper associatedMapper = sqlSession
                .getMapper(AssociatedMapper.class);
        BsBookCombine bsBookCombine = associatedMapper
                .queryBsBookCombineByBsIdCollectionNestSelect(1);
        System.out.println(bsBookCombine.getBookStoreName());
        List<Book> books = bsBookCombine.getBooks();
        books.forEach(book -> System.out.println(book.getBookName()));
    }

    @Test
    public void 集合的嵌套结果查询() {
        AssociatedMapper associatedMapper = sqlSession
                .getMapper(AssociatedMapper.class);
        BsBookCombine bsBookCombine = associatedMapper
                .queryBsBookCombineByBsIdCollectionNestResult(1);
        System.out.println(bsBookCombine.getBookStoreName());
        List<Book> books = bsBookCombine.getBooks();
        books.forEach(book -> System.out.println(book.getBookName()));
    }

    @Test
    public void 关联和集合的嵌套SELECT查询() {
        AssociatedMapper associatedMapper = sqlSession
                .getMapper(AssociatedMapper.class);
        BsBkPeopleCombine bsBkPeopleCombine = associatedMapper
                .queryBsBkPeopleCombineByBsIdNestSelect(1);
        System.out.println(bsBkPeopleCombine.getBookStoreName());
        People boss = bsBkPeopleCombine.getBoss();
        System.out.println(boss.getPeopleName());
        List<Book> books = bsBkPeopleCombine.getBooks();
        books.forEach(book -> System.out.println(book.getBookName()));
    }

    @Test
    public void 关联和集合的嵌套结果查询() {
        AssociatedMapper associatedMapper = sqlSession
                .getMapper(AssociatedMapper.class);
        BsBkPeopleCombine bsBkPeopleCombine = associatedMapper
                .queryBsBkPeopleCombineByBsIdNestResult(1);
        System.out.println(bsBkPeopleCombine.getBookStoreName());
        People boss = bsBkPeopleCombine.getBoss();
        System.out.println(boss.getPeopleName());
        List<Book> books = bsBkPeopleCombine.getBooks();
        books.forEach(book -> System.out.println(book.getBookName()));
    }

}
复制代码

二. select标签

通过<select>标签，可以在映射文件中编写查询SQL语句，例如示例工程中，映射接口PeopleMapper的simpleQueryPeopleByPeopleId() 方法对应的查询语句，如下所示。

<select id="simpleQueryPeopleByPeopleId" resultType="Map">
    SELECT
        id,
        p_name,
        p_age
    FROM people
    WHERE id=#{id}
</select>
复制代码

<select>标签的id属性是该查询语句在当前映射文件下的唯一标识，通常需要与映射接口中的方法名一样，而resultType属性告诉MyBatis应该将查询结果映射成什么对象类型，这里的对象类型需要与映射接口中的方法的返回类型一致，示例中是Map类型，那么表示需要将查询结果映射成一个Map对象，Map的key就是列名，value就是记录值。

如果将<select>标签的resultType属性设置为某一个实体对象类型，只要列名与对象属性名一样或者满足驼峰命名规则且开启了自动映射机制（<setting name="mapUnderscoreToCamelCase" value="true"/>），MyBatis也能够完成查询结果到实体对象的映射。

但如果列名与对象属性名不一样，并且也不满足驼峰命名规则，此时要完成查询结果与实体对象的映射，需要借助<resultMap>标签，这里后面会详细说明。

<select>标签的常用属性配置可以参考select标签属性。 这里对一些常用的属性配置进行说明。

属性配置
id当前<select>标签在映射文件下的唯一标识。需要与映射接口的方法名一致
parameterType传入SQL的参数的类型。例如上面例子中，就可以设置parameterType="int"，但通常不需要设置，MyBatis能够自行推断出入参类型
resultType告诉MyBatis需要将查询结果映射成什么类型。如果需要映射成集合类型，则resultType应该设置为集合的泛型类型。注意：resultType与resultMap只能同时配置一个
resultMap告诉MyBatis需要使用那个<resultMap>来做结果映射。需要配置为<resultMap>标签的id值
flushCache如果配置为true，则语句执行时清空一级缓存和二级缓存。<select>标签默认为false
useCache如果配置为true，则语句执行结果会被缓存到二级缓存。<select>标签默认为true

三. resultMap标签

1. 认识标签和属性

如下是一个示例。

<!--
    id：表示resultMap在当前映射文件下的唯一标识，当前映射文件中通过id就可以引用该resultMap，其它映射
        文件中要引用该resultMap，需要通过当前映射文件的命名空间和resultMap的id来引用，即namesapce.id
    type：标识resultMap需要映射到那个实体对象
 -->
<resultMap id="BsBkPeopleCombineResultMap" type="com.lee.learn.mybatis.entity.BsBkPeopleCombine">
    <!--
        <id>标签：可以完成将一个列的值映射到实体对象的一个简单类型的属性值，<id>标签标记的
                 属性可以作为对象的唯一标识符，用于对象的快速比较
        property：实体对象的属性名
        column：表的列名
        javaType：指定实体对象的属性的Java类型，用于TypeHandler的推断
        jdbcType：指定列的Jdbc类型，用于TypeHandler的推断
        typeHandler：直接指定使用的TypeHandler
    -->
    <id property="id" column="bs_id"/>
    <!--
        <result>标签：可以完成将一个列的值映射到实体对象的一个简单类型的属性值
        property：实体对象的属性名
        column：表的列名
        javaType：指定实体对象的属性的Java类型，用于TypeHandler的推断
        jdbcType：指定列的Jdbc类型，用于TypeHandler的推断
        typeHandler：直接指定使用的TypeHandler
    -->
    <result property="bookStoreName" column="bs_name"/>
    <!--
        <association>标签：有两种工作方式
                            嵌套SELECT：将另外一个SELECT查询的结果映射为实体对象的某一个对象属性
                            嵌套结果：将查询出来的若干列映射为实体对象的某一个对象属性
                          本示例是嵌套结果的工作方式
        property：实体对象的属性名
        javaType：实体对象的属性的Java类型
        column：（嵌套SELECT）通过列名或者列别名指定列，指定列的值会作为参数传递给嵌套的select语句
        select：（嵌套SELECT）通过namespace.id的形式引用select语句
        fetchType：（嵌套SELECT）指定为lazy会让select引用的查询语句延迟执行，指定为eager会让
                    select引用的查询语句随着当前查询语句的执行而执行
    -->
    <association property="boss" javaType="com.lee.learn.mybatis.entity.People">
        <id property="id" column="p_id"/>
        <result property="peopleName" column="p_name"/>
        <result property="peopleAge" column="p_age"/>
    </association>
    <!--
        <collection>标签：有两种工作方式
                            嵌套SELECT：将另外一个SELECT查询的结果映射为实体对象的某一个集合属性
                            嵌套结果：将查询出来的若干列映射为实体对象的某一个集合属性中的一个对象
                         本示例是嵌套结果的工作方式
        property：实体对象的属性名
        javaType：实体对象的属性的集合类型，通常可以省略
        ofType：集合的泛型的类型
        column：（嵌套SELECT）通过列名或者列别名指定列，指定列的值会作为参数传递给嵌套的select语句
        select：（嵌套SELECT）通过namespace.id的形式引用select语句
        fetchType：（嵌套SELECT）指定为lazy会让select引用的查询语句延迟执行，指定为eager会让
                    select引用的查询语句随着当前查询语句的执行而执行
    -->
    <collection property="books" ofType="com.lee.learn.mybatis.entity.Book">
        <id property="id" column="b_id"/>
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
        <result property="bookStoreId" column="bbs_id"/>
    </collection>
</resultMap>
复制代码

首先是<resultMap>标签，该标签会定义一种查询结果到实体对象的映射关系，通过namespace.id就可以引用。标签上的重要属性，说明如下。

属性说明
id表示resultMap在当前映射文件下的唯一标识，当前映射文件中通过id就可以引用该resultMap，其它映射文件中要引用该resultMap，需要通过当前映射文件的命名空间和resultMap的id来引用，即namesapce.id
type标识resultMap需要映射到哪个实体对象

然后是<id>和<result>标签，这两个标签作用一样：可以完成将一个列映射到实体对象的一个简单类型的属性上。唯一的区别就是<id>标签标记的属性可以作为对象的唯一标识符，用于对象的快速比较。标签上的重要属性，说明如下。

属性说明
property实体对象的属性名
column表的列名
javaType指定实体对象的属性的Java类型，用于TypeHandler的推断。通常可以不指定，MyBatis能够通过<resultMap>标签的type属性拿到实体对象对应的属性的Java类型
jdbcType指定列的Jdbc类型，用于TypeHandler的推断
typeHandler直接指定使用的TypeHandler

再然后是<association>标签，该标签用于映射结果时，映射的对象具有关联关系，例如下面的对象。

public class BsPeopleCombine {

    private int id;
    private String bookStoreName;

    private People boss;

    // 省略get和set

}
复制代码

书店关联一个老板，查询书店时需要将书店关联的老板也查询出来，通常有两种关联方式。

  • 先查询出书店，然后再根据书店的查询结果查询出老板，最后组装两次查询的结果；
  • 通过关联查询一次查询出书店以及和书店关联的老板，关联查询的结果直接完成组装。

所以在MyBatis中，就可以通过<association>标签，完成上述的功能。<association>标签有两种使用方式，分别对应上面的两种关联方式。

  • 嵌套SELECT。将另外一个SELECT查询的结果映射为实体对象的某一个对象属性。也就是示例中的BsPeopleCombine的boss属性的值由一个查询People的查询语句的查询结果来完成映射。这种方式很简单，但会带来N+1问题，这点后面再分析；
  • 嵌套结果。将关联查询（内连接，左右外连）出来的若干列映射为实体对象的某一个对象属性。这种方式能规避N+1问题，但会增加SQL的复杂度。

<association>标签的重要属性如下所示。

属性说明
property实体对象的属性名
javaType实体对象的属性的Java类型
column（嵌套SELECT）通过列名或者列别名指定列，指定列的值会作为参数传递给嵌套的select语句
select（嵌套SELECT）通过namespace.id的形式引用select语句
fetchType（嵌套SELECT）指定为lazy会让select引用的查询语句延迟执行，指定为eager会让select引用的查询语句随着当前查询语句的执行而执行

如果对上述的标签作用和属性还是不清楚，可以先有个印象，下面的小节会以实际的例子进行说明。

最后是<collection>标签，作用与<association>标签相似，不过适用于和集合关联的情况。示例如下。

public class BsBookCombine {

    private int id;
    private String bookStoreName;

    private List<Book> books;

    // 省略get和set
	
}
复制代码

书店关联多本书，查询书店时需要将书店关联的所有书也查询出来，通常也有两种关联方式。

  • 先查询出书店，然后再根据书店的查询结果查询出所有书，最后组装两次查询的结果；
  • 通过关联查询一次查询出书店以及和书店关联的所有书，关联查询的结果直接完成组装。

那么到这里也就知道了<collection>标签和<association>标签极其相似，两个标签的属性也是近乎一样，不同点在于<collection>标签比<association>标签多了一个ofType属性，该属性用于配置集合的泛型的类型。

2. 简单查询的结果映射

book表列信息如下。

列名JDBC类型
idINT
b_nameVARCHAR
b_priceFLOAT
bs_idINT

Book实体对象如下。

public class Book {

    private int id;
    private String bookName;
    private float bookPrice;
    private int bookStoreId;
	
    // 省略get和set
	
}
复制代码

那么映射文件中对应的查询语句的<select>标签如下所示。

<select id="queryBookByBookId" resultMap="bookResultMap">
    SELECT
        id,
        b_name,
        b_price,
        bs_id
    FROM book
    WHERE id=#{bookId}
</select>
复制代码

在<select>标签中通过resultMap属性设置<resultMap>标签的id来引用resultMap。

那么对应的<resultMap>如下所示。

<resultMap id="bookResultMap" type="com.lee.learn.mybatis.entity.Book">
    <id property="id" column="id"/>
    <result property="bookName" column="b_name"/>
    <result property="bookPrice" column="b_price"/>
    <result property="bookStoreId" column="bs_id"/>
</resultMap>
复制代码

3. 关联的嵌套SELECT查询的结果映射

本小节演示使用<association>标签来完成嵌套SELECT查询结果的映射。

关联的两张表分别为bookstore和people。bookstore表列信息如下。

列名JDBC类型
idINT
bs_nameVARCHAR
p_idINT

people表列信息如下。

列名JDBC类型
idINT
p_nameVARCHAR
p_ageINT

关联查询结果的实体对象为BsPeopleCombine，如下所示。

public class BsPeopleCombine {

    private int id;
    private String bookStoreName;

    private People boss;

    // 省略get和set
	
}
复制代码

映射文件中对应的查询语句的<select>标签如下所示。

<select id="queryBsPeopleCombineByBsIdAssociatedNestSelect" resultMap="bsPeopleCombineQueryMap">
    SELECT
        id,
        bs_name,
        p_id
    FROM bookstore
    WHERE id=#{bsId}
</select>
复制代码

引用的<resultMap>如下所示。

<resultMap id="bsPeopleCombineQueryMap" type="com.lee.learn.mybatis.entity.BsPeopleCombine">
    <id property="id" column="id"/>
    <result property="bookStoreName" column="bs_name"/>
    <association property="boss" column="p_id"
                 javaType="com.lee.learn.mybatis.entity.People"
                 select="com.lee.learn.mybatis.dao.PeopleMapper.queryPeopleByPeopleId"/>
</resultMap>
复制代码

select属性引用的<select>标签在映射文件PeopleMapper.xml文件中，其namespace是com.lee.learn.mybatis.dao.PeopleMapper，PeopleMapper.xml中的id为queryPeopleByPeopleId的<select>标签如下所示。

<select id="queryPeopleByPeopleId" resultMap="peopleResultMap">
    SELECT
        id,
        p_name,
        p_age
    FROM people
    WHERE id=#{id}
</select>
复制代码

上述查询语句的入参，就取<association>标签中通过column指定的列的值，也就是id为queryBsPeopleCombineByBsIdAssociatedNestSelect的<select>标签查询回来的p_id会作为入参传入到id为queryPeopleByPeopleId的<select>标签中。

测试程序如下。

@Test
public void 关联的嵌套SELECT查询() throws Exception {
    AssociatedMapper associatedMapper = sqlSession
            .getMapper(AssociatedMapper.class);
    BsPeopleCombine bsPeopleCombine = associatedMapper
            .queryBsPeopleCombineByBsIdAssociatedNestSelect(1);
    System.out.println(bsPeopleCombine.getBookStoreName());
    People boss = bsPeopleCombine.getBoss();
    System.out.println(objectMapper.writeValueAsString(boss));
}
复制代码

运行测试程序，打印如下。

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@38e79ae3]
==>  Preparing: SELECT id, bs_name, p_id FROM bookstore WHERE id=?
==> Parameters: 1(Integer)
<==    Columns: id, bs_name, p_id
<==        Row: 1, XinHua, 1
<==      Total: 1
XinHua
==>  Preparing: SELECT id, p_name, p_age FROM people WHERE id=?
==> Parameters: 1(Integer)
<==    Columns: id, p_name, p_age
<==        Row: 1, Lee, 20
<==      Total: 1
{"id":1,"peopleName":"Lee","peopleAge":20}
复制代码

由于在配置文件中添加了如下设置。

<setting name="lazyLoadingEnabled" value="true"/>
复制代码

表示所有的嵌套查询都延迟执行，即用到对应的属性时才执行对应的查询语句，也就是测试程序中执行到bsPeopleCombine.getBoss() 时才会触发id为queryPeopleByPeopleId的<select>标签的语句的执行。

4. 关联的嵌套结果查询的结果映射

本小节演示使用<association>标签来完成嵌套结果查询的结果映射。

关联的两张表分别为bookstore和people。bookstore表列信息如下。

列名JDBC类型
idINT
bs_nameVARCHAR
p_idINT

people表列信息如下。

列名JDBC类型
idINT
p_nameVARCHAR
p_ageINT

关联查询结果的实体对象为BsPeopleCombine，如下所示。

public class BsPeopleCombine {

    private int id;
    private String bookStoreName;

    private People boss;

    // 省略get和set
	
}
复制代码

映射文件中对应的查询语句的<select>标签如下所示。

<select id="queryBsPeopleCombineByBsIdAssociatedNestResult" resultMap="bsPeopleCombineResultMap">
    SELECT
        bs.id AS bs_id,
        bs.bs_name AS bs_name,
        p.id AS p_id,
        p.p_name AS p_name,
        p.p_age AS p_age
    FROM bookstore bs
        LEFT OUTER JOIN people p ON bs.p_id=p.id
    WHERE bs.id=#{bsId}
</select>
复制代码

上述是一个左外连接的关联查询，引用的<resultMap>如下所示。

<resultMap id="bsPeopleCombineResultMap" type="com.lee.learn.mybatis.entity.BsPeopleCombine">
    <id property="id" column="bs_id"/>
    <result property="bookStoreName" column="bs_name"/>
    <association property="boss" javaType="com.lee.learn.mybatis.entity.People">
        <id property="id" column="p_id"/>
        <result property="peopleName" column="p_name"/>
        <result property="peopleAge" column="p_age"/>
    </association>
</resultMap>
复制代码

测试程序如下所示。

@Test
public void 关联的嵌套结果查询() throws Exception {
    AssociatedMapper associatedMapper = sqlSession
            .getMapper(AssociatedMapper.class);
    BsPeopleCombine bsPeopleCombine = associatedMapper
            .queryBsPeopleCombineByBsIdAssociatedNestResult(1);
    System.out.println(objectMapper.writeValueAsString(bsPeopleCombine));
}
复制代码

执行结果如下。

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@38e79ae3]
==>  Preparing: SELECT bs.id AS bs_id, bs.bs_name AS bs_name, p.id AS p_id, p.p_name AS p_name, p.p_age AS p_age FROM bookstore bs LEFT OUTER JOIN people p ON bs.p_id=p.id WHERE bs.id=?
==> Parameters: 1(Integer)
<==    Columns: bs_id, bs_name, p_id, p_name, p_age
<==        Row: 1, XinHua, 1, Lee, 20
<==      Total: 1
{"id":1,"bookStoreName":"XinHua","boss":{"id":1,"peopleName":"Lee","peopleAge":20}}
复制代码

可见只会执行一次查询，并且能够完成结果映射。

5. 集合的嵌套SELECT查询的结果映射

本小节演示使用<collection>标签来完成嵌套SELECT查询结果的映射。

关联的两张表分别为bookstore和book。bookstore表列信息如下。

列名JDBC类型
idINT
bs_nameVARCHAR
p_idINT

book表列信息如下。

列名JDBC类型
idINT
b_nameVARCHAR
b_priceFLOAT
bs_idINT

关联查询结果的实体对象为BsBookCombine，如下所示。

public class BsBookCombine {

    private int id;
    private String bookStoreName;

    private List<Book> books;

    // 省略get和set
	
}
复制代码

映射文件中对应的查询语句的<select>标签如下所示。

<select id="queryBsBookCombineByBsIdCollectionNestSelect" resultMap="bsBookCombineQueryMap">
    SELECT
        id,
        bs_name
    FROM bookstore
    WHERE id=#{bsId}
</select>
复制代码

引用的<resultMap>如下所示。

<resultMap id="bsBookCombineQueryMap" type="com.lee.learn.mybatis.entity.BsBookCombine">
    <id property="id" column="id"/>
    <result property="bookStoreName" column="bs_name"/>
    <collection property="books" column="id"
                javaType="ArrayList" ofType="com.lee.learn.mybatis.entity.Book"
                select="com.lee.learn.mybatis.dao.BookMapper.queryBooksByBsId"/>
</resultMap>
复制代码

select属性引用的<select>标签在映射文件BookMapper.xml文件中，其namespace是com.lee.learn.mybatis.dao.BookMapper，BookMapper.xml中的id为queryBooksByBsId的<select>标签如下所示。

<select id="queryBooksByBsId" resultMap="bookResultMap">
    SELECT
        id,
        b_name,
        b_price,
        bs_id
    FROM book
    WHERE bs_id=#{bsId}
</select>
复制代码

上述查询语句的入参，就取<collection>标签中通过column指定的列的值，也就是id为queryBsBookCombineByBsIdCollectionNestSelect的<select>标签查询回来的id会作为入参传入到id为queryBooksByBsId的<select>标签中。

测试程序如下。

@Test
public void 集合的嵌套SELECT查询() {
    AssociatedMapper associatedMapper = sqlSession
            .getMapper(AssociatedMapper.class);
    BsBookCombine bsBookCombine = associatedMapper
            .queryBsBookCombineByBsIdCollectionNestSelect(1);
    System.out.println(bsBookCombine.getBookStoreName());
    List<Book> books = bsBookCombine.getBooks();
    books.forEach(book -> System.out.println(book.getBookName()));
}
复制代码

运行测试程序，打印如下。

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@38e79ae3]
==>  Preparing: SELECT id, bs_name FROM bookstore WHERE id=?
==> Parameters: 1(Integer)
<==    Columns: id, bs_name
<==        Row: 1, XinHua
<==      Total: 1
XinHua
==>  Preparing: SELECT id, b_name, b_price, bs_id FROM book b WHERE bs_id=?
==> Parameters: 1(Integer)
<==    Columns: id, b_name, b_price, bs_id
<==        Row: 1, Math, 20.5, 1
<==        Row: 2, English, 21.5, 1
<==      Total: 2
Math
English
复制代码

6. 集合的嵌套结果查询的结果映射

本小节演示使用<collection>标签来完成嵌套结果查询的结果映射。

关联的两张表分别为bookstore和book。bookstore表列信息如下。

列名JDBC类型
idINT
bs_nameVARCHAR
p_idINT

book表列信息如下。

列名JDBC类型
idINT
b_nameVARCHAR
b_priceFLOAT
bs_idINT

关联查询结果的实体对象为BsBookCombine，如下所示。

public class BsBookCombine {

    private int id;
    private String bookStoreName;

    private List<Book> books;

    // 省略get和set
	
}
复制代码

映射文件中对应的查询语句的<select>标签如下所示。

<select id="queryBsBookCombineByBsIdCollectionNestResult" resultMap="bsBookCombineResultMap">
    SELECT
        bs.id AS bs_Id,
        bs.bs_name AS bs_name,
        b.id AS b_id,
        b.b_name AS b_name,
        b.b_price AS b_price,
        b.bs_id AS bbs_id
    FROM bookstore bs
        LEFT OUTER JOIN book b ON bs.id=b.bs_id
    WHERE bs.id=#{bsId}
</select>
复制代码

上述是一个左外连接的关联查询，引用的<resultMap>如下所示。

<resultMap id="bsBookCombineResultMap" type="com.lee.learn.mybatis.entity.BsBookCombine">
    <id property="id" column="bs_Id"/>
    <result property="bookStoreName" column="bs_name"/>
    <collection property="books" ofType="com.lee.learn.mybatis.entity.Book">
        <id property="id" column="b_id"/>
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
        <result property="bookStoreId" column="bbs_id"/>
    </collection>
</resultMap>
复制代码

测试程序如下所示。

@Test
public void 集合的嵌套结果查询() {
    AssociatedMapper associatedMapper = sqlSession
            .getMapper(AssociatedMapper.class);
    BsBookCombine bsBookCombine = associatedMapper
            .queryBsBookCombineByBsIdCollectionNestResult(1);
    System.out.println(bsBookCombine.getBookStoreName());
    List<Book> books = bsBookCombine.getBooks();
    books.forEach(book -> System.out.println(book.getBookName()));
}
复制代码

执行结果如下。

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@38e79ae3]
==>  Preparing: SELECT bs.id AS bs_Id, bs.bs_name AS bs_name, b.id AS b_id, b.b_name AS b_name, b.b_price AS b_price, b.bs_id AS bbs_id FROM bookstore bs LEFT OUTER JOIN book b ON bs.id=b.bs_id WHERE bs.id=?
==> Parameters: 1(Integer)
<==    Columns: bs_Id, bs_name, b_id, b_name, b_price, bbs_id
<==        Row: 1, XinHua, 1, Math, 20.5, 1
<==        Row: 1, XinHua, 2, English, 21.5, 1
<==      Total: 2
XinHua
Math
English
复制代码

7. N+1问题与解决

第3和第5小节中，分别在<association>和<collection>标签中使用了select属性来引用查询语句，表示在进行结果映射时，需要执行这个查询语句来得到更多的结果来完成映射。以如下的查询语句为例。

<resultMap id="bsPeopleCombineQueryMap" type="com.lee.learn.mybatis.entity.BsPeopleCombine">
    <id property="id" column="id"/>
    <result property="bookStoreName" column="bs_name"/>
    <association property="boss" column="p_id"
                 javaType="com.lee.learn.mybatis.entity.People"
                 select="com.lee.learn.mybatis.dao.PeopleMapper.queryPeopleByPeopleId"/>
</resultMap>

<select id="queryBsPeopleCombineByBsIdAssociatedNestSelect" resultMap="bsPeopleCombineQueryMap">
    SELECT
        id,
        bs_name,
        p_id
    FROM bookstore
    WHERE id=#{bsId}
</select>
复制代码

由于是通过id=#{bsId}作为查询条件，所以上述查询语句的一次查询只会返回一条数据，而这一条数据会触发一次<association>标签的select属性引用的查询语句，所以一次查询实际触发了两次查询操作。但是试想一下，如果上述的条件变更为id>#{bsId}，那么上述查询语句的一次查询有可能会返回多条数据，从而触发多次查询操作，这在大数据量时会十分影响性能，称这种问题为N+1问题。

解决N+1问题，有两种方式，如下所示。

  • 延迟执行额外的select。也就是使用到对应的属性时，才触发这个属性对应的select查询语句，这能够一定程度缓解N+1问题带来的性能影响。要想延时执行，也有两种方式：第一种是在配置文件中通过<setting name="lazyLoadingEnabled" value="true"/>设置lazyLoadingEnabled为true，第二种是在<association>或<collection>标签中设置fetchType为lazy，其中第二种方式优先级高于第一种方式；
  • 采用嵌套结果查询。也就是使用第4和第6小节中的嵌套结果查询的方式来代替嵌套SELECT查询的方式。

总结

在MyBatis中的映射文件中，可以通过<select>标签来配置查询语句，而执行查询后的结果映射，可以通过两种方式来配置。

  1. <select>标签的resultType。使用resultType告诉MyBatis需要将查询结果映射为什么对象类型，这要求表列名与对象的属性名一样或者满足驼峰命名规则，如果是满足驼峰命名规则，还需要开启自动映射机制（<setting name="mapUnderscoreToCamelCase" value="true"/>），才能完成查询结果映射；
  2. <select>标签的resultMap。

<select>标签的resultMap能够引用<resultMap>标签的内容，即当前<select>标签的结果映射规则使用引用的<resultMap>标签配置的规则。<resultMap>标签能够完成如下规则配置。

  1. <id>和<result>配置一个列与简单数据类型的映射关系。在这两个标签中，通过column配置列，通过property配置简单数据类型的属性名，MyBatis会在结果映射时，完成配置的列到属性的映射；
  2. <association>配置查询结果到一个复杂属性的映射关系。假如一个书店有一个老板，那么在查询书店时，可以通过<association>配置一个查询语句，在查询出书店后，再通过这个查询语句查询出老板，这会带来N+1问题；也可以通过<association>配置一个映射关系，在关联查询出书店和老板的记录后，通过关联关系将老板对应的列映射到老板对应的属性对象上。
  3. <collection>配置查询结果到多个复杂属性的映射关系。<collection>和<association>几乎一模一样，只不过<association>适用场景是一个书店有一个老板的场景，而<collection>适用场景是一个书店有多本书的场景。

 

搬山道猿
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MyBatis——查询进阶(resultMap)详解,模糊查询
笔记别偷看
03-28 675
自动映射 1、全局setting设置 autoMappingBehavior默认是PARTIAL，开启自动映射的功能。唯一的要求是列名和javaBean属性名一致 如果autoMappingBehavior设置为null则会取消自动映射 数据库字段命名规范，POJO属性符合驼峰命名法， 如 A_COLUMN->aColumn，我们可以开启自动驼峰命名规则映射功能，mapUnderscoreToCamelCase=true。 2、自定义resultMap，实现高级结果集映射
mybatis映射map集合
qq_36939013的博客
07-31 7085
简单的map映射就不介绍了，这里只介绍复杂的map映射，比如我的数据类型是这样的 前端需要映射成一个map里面6个键值对 比如键是pm2_5 值是96.52727020240256 数据结构 要把这些数据映射到pollutantList里面 这里说明一下，在mybatis里面不能完全处理，需要借助java mybatis代码 <resultMap id="AirDayReportMa...
Mybatis的ResultMap的使用
weixin_33882452的博客
10-12 450
　　本篇文章通过一个实际工作中遇到的例子开始吧： 　　工程使用Spring+Mybatis+Mysql开发。具体的业务逻辑很重，对象之间一层一层的嵌套。和数据库表对应的是大量的model类，而和前端交互的是Vo类。现在需要做一个需求，有两种方式来实现： 　　使用现有的Service接口，或者自己在编写一些用到的接口，手动使用Java代码来分别调用Service接口来查出各个model，然后...
Mybatis之ResultMap
最新发布
好记性不如烂笔头
05-10 1021
select语句查询得到的结果集是一张二维表，水平方向上看是一个个字段，垂直方向上看是一条条记录。而Java是面向对象的程序设计语言，对象是根据类定义创建的，类之间的引用关系可以认为是嵌套的结构。在JDBC编程中，为了将结果集中的数据映射成对象，我们需要自己写代码从结果集中获取数据，然后封装成对应的对象并设置对象之间的关系，而这些都是大量的重复性代码。
Mybatis中强大的功能元素：resultMap
茅坤宝骏氹的博客
08-31 736
转载自Mybatis中强大的功能元素：resultMap 前言 在Mybatis中，有一个强大的功能元素resultMap。当我们希望将JDBC ResultSets中的数据，转化为合理的Java对象时，你就能感受到它的非凡之处。正如其官方所述的那样： resultMap元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码...
mybatis的mapper映射配置文件、个别场景记录
YR_112233的博客
11-30 4085
mybatis的mapper映射配置文件详解 一、常用属性标签 1、namespace的作用 在MyBatis中，Mapper中的namespace用于绑定Dao接口的，即面向接口编程。namespace属性的值要和对应的Mapper接口的全限定名保持一致 它的好处在于当使用了namespace之后就可以不用写接口实现类，业务逻辑会直接通过这个绑定寻找到相对应的SQL语句进行对应的数据处理 2、常用标签介绍 insert,update,delete,select,sql,resultMap sql:可被其它
Mybatis中Mapper映射文件使用详解
08-19
Mybatis中Mapper映射文件使用详解 Mapper映射文件是Mybatis框架中一个非常重要的组件，它是Mybatis的核心组件之一。Mapper映射文件是一个xml格式文件，必须遵循相应的dtd文件规范，如ibatis-3-mapper.dtd。Mapper...
MyBatis中resultMap和resultType的区别详解
08-18
MyBatis中resultMap和resultType的区别详解 MyBatis是当前最流行的持久层框架之一，它提供了强大的SQL映射能力和灵活的配置机制。在MyBatis中，我们经常会遇到resultMap和resultType这两个概念，虽然它们都用于将...
mybatis的mapper.xml中resultMap标签的使用详解
08-19
mybatis的mapper.xml中resultMap标签的使用详解 Mybatis作为一个流行的持久层框架，提供了许多灵活的方式来映射数据库表和实体类。其中，resultMap标签是一个非常重要的概念，它主要用来将实体类中的字段与数据库表...
mybatis教程之resultmap_动力节点Java学院整理
08-29
MyBatis ResultMap 详解 MyBatis 中的 ResultMap 是一个强大的元素，它描述如何从...ResultMap 是 MyBatis 中一个非常强大的元素，它可以帮助开发者快速地将结果集映射到 Java 实体类中，从而提高开发效率和代码质量。
Mybatis中的resultType和resultMap查询操作实例详解
09-01
resultType是直接表示返回类型的，而resultMap则是对外部ResultMap的引用，resultMap解决复杂查询是的映射问题。这篇文章主要介绍了Mybatis中的resultType和resultMap查询操作实例详解,需要的朋友可以参考下
mybatis系列之返回结果映射
热门推荐
uzong
10-13 1万+
一、映射器 1.1 select元素 select元素来定义查询操作。 参数 描述 Id 唯一标识符。 – 用来引用这条语句，需要和接口的方法名一致 parameterType 参数类型。可以不传，MyBatis会根据TypeHandler自动推断 resultType 返回值类型。别名或者全类名，如果返回的是集合，定义集合中元 素的类型...
在Mybatis中使用Mapper代理-映射文件中语句参数-动态SQL-resultMap实体对象之间的映射关系
norang的博客
07-01 276
这里写目录标题四、按照DAO层的设计规范来使用 Mybatis五、在Mybatis中使用Mapper代理**第一，必须要有接口，****第二，接口所在的包必须被扫描（保证接口能够被精确的获取），****第三，映射文件的命名空间与语句的id分别必须取值为接口的全限定名及接口的方法名，****第四，语句的参数必须与接口方法的参数保持一致，****第五，接口与对应的映射文件可以放在同一包下且映射文件的名称与接口的名称要相同，****第六、在Maven项目中，映射文件可以放在resources下面但是目录层必须与对
Mybatis 标签大全及标签中各属性详解
Pandfson的专栏
07-11 5220
Mybatis 标签大全及标签中各属性详解
MyBatis自定义映射resultMap，处理一对多，多对一
weixin_60664694的博客
10-14 969
MyBatis的自定义映射resultMap，一对多，多对一
Mybatis 返回结果映射
jsdxshi的博客
07-28 710
1、返回 int 、 String 等 直接使用resultType即可 2、返回的是对象 2.1 可用resultmap做映射： 主要用在进行复杂联合查询上，因为进行简单查询是没有什么必要的。 2.2 使用resultType： 一直以来，在sqlmap文件中，对于数据库中的下划线字段转驼峰，我们都是通过resultmap来做的，如下： select ews.T
MyBatis框架（四）自定义映射
超级程序诞生的博客
10-26 2102
我们先把如下所示写好，然后下来写resultMap里面常用的标签一共有四个，id来处理主键和属性的映射关系，result来处理普通字段和属性的映射关系，association来处理多对一，collection处理一对多。我们进行查看主键的属性如下所示：其中property为属性，column为字段，javaType：属性的类型，jdbcTypexml里面有个规则，注释是不能嵌套的。
mybatis实践篇（三）—— ResultMap映射详细介绍
zhoushimiao1990的博客
08-27 3643
ResultMap ResultMap 的设计思想是，对于简单的语句不需要配置结果映射，而对于复杂一点的语句只需要描述它们的关系。下面来看一下ResultMap下的部分标签和属性： <!-- 非常复杂的结果映射 --> <resultMap id="detailedBlogResultMap" type="Blog"> <!-- 实例化类时，注入结...
mybatis多表查询的结果映射（resultMap）
tuoniaoxs的博客
04-26 4179
Mybait多张表查询时的结果映射resultMap 1、mybatis简介 MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。它可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 2、resultMap（多表查询 或 数据库列名与实体属性名不一致时使用） resultMap
mybatis中resultMap详解
09-02
在MyBatis中，resultMap用于自定义查询结果的映射规则。通过resultMap，我们可以将查询结果的列与对象的属性进行映射，实现灵活的结果处理。 resultMap的定义可以在元素中使用，也可以在外部进行定义并在元素中引用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值