文章目录
 
概述
需求
方式一：使用自动映射处理一对一映射
实体类改造
UserMapper接口增加接口方法
UserMapper.xml增加SQL
单元测试
  
方式二：使用resultMap配置一对一映射
UserMapper接口增加接口方法
UserMapper.xml增加SQL
单元测试
  
方式三：使用resultMap的asscociation标签配置一对一映射
UserMapper接口增加接口方法
UserMapper.xml增加SQL
单元测试
  
方式四：asscociation标签的嵌套查询

 
概述
 
我们还是继续使用我们的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的方式很像，最后将结果组成一个对象。
 
场景和情况比较复杂，后续单独阐述

 
 

 
 
 
前言
 
 
       当我们学习heribnate的时候，也就是SSH框架的网上商城的时候，我们就学习过它对应的高级映射，一对一映射，一对多映射，多对多映射。对于SSM的Mybatis来说，肯定也是差不多的。既然开了头了，我们就也来简单说一些Mybatis的高级映射。当然说到这些东西的时候，最简单也最常用的就是级联查询，所以我们就以几个简单的级联查询为例，分别说一下Mybatis的一对一、一对多、多对多查询。
 
 
一、一对一映射
 
 
1、需求：
 
 
       电商类做买卖，用户提交订单后，某宝根据订单信息和客户的姓名、地址派送，现在查询所有的订单信息，关联查询下但用户信息。
 
 
(1)首先确定执行的sql语句为：
 
 
 
 
 
 
SELECT orders.*,user.username,userss.address FROM orders,user WHEREorders.user_id = user.id
 
 
 
 
 
resultType方式解决这个问题：
 
 
 
 
(1)定义po类：
 
 
 
 
public class OrdersCustom extends Orders {  //OrdersCustom类继承Orders类后OrdersCustom类包括了Orders类的所有字
 
段，只需要定义用户的信息字段即可。
 
    private String username;// 用户名称
    private String address;// 用户地址
    public String getUsername(){
                return username；
    }
    public String setUsername（String username）{
                this.username=username;
    }
     ……
}
 
 
 
 

 
 
 
(2)Mapper映射文件：
 
 
 
 
<!-- 查询所有订单信息 -->
    <select id="findOrdersList" resultType="cn.itcast.mybatis.po.OrdersCustom">
    SELECT
    orders.*,
    user.username,
    user.address
    FROM
    orders,    user
    WHERE orders.user_id = user.id
    </select>
 
 
 (3)定义mapper接口： 
 
 
 
 
 
public List<OrdersCustom> findOrdersList() throws Exception;
 
 
 (4)测试： 
 
 
 
 
 
Public void testfindOrdersList()throws Exception{
       //获取session
       SqlSession session = sqlSessionFactory.openSession();
       //获限mapper接口实例
       UserMapper userMapper = session.getMapper(UserMapper.class);
       //查询订单信息
       List<OrdersCustom> list =userMapper.findOrdersList();
       System.out.println(list);
       //关闭session
       session.close();
    }
 
 
 
 
 
 
 
使用resultMap解决问题：
 
 
(1)定义resultMap：
 
 
 
 
<!-- 订单信息resultmap___需要关联查询映射的是用户信息，使用association将用户信息映射到订单对象的用户属性中 -->
<resultMap type="cn.itcast.mybatis.po.Orders"id="userordermap">
<!-- 这里的id，是mybatis在进行一对一查询时将user字段映射为user对象时要使用，必须写 -->
<id property="id" column="id"/>
<resultproperty="user_id" column="user_id"/>
<resultproperty="number" column="number"/>
<associationproperty="user" javaType="cn.itcast.mybatis.po.User">
<!-- 这里的id为user的id，如果写上表示给user的id属性赋值 -->
<id property="id" column="user_id"/>
<resultproperty="username" column="username"/>
<resultproperty="address" column="address"/>
</association>
</resultMap>
 
 
 
 

 
 
 
(2)调用resultMap：
 
 
 
 
<select id="findOrdersListResultMap" resultMap="userordermap">
    SELECT
    orders.*,
    user.username,
    user.address
    FROM
    orders,    user
    WHERE orders.user_id = user.id
</select>
 
 
 (3)定义mapper接口 
 
 
 

 
 
 
