MyBatis-20MyBatis高级结果映射【一对一映射（4种方式）】

其他 2018-05-18 05:11:38 阅读次数: 3

概述

我们还是继续使用我们的RBAC权限系统来演示。

假设在RBAC权限系统中，一个用户只能拥有一个角色。

需求

实现在查询用户信息的同时获取用户拥有的角色信息

方式一：使用自动映射处理一对一映射

实体类改造

一个用户拥有一个角色，因此现在SysUser类中增加SysRole字段 

/**
 * 
 * 
 * @ClassName: SysUser
 * 
 * @Description: 用户表
 * 
 * @author: Mr.Yang
 * 
 * @date: 2018年4月13日 下午9:24:21
 */
public class SysUser  {

    //其他原有字段以及setter getter

    /**
     * 用户角色
     */
    private SysRole sysRole;

    // setter getter
    public SysRole getSysRole() {
        return sysRole;
    }

    public void setSysRole(SysRole sysRole) {
        this.sysRole = sysRole;
    }


}

使用自动映射就是通过别名让MyBatis自动将值匹配到对应的子弹上，简单的别名映射如user_name 对应userName .

除此之外MyBatis还支持复杂的属性映射，可以多层嵌套。 比如将role.role_name 映射到 role.roleName上。 MyBatis首先会查找role属性，如果存在role属性就创建role对象，然后在role对象中继续查找roleName， 将role_name的值绑定到role对象的roleName属性上 。

UserMapper接口增加接口方法

/**
     * 
     * 
     * @Title: selectSysUserAndSysRoleById
     * 
     * @Description: 根据Id查询用户信息的同时获取用户拥有的角色信息
     * 
     * @param id
     * @return
     * 
     * @return: SysUser
     */
    SysUser selectSysUserAndSysRoleById(Long id);

UserMapper.xml增加SQL

<select id="selectSysUserAndSysRoleById" resultType="com.artisan.mybatis.xml.domain.SysUser">
        SELECT
            u.id,
            u.user_name userName,
            u.user_password userPassword,
            u.user_email userEmail,
            u.user_info userInfo,
            u.create_time createTime,
            u.head_img headImg,
            r.id "sysRole.id",
            r.role_name "sysRole.roleName",
            r.enabled "sysRole.enabled",
            r.create_by "sysRole.createBy",
            r.create_time "sysRole.createTime"
        FROM
            sys_user u
        INNER JOIN sys_user_role ur ON u.id = ur.user_id
        INNER JOIN sys_role r ON ur.role_id = r.id
        WHERE
            u.id = #{id}
    </select>

注意上述SQL中 sys_role查询的列的别名都是 “sysRole.”前缀，这和SysUser实体类中SysRole属性的名称保持一致，通过这种方式将sysRole的属性都映射到了SysUser的sysRole属性上
。

单元测试

@Test
    public void selectSysUserAndSysRoleByIdTest() {
        logger.info("selectSysUserAndSysRoleByIdTest");
        // 获取SqlSession
        SqlSession sqlSession = getSqlSession();
        try {
            // 获取UserMapper接口
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            // 注意:数据库中id=1的用户拥有2个角色，不适合这个例子。
            // 调用selectSysUserAndSysRoleById方法，查询id=1001的用户及其角色
            SysUser sysUser = userMapper.selectSysUserAndSysRoleById(1001L);
            // 期望用户不为空
            Assert.assertNotNull(sysUser);
            // 期望角色不为空
            Assert.assertNotNull(sysUser.getSysRole());

            logger.info(sysUser);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
            logger.info("sqlSession close successfully ");
        }
    }

debug调测下数据

这里写图片描述

日志

