mybatis 详解（七）——一对一、一对多、多对多编程语言

　　前面几篇博客我们用mybatis能对单表进行增删改查操作了，也能用动态SQL书写比较复杂的sql语句。但是在实际开发中，我们做项目不可能只是单表操作，往往会涉及到多张表之间的关联操作。那么我们如何用 mybatis 处理多表之间的关联操作呢？请看本篇博客详解。

　　本篇详细代码：http://pan.baidu.com/s/1eSzmst8 密码：3n3o

1、一对一

　　我们以用户表 user 和订单表 orders 为例。设定一个订单只能由一个用户创建，那么由订单到用户就是一对一的关系。

①、创建用户表 user 和订单表 orders

　　用户表 user

　　 mybatis 详解（七）------一对一、一对多、多对多编程语言

　　订单表 orders

　　 mybatis 详解（七）------一对一、一对多、多对多编程语言

②、创建项目工程，导入相应的 jar 包

　　 mybatis 详解（七）------一对一、一对多、多对多编程语言

③、创建实体类

　　User.java

package com.ys.po; 
 
public class User { 
	//用户ID 
	private int id; 
	//用户姓名 
	private String username; 
	//用户性别 
	private String sex; 
	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; 
	} 
	@Override 
	public String toString() { 
		return "User [id=" + id + ", username=" + username + ", sex=" + sex 
				+ "]"; 
	} 
}

　　Orders.java

package com.ys.po; 
 
public class Orders { 
	//订单ID 
	private int id; 
	//用户ID 
	private int userId; 
	//订单数量 
	private String number; 
	//和用户表构成一对一的关系，即一个订单只能由一个用户创建 
	private User user; 
	 
	public int getId() { 
		return id; 
	} 
 
	public void setId(int id) { 
		this.id = id; 
	} 
 
	public int getUserId() { 
		return userId; 
	} 
 
	public void setUserId(int userId) { 
		this.userId = userId; 
	} 
 
	public String getNumber() { 
		return number; 
	} 
 
	public void setNumber(String number) { 
		this.number = number; 
	} 
 
	public User getUser() { 
		return user; 
	} 
 
	public void setUser(User user) { 
		this.user = user; 
	} 
 
	@Override 
	public String toString() { 
		return "Orders [id=" + id + ", userId=" + userId + ", number=" + number 
				+ ", user=" + user + "]"; 
	} 
 
}

④、创建 OrderMapper 接口和 OrderMapper.xml 文件

　　由于我们采用 Mapper 代理加载 xxxMapper.xml 文件，这里我们重复一下 Mapper 代理所需的条件，接口和xml文件必须满足以下几个条件：

　　1、接口必须要和 xml 文件同名且在同一个包下，也就是说 xml 文件中的namespace是接口的全类名　　

　　2、接口中的方法名和xml 文件中定义的 id 一致

　　3、接口输入参数类型要和xml 中定义的 parameterType 一致

　　4、接口返回数据类型要和xml 中定义的 resultType 一致

　　详细介绍参考上一篇博客：http://www.cnblogs.com/ysocean/p/7301548.html

　　OrderMapper 接口

package one.to.one.mapper; 
 
import com.ys.po.Orders; 
import com.ys.po.User; 
 
public interface OrdersMapper { 
	/** 
	 * 方式一：嵌套结果 
	 * select * from orders o,user u where o.user_id=u.id and o.id=#{id} 
	 * @param orderId 
	 * @return 
	 */ 
	//根据订单ID查询订单和用户信息 
	public Orders selectOrderAndUserByOrderID(int orderId); 
	 
	/** 
	 * 方式二：嵌套查询 
	 * select * from order WHERE id=1;//得到user_id 
     * select * from user WHERE id=1   //1 是上一个查询得到的user_id的值 
	 * @param userID 
	 * @return 
	 */ 
	//根据订单ID得到订单信息(包含user_id) 
	public Orders getOrderByOrderId(int orderId); 
	//根据用户ID查询用户信息 
	public User getUserByUserId(int userID); 
 
}

