MyBatis一对一、一对多、多对多映射查询

MyBatis在映射文件中加载关联关系对象主要通过两种方式：嵌套查询和嵌套结果。

嵌套查询是指通过执行另外一条SQL映射语句来返回预期的复杂类型；

嵌套结果是使用嵌套结果映射来处理重复的联合结果的子集；

1、一对一关系使用中的子元素

该元素中包含以下属性：

property:指定映射到的实体类对象属性，与表字段一一对应。

column:指定表中对应的字段。

javaType：指定映射到实体对象属性的类型。

select:指定引入嵌套查询的子SQL语句，该属性用于关联映射中的嵌套查询。

fetchType：指定在关联查询时是否启用延迟加载。fetchType属性有lazy和eager两个属性值，默认值为lazy(延迟加载）。

案例：

1、目前有两张表：tb_idcard表和tb_person表

CREATE TABLE tb_idcard(
	id INT PRIMARY KEY AUTO_INCREMENT,
	CODE VARCHAR(18)
);
CREATE TABLE tb_person(
	id INT PRIMARY KEY AUTO_INCREMENT,
	name VARCHAR(32),
	age INT,
	sex VARCHAR(8),
	card_id INT UNIQUE,
	FOREIGN KEY(card_id) REFERENCES tb_idcard(id)	
);

2、定义实体类（使用Lombok简化getters and setters）

@Data
public class IdCard{
	private Integer id;
	private String code;
}

@Data
public class Person {
	private Integer id;
	private String name;
	private Integer age;
	private String sex;
	private IdCard card; //一对一，关联的身份证
}

3、映射文件 IdCardMapper.xml

	
		select * from tb_idcard where id=#{id}
	

4、映射文件PersonMapper.xml

	
		select * from tb_person where id=#{id}
	
	
		
		
		
		
		
		
	

上面这种方式是嵌套查询，先执行一个简单的SQL语句，然后再进行结果映射时，将关联对象再元素中使用select属性执行另一条SQL语句。这种方式虽然简单，但要执行多条SQL语句，对于大型数据集的展示不是很好，可能导致成百上千条关联SQL语句被执行，从而极大消耗数据库性能，降低查询效率。因此可以使用嵌套结果进行关联查询。

	
	    	select p.id, p.name, p.sex, p.age, p.card_id, c.`CODE` from tb_person p, 
            tb_idcard c where c.id=p.card_id 
            and p.id=#{id}
	
	
		
		
		
		
		
			
			
		
	

2、一对多关系使用中的子元素

案例：以用户和订单为案例，一个用户可以拥有多个订单（一对多），同样多个订单也可以同属于一个用户（多对一）。

1、创建用户表和订单表

CREATE TABLE tb_user(
	id INT(32) PRIMARY KEY AUTO_INCREMENT,
	username VARCHAR(32),
	address VARCHAR(256)
);
CREATE TABLE tb_order(
	id INT(32) PRIMARY KEY AUTO_INCREMENT,
	number VARCHAR(32) NOT NULL,
	user_id INT(32),
	FOREIGN KEY(user_id) REFERENCES tb_user(id)	
);

2、实体类

@Data
public class Orders{
	private Integer id; //订单id
	private String number； //订单编号
}

@Data 
public class User{
	private Integer id;      //用户编号
	pirvate String username; //用户姓名
	private String address;  //用户地址
	private List ordersList; //用户关联订单
}

3、映射文件

	
	    SELECT
        	u.*,
	        o.id AS orders_id,
        	o.number 
            FROM
        	tb_user u,
        	tb_order o 
            WHERE
        	u.id = o.user_id 
            AND u.id = #{id}
	
	
		
		
		
		
		
			
			
		
	

3、多对多关联查询

案例：以订单和商品为例，一个订单可以包含多个商品，而一种商品又可以属于多个订单，因此订单和商品就是多对多的关系。

在数据库中多对多的关系通过一个中间表进行维护。

1、创建商品表，订单表，中间表

CREATE TABLE tb_product(
	id INT(32) PRIMARY KEY AUTO_INCREMENT,
	name VARCHAR(32),
	price DOUBLE
);

CREATE TABLE tb_order(
	id INT(32) PRIMARY KEY AUTO_INCREMENT,
	number VARCHAR(32) NOT NULL,
	user_id INT(32),
	FOREIGN KEY(user_id) REFERENCES tb_user(id)	
);

CREATE TABLE tb_ordersitem(
	id INT(32) PRIMARY KEY AUTO_INCREMENT,
	orders_id INT(32),
	product_id INT(32),
	FOREIGN KEY(orders_id) REFERENCES tb_order(id),
	FOREIGN KEY(product_id) REFERENCES tb_product(id)
);

2、实体类

@Data
public class Product{
	private Integer id;      //商品编号
	private String name;     //商品名称
	private Integer price;   //商品价格
	private List ordersList; //与订单的关联属性
}

@Data
public class Orders{
        private Integer id; //订单id
	private String number； //订单编号
	private List productList; //与商品的关联属性
}

3、映射文件

		SELECT
        	o.*,
        	p.id AS pid,
        	p.NAME,
        	p.price
        FROM
        	tb_order o,
        	tb_product p,
        	tb_ordersitem oi 
        WHERE
        	oi.orders_id =o.id
        	AND oi.product_id=p.id
        	AND o.id = #{id}
	
	
		
		
		
			
			
			
		
	

文章参考《Java EE企业级应用开发教程》