2018-04-29 23:43:15,905  INFO [main] (BaseMapperTest.java:26) - sessionFactory bulit successfully
2018-04-29 23:43:15,913  INFO [main] (BaseMapperTest.java:29) - reader close successfully
2018-04-29 23:43:15,918  INFO [main] (UserMapperTest.java:1007) - selectSysUserAndSysRoleByIdTest
2018-04-29 23:43:16,008 DEBUG [main] (BaseJdbcLogger.java:145) - ==>  Preparing: SELECT u.id, u.user_name userName, u.user_password userPassword, u.user_email userEmail, u.user_info userInfo, u.create_time createTime, u.head_img headImg, r.id "sysRole.id", r.role_name "sysRole.roleName", r.enabled "sysRole.enabled", r.create_by "sysRole.createBy", r.create_time "sysRole.createTime" FROM sys_user u INNER JOIN sys_user_role ur ON u.id = ur.user_id INNER JOIN sys_role r ON ur.role_id = r.id WHERE u.id = ? 
2018-04-29 23:43:16,135 DEBUG [main] (BaseJdbcLogger.java:145) - ==> Parameters: 1001(Long)
2018-04-29 23:43:16,196 TRACE [main] (BaseJdbcLogger.java:151) - <==    Columns: id, userName, userPassword, userEmail, userInfo, createTime, headImg, sysRole.id, sysRole.roleName, sysRole.enabled, sysRole.createBy, sysRole.createTime
2018-04-29 23:43:16,198 TRACE [main] (BaseJdbcLogger.java:151) - <==        Row: 1001, artisan, 123456, test@artisan.com, <<BLOB>>, 2018-04-13 21:12:47.0, <<BLOB>>, 2, 普通用户, 1, 1, 2018-04-13 21:12:46.0
2018-04-29 23:43:16,215 DEBUG [main] (BaseJdbcLogger.java:145) - <==      Total: 1
2018-04-29 23:43:16,216  INFO [main] (UserMapperTest.java:1021) - SysUser [id=1001, userName=artisan, userPassword=123456, userEmail=test@artisan.com, userInfo=测试用户, headImg=[18, 49, 35, 18, 48], createTime=Fri Apr 13 21:12:47 BOT 2018, sysRole=SysRole [id=2, roleName=普通用户, enabled=1, createBy=1, createTime=Fri Apr 13 21:12:46 BOT 2018, user=null, privilegeList=null]]
2018-04-29 23:43:16,222  INFO [main] (UserMapperTest.java:1026) - sqlSession close successfully

通过SQL日志可以看到已经查询出的一条数据，MyBatis将这条数据映射到了两个类中，像这种通过一次查询将结果映射到不同对象的方式，称之为关联的嵌套结果查询。

关联的嵌套结果映射需要关联多个表将所有需要的值一次性查询出来， 这种方式的好处是减少数据库的查询次数，减轻数据库的压力。 缺点是需要些很复杂的SQL，并且当嵌套结果更负载时，不容易一次写正确。 由于要在服务器上将结果映射到不同的类上，因此也会增加应用服务器的压力。 当一定会使用到嵌套查询，并且整个复杂的SQL执行速度很快时，建议使用关联的其那套结果查询。

方式二：使用resultMap配置一对一映射

UserMapper接口增加接口方法

// 使用resultMap配置一对一映射
SysUser selectSysUserAndSysRoleById2(Long id);

UserMapper.xml增加SQL

<!-- 使用resultMap配置一对一映射 -->
    <resultMap id="userRoleMap" 
               type="com.artisan.mybatis.xml.domain.SysUser">
        <id column="id" property="id" />
        <result property="userName" column="user_name" />
        <result property="userPassword" column="user_password" />
        <result property="userEmail" column="user_email" />
        <result property="userInfo" column="user_info" />
        <result property="headImg" column="head_img" jdbcType="BLOB" />
        <result property="createTime" column="create_time" jdbcType="TIMESTAMP" />
        <!-- sysRole相关的属性 -->
        <result property="sysRole.id" column="role_id"/>
        <result property="sysRole.roleName" column="role_name"/>
        <result property="sysRole.enabled" column="enabled"/>
        <result property="sysRole.createBy" column="create_by"/>
        <result property="sysRole.createTime" column="role_create_time" jdbcType="TIMESTAMP"/>
    </resultMap>

这种配置和上一个配置相似的地方在于，sysRole中的property配置部分使用“sysRole.”前缀，在column部分，为了避免不同表中存在相同的的字段，所有可能重名的列都加了 “role_”前缀。

这种方式配置的时候，还需要再查询时设置不同的列名，别名和resultMap配置的colunm一致。 然后使用resultMap配置映射。 