　　OrderMapper .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="one.to.one.mapper.OrdersMapper"> 
	<!--  
	嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集 
                               封装联表查询的数据(去除重复的数据) 
     select * from orders o,user u where o.user_id=u.id and o.id=#{id} 
	 --> 
	<select id="selectOrderAndUserByOrderID" resultMap="getOrderAndUser"> 
		select * from orders o,user u where o.user_id=u.id and o.id=#{id} 
	</select> 
	<resultMap type="com.ys.po.Orders" id="getOrderAndUser"> 
		<!-- 
			id:指定查询列表唯一标识，如果有多个唯一标识，则配置多个id 
			column:数据库对应的列 
			property:实体类对应的属性名 
		  --> 
		<id column="id" property="id"/> 
		<result column="user_id" property="userId"/> 
		<result column="number" property="number"/> 
		<!--association:用于映射关联查询单个对象的信息 
			property:实体类对应的属性名 
			javaType:实体类对应的全类名 
		  --> 
		<association property="user" javaType="com.ys.po.User"> 
			<!-- 
				id:指定查询列表唯一标识，如果有多个唯一标识，则配置多个id 
				column:数据库对应的列 
				property:实体类对应的属性名 
			  --> 
			<id column="id" property="id"/> 
			<result column="username" property="username"/> 
			<result column="sex" property="sex"/> 
		</association> 
	</resultMap> 
	 
	 
	<!-- 
         方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型 
         select user_id from order WHERE id=1;//得到user_id 
         select * from user WHERE id=1   //1 是上一个查询得到的user_id的值 
         property:别名(属性名)    column：列名 --> 
    <select id="getOrderByOrderId" resultMap="getOrderMap"> 
    	select * from order where id=#{id} 
    </select> 
    <resultMap type="com.ys.po.Orders" id="getOrderMap"> 
    	<id column="id" property="id"/> 
		<result column="number" property="number"/> 
		<association property="userId"  column="id" select="getUserByUserId"> 
		 
		</association> 
    </resultMap> 
    <select id="getUserByUserId" resultType="com.ys.po.User"> 
    	select * from user where id=#{id} 
    </select> 
	 
</mapper>

⑤、向 mybatis-configuration.xml 配置文件中注册 OrderMapper.xml 文件

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> 
<configuration> 
<!-- 加载数据库属性文件 --> 
<properties resource="db.properties"></properties> 
<!-- 定义别名 --> 
<typeAliases> 
	<!-- mybatis自动扫描包中的po类，自动定义别名，别名是类名(首字母大写或小写都可以,一般用小写) --> 
	<package name="com.ys.po"/> 
</typeAliases> 
 <environments default="development"> 
    <environment id="development"> 
      <transactionManager type="JDBC"/> 
      <!--dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象源  --> 
      <dataSource type="POOLED"> 
        <property name="driver" value="${jdbc.driver}"/> 
        <property name="url" value="${jdbc.url}"/> 
        <property name="username" value="${jdbc.username}"/> 
        <property name="password" value="${jdbc.password}"/> 
      </dataSource> 
    </environment> 
  </environments> 
   
  <mappers> 
         <!-- 通过OrdersMapper接口注册OrdersMapper.xml文件，  
         	必须保证：接口和xml在同一个包下，而且名字一样 
         	OrdersMapper接口的方法名和OrdersMapper.xml文件的id一样 
         	OrdersMapper接口的输出输出参数和OrdersMapper.xml文件resultType，parameterType类型一样 
         --> 
         <mapper class="one.to.one.mapper.OrdersMapper"/>  
  </mappers> 
</configuration>

⑥、测试

package one.to.one.mapper; 
 
import java.io.InputStream; 
 
import org.apache.ibatis.session.SqlSession; 
import org.apache.ibatis.session.SqlSessionFactory; 
import org.apache.ibatis.session.SqlSessionFactoryBuilder; 
import org.junit.Before; 
import org.junit.Test; 
 
import com.ys.po.Orders; 
 