一对一查询总结：
 
 
       个人认为啊，这种情况下使用resultType定义输出映射相对简单，因为这样只需要去添加一个po类就行了，按需求添加额外需要的属性，就可以完成映射。而相对于resultType来说，resultMap就显得稍微麻烦一些了，他需要特别定义resultMap来映射相关联表的实体属性。
 
 

 
 
 
二、一对多查询：
 
 
1、需求：
 
 
       继上面的需求，查询所有订单信息及订单下的订单明细信息（一个订单信息下面或有很多商品，这个女生买护肤品的时候应该很有感触吧。所以订单信息与订单明细是一对多的关系）
 
 
(1)确定在数据库执行的sql语句：
 
 

  
  
Select  orders.*, user.username, user.address,orderdetail.idorderdetail_id,orderdetail.items_id, 
orderdetail.items_num FROM orders,user,orderdetail   
WHERE orders.user_id = user.id AND orders.id = orderdetail.orders_id
 
 
 

  
 
 
 
 

  执行结果：
 
 
 
 
 
 
 
(2)定义po类：
 
 
 
 
public class Orders{
	private Integer id;
	private Integer userId;
	private String number;
	private Date createtime;
	private String note;
	private User user;
	private List<OrderDetial> orderDetails;
	//getter、setter
}
 
 
 
  
 
 
 
(3)定义resultMap
 
 
 
 
<!-- 订单信息resultmap -->
<resultMaptype="cn.itcast.mybatis.po.Orders"id="userorderdetailmap">
<id property="id"column="id"/>
<result property="user_id" column="user_id"/>
<result property="number" column="number"/>
<association property="user" javaType="cn.itcast.mybatis.po.User">
<id property="id" column="user_id"/>
<result property="username" column="username"/>
<result property="address" column="address"/>
</association>
<collectionproperty="orderdetails" ofType="cn.itcast.mybatis.po.Orderdetail">
    <id property="id" column="orderdetail_id"/>
    <result property="items_id" column="items_id"/>
    <result property="items_num" column="items_num"/>
</collection>
</resultMap>
 
 
 
 
       大家可以跟上面对比一下，这两个resultMap除了对订单详细的映射定义外，其他的是完全一样的，现在问题来了，我们需要重新定义上面重复的映射信息吗？答案是不用，resultMap具有可继承特性，我们只需要继承上面的resultMap（userordermap），然后只定义别的就可以了，如下:
 
 
 
 
<resultMaptype="cn.itcast.mybatis.po.Orders" id="userorderdetailmap" extends="userordermap">
<collection property="orderdetails" ofType="cn.itcast.mybatis.po.Orderdetail">
   <id property="id" column="orderdetail_id"/>
   <result property="items_id" column="items_id"/>
   <result property="items_num" column="items_num"/>
</collection>
</resultMap>
 
 
 
 
使用extends来继承订单信息resultmap：userordermap
 
 

 
 
 
(4)实现调用：
 
 
 
 
<selectid="findOrdersDetailList" resultMap="userorderdetailmap">
    SELECT
    orders.*,
    user.username,
    user.address,
    orderdetail.id orderdetail_id,
    orderdetail.items_id,
    orderdetail.items_num
    FROM orders,user,orderdetail
    WHERE orders.user_id = user.id
    AND orders.id =orderdetail.orders_id
</select>
 
 
 
 

 
 
 
(5)定义mapper接口：
 
 
 
 
publicList<Orders>findOrdersDetailList () throws Exception;
 
 
 (6)来测试一下： 
 
 
 
 
 
Public void testfindOrdersDetailList()throws Exception{
       //获取session
       SqlSession session = sqlSessionFactory.openSession();
       //获限mapper接口实例
       UserMapper userMapper =session.getMapper(UserMapper.class);
       //查询订单信息
       List<Orders> list =userMapper.findOrdersDetailList();
       System.out.println(list);
       //关闭session
       session.close();
    }
 
 
 
 
       这个吧，图没有了，可是可以给大家形容一下，就是返回结果只有四个订单信息，然后每个订单信息里面有两个商品信息list压到这里面。就这样，我们就实现了一对多的查询，为什么这个例子我们不用resultType来执行，其实结果早就给大家了，上面执行sql的结果图，就是返回的信息列表，实际上只有四个订单信息，但是使用resultType会返回8条信息，也就是没有完成去重，还需要我们去手动去重，了然了吗？不是很方便
 
 

 
 
 