<!-- 使用resultMap配置一对一映射 -->
    <select id="selectSysUserAndSysRoleById2" resultMap="userRoleMap">
        SELECT
            u.id,
            u.user_name ,
            u.user_password ,
            u.user_email ,
            u.user_info ,
            u.create_time ,
            u.head_img ,
            r.id role_id,
            r.role_name ,
            r.enabled ,
            r.create_by ,
            r.create_time role_create_time 
        FROM
            sys_user u
        INNER JOIN sys_user_role ur ON u.id = ur.user_id
        INNER JOIN sys_role r ON ur.role_id = r.id
        WHERE
            u.id = #{id}
    </select>

单元测试

@Test
    public void selectSysUserAndSysRoleById2Test() {
        logger.info("selectSysUserAndSysRoleById2Test");
        // 获取SqlSession
        SqlSession sqlSession = getSqlSession();
        try {
            // 获取UserMapper接口
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            // 注意:数据库中id=1的用户拥有2个角色，不适合这个例子。
            // 调用selectSysUserAndSysRoleById方法，查询id=1001的用户及其角色
            SysUser sysUser = userMapper.selectSysUserAndSysRoleById2(1001L);
            // 期望用户不为空
            Assert.assertNotNull(sysUser);
            // 期望角色不为空
            Assert.assertNotNull(sysUser.getSysRole());

            logger.info(sysUser);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
            logger.info("sqlSession close successfully ");
        }
    }

日志

2018-04-30 00:52:25,287  INFO [main] (BaseMapperTest.java:26) - sessionFactory bulit successfully
2018-04-30 00:52:25,291  INFO [main] (BaseMapperTest.java:29) - reader close successfully
2018-04-30 00:52:25,295  INFO [main] (UserMapperTest.java:1032) - selectSysUserAndSysRoleById2Test
2018-04-30 00:52:25,390 DEBUG [main] (BaseJdbcLogger.java:145) - ==>  Preparing: SELECT u.id, u.user_name , u.user_password , u.user_email , u.user_info , u.create_time , u.head_img , r.id role_id, r.role_name , r.enabled , r.create_by , r.create_time role_create_time FROM sys_user u INNER JOIN sys_user_role ur ON u.id = ur.user_id INNER JOIN sys_role r ON ur.role_id = r.id WHERE u.id = ? 
2018-04-30 00:52:25,519 DEBUG [main] (BaseJdbcLogger.java:145) - ==> Parameters: 1001(Long)
2018-04-30 00:52:25,559 TRACE [main] (BaseJdbcLogger.java:151) - <==    Columns: id, user_name, user_password, user_email, user_info, create_time, head_img, role_id, role_name, enabled, create_by, role_create_time
2018-04-30 00:52:25,561 TRACE [main] (BaseJdbcLogger.java:151) - <==        Row: 1001, artisan, 123456, test@artisan.com, <<BLOB>>, 2018-04-13 21:12:47.0, <<BLOB>>, 2, 普通用户, 1, 1, 2018-04-13 21:12:46.0
2018-04-30 00:52:25,572 DEBUG [main] (BaseJdbcLogger.java:145) - <==      Total: 1
2018-04-30 00:52:25,573  INFO [main] (UserMapperTest.java:1046) - SysUser [id=1001, userName=artisan, userPassword=123456, userEmail=test@artisan.com, userInfo=测试用户, headImg=[18, 49, 35, 18, 48], createTime=Fri Apr 13 21:12:47 BOT 2018, sysRole=SysRole [id=2, roleName=普通用户, enabled=1, createBy=1, createTime=Fri Apr 13 21:12:46 BOT 2018, user=null, privilegeList=null]]
2018-04-30 00:52:25,580  INFO [main] (UserMapperTest.java:1051) - sqlSession close successfully

这种方法是不是和第一种使用自动映射处理一对一映射相比起来，resultMap相当麻烦？

事实上 ，resultMap映射是可以被继承的，因此要先简化上面的resultMap的配置。 因为我们这个映射文件中本来就存在一个userMap的映射配置，改造如下

