Mybatis中的关联映射和查询

一、商品订单数据模型
1、数据表
这里定义了四个表，分别表示用户，商品，订单，和订单详情。
用户表user

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` date DEFAULT NULL COMMENT '生日',
  `sex` char(1) DEFAULT NULL COMMENT '性别',
  `address` varchar(256) DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8

表中的数据如下图：

商品表items

CREATE TABLE `items` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) NOT NULL COMMENT '商品名称',
  `price` float(10,1) NOT NULL COMMENT '商品定价',
  `detail` text COMMENT '商品描述',
  `pic` varchar(64) DEFAULT NULL COMMENT '商品图片',
  `createtime` datetime NOT NULL COMMENT '生产日期',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8

表中的数据如下图：

订单表orders

CREATE TABLE `orders` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL COMMENT '下单用户id',
  `number` varchar(32) NOT NULL COMMENT '订单号',
  `createtime` datetime NOT NULL COMMENT '创建订单时间',
  `note` varchar(100) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`),
  KEY `FK_orders_1` (`user_id`),
  CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8

在订单表中有一个外键user_id，和用户表user中的id相关联。
表中的数据如下图：


订单详情orderdetail

CREATE TABLE `orderdetail` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `orders_id` int(11) NOT NULL COMMENT '订单id',
  `items_id` int(11) NOT NULL COMMENT '商品id',
  `items_num` int(11) DEFAULT NULL COMMENT '商品购买数量',
  PRIMARY KEY (`id`),
  KEY `FK_orderdetail_1` (`orders_id`),
  KEY `FK_orderdetail_2` (`items_id`),
  CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8

在订单详情表中有两个外键：orders_id和订单表orders中的id相关联；items_id和商品表items中的id相关联。
表中的数据如下图：

综合以上四张表，结合里面已有的数据，最终整合得到如下信息：
张三有编号为1000010和1000011两个订单。其中1000010订单包含1个台式机和3个笔记本；1000011订单包含4个IPAD和3个笔记本。
而李四有一个编号为1000012的订单，包含2个IPAD。
信息如下图：


2、表与表之间的关系
先分析明确有外键关联的数据表。
user和orders：
user---->orders：一个用户可以创建多个订单，一对多。
orders--->user：一个订单只能属于一个用户，一对一。

orders和orderdetail：
orders--->orderdetail：一个订单可以包括多个订单明细。因为一个订单可以购买多个商品，每个商品的购买信息都在orderdetail有一行记录。一对多关系。
orderdetail--->orders：一个订单明细只能属于一个订单，一对一。

orderdetail和items：
orderdetail--->items：一个订单明细只对应一个商品信息，一对一。
items---> orderdetail:一个商品可以属于多个订单明细（在不同的订单中） ，一对多。

再分析没有明确关系的表之间是否有业务关系：
orders和items：
通过订单明细表orderdetail，orders和items可以建立关系。
orders--->items一个订单可以包含多个商品，一对多。
items--->orders一个商品可以属于多个订单，一对多。
订单表和商品表是多对多关系。


二、建立数据表对应的POJO类
1、user.java

package com.kang.pojo;


import java.io.Serializable;
import java.util.Date;
import java.util.List;


public class user implements Serializable {
	
	//属性名和数据库表的字段对应
	private int id;
	private String username;// 用户姓名
	private String sex;// 性别
	private Date birthday;// 生日
	private String address;// 地址
	
	//用户创建的订单列表
	private List<Orders> ordersList;
	
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getusername() {
		return username;
	}
	public void setusername(String username) {
		this.username = username;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public List<Orders> getOrdersList() {
		return ordersList;
	}
	public void setOrdersList(List<Orders> ordersList) {
		this.ordersList = ordersList;
	}
	@Override
	public String toString() {
		return "user [id=" + id + ", username=" + username + ", sex=" + sex + ", birthday=" + birthday + ", address="
				+ address + ", ordersList=" + ordersList + "]";
	}




}

2、Items.java

package com.kang.pojo;


import java.util.Date;


public class Items {
    private Integer id;
    private String name;
    private Float price;
    private String pic;
    private Date createtime;
    private String detail;
    
    public Integer getId() {
        return id;
    }


    public void setId(Integer id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }


    public Float getPrice() {
        return price;
    }


    public void setPrice(Float price) {
        this.price = price;
    }


