Mybatis中的关联映射和查询

红太狼 2022-06-18 01:59 144阅读 0赞

一、商品订单数据模型  
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

表中的数据如下图：

![20170328101359938][]

商品表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

表中的数据如下图：  
![20170328101405907][]  
订单表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相关联。  
表中的数据如下图：  
![20170328101409422][]  
  
订单详情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相关联。  
表中的数据如下图：  
![20170328101413421][]  
综合以上四张表，结合里面已有的数据，最终整合得到如下信息：  
张三有编号为1000010和1000011两个订单。其中1000010订单包含1个台式机和3个笔记本；1000011订单包含4个IPAD和3个笔记本。  
而李四有一个编号为1000012的订单，包含2个IPAD。  
信息如下图：  
![20170328101416922][]  
  
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来指定。

<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();
    	}
    }

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

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

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

<resultMap type="com.kang.pojo.Orders" id="OrdersuserResultMap">
    		
    		
    		<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="user" javaType="com.kang.pojo.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。

<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();
    	}

测试结果：  
![20170328101427891][]  
  
详细结果：

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 type="com.kang.pojo.Orders" id="OrdersAndOrderDetailResultMap"
    		extends="OrdersuserResultMap">
    		
    		
    		
    		
    		<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" />
    		</collection>
    	</resultMap>

然后在XML映射文件中引用该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();
    	}

测试结果：  
![20170328101434812][]  
  
详细结果：

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 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。

<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();
    	}

测试结果：  
![20170328101440718][]  
  
  
  
详细结果：

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集合中。

[20170328101359938]: /images/20220618/57a1c36cb7f64c66950d9688382ca54f.png
[20170328101405907]: /images/20220618/054e940686354d53b3e3a28f41e48cff.png
[20170328101409422]: /images/20220618/d01688e7afca46ff83a3ea6dffb28ad0.png
[20170328101413421]: /images/20220618/8c5ce2b69c494553ba8c0f61f24ed72b.png
[20170328101416922]: /images/20220618/7d4e7b6825e84c58b786724adfae25b7.png
[20170328101421391]: /images/20220618/af487c7ba8db4bbb87e8a3b5c0c0da04.png
[20170328101427891]: /images/20220618/5312734b5a5f437b8903df0be707d06a.png
[20170328101434812]: /images/20220618/0bc5f5216cd74221a0a43e206164f394.png
[20170328101440718]: /images/20220618/9a9b511346f444bab7b05911b10c4435.png