<!-- 使用resultMap配置一对一映射  继承原有的resultMap -->
    <resultMap id="userRoleMap_byExtends"  extends="userMap"
               type="com.artisan.mybatis.xml.domain.SysUser">
        <!-- sysRole相关的属性 -->
        <result property="sysRole.id" column="role_id"/>
        <result property="sysRole.roleName" column="role_name"/>
        <result property="sysRole.enabled" column="enabled"/>
        <result property="sysRole.createBy" column="create_by"/>
        <result property="sysRole.createTime" column="role_create_time" jdbcType="TIMESTAMP"/>
    </resultMap>

使用继承不仅可以简化配置，而且当对主表userMap进行修改时也只需要修改一处。 虽然还不是太方便，至少简洁了一点。 要想更加简洁，只有派上asscociation了，请往下看

测试过了，就不贴代码了，github上已经托管。

方式三：使用resultMap的asscociation标签配置一对一映射

在resultMap中，association标签用于和一个复杂的类型进行关联，即用于一对一的关联配置。

UserMapper接口增加接口方法

// 使用resultMap配置一对一映射 resultMap association
SysUser selectSysUserAndSysRoleById4(Long id);

UserMapper.xml增加SQL

在上面的基础上，再做修改，改成association标签的配置方式。

    <!-- 使用resultMap配置一对一映射  使用association -->
    <resultMap id="userRoleMap_byExtendsAndAssociation"  extends="userMap"
               type="com.artisan.mybatis.xml.domain.SysUser">
        <association property="sysRole" columnPrefix="sysRole_"
            javaType="com.artisan.mybatis.xml.domain.SysRole">
            <result property="id" column="id"/>
            <result property="roleName" column="role_name"/>
            <result property="enabled" column="enabled"/>
            <result property="createBy" column="create_by"/>
            <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
        </association>     
    </resultMap>



<!-- 使用resultMap配置一对一映射 result中Map中使用association  -->
    <select id="selectSysUserAndSysRoleById4" resultMap="userRoleMap_byExtendsAndAssociation">
        SELECT
            u.id,
            u.user_name ,
            u.user_password ,
            u.user_email ,
            u.user_info ,
            u.create_time ,
            u.head_img ,
            r.id sysRole_id,
            r.role_name sysRole_role_name,
            r.enabled sysRole_enabled,
            r.create_by sysRole_create_by,
            r.create_time sysRole_create_time
        FROM
            sys_user u
        INNER JOIN sys_user_role ur ON u.id = ur.user_id
        INNER JOIN sys_role r ON ur.role_id = r.id
        WHERE
            u.id = #{id}
    </select>

association标签包含如下主要属性
- property:对应实体列中的属性名，必填
- javaType:属性对应的Java类型
- resultMap：可以直接使用现有的resultMap,从而不需要在这里配置
- colunmPrefix: 查询列的前缀，配置前缀后，在子标签配置result的colunm时，可以省略前缀
- 其他属性，略…

因为配置了列的前缀，因此还需要SQL，如上所示。

使用association配置还可以使用resultMap属性配置成一个已经存在的resultMap映射。 我们吧sys_role相关的映射提取出来，改造如下

    <!-- 使用resultMap配置一对一映射  使用association -->
    <resultMap id="roleMap"  type="com.artisan.mybatis.xml.domain.SysRole" >
        <id  property="id" column="id"/>
        <result property="roleName" column="role_name"/>
        <result property="enabled" column="enabled"/>
        <result property="createBy" column="create_by"/>
        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
    </resultMap>

    <resultMap id="userRoleMap_byExtendsAndAssociation_ResultMap"  extends="userMap"
               type="com.artisan.mybatis.xml.domain.SysUser">
        <association property="sysRole" columnPrefix="sysRole_"
            javaType="com.artisan.mybatis.xml.domain.SysRole" resultMap="roleMap">
        </association>     
    </resultMap>

到这里，是不是没有这么麻烦了？ 还有一个需要注意的地方：roleMap我们目前是写在UserMapper.xml中，更合理的应该在RoleMapper.xml中。如果真的在RoleMapper.xml中的话，，通过resultMap来引用的话，就必须要加上命名空间了。 如果不加的话，MyBatis会默认添加调用者当前命名空间的前缀。 