    public String getPic() {
        return pic;
    }


    public void setPic(String pic) {
        this.pic = pic == null ? null : pic.trim();
    }


    public Date getCreatetime() {
        return createtime;
    }


    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }


    public String getDetail() {
        return detail;
    }


    public void setDetail(String detail) {
        this.detail = detail == null ? null : detail.trim();
    }


	@Override
	public String toString() {
		return "Items [id=" + id + ", name=" + name + ", price=" + price
				+ ", pic=" + pic + ", createtime=" + createtime + ", detail="
				+ detail + "]";
	}
    
}

3、Orders.java

package com.kang.pojo;


import java.util.Date;
import java.util.List;


public class Orders {
    private Integer id;
    private Integer userId;
    private String number;
    private Date createtime;
    private String note;
    //用户信息
    private user user;
    //订单明细
    private List<Orderdetail> orderdetails;


    public Integer getId() {
        return id;
    }


    public void setId(Integer id) {
        this.id = id;
    }


    public Integer getuserId() {
        return userId;
    }


    public void setuserId(Integer userId) {
        this.userId = userId;
    }


    public String getNumber() {
        return number;
    }


    public void setNumber(String number) {
        this.number = number == null ? null : number.trim();
    }


    public Date getCreatetime() {
        return createtime;
    }


    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }


    public String getNote() {
        return note;
    }


    public void setNote(String note) {
        this.note = note == null ? null : note.trim();
    }


	public user getuser() {
		return user;
	}


	public void setuser(user user) {
		this.user = user;
	}


	public List<Orderdetail> getOrderdetails() {
		return orderdetails;
	}


	public void setOrderdetails(List<Orderdetail> orderdetails) {
		this.orderdetails = orderdetails;
	}


	@Override
	public String toString() {
		return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
				+ ", note=" + note + ", user=" + user + ", orderdetails=" + orderdetails + "]";
	}


    
}

4、Orderdetail.java

package com.kang.pojo;


public class Orderdetail {
    private Integer id;
    private Integer ordersId;
    private Integer itemsId;
    private Integer itemsNum;
    //明细对应的商品信息
    private Items items;
    
    public Integer getId() {
        return id;
    }


    public void setId(Integer id) {
        this.id = id;
    }


    public Integer getOrdersId() {
        return ordersId;
    }


    public void setOrdersId(Integer ordersId) {
        this.ordersId = ordersId;
    }


    public Integer getItemsId() {
        return itemsId;
    }


    public void setItemsId(Integer itemsId) {
        this.itemsId = itemsId;
    }


    public Integer getItemsNum() {
        return itemsNum;
    }


    public void setItemsNum(Integer itemsNum) {
        this.itemsNum = itemsNum;
    }


	public Items getItems() {
		return items;
	}


	public void setItems(Items items) {
		this.items = items;
	}


	@Override
	public String toString() {
		return "Orderdetail [id=" + id + ", ordersId=" + ordersId
				+ ", itemsId=" + itemsId + ", itemsNum=" + itemsNum + "]";
	}
    
}

二、一对一查询
这里对Mybatis的基础配置信息不再列出，只分析对应的映射文件的内容。
业务需求：查询出订单信息，并且关联查询出创建订单的用户信息。
1、构想查询的SQL语句
查询涉及的数据表：orders和user。
查询的结果信息：orders表的全部字段信息和user的三个信息。
如何关联：通过外键orders.user_id = user.id。
SQL查询语句如下：

SELECT
orders.*,
user.username,
user.sex,
user.address
FROM
orders,
user
WHERE orders.user_id = user.id

2、实现方案
第一种：使用POJO扩展类来映射，从而避免使用resultMap。
首先根据查询结果的形式定义POJO类：这个类继承自Orders类。

package com.kang.pojo;
//通过此类映射订单和用户查询的结果，让此类继承包括字段较多的pojo类。
public class OrdersCustom extends Orders{
	
	//添加用户属性
	/*user.username,
	  user.sex,
	  user.address */
	
	private String username;
	private String sex;
	private String address;
	public String getusername() {
		return username;
	}
	public void setusername(String username) {
		this.username = username;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "OrdersCustom [username=" + username + ", sex=" + sex + ", address=" + address + "]";
	}


}

然后再映射XML文件中用resultType来指定。