三、多对多查询
 
 
(1)需求：
 
 
       查询用户购买的商品信息（一个用户可以有N个订单信息，每个订单信息可以有M个商品信息，所以我们需要查询所有的用户信息，关联查询订单及订单明细信息，订单名信息中关联查询商品信息）
 
 
(2)确定要执行的sql：
 
 

  
  
SELECT
         orders.*,
         USER.username,
         USER.address,
         orderdetail.idorderdetail_id,
         orderdetail.items_id,
         orderdetail.items_num,
         items.nameitems_name,
         items.detailitems_detail
FROM
         orders,
         USER,
         orderdetail,
         items
WHERE
         orders.user_id= USER .id
AND orders.id = orderdetail.orders_id
ANDorderdetail.items_id = items.id
  
 
  
(3)po类变化：
 
 
 
 
 
 
       在User中添加List<Orders>orders 属性；在Orders类中加入List<Orderdetail> orderdetails属性；Items类，不用动
 
 
 
 
(4)定义resultMap：
 
 

  
  
<resultMap type="cn.itcast.mybatis.po.User"id="userOrderListResultMap">
       <id column="user_id"property="id"/>
       <result column="username"property="username"/>
       <collection property="orders"ofType="cn.itcast.mybatis.po.Orders">
          <id  column="id"property="id"/>
          <result property="number" column="number"/>
          <collection property="orderdetails"ofType="cn.itcast.mybatis.po.Orderdetail">
               <id  column="orderdetail_id" property="id"/>
               <result property="ordersId"column="id"/>
               <result property="itemsId"column="items_id"/>
               <result property="itemsNum"column="items_num"/>
               <association property="items"javaType="cn.itcast.mybatis.po.Items">
                   <id column="items_id" property="id"/>
                   <result column="items_name" property="name"/>
                   <result column="items_detail" property="detail"/>
              </association>
         </collection>
     </collection>
</resultMap>
 
 
 
 
 

 
 
 
(5)调用resultMap：
 
 
 
 
<select id="findUserItemResultMap" resultMap="UserItemResultMap" >        
       select orders.*,
			  user.username,
			  user.sex,
			  user.address,
			  orderdetail.id，
			  orderdetail_id,
			  orderdetail.items_id,
			  orderdetail.items_num,
			  orderdetail.orders_id,
			  item.id item_id,
			  item.name item_name,
			  item.detail item_detail,
			  item.price item_price 
	   from orders,user,orderdetail,item 
	   where orders.user_id=user.id 
			and orders.id=orderdetail.orders_id 
			and orderdetail.items_id=item.id
</select>
 
 
 
 
到这里，相信大家能看出点端倪来了吧，我们一直都是用<collection></collection>和<association></association>分别对集合和实体进行关联映射，而且它们层层嵌套的方式就跟实体之间层层嵌套的方式一样：user中包含orders，orders中包含orderdetail，orderdetail中包含item。
 
 

 
 
 
(6)然后定义mapper接口：
 
 
 
 
public interface UserMapper {    List<User> findUserItemResultMap() throws Exception;}
 
 
 结果，就请大家自己去动手实验一下吧！ 
 
 
 

 
 
 
到此，我们的Mybatis高级映射之一对一，一对多，多对多映射就分享完了，期间自己又有点收获，总结一下：
 
 
1、resultType：将查询结果按照sql列名pojo属性名一致性映射到pojo中。常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list（list中是pojo）即可。
 
 
2、resultMap：使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。其中association见关联查询信息映射到一个pojo对象中，collection将关联查询信息映射到一个list集合中然而，使用resultType无法将查询结果映射到pojo对象的pojo属性中，根据对结果集查询遍历的需要选择使用resultType还是resultMap。那就要看我们自己的判断力了。
 

mybatis-generator这是原来的github地址
 现在在此基础上添加了一对一和一对多映射配置，配置在table标签上
 如果需要一对一配置生成，需要添加插件配置
 在context中添加如下配置
 
<!-- 生成一对一配置 -->
<plugin type="cc.bandaotixi.plugins.OneToOnePlugin"></plugin>
 
一对多配置如下
 
<!-- 生成一对多配置 -->
<plugin type="cc.bandaotixi.plugins.OneToManyPlugin"></plugin>
 
批量插入和批量更新
 
<plugin type="cc.bandaotixi.plugins.BatchInsertPlugin"></plugin>
<plugin type="cc.bandaotixi.plugins.BatchUpdatePlugin"></plugin>
 
