• 【Mybatis】08 ResultMap、Association、分步查询、懒加载


    ResultMap自定义结果集

    可以把查询返回的结果集封装成复杂的JavaBean对象

    原来的ResultType属性,只能把查询到的结果集转换为简单的JavaBean

    什么是简单的JavaBean对象?

    - 不具有JavaBean和集合类型属性的对象

    - 也就是不能建立ORM的多表关联映射

    问题的引入:

    如果字段标识符和数据表不一致,

    例如实体类的user的密码字段,现在更改为pwd

    数据表的字段依然为user_password

    我们查询这个结果看看

    所有的密码字段接受失败

    那么,该如何解决这个问题?

    方案一,在SQL语句中给这个字段起别名

    再次测试,这个数据又能获取到了

    但是这样的解决方案并不优雅

    Mybatis提供了一个解决方案,使用ResultMap对字段标识进行映射绑定

    测试结果,可行

    一对一关系案例:

    创建数据表

    锁表 & 钥匙【一把锁就配一把钥匙】

    CREATE TABLE t_lock(
        `id` INT PRIMARY KEY AUTO_INCREMENT,
        `name` VARCHAR(50)
    
    );
    
    CREATE TABLE t_key(
        `id` INT PRIMARY KEY AUTO_INCREMENT,
        `name` VARCHAR(50),
        `lock_id` INT,
        FOREIGN KEY(`lock_id`) REFERENCES t_lock(`id`)
    );

    添加数据

    INSERT INTO t_lock(`name`) 
    VALUES
        ('阿里巴巴'),
        ('联想'),
        ('华为');
        
    INSERT INTO t_key(`name`,`lock_id`) 
    VALUES
        ('马云',1),
        ('任正非',2),
        ('柳传志',3);

    【写反了,唉就这样把】

    创建ORM实体类

    锁类

    package cn.dai.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author ArkD42
     * @file Mybatis
     * @create 2020 - 05 - 29 - 13:30
     */
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Lock {
    
        private Integer id;
        private String name;
    }

    钥匙类

    package cn.dai.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author ArkD42
     * @file Mybatis
     * @create 2020 - 05 - 29 - 13:32
     */
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Key {
    
        private Integer id;
        private String name;
    
        // 注意这个设置的外键是来自这个锁对象的属性
        private Lock lock;
    
    }

    映射器【KeyMaper.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接口名称-->
    <mapper namespace="cn.dai.mapper.KeyMapper">
    
        <select id="queryKeyById" resultType="cn.dai.pojo.Key" parameterType="java.lang.Integer">
            SELECT * FROM t_key WHERE id = #{id}
        </select>
    
    </mapper>

    注意!在这里采用的结果集类型,先看看结果如何

    测试类

        @Test
        public void sqlTest6(){
            logger.info("- - - - TESTING - - - -");
            SqlSession sqlSession = MybatisUtil.getSqlSession(true);
            KeyMapper keyMapper = sqlSession.getMapper(KeyMapper.class);
    
            Key key = keyMapper.queryKeyById(2);
            System.out.println(key);
    
            sqlSession.close();
        }

    结果:我们对应的锁类无法获取

    我们需要一个关联查询来实现

    首先从SQL语句实现

    【查询钥匙表关联锁表,一起获取】

            SELECT
                t_key.*,t_lock.name lock_name
            FROM
                t_key LEFT JOIN t_lock
            ON
                t_key.lock_id = t_lock.id
            WHERE
                t_key.id = #{id}

    【就算是这样,没有类型匹配,返回的结果还是和上面一样,这里不展示了】

    【留意SELECT子句筛选的字段】

    所以需要通过结果集映射标签实现一些类型的绑定

    使用默认的result标签处理

    然后使用我们的结果集映射标签实现关联处理

    <?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接口名称-->
    <mapper namespace="cn.dai.mapper.KeyMapper">
    
        <!--
            id 设置这个结果集映射标签的标识,
            type 设置需要转换出来的实体类对象的全限定类名
        -->
        <resultMap id="key" type="key">
    
            <!-- id标签负责 转换主键列 -> 实体类的属性 -->
            <id column="id" property="id"/>
            <!-- 非主键列 转换给 实体类属性 -->
            <result column="name" property="name"/>
            <!-- 一般匹配的字段不需要显示的写出来,因为是默认的了 -->
    
    
            <!--
                property 对应的是实体类的属性
                column 对应的是数据表的列
            -->
            <result column="lock_id" property="lock.id" />
            <result column="lock_name" property="lock.name" />
    
        </resultMap>
    
        <!-- 这里的结果集映射就对应上面设置的id -->
        <select id="queryKeyById" resultMap="key" parameterType="int">
            SELECT
                t_key.*,t_lock.name lock_name
            FROM
                t_key LEFT JOIN t_lock
            ON
                t_key.lock_id = t_lock.id
            WHERE
                t_key.id = #{id}
        </select>
    
    </mapper>

    测试结果

    千万要注意,要实现这个锁的名称的输出,就要留意上面的SELECT 筛选的字段

    可以通过别名映射实现一些实体类的绑定

    在这里是因为左外链接,所以可以看到,钥匙表是没有写这个表名的

     或者使用Association标签实现映射

     在结果集中设置关联映射标签,绑定属性标识和所对应的类型

    其次声明关联表的属性映射

           <association property="lock" javaType="cn.dai.pojo.Lock">
               <id column="lock_id" property="id"/>
               <result column="lock_name" property="name" />
           </association>

    Association定义分布查询

    什么意思?

    可以通过一个查询得到子对象

    分两种加载,立即加载和懒加载

    一张表可能存在50多列,其中主要常用的是最前面的6列

    后面的44列不一定马上需要,所以我们的查询应该拆分成两次查询

    我们声明一个两步查询的方法

    Key queryKeyByIdForTwoStep(Integer id);

    对副表的二次查询在锁表中编写

    package cn.dai.mapper;
    
    import cn.dai.pojo.Lock;
    
    /**
     * @author ArkD42
     * @file Mybatis
     * @create 2020 - 05 - 30 - 11:59
     */
    public interface LockMapper {
        
        Lock queryLockById(Integer id);
        
    }

    锁表的映射器

    <?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接口名称-->
    <mapper namespace="cn.dai.mapper.LockMapper">
        
        <select id="queryLockById" resultType="cn.dai.pojo.Lock" >
            select * from t_lock where id = #{id}
        </select>
    
    </mapper>

    钥匙表的映射器

        <resultMap id="key2" type="cn.dai.pojo.Key">
    
            <id column="id" property="id"/>
            <result column="name" property="name"/>
            
            <!-- 
                select 调用另外一个映射器的查询方法,来获取对象的结果
                column 把这钥匙表的查询SQL的字段结果返回给这个关联查询调用【就是那个查询的参数】
                
            -->
            <association 
                    property="lock" 
                    javaType="cn.dai.pojo.Lock" 
                    select="cn.dai.mapper.LockMapper.queryLockById"
                    column="lock_id"
            />
    
        </resultMap>
    
        <select id="queryKeyByIdForTwoStep" resultMap="key2" parameterType="int">
            SELECT
                id,name,lock_id
            FROM
                t_key
            WHERE
                t_key.id = #{id}
        </select>

    测试结果

    可以看到这样查询分了两次执行,并且把字段的参数传递给下一个查询的使用

    开启懒加载查询

    即延迟加载,减少非必要性的查询

    优化数据库性能,需要在全局配置中开启

            <!-- 开启懒加载 -->
            <setting name="lazyLoadingEnabled" value="true"/>
            <setting name="aggressiveLazyLoading" value="false"/>

        @Test
        public void sqlTest7(){
            logger.info("- - - - TESTING - - - -");
            SqlSession sqlSession = MybatisUtil.getSqlSession(true);
            KeyMapper keyMapper = sqlSession.getMapper(KeyMapper.class);
    
            Key key = keyMapper.queryKeyByIdForTwoStep(2);
    
            //System.out.println(key);
    
            //开启懒加载是什么效果?如果我们不调用附表的信息,第二个查询是不会调用的
            System.out.println(key.getName());
    
            sqlSession.close();
        }

    结果

    实际作用远不止这些,详见官方文档:

    https://mybatis.org/mybatis-3/zh/sqlmap-xml.html

  • 相关阅读:
    day14: 生成器进阶
    day13: 迭代器和生成器
    day12:装饰器的进阶
    day11:装饰器
    day10:函数进阶
    English class 81:How Vulnerability can make our lives better?
    piano class 12
    UE4之循环
    UE4之数组
    UE4中常见的类
  • 原文地址:https://www.cnblogs.com/mindzone/p/12825673.html
Copyright © 2020-2023  润新知