<!-- 查询订单关联查询用户信息，使用 resultType -->
	<select id="findOrdersuser" resultType="com.kang.pojo.OrdersCustom">
		SELECT
		orders.*,
		user.username,
		user.sex,
		user.address
		FROM
		orders,
		user
		WHERE orders.user_id
		= user.id
	</select>

之后在接口类中定义相关的方法

public interface OrdersMapperCustom {
	//查询订单关联查询用户信息
	public List<OrdersCustom> findOrdersuser()throws Exception;
}

最后进行测试

public class OrderTest {
	// 会话工厂
	private SqlSessionFactory sqlSessionFactory;
	@Before
	public void createSqlSessionFactory() throws IOException {
		// 配置文件SqlMapConfig.xml在类路径下
		String resource = "SqlMapConfig.xml";
		// 得到配置文件流
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 创建会话工厂，传入mybatis的配置文件信息
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);


	}


	@Test
	public void testFindOrdersuser() throws Exception {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 创建代理对象
		OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);
		// 调用maper的方法
		List<OrdersCustom> list = ordersMapperCustom.findOrdersuser();


		//System.out.println(list);


		for (OrdersCustom ordersCustom : list) {
			System.out.println(ordersCustom);
		}
		sqlSession.close();
	}
}

测试结果：




第二种：不使用POJO扩展类
我们可以在Orders类中添加一个属性user，然后把查询结果映射到Orders即可。

//用户信息
private user user;
//提供get/set方法。

在XML中使用resultMap来映射。
首先定义一个resultMap片段，以供引用。

<!-- type表示订单查询关联用户的resultMap 将整个查询的结果映射到com.kang.pojo.Orders中 -->
	<resultMap type="com.kang.pojo.Orders" id="OrdersuserResultMap">
		<!-- 配置映射的订单信息 -->
		<!-- id：指定查询列中的唯一标识，也就是订单信息的中的唯一标识。如果有多个列组成唯一标识，配置多个id。 
                     column：数据库中订单信息表的唯一标识列，通常就是主键。 
                     property：订单信息表的唯一标识列所映射到Orders类中哪个属性。
                 -->
		<id column="id" property="id" />
		<result column="user_id" property="userId" />
		<result column="number" property="number" />
		<result column="createtime" property="createtime" />
		<result column="note" property="note" />


		<!-- 配置映射的关联的用户信息 -->
		<!-- association：用于映射关联查询单个对象的信息。 
                     property：要将关联查询的用户信息映射到Orders中哪个属性。 
                 -->
		<association property="user" javaType="com.kang.pojo.user">
			<!-- id：关联查询用户的唯一标识。column：指定唯一标识用户信息的列，通常就是外键。 javaType：映射到user的哪个属性 -->
			<id column="user_id" property="id" />
			<result column="username" property="username" />
			<result column="sex" property="sex" />
			<result column="address" property="address" />


		</association>
	</resultMap>

然后在XML映射文件中引用该resultMap。

<!-- 查询订单关联查询用户信息，使用resultmap -->
	<select id="findOrdersuserResultMap" resultMap="OrdersuserResultMap">
		SELECT
		orders.*,
		user.username,
		user.sex,
		user.address
		FROM
		orders,
		user
		WHERE orders.user_id
		= user.id
	</select>

在接口中添加相应的方法

//查询订单关联查询用户使用resultMap
	public List<Orders> findOrdersuserResultMap()throws Exception;

在测试类中添加测试方法：
       

 @Test
	public void testFindOrdersuserResultMap() throws Exception {


		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 创建代理对象
		OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);


		// 调用maper的方法
		List<Orders> list = ordersMapperCustom.findOrdersuserResultMap();


		//System.out.println(list);
                for (Orders orders : list) {
			System.out.println(orders);
		}


		sqlSession.close();
	}

测试结果：


详细结果：

DEBUG [main] - <==      Total: 3
Orders [id=3, userId=1, number=1000010, createtime=Mon Feb 27 13:22:35 CST 2017, note=尽快发货, user=User [id=1, username=张三, sex=2, birthday=null, address=成都市, ordersList=null], orderdetails=null]
Orders [id=4, userId=1, number=1000011, createtime=Mon Feb 27 14:22:35 CST 2017, note=买来看看, user=User [id=1, username=张三, sex=2, birthday=null, address=成都市, ordersList=null], orderdetails=null]
Orders [id=5, userId=2, number=1000012, createtime=Mon Mar 27 22:46:36 CST 2017, note=记得发中通, user=User [id=2, username=李四, sex=1, birthday=null, address=北京市, ordersList=null], orderdetails=null]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5d76b067]