<resultMap id="userRoleMap_byExtendsAndAssociation_ResultMap"  extends="userMap"
               type="com.artisan.mybatis.xml.domain.SysUser">
        <association property="sysRole" columnPrefix="sysRole_"
            javaType="com.artisan.mybatis.xml.domain.SysRole" resultMap="com.artisan.mybatis.xml.mapper.RoleMapper.roleMap">
        </association>     
    </resultMap>

单元测试

@Test
    public void selectSysUserAndSysRoleById4Test() {
        logger.info("selectSysUserAndSysRoleById4Test");
        // 获取SqlSession
        SqlSession sqlSession = getSqlSession();
        try {
            // 获取UserMapper接口
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            // 注意:数据库中id=1的用户拥有2个角色，不适合这个例子。
            // 调用selectSysUserAndSysRoleById4方法，查询id=1001的用户及其角色
            SysUser sysUser = userMapper.selectSysUserAndSysRoleById4(1001L);
            // 期望用户不为空
            Assert.assertNotNull(sysUser);
            // 期望角色不为空
            Assert.assertNotNull(sysUser.getSysRole());

            logger.info(sysUser);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
            logger.info("sqlSession close successfully ");
        }
    }

日志

2018-05-01 01:08:18,898  INFO [main] (BaseMapperTest.java:26) - sessionFactory bulit successfully
2018-05-01 01:08:18,905  INFO [main] (BaseMapperTest.java:29) - reader close successfully
2018-05-01 01:08:18,913  INFO [main] (UserMapperTest.java:1083) - selectSysUserAndSysRoleById4Test
2018-05-01 01:08:19,019 DEBUG [main] (BaseJdbcLogger.java:145) - ==>  Preparing: SELECT u.id, u.user_name , u.user_password , u.user_email , u.user_info , u.create_time , u.head_img , r.id sysRole_id, r.role_name sysRole_role_name, r.enabled sysRole_enabled, r.create_by sysRole_create_by, r.create_time sysRole_create_time FROM sys_user u INNER JOIN sys_user_role ur ON u.id = ur.user_id INNER JOIN sys_role r ON ur.role_id = r.id WHERE u.id = ? 
2018-05-01 01:08:19,155 DEBUG [main] (BaseJdbcLogger.java:145) - ==> Parameters: 1001(Long)
2018-05-01 01:08:19,212 TRACE [main] (BaseJdbcLogger.java:151) - <==    Columns: id, user_name, user_password, user_email, user_info, create_time, head_img, sysRole_id, sysRole_role_name, sysRole_enabled, sysRole_create_by, sysRole_create_time
2018-05-01 01:08:19,213 TRACE [main] (BaseJdbcLogger.java:151) - <==        Row: 1001, artisan, 123456, test@artisan.com, <<BLOB>>, 2018-04-13 21:12:47.0, <<BLOB>>, 2, 普通用户, 1, 1, 2018-04-13 21:12:46.0
2018-05-01 01:08:19,231 DEBUG [main] (BaseJdbcLogger.java:145) - <==      Total: 1
2018-05-01 01:08:19,232  INFO [main] (UserMapperTest.java:1097) - SysUser [id=1001, userName=artisan, userPassword=123456, userEmail=test@artisan.com, userInfo=测试用户, headImg=[18, 49, 35, 18, 48], createTime=Fri Apr 13 21:12:47 BOT 2018, sysRole=SysRole [id=2, roleName=普通用户, enabled=1, createBy=1, createTime=Fri Apr 13 21:12:46 BOT 2018, user=null, privilegeList=null]]
2018-05-01 01:08:19,239  INFO [main] (UserMapperTest.java:1102) - sqlSession close successfully

方式四：asscociation标签的嵌套查询

前面三种方式通过负载的SQL查询获取结果，其实还可以利用简单的SQL通过多次查询转换为我们需要的结果，这种方式与根据业务逻辑手动执行多次SQL的方式很像，最后将结果组成一个对象。

场景和情况比较复杂，后续单独阐述

猜你喜欢

转载自blog.csdn.net/yangshangwei/article/details/80147013
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022