public class OneToOneTest { 
	//定义 SqlSession 
	SqlSession session =null; 
	 
	@Before 
	public void init(){ 
		//定义mybatis全局配置文件 
		String resource = "mybatis-configuration.xml"; 
		//加载 mybatis 全局配置文件 
		InputStream inputStream = OneToOneTest.class.getClassLoader() 
									.getResourceAsStream(resource); 
		//构建sqlSession的工厂 
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream); 
		//根据 sqlSessionFactory 产生 session 
		session = sessionFactory.openSession(); 
	} 
	 
	/** 
	 * 方式一：嵌套结果 
	 * select * from orders o,user u where o.user_id=u.id and o.id=#{id} 
	 */ 
	@Test 
	public void testSelectOrderAndUserByOrderId(){ 
		String statement = "one.to.one.mapper.OrdersMapper.selectOrderAndUserByOrderID"; 
		//创建OrdersMapper对象，mybatis自动生成mapepr代理对象 
		OrdersMapper orderMapper = session.getMapper(OrdersMapper.class); 
		Orders order = orderMapper.selectOrderAndUserByOrderID(1); 
		System.out.println(order); 
		session.close(); 
	} 
	 
	/** 
	 * 方式二：嵌套查询 
	 * select * from order WHERE id=1;//得到user_id 
	 * select * from user WHERE id=1   //1 是上一个查询得到的user_id的值 
	 */ 
	@Test 
	public void testgetOrderByOrderId(){ 
		String statement = "one.to.one.mapper.OrdersMapper.getOrderByOrderId"; 
		//创建OrdersMapper对象，mybatis自动生成mapepr代理对象 
		OrdersMapper orderMapper = session.getMapper(OrdersMapper.class); 
		Orders order = orderMapper.selectOrderAndUserByOrderID(1); 
		System.out.println(order); 
		session.close(); 
	} 
}

2、一对多

　　还是以用户表 user 和订单表 orders 为例，一个用户能创建多个订单。故用户和订单构成一对多的关联。

　　我们在 user.java 中添加一个属性 public List<Orders> orders;

①、创建实体类

　　user.java如下，orders.java保持不变

package com.ys.po; 
 
import java.util.List; 
 
public class User { 
	//用户ID 
	private int id; 
	//用户姓名 
	private String username; 
	//用户性别 
	private String sex; 
	//一个用户能创建多个订单，用户和订单构成一对多的关系 
	public List<Orders> orders; 
	 
	public List<Orders> getOrders() { 
		return orders; 
	} 
	public void setOrders(List<Orders> orders) { 
		this.orders = orders; 
	} 
	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; 
	} 
	@Override 
	public String toString() { 
		return "User [id=" + id + ", username=" + username + ", sex=" + sex 
				+ "]"; 
	} 
}

②、创建 UserMapper 接口和 UserMapper.xml 文件

　　UserMapper接口

package one.to.many.mapper; 
 
import com.ys.po.User; 
 
public interface UserMapper { 
	//根据用户id查询用户信息，以及用户下面的所有订单信息 
	public User selectUserAndOrdersByUserId(int UserId); 
 
}

　　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="one.to.many.mapper.UserMapper"> 
	<!--  
	方式一：嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集 
                               封装联表查询的数据(去除重复的数据) 
     select * from user u,orders o where u.id=o.user_id and u.id=#{id} 
	 --> 
	<select id="selectUserAndOrdersByUserId" resultMap="getUserAndOrders"> 
		select u.*,o.id oid,o.number number from user u,orders o where u.id=o.user_id and u.id=#{id} 
	</select> 
	<resultMap type="com.ys.po.User" id="getUserAndOrders"> 
		<!--id:指定查询列表唯一标识，如果有多个唯一标识，则配置多个id 
			column:数据库对应的列 
			property:实体类对应的属性名 --> 
		<id column="id" property="id"/> 
		<result column="username" property="username"/> 
		<result column="sex" property="sex"/> 
		<!-- 
			property:实体类中定义的属性名 
			ofType：指定映射到集合中的全类名 
		  --> 
		<collection property="orders" ofType="com.ys.po.Orders"> 
			<id column="oid" property="id"/> 
			<result column="number" property="number"/> 
		</collection> 
	</resultMap> 