3、resultType和resultMap实现一对一查询的比较
resultType：使用resultType实现较为简单，如果pojo类中没有包括查询出来的列名，需要在其中增加列名对应的属性，即可完成映射。
resultMap：需要单独定义resultMap，实现较为麻烦。如果对查询结果有特殊的要求，使用resultMap可以完成将关联查询映射pojo的属性中。
如果没有查询结果的特殊要求建议使用resultType。resultMap可以实现延迟加载，resultType无法实现延迟加载。


三、实现一对多查询
业务需求：查询出所有的订单并关联查询出订单的用户和其中的订单明细。
1、构想查询的SQL语句
查询涉及的数据表：orders，user和orderdetail。
查询的结果信息：orders表的全部字段信息+user的三个信息+订单明细的四个信息。
如何关联：通过外键orders.user_id = user.id关联用户查询；通过外键orders.id=orderdetail.orders_id关联查询订单明细。
SQL查询语句如下：

SELECT
orders.*,
user.username,
user.sex,
user.address,
orderdetail.id orderdetail_id,
orderdetail.items_id,
orderdetail.items_num,
orderdetail.orders_id
FROM
orders,
user,
orderdetail
WHERE orders.user_id = user.id AND orders.id=orderdetail.orders_id

2、实现方案
使用resultMap来实现一对多关联。
首先需要在Orders的类中添加一个属性，来表示订单明细表。

//订单明细
private List<Orderdetail> orderdetails;
//提供get/set方法。

然后在XML中使用resultMap来映射，这里采用了继承。

<!-- 订单关联用户和订单明细的resultMap。使用extends继承，不用在中配置订单信息和用户信息的映射 -->
	<resultMap type="com.kang.pojo.Orders" id="OrdersAndOrderDetailResultMap"
		extends="OrdersuserResultMap">
		<!-- 订单信息继承而来 -->
		<!-- 用户信息继承而来 -->
		<!-- 使用extends继承，不用配置订单信息和用户信息的映射 -->
		<!-- 订单明细信息：一个订单关联查询出了多条明细，要使用collection进行一对多映射。
                     collection：对关联查询到多条记录映射到集合对象中。 
		     property：将关联查询到多条记录映射到com.kang.pojo.Orders哪个属性 。
                     ofType：指定映射到list集合属性中pojo的类型。 
                 -->
		<collection property="orderdetails" ofType="com.kang.pojo.Orderdetail">
			<!-- id：订单明细唯一标识，一般就是主键，注意这里使用了别名，结合SQL语句一看便知。
                             property:要将订单明细的唯一标识映射到com.kang.pojo.Orderdetail的哪个属性 -->
			<id column="orderdetail_id" property="id" />
			<result column="items_id" property="itemsId" />
			<result column="items_num" property="itemsNum" />
			<result column="orders_id" property="ordersId" />
		</collection>
	</resultMap>

然后在XML映射文件中引用该resultMap。

<!-- 查询订单关联查询用户及订单明细，使用resultmap -->
	<select id="findOrdersAndOrderDetailResultMap" resultMap="OrdersAndOrderDetailResultMap">
		SELECT
		orders.*,
		user.username,
		user.sex,
		user.address,
		orderdetail.id orderdetail_id,
		orderdetail.items_id,
		orderdetail.items_num,
		orderdetail.orders_id
		FROM
		orders,
		user,
		orderdetail
		WHERE orders.user_id = user.id AND orders.id=orderdetail.orders_id
	</select>

在接口中添加相应的方法

//查询订单(关联用户)及订单明细
	public List<Orders>  findOrdersAndOrderDetailResultMap()throws Exception;

在测试类中添加测试方法：

        @Test
	public void testFindOrdersAndOrderDetailResultMap() throws Exception {


		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 创建代理对象
		OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);


		// 调用maper的方法
		List<Orders> list = ordersMapperCustom.findOrdersAndOrderDetailResultMap();
                for (Orders orders : list) {
			System.out.println(orders);
		}
		sqlSession.close();
	}

