在现实生活中，一对一关联关系是十分常见的。例如，一个人只能有一个身份证，同时一个身份证也只会对应一个人。
那么使用MyBatis是怎么处理这种一对一关联关系的呢？在前面讲解的<resultMap>元素中，包含了一个<association>子元素，MyBatis就是通过该元素来处理一对一关联关系的。
在<association>元素中，通常可以配置以下属性。
- property：指定映射到的实体类对象属性，与表字段一一对应。
- column：指定表中对应的字段。
- javaType：指定映射到实体对象属性的类型。
- select：指定引入嵌套查询的子SQL语句，该属性用于关联映射中的嵌套查询。
- fetchType：指定在关联查询时是否启用延迟加载。fetchType属性有lazy和eager两个属性值，默认值为lazy(即默认关联映射延迟加载)。
<association>元素的使用非常简单，只需要参考如下两种示例配置即可，具体如下。
<!-- 方式一：嵌套查询-->
<resultMap type="IdCard" id="IdCardById">
<id property="id" column="id" />
<result property="userName" column="userName" />
<!-- 一对一：association使用select属性引入另外一条SQL语句 -->
<association property="user" column="uid" javaType="User"
select="cn.dsscm.dao.UserMapper.findUserById" />
</resultMap>
<!-- 方式二：嵌套结果 -->
<resultMap type="IdCard" id="userRoleResult2">
<id property="id" column="id"/>
<result property="code" column="code"/>
<association property="user" javaType="User">
<id property="id" column="cid"/>
<result property="userName" column="userName" />
</association>
</resultMap>
MyBatis在映射文件中加载关联关系对象主要通过两种方式：嵌套查询和嵌套结果。嵌套查询是指通过执行另外一条SQL映射语句来返回预期的复杂类型；嵌套结果是使用嵌套结果映射来处理重复的联合结果的子集。开发人员可以使用上述任意一种方式实现对关联关系的加载。
示例：用户和身份证间关联
了解了MyBatis中处理一对一关联关系的元素和方式后，接下来就以用户和身份证之间的一对一关联关系为例，进行详细讲解。
查询个人及其关联的身份证信息是先通过查询个人表中的主键来获个人信息，然后通过表中的外键，来获取证件表中的身份证号信息。其具体实现步骤如下。
创建数据表，在dsscm数据库中重新创建名为tb_idcard的数据表，同时预先插入两条数据。其执行的SQL语句如下所示。
USE dsscm;
#创建一个名称为tb idcard 的表
CREATE TABLE `tb_idcard` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`uid` int(11) NOT NULL,
`CODE` varchar(18) DEFAULT NULL,
PRIMARY KEY (`id`)
);
#插入n条数据
INSERT INTO tb_idcard(uid ,CODE) VALUES (1,'430101200001011234');
INSERT INTO tb_idcard(uid ,CODE) VALUES (2,'430101200001014321');
INSERT INTO tb_idcard(uid ,CODE) VALUES (3,'430101200001011235');
INSERT INTO tb_idcard(uid ,CODE) VALUES (4,'430101200001014326');
......
完成上述操作后，数据库tb_idcard表中的数据。
在项目的cn.dsscm.pojo包下创建持久化类IdCard，编辑后的代码，如示例所示。
【示例1】 IdCard.java
public class IdCard {
private Integer id; // id
private Integer uid; // 用户id
private String code;// 身份证号码
private User user;// 一对一
//省略getter和setter方法
}
在上述示例中，分别定义了各自的属性以及对应的getter/setter方法，同时为了方便查看输出结果还重写了toString()方法。
在cn.dsscm.mapper包中，创建证件映射文件IdCardMapper.xml和用户映射文件UserMapper.xml，并在两个映射文件中编写一对一关联映射查询的配置信息，如示例所示。
【示例2】 IdCardMapper.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="cn.dsscm.dao.IdCardMapper">
<!-- 嵌套查询：通过执行另外一条SQL映射语句来返回预期的特殊类型 -->
<select id="findCodeById" parameterType="Integer" resultMap="IdCardById">
SELECT * FROM tb_idcard WHERE id=#{id}
</select>
<resultMap type="IdCard" id="IdCardById">
<id property="id" column="id" />
<result property="userName" column="userName" />
<!-- 一对一：association使用select属性引入另外一条SQL语句 -->
<association property="user" column="uid" javaType="User"
select="cn.dsscm.dao.UserMapper.findUserById" />
</resultMap>
</mapper>
【示例3】 UserMapper.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="cn.dsscm.dao.UserMapper">
<!-- 根据id查询用户信息 -->
<select id="findUserById" parameterType="Integer" resultType="User">
SELECT * from tb_user where id=#{id}
</select>
</mapper>
在上述两个映射文件中，使用了MyBatis中的嵌套查询方式进行了个人及其关联的证件信息查询，因为返回的个人对象中除了基本属性外还有一个关联的uid属性，所以需要手动编写结果映射。从映射文件IdCardMapper.xml中可以看出，嵌套查询的方法是先执行一个简单的SQL语句，然后在进行结果映射时，将关联对象在<association>元素中使用select属性执行另一条SQL语句(即 IdCardMapper.xml中的SQL )。
创建映射文件的对应接口如下：
public List<IdCard> findCodeById(@Param("id")Integer id);
在核心配置文件mybatis-config.xml中，引入Mapper映射文件并定义别名，如下所示。
【示例4】 mybatis-config.xml
<!-- 将mapper文件加入到配置文件中 -->
<mappers>
<mapper resource="cn/dsscm/dao/UserMapper.xml" />
<mapper resource="cn/dsscm/dao/IdCardMapper.xml" />
</mappers>
在上述核心配置文件中，首先引入了数据库连接的配置文件，然后使用扫描包的形式自定义别名，接下来进行环境的配置，最后配置了Mapper映射文件的位置信息。
在测试包中，创建测试类UserMapperTest，并在类中编写测试方法getUserListByIdTest ()，如下所示。
【示例5】 UserMapperTest.java
@Test
public void getUserListByIdTest(){
SqlSession sqlSession = null;
List<IdCard> userList = new ArrayList<IdCard>();
Integer id = 3;
try {
sqlSession = MyBatisUtils.createSqlSession();
userList = sqlSession.getMapper(IdCardMapper.class).findCodeById(id);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}finally{
MyBatisUtils.closeSqlSession(sqlSession);
}
logger.debug("getUserListByRoleIdTest userList.size : " + userList.size());
for(IdCard user:userList){
logger.debug(user);
}
}
在getUserListByIdTest()方法中，首先通过MybatisUtils工具类获取了SqlSession对象，然后通过SqlSession对象的接口方法获取了用户信息。为了查看结果，这里使用了输出语句输出查询结果信息。最后程序执行完毕时，关闭了SqlSession。
使用JUnit4执行getUserListByIdTest()方法后，控制台的输出结果如下：
cn.dsscm.dao.IdCardMapper.findCodeById - ==> Preparing: SELECT * FROM tb_idcard WHERE id=?
cn.dsscm.dao.IdCardMapper.findCodeById - ==> Parameters: 3(Integer)
......
cn.dsscm.dao.UserMapper.findUserById - ==> Preparing: SELECT * from tb_user where id=?
cn.dsscm.dao.UserMapper.findUserById - ==> Parameters: 3(Integer)
......
cn.dsscm.test.UserMapperTest - getUserListByRoleIdTest userList.size : 1
cn.dsscm.test.UserMapperTest - IdCard [id=3, uid=null, code=430101200001011235, user=User [id=3, userCode=zhangwei, userName=张伟, userPassword=0000000, birthday=Sun Jun 05 00:00:00 CST 1994, gender=2, phone=18567542321, email=null, address=北京市朝阳区, userDesc=null, userRole=2, createdBy=1, imgPath=null, creationDate=Thu Oct 24 13:01:51 CST 2019, modifyBy=null, modifyDate=null, age=null, userRoleName=null]]
从控制台的输出结果可以看出，使用MyBatis嵌套查询的方式查询出了用户身份证信息及其用户的信息，这就是MyBatis中的一对一关联查询。
修改代码，使用MyBatis嵌套结果的方式查询出了用户身份证信息及其用户的信息。
创建映射文件的对应接口如下：
public List<IdCard> findCodeById2(@Param("uid")Integer id);
在cn.dsscm.mapper包中，修改证件映射文件IdCardMapper.xml，并在映射文件中使用MyBatis嵌套结果编写一对一关联映射查询的配置信息，如示例所示。
【示例6】 IdCardMapper.xml
<!-- 根据roleId获取用户列表 association start-->
<resultMap type="IdCard" id="userRoleResult2">
<id property="id" column="id"/>
<result property="code" column="code"/>
<association property="user" javaType="User">
<id property="id" column="cid"/>
<result property="userName" column="userName" />
</association>
</resultMap>
<select id="findCodeById2" parameterType="Integer" resultMap="userRoleResult2">
SELECT u.* ,c.id cid ,c.code
FROM tb_user u, tb_idcard c
WHERE u.id=c.uid
AND c.uid= #{uid}
</select>
在测试包中，在类中编写测试方法getUserListByIdTest2()，如下所示。
【示例7】 UserMapperTest.java
@Test
public void getUserListByIdTest2(){
SqlSession sqlSession = null;
List<IdCard> userList = new ArrayList<IdCard>();
Integer id = 3;
try {
sqlSession = MyBatisUtils.createSqlSession();
userList = sqlSession.getMapper(IdCardMapper.class).findCodeById2(id);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}finally{
MyBatisUtils.closeSqlSession(sqlSession);
}
logger.debug("getUserListByRoleIdTest userList.size : " + userList.size());
for(IdCard user:userList){
logger.debug(user);
}
}
使用JUnit4执行getUserListByIdTest2()方法后，控制台的输出结果如下：
cn.dsscm.dao.IdCardMapper.findCodeById2 - ==> Preparing: SELECT u.* ,c.id cid ,c.code FROM tb_user u, tb_idcard c WHERE u.id=c.uid AND c.uid= ?
cn.dsscm.dao.IdCardMapper.findCodeById2 - ==> Parameters: 3(Integer)
......
cn.dsscm.test.UserMapperTest - getUserListByRoleIdTest userList.size : 1
cn.dsscm.test.UserMapperTest - IdCard [id=3, uid=null, code=430101200001011235, user=User [id=3, userCode=null, userName=张伟, userPassword=null, birthday=null, gender=null, phone=null, email=null, address=null, userDesc=null, userRole=null, createdBy=null, imgPath=null, creationDate=null, modifyBy=null, modifyDate=null, age=null, userRoleName=null]]
上述示例使用身份证类关联用户信息，改变实体类用用户类关联身份证类也可以实现同样效果，此处不再赘述。
虽然使用嵌套查询的方式比较简单，但是从控制台的输出结果中可以看出，MyBatis嵌套查询的方式要执行多条SQL语句，这对于大型数据集合和列表展示不是很好，因为这样可能会导致成百上千条关联的SQL语句被执行，从而极大地消耗数据库性能并且会降低查询效率。这并不是开发人员所期望的。为此，我们可以使用MyBatis提供的嵌套结果方式，来进行关联查询。
示例：用户和用户角色关联
association：映射到JavaBean的某个"复杂类型"属性，比如JavaBean类，即JavaBean内部嵌套一个复杂数据类型（JavaBean）属性，这种情况就属于复杂类型的关联。但是需要注意：association仅处理一对一的关联关系。
在实际的开发项目中此类绝对的双向的一对一的关联比较少见，很多时候是单向的。比如用户角色和用户列表关系，从不同角度看映射关系不一样，这里面涉及用户表（tb_user）和用户权限表（tb_role），从用户角度关联权限信息这是一对一，从用户权限关联用户信息是一对多。如果根据用户角色id获取该角色下的用户列表的情况，我们只需要根据用户表关联用户角色表，association便可以处理此种情况下一对一的关联关系，那么对于用户角色关联用户信息的一对多的关联关系的处理，则需要collection元素来实现了，这个后面介绍。
创建数据表，在dsscm数据库中重新创建名为tb_idcard的数据表，同时预先插入两条数据。其执行的SQL语句如下所示。
#用户表
CREATE TABLE `tb_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`userCode` varchar(15) NOT NULL COMMENT '用户编码',
`userName` varchar(15) NOT NULL COMMENT '用户名称',
`userPassword` varchar(15) NOT NULL COMMENT '用户密码',
`gender` int(10) DEFAULT NULL COMMENT '性别（1:女、 2:男）',
`birthday` date DEFAULT NULL COMMENT '出生日期',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
`phone` varchar(15) COMMENT '手机',
`address` varchar(30) COMMENT '地址',
`userDesc` text COMMENT '简介',
`userRole` int(10) DEFAULT NULL COMMENT '用户角色（取自角色表-角色id）',
`imgPath` varchar(100) DEFAULT NULL COMMENT '用户照片',
`createdBy` bigint(20) DEFAULT NULL COMMENT '创建者（userId）',
`creationDate` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`modifyBy` bigint(20) DEFAULT NULL COMMENT '更新者（userId）',
`modifyDate` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `userCode` (`userCode`)
);
#用户权限表
CREATE TABLE `tb_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`roleCode` varchar(50) NOT NULL COMMENT '角色编码',
`roleName` varchar(50) NOT NULL COMMENT '角色名称',
`createdBy` bigint(20) DEFAULT NULL COMMENT '创建者',
`creationDate` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`modifyBy` bigint(20) DEFAULT NULL COMMENT '修改者',
`modifyDate` datetime DEFAULT NULL COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `roleCode` (`roleCode`)
);
首先创建Role类，并增加相应的getter和setter方法，示例代码如下:
【示例8】 Role.java
public class Role {
private Integer id; // id
private String roleCode; // 角色编码
private String roleName; // 角色名称
private Integer createdBy; // 创建者
private Date creationDate; // 创建时间
private Integer modifyBy; // 更新者
private Date modifyDate;// 更新时间
//省略getter和setter方法
}
修改User类，增加角色属性（Role role），并增加相应的getter和setter方法；注释掉用户角色名称属性（String userRoleName），并注释掉其getter和setter方法，示例代码如下：
【示例9】 User.java
public class User {
private Integer id; //id
private String userCode; //用户编码
private String userName; //用户名称
private String userPassword; //用户密码
private Integer gender; //性别
private Date birthday; //出生日期
private String phone; //电话
private String address; //地址
private Integer userRole; //用户角色ID
private Integer createdBy; //创建者
private Date creationDate; //创建时间
private Integer modifyBy; //更新者
private Date modifyDate; //更新时间
private Integer age;//年龄
//private String userRoleName; //用户角色名称
//association
private Role role; //用户角色
//省略getter和setter方法
}
通过以上改造，我们的JavaBean：User对象内部嵌套了一个复杂数据类型的属性：role。接下来在UserMapper接口里增加根据角色id获取用户列表的方法，代码如下：
public List<User> getUserListByRoleId(@Param("userRole")Integer roleId);
修改对应UserMapper.xml，增加getUserListByRoleId，该select查询语句返回类型为resultMap，并且外部引用的resultMap的类型为User。由于User对象内嵌JavaBean对象（Role），因此需要使用association来实现结果映射。代码如下：
【示例10】 UserMapper.xml
<!-- 根据roleId获取用户列表 association start-->
<resultMap type="User" id="userRoleResult">
<id property="id" column="id"/>
<result property="userCode" column="userCode" />
<result property="userName" column="userName" />
<result property="userRole" column="userRole" />
<association property="role" javaType="Role">
<id property="id" column="r_id"/>
<result property="roleCode" column="roleCode"/>
<result property="roleName" column="roleName"/>
</association>
</resultMap>
<select id="getUserListByRoleId" parameterType="Integer" resultMap="userRoleResult">
select u.*,r.id as r_id,r.roleCode,r.roleName
from tb_user u,tb_role r
where u.userRole = #{userRole} and u.userRole = r.id
</select>
从上述代码，简单分析association的属性。
- javaType：完整Java类名或者别名。若映射到一个JavaBean，则MyBatis通常会自行检测到其类型；若映射到一个HashMap，则应该明确指定javaType，来确保所需行为。此处为Role。
- property ：映射数据库列的实体对象的属性。此处为在User里定义的属性：role。
- association的子元素如下： id； result；property:映射数据库列的实体对象的属性。此处为Role的属性； column：数据库列名或别名。
在做结果映射的过程中，需要注意：要确保所有的列名都是唯一且无歧义的。id子元素在嵌套结果映射中扮演了非常重要的角色，应该指定一个或者多个属性来唯一标识这个结果集。实际上，即便没有指定id，MyBatis也会工作，但是会导致严重的性能开销，所以最好选择尽量少的属性来唯一标识结果，主键或者联合主键均可。
最后修改测试类UserMapperTest.java，增加测试方法，示例代码如下：
【示例11】 UserMapperTest.java
@Test
public void getUserListByRoleIdTest(){
SqlSession sqlSession = null;
List<User> userList = new ArrayList<User>();
Integer roleId = 3;
try {
sqlSession = MyBatisUtils.createSqlSession();
userList = sqlSession.getMapper(UserMapper.class).getUserListByRoleId(roleId);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}finally{
MyBatisUtils.closeSqlSession(sqlSession);
}
logger.debug("getUserListByRoleIdTest userList.size : " + userList.size());
for(User user:userList){
logger.debug("userList =====> userName: " + user.getUserName()
+", <未做映射字段>userPassworD. " + user.getUserPassword()
+ ", Role: " + user.getRole().getId() + " --- "
+ user.getRole().getRoleCode() +" --- " + user.getRole().getRoleName());
}
}
在测试方法中调用getUserListByRoleId()方法获取userList，并进行结果输出，关键是映射的用户角色相关信息。
cn.dsscm.dao.UserMapper.getUserListByRoleId - ==> Preparing: select u.*,r.id as r_id, r.roleCode ,r.roleName from tb_user u,tb_role r where u.userRole = ? and u.userRole = r.id
cn.dsscm.dao.UserMapper.getUserListByRoleId - ==> Parameters: 3(Integer)
......
cn.dsscm.test.UserMapperTest - getUserListByRoleIdTest userList.size : 7
cn.dsscm.test.UserMapperTest - userList =====> userName: 张华, <未做映射字段>userPassworD. null, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
cn.dsscm.test.UserMapperTest - userList =====> userName: 王洋, <未做映射字段>userPassworD. null, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
cn.dsscm.test.UserMapperTest - userList =====> userName: 赵燕, <未做映射字段>userPassworD. null, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
......
通过上面的示例，我们了解了关于association的基本用法以及适用场景，那么现在再思考一个问题：上一个例子中使用"userRoleResult"联合一个association的结果映射来加载User实例，那么association的role结果映射是否可复用？
答案是肯定的，association提供了的另一个属性：resultMap。通过这个属性可以扩展一个resultMap来进行联合映射，这样就可以使role结果映射重复使用。当然，若不需要重用，也可按照之前的写法，直接嵌套这个联合结果映射，根据具体业务而定。下面就来改造刚才的示例，使用resultMap完成association的role映射结果的复用。具体操作如下。
修改UserMapper.xml，增加resultMap来完成role的结果映射，association增加属性resultMap来引用外部的"roleResult"，代码如下：
【示例12】 UserMapper.xml
<!-- 根据roleId获取用户列表 association start-->
<resultMap type="User" id="userRoleResult2">
<id property="id" column="id"/>
<result property="userCode" column="userCode" />
<result property="userName" column="userName" />
<result property="userRole" column="userRole" />
<association property="role" javaType="Role" resultMap="roleResult"/>
</resultMap>
<resultMap type="Role" id="roleResult">
<id property="id" column="r_id"/>
<result property="roleCode" column="roleCode"/>
<result property="roleName" column="roleName"/>
</resultMap>
<select id="getUserListByRoleId2" parameterType="Integer" resultMap="userRoleResult2">
select u.*,r.id as r_id,r.roleCode,r.roleName from tb_user u,tb_role r
where u.userRole = #{userRole} and u.userRole = r.id
</select>
在上述代码中，把之前的角色结果映射代码抽取出来放在一个resultMap中，然后设置了association的resultMap属性来引用外部的"roleResult"。这样做的好处就是可以达到复用的效果，并且整体的结构较为清晰明了，特别适合association的结果映射比较多的情况。
运行结果如下：
cn.dsscm.dao.UserMapper.getUserListByRoleId3 - ==> Preparing: select * from tb_user u where u.userRole = ?
cn.dsscm.dao.UserMapper.getUserListByRoleId3 - ==> Parameters: 3(Integer)
......
cn.dsscm.dao.UserMapper.getRoleList - ==> Preparing: select * from tb_role where id=?
cn.dsscm.dao.UserMapper.getRoleList - ==> Parameters: 3(Integer)
......
cn.dsscm.test.UserMapperTest - getUserListByRoleIdTest userList.size : 7
cn.dsscm.test.UserMapperTest - userList =====> userName: 张华, <未做映射字段>userPassworD. 0000000, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
cn.dsscm.test.UserMapperTest - userList =====> userName: 王洋, <未做映射字段>userPassworD. 0000000, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
cn.dsscm.test.UserMapperTest - userList =====> userName: 赵燕, <未做映射字段>userPassworD. 0000000, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
......
从控制台的输出结果可以看出，使用MyBatis嵌套查询的方式查询出了用户及其权限的信息，这就是MyBatis中的一对一关联查询。
虽然使用嵌套查询的方式比较简单，但是从控制台的输出结果中可以看出，MyBatis嵌套查询的方式要执行多条SQL语句，这对于大型数据集合和列表展示不是很好，因为这样可能会导致成百上千条关联的SQL语句被执行，从而极大地消耗数据库性能并且会降低查询效率。这并不是开发人员所期望的。为此，我们可以使用MyBatis提供的嵌套结果方式，来进行关联查询。
在PersonMapper.xml中，使用MyBatis嵌套结果的方式进行个人及其关联的证件信息查询，所添加的代码如下所示。
【示例13】 UserMapper.xml
<!-- 嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集 -->
<select id="findPersonById2" parameterType="Integer" resultMap="IdCardWithPersonResult2">
SELECT p.*,idcard.code
from tb_person p,tb_idcard idcard
where p.card_id=idcard.id
and p.id= #{id}
</select>
<resultMap type="Person" id="IdCardWithPersonResult2">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="age" column="age" />
<result property="sex" column="sex" />
<association property="card" javaType="IdCard">
<id property="id" column="card_id" />
<result property="code" column="code" />
</association>
</resultMap>
从上述代码中可以看出，MyBatis嵌套结果的方式只编写了一条复杂的多表关联的SQL语句，并且在<association>元素中继续使用相关子元素进行数据库表字段和实体类属性的一一映射。
在测试类中编写测试方法getUserListByRoleIdTest3()，其代码如下所示。
【示例14】 UserMapperTest.java
@Test
public void getUserListByRoleIdTest3(){
SqlSession sqlSession = null;
List<User> userList = new ArrayList<User>();
Integer roleId = 3;
try {
sqlSession = MyBatisUtils.createSqlSession();
userList = sqlSession.getMapper(UserMapper.class).getUserListByRoleId3(roleId);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}finally{
MyBatisUtils.closeSqlSession(sqlSession);
}
logger.debug("getUserListByRoleIdTest userList.size : " + userList.size());
for(User user:userList){
logger.debug("userList =====> userName: " + user.getUserName()
+", <未做映射字段>userPassworD. " + user.getUserPassword()
+ ", Role: " + user.getRole().getId() + " --- "
+ user.getRole().getRoleCode() +" --- " + user.getRole().getRoleName());
}
}
使用JUnit4执行getUserListByRoleIdTest3()方法后，控制台的输出结果如下：
cn.dsscm.dao.UserMapper.getUserListByRoleId3 - ==> Preparing: select * from tb_user u where u.userRole = ?
cn.dsscm.dao.UserMapper.getUserListByRoleId3 - ==> Parameters: 3(Integer)
......
cn.dsscm.dao.UserMapper.getRoleList - ==> Preparing: select * from tb_role where id=?
cn.dsscm.dao.UserMapper.getRoleList - ==> Parameters: 3(Integer)
......
cn.dsscm.test.UserMapperTest - getUserListByRoleIdTest userList.size : 7
cn.dsscm.test.UserMapperTest - userList =====> userName: 张华, <未做映射字段>userPassworD. 0000000, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
cn.dsscm.test.UserMapperTest - userList =====> userName: 王洋, <未做映射字段>userPassworD. 0000000, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
cn.dsscm.test.UserMapperTest - userList =====> userName: 赵燕, <未做映射字段>userPassworD. 0000000, Role: 3 --- DSSCM_EMPLOYEE --- 普通员工
......
从控制台的输出结果可以看出，使用MyBatis嵌套结果的方式只执行了一条SQL语句，并且同样查询出了个人及其关联的身份证的信息。
经验
MyBatis延迟加载的配置，在使用MyBatis嵌套查询方式进行MyBatis关联查询映射时，使用MyBatis的延迟加载在一定程度上可以降低运行消耗并提高查询效率。MyBatis默认没有开启延迟加载，需要在核心配置文件mybatis-config.xml中的<settings>元素内进行配置，具体配置方式如下。
<settings>
<!--打开延迟加载的开关-->
<setting name="lazyLoadingEnabled" value="true" />
<!--将积极加载改为消息加载，即按需加载-->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
在映射文件中，MyBatis关联映射的<association>元素和<collection>元素中都已默认配置了延迟加载属性，即默认属性fetchType=“lazy”（属性fetchType="eager"表示立即加栽），所以在配置文件中开启延迟加载后，无须在映射文件中再做配置。
超全面的测试IT技术课程，0元立即加入学习！有需要的朋友戳：
欢迎转载，但未经作者同意请保留此段声明，并在文章页面明显位置给出原文链接。