如果需要把数据库注释添加到java文件中，配置如下
 
<commentGenerator type="cc.bandaotixi.plugins.BDTCommentGenerator">
 	<property name="javaFileEncoding" value="UTF-8"/>
	<property name="suppressDate" value="true"/>
	<property name="suppressAllComments" value="false" /></commentGenerator>
 
那么配置一对一表时应这么配置
 
<table tableName="t_test" domainObjectName="TEst">
 	<generatedKey column="test_id" sqlStatement="MySql" identity="true" />
 	<oneToOne mappingTable="t_test" column="test_id" joinColumn="parent_test_id" where="t_test.is_deleted=0" />
 </table>
 
配置一对多表时
 
<table tableName="t_test" domainObjectName="Test">
 	<generatedKey column="test_id" sqlStatement="MySql" identity="true" />
 	<oneToMany mappingTable="t_test" column="test_id" joinColumn="parent_test_id" where="t_test.is_deleted=0" />
 </table>
 
下面补上全部配置
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<!--
生成mapper命令
java -jar mybatis.jar -configfile generatorConfig.xml -overwrite
-->
<generatorConfiguration>
	<classPathEntry location="C:\Users\administrator\.m2\repository\mysql\mysql-connector-java\5.1.39\mysql-connector-java-5.1.39.jar" />
 	<context id="appInfo" targetRuntime="MyBatis3">
 		<property name="javaFileEncoding" value="UTF-8"/>
 		<!-- 生成一对一配置 -->
		<plugin type="cc.bandaotixi.plugins.OneToOnePlugin"></plugin>
		<!-- 生成一对多配置 -->
		<plugin type="cc.bandaotixi.plugins.OneToManyPlugin"></plugin>
		<plugin type="cc.bandaotixi.plugins.BatchInsertPlugin"></plugin>
		<plugin type="cc.bandaotixi.plugins.BatchUpdatePlugin"></plugin>
 		<commentGenerator type="cc.bandaotixi.plugins.BDTCommentGenerator">
	        <property name="suppressDate" value="true"/>
	        <property name="suppressAllComments" value="false" />
	    </commentGenerator>
 		<jdbcConnection connectionURL="jdbc:mysql://localhost:3307/test?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true" driverClass="com.mysql.jdbc.Driver" password="test" userId="root" />
 		<!-- 数据表对应的实体层 -->
		<javaModelGenerator targetPackage="com.entity"
			targetProject="src/main/java">
			<property name="enableSubPackages" value="true" />
			<property name="trimStrings" value="true" />
		</javaModelGenerator>
		
 		<sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources">
 			<property name="enableSubPackages" value="true" />
			<property name="isMergeable" value="false"/>
 		</sqlMapGenerator>
 		
 		<!-- 在ibatis2 中是dao层，但在mybatis3中，其实就是mapper接口 -->
 		<javaClientGenerator type="XMLMAPPER" targetPackage="com.dao" targetProject="src/main/java">
			<property name="enableSubPackages" value="true" />
		</javaClientGenerator>

 		<table tableName="t_test" domainObjectName="Test">
 			<generatedKey column="test_id" sqlStatement="MySql" identity="true" />
 			<oneToMany mappingTable="t_test" column="parent_est_id" joinColumn="test_id" where="t_test.is_deleted=0" />
                        <!--映射的表必须配置table-->
 		</table>
 	</context>
</generatorConfiguration>
 
值得注意的是，如果使用批量更新功能需要在连接的配置上添加allowMultiQueries=true
 如果你比较懒，不想编译代码也可以直接下载，但是需要一个积分
 如果需要进一步添加插件，请fork郗瑞强MybatisGenerator工具
 如果有问题或者BUG请发邮件到:bandaotixi@hotmail.com
 感谢
 
很抱歉,因为代码很久远,这里已经不再维护,请理解

假设是person和cardid两个对象
 
单向一对一映射
 
注解：在关系拥有端 @OneToOne(cascade=CascadeType.ALL)
 
          关系维护端  @OneToOne(mappedBy="card")
 
 假设在person类中有cardid的一个变量叫card
 
这样在数据库中就会建两个表，但是person中有cardid，但是cardid中没有person，所以是单向一对一映射
 
双向一对一映射
 
注解：两方都是
 
 @OneToOne(cascade=CascadeType.ALL)
 
就会一对一了