测试结果：


详细结果：

DEBUG [main] - <==      Total: 5
Orders [id=3, userId=1, number=1000010, createtime=Mon Feb 27 13:22:35 CST 2017, note=尽快发货, user=User [id=1, username=张三, sex=2, birthday=null, address=成都市, ordersList=null], orderdetails=[Orderdetail [id=1, ordersId=3, itemsId=1, itemsNum=1], Orderdetail [id=2, ordersId=3, itemsId=2, itemsNum=3]]]
Orders [id=4, userId=1, number=1000011, createtime=Mon Feb 27 14:22:35 CST 2017, note=买来看看, user=User [id=1, username=张三, sex=2, birthday=null, address=成都市, ordersList=null], orderdetails=[Orderdetail [id=3, ordersId=4, itemsId=3, itemsNum=4], Orderdetail [id=4, ordersId=4, itemsId=2, itemsNum=3]]]
Orders [id=5, userId=2, number=1000012, createtime=Mon Mar 27 22:46:36 CST 2017, note=记得发中通, user=User [id=2, username=李四, sex=1, birthday=null, address=北京市, ordersList=null], orderdetails=[Orderdetail [id=5, ordersId=5, itemsId=3, itemsNum=2]]]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5d76b067]

3、总结
mybatis使用resultMap中collection实现一对查询，它可以把关联查询的多条记录映射到一个list集合属性中。
一对多查询也可以使用resultType实现：
我们将订单明细映射到orders中的orderdetails中，需要自己处理，使用双重循环遍历，去掉重复记录，将订单明细放在orderdetails中。


四、实现多对多查询
业务需求：查询出所有订单，并关联查询出订单的用户，订单的明细以及订单中的商品信息。而订单和商品信息之间就是多对多关系。
1、构想查询的SQL语句
查询涉及的数据表：orders，user，orderdetail和items。
查询的结果信息：orders表的全部字段信息+user的四个信息+orderdetail的四个信息+items的三个信息。
如何关联：通过外键orders.user_id = user.id关联用户查询；通过外键orders.id=orderdetail.orders_id关联查询订单明细；通过外键orderdetail.items_id = items.id关联查询商品信息；
SQL查询语句如下：

SELECT
orders.*,
user.username,
user.sex,
user.birthday,
user.address,
orderdetail.id orderdetail_id,
orderdetail.items_id,
orderdetail.items_num,
orderdetail.orders_id,
items.name items_name,
items.detail items_detail,
items.price items_price
FROM
orders,
user,
orderdetail,
items
WHERE orders.user_id = user.id 
AND orderdetail.orders_id=orders.id 
AND orderdetail.items_id = items.id

2、实现方案
使用resultMap来实现多对多关联。
我们可以将查询结果映射到user中。
首先在user类中添加订单列表属性List<Orders> orderslist，将用户创建的订单映射到orderslist。
然后在Orders中添加订单明细列表属性List<OrderDetail>orderdetials，将订单的明细映射到orderdetials。
最后在OrderDetail中添加Items属性，将订单明细所对应的商品映射到Items。
这样我们通过user类就可得到所有我们查询到的信息。
这里不去展示具体过程，可参考上面提供的POJO类即可。
定义好POJO了类后，我们在XML中使用resultMap来映射，这里进行了collection的嵌套。

<!-- 查询用户及购买的商品 -->
	<resultMap type="com.kang.pojo.user" id="userAndItemsResultMap">
		<!-- 用户信息 -->
		<id column="user_id" property="id" />
		<result column="username" property="username" />
		<result column="sex" property="sex" />
		<result column="address" property="address" />
		<result column="birthday" property="birthday" />


		<!-- 订单信息 一个用户对应多个订单，使用collection映射 -->
		<collection property="ordersList" ofType="com.kang.pojo.Orders">
			<id column="id" property="id" />
			<result column="user_id" property="userId" />
			<result column="number" property="number" />
			<result column="createtime" property="createtime" />
			<result column="note" property="note" />


			<!-- 订单明细，一个订单包括多个明细 -->
			<collection property="orderdetails" ofType="com.kang.pojo.Orderdetail">
				<id column="orderdetail_id" property="id" />
				<result column="items_id" property="itemsId" />
				<result column="items_num" property="itemsNum" />
				<result column="orders_id" property="ordersId" />


				<!-- 商品信息 一个订单明细对应一个商品 -->
				<association property="items" javaType="com.kang.pojo.Items">
					<id column="items_id" property="id" />
					<result column="items_name" property="name" />
					<result column="items_detail" property="detail" />
					<result column="items_price" property="price" />
				</association>
			</collection>
		</collection>
	</resultMap>