</mapper>

③、向 mybatis-configuration.xml 配置文件中注册 UserMapper.xml 文件

④、测试

@Test 
public void testSelectOrderAndUserByOrderId(){ 
	String statement = "one.to.many.mapper.UserMapper.selectUserAndOrdersByUserId"; 
	//创建OrdersMapper对象，mybatis自动生成mapepr代理对象 
	UserMapper userMapper = session.getMapper(UserMapper.class); 
	User user = userMapper.selectUserAndOrdersByUserId(1); 
	System.out.println(user.getOrders().size()); 
	session.close(); 
}

3、多对多

　　这里我们以用户 user 表和角色role 表为例，假定一个用户能被分配成多重角色，而一种角色也能分给多个用户，故用户和角色构成多对多的关系。

　　需求：给定角色id，查询这个角色所属的所有用户信息

①、在数据库中建立相应的表

　　user 表和上面的保持不变

　　role 表

　　 mybatis 详解（七）------一对一、一对多、多对多编程语言

　　两者之间的关联表user_role

　　 mybatis 详解（七）------一对一、一对多、多对多编程语言

②、建立对应的实体类

　　User.java

　　Role.java

package com.ys.po; 
 
import java.util.List; 
 
public class Role { 
	private int id; 
	private String name; 
	 
	private List<User> users; 
 
	public int getId() { 
		return id; 
	} 
	public void setId(int id) { 
		this.id = id; 
	} 
 
	public String getName() { 
		return name; 
	} 
 
	public void setName(String name) { 
		this.name = name; 
	} 
 
	public List<User> getUsers() { 
		return users; 
	} 
 
	public void setUsers(List<User> users) { 
		this.users = users; 
	} 
 
}

　　User_Role.java

package com.ys.po; 
 
public class User_Role { 
	private User user; 
	private Role role; 
	public User getUser() { 
		return user; 
	} 
	public void setUser(User user) { 
		this.user = user; 
	} 
	public Role getRole() { 
		return role; 
	} 
	public void setRole(Role role) { 
		this.role = role; 
	} 
}

③、创建 UserMapper 接口和 UserMapper.xml 文件

　　UserMapper 接口

package many.to.many.mapper; 
 
import java.util.List; 
 
import com.ys.po.User; 
 
public interface UserMapper { 
	 
	//给定一个角色id，要得到具有这个角色的所有用户信息 
	public List<User> getUserByRoleId(int roleId); 
 
}

　　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="many.to.many.mapper.UserMapper"> 
	 
	<select id="getUserByRoleId" resultMap="getUserMap"> 
		select * from user_role ur,user u where ur.user_id=u.id and ur.role_id=#{id}  
	</select> 
	 
	<resultMap type="com.ys.po.User" id="getUserMap"> 
		<id column="id" property="id"/> 
		<result column="username" property="username"/> 
		<result column="sex" property="sex"/> 
	</resultMap> 
</mapper>

④、向 mybatis-configuration.xml 配置文件中注册 UserMapper.xml 文件

　　 mybatis 详解（七）------一对一、一对多、多对多编程语言

⑤、测试

@Test 
public void testGetUserByRoleId(){ 
	String statement = "many.to.many.mapper.UserMapper.getUserByRoleId"; 
	//创建OrdersMapper对象，mybatis自动生成mapepr代理对象 
	UserMapper userMapper = session.getMapper(UserMapper.class); 
	List<User> users = userMapper.getUserByRoleId(1); 
	session.close(); 
}

　　多对多主要是关联关系要找好，然后根据关联去查询。

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/tech/pnotes/14124.html

mybatis 详解（七）——一对一、一对多、多对多编程语言

1、一对一

2、一对多

3、多对多

相关推荐

发表回复