然后在XML映射文件中引用该resultMap。

<!-- 查询用户及购买的商品信息，使用resultmap -->
	<select id="finduserAndItemsResultMap" resultMap="userAndItemsResultMap">
		SELECT
		orders.*,
		user.username,
		user.sex,
		user.birthday,
		user.address,
		orderdetail.id orderdetail_id,
		orderdetail.items_id,
		orderdetail.items_num,
		orderdetail.orders_id,
		items.name items_name,
		items.detail items_detail,
		items.price items_price
		FROM
		orders,
		user,
		orderdetail,
		items
		WHERE orders.user_id = user.id AND orderdetail.orders_id=orders.id AND
		orderdetail.items_id = items.id
	</select>

在接口中添加相应的方法

//查询用户购买商品信息
	public List<User>  findUserAndItemsResultMap()throws Exception;

在测试类中添加测试方法：

        @Test
	public void testFindUserAndItemsResultMap() throws Exception {


		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 创建代理对象
		OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);


		// 调用maper的方法
		List<User> list = ordersMapperCustom.findUserAndItemsResultMap();


		//System.out.println(list);
		for (User user : list) {
			System.out.println(user);
		}
		sqlSession.close();
	}

测试结果：




详细结果：

DEBUG [main] - <==      Total: 5
User [id=1, username=张三, sex=2, birthday=Tue Oct 27 00:00:00 CST 1998, address=成都市, ordersList=[Orders [id=3, userId=1, number=1000010, createtime=Mon Feb 27 13:22:35 CST 2017, note=尽快发货, user=null, orderdetails=[Orderdetail [id=1, ordersId=3, itemsId=1, itemsNum=1], Orderdetail [id=2, ordersId=3, itemsId=2, itemsNum=3]]], Orders [id=4, userId=1, number=1000011, createtime=Mon Feb 27 14:22:35 CST 2017, note=买来看看, user=null, orderdetails=[Orderdetail [id=3, ordersId=4, itemsId=3, itemsNum=4], Orderdetail [id=4, ordersId=4, itemsId=2, itemsNum=3]]]]]
User [id=2, username=李四, sex=1, birthday=Fri Oct 01 00:00:00 CST 1993, address=北京市, ordersList=[Orders [id=5, userId=2, number=1000012, createtime=Mon Mar 27 22:46:36 CST 2017, note=记得发中通, user=null, orderdetails=[Orderdetail [id=5, ordersId=5, itemsId=3, itemsNum=2]]]]]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5d76b067]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@5d76b067]

3、总结
一对多是多对多的特例，查询用户购买的商品信息，用户和商品的关系是多对多关系。
需求1：
查询字段：用户账号、用户名称、用户性别、商品名称、商品价格(最常见)。
企业开发中常见明细列表，用户购买商品明细列表，使用resultType将上边查询列映射到pojo输出。
需求2：
查询字段：用户账号、用户名称、购买商品数量、商品明细。
使用resultMap将用户购买的商品明细列表映射到user对象中。

五、总结

1、resultType
作用：
将查询结果按照sql列名pojo属性名一致性映射到pojo中。
使用场合：
常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list（list中是pojo）即可。


2、resultMap
使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。
association：
作用：
将关联查询信息映射到一个pojo对象中。
使用场合：
为了方便查询关联信息可以使用association将关联订单信息映射为用户对象的pojo属性中，比如：查询订单及关联用户信息。
使用resultType无法将查询结果映射到pojo对象的pojo属性中，根据对结果集查询遍历的需要选择使用resultType还是resultMap。
collection：
作用：
将关联查询信息映射到一个list集合中。
使用场合：
为了方便查询遍历关联信息可以使用collection将关联信息映射到list集合中，比如：查询用户权限范围模块及模块下的菜单，可使用collection将模块映射到模块list中，将菜单列表映射到模块对象的菜单list属性中，这样的作的目的也是方便对查询结果集进行遍历查询。
如果使用resultType无法将查询结果映射到list集合中。