mybatis 详解（七）------一对一、一对多、多对多
前面几篇博客我们用mybatis能对单表进行增删改查操作了，也能用动态SQL书写比较复杂的sql语句。但是在实际开发中，我们做项目不可能只是单表操作，往往会涉及到多张表之间的关联操作。那么我们如何用 mybatis 处理多表之间的关联操作呢？请看本篇博客详解。
本篇详细代码：http://pan.baidu.com/s/1eSzmst8 密码：3n3o
1、一对一
我们以用户表 user 和订单表 orders 为例。设定一个订单只能由一个 用户创建，那么由订单到用户就是一对一的关系。
①、创建用户表 user 和订单表 orders
用户表 user
订单表 orders
②、创建项目工程，导入相应的 jar 包
③、创建实体类
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 表
两者之间的关联表user_role
②、建立对应的实体类
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 文件
⑤、测试
@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();
}
多对多主要是关联关系要找好，然后根据关联去查询。
mybatis 详解（七）------一对一、一对多、多对多的更多相关文章
- MyBatis 详解（一对一，一对多，多对多）
1.什么是MyBatis? MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且 ...
- mybatis 一对一 一对多 多对多
一对一 一对多 多对多
- [原创]mybatis详解说明
mybatis详解 2017-01-05MyBatis之代理开发模式1 mybatis-Dao的代理开发模式 Dao:数据访问对象 原来:定义dao接口,在定义dao的实现类 dao的代理开发模式 只 ...
- mybatis 详解（三）------入门实例（基于注解）
1.创建MySQL数据库:mybatisDemo和表:user 详情参考:mybatis 详解(二)------入门实例(基于XML) 一致 2.建立一个Java工程,并导入相应的jar包,具体目录如 ...
- Iptables详解七层过滤
<Iptables详解七层过滤> 一.防火墙简介 防火墙其实就是一个加固主机或网络安全的一个设备或者软件而已,通过防火墙可以隔离风险区域与安全区域的连接,同时不会妨碍风险区域的访问.当然需 ...
- mybatis 详解------动态SQL
mybatis 详解------动态SQL 目录 1.动态SQL:if 语句 2.动态SQL:if+where 语句 3.动态SQL:if+set 语句 4.动态SQL:choose(when,o ...
- JPA级联（一对一 一对多 多对多）注解【实际项目中摘取的】并非自己实际应用
下面把项目中的用户类中有个:一对一 一对多 多对多的注解对应关系列取出来用于学习 说明:项目运行正常 问题类:一对多.一对一.多对多 ============一对多 一方的设置 @One ...
- Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作
Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作,单表查询,多表查询 一丶表与表之间的关系 背景: 由于如果只使用一张表存储所有的数据,就会操作数 ...
- 使用NHibernate（7）-- 一对一 && 一对多 && 多对多
1, 一对一. 对于数据量比较大的时候,考虑查询的性能,肯能会把一个对象的属性分到两个表中存放:比如用户和用户资料,经常使用的一般是Id和用户名,用户资料(学校,籍贯等)是不经常被查询的,所以就会分成 ...
随机推荐
- hibernate in List查询条件 sum求和使用参考
@Override public Integer getSumZongShuByidList(List<String> idList){ Integer zongshu = 0; Stri ...
- Maven转化为Dynamic Web Module
如今Maven仍然是最常用的项目管理工具,若要将Java Web项目使用Maven进行管理,则首先需要新建Maven项目,然后将其转化为web项目. 在项目右键选择properties,然后点击左侧P ...
- 理解Hibernate事务机制，首先需要搞清楚的6个问题
问题1:到底该用getTransaction还是beginTransaction? 上图说明的问题: 第1步,调用session.getTransaction()的时候,会创建一个全新的Transac ...
- 【Android Developers Training】 34. 添加一个简单的分享行为（Action）
注:本文翻译自Google官方的Android Developers Training文档,译者技术一般,由于喜爱安卓而产生了翻译的念头,纯属个人兴趣爱好. 原文链接:http://developer ...
- 【Android Developers Training】 25. 保存文件
注:本文翻译自Google官方的Android Developers Training文档,译者技术一般,由于喜爱安卓而产生了翻译的念头,纯属个人兴趣爱好. 原文链接:http://developer ...
- C++ inline函数与编译器设置
1. 经过测试#define与inline的速度几乎没有区别. 2. inline函数更为安全,有效避免了#define二义性问题.inline是真正的函数,而#define只是在字符串意义上的宏替换 ...
- js 实现图片压缩并转换成base64(data:image/jpeg;base64)格式
<!DOCTYPE html> <html> <head> <!--by 0o晓月メ http://www.cnblogs.com/final-elysion ...
- 用maven创建工程
用maven创建工程 开始 mvn archetype:generate 遇到问题:冗长的工程原型列表和等待时间 改进 mvn archetype:generate -DarchetypeCatalo ...
- SDP
SDP语法 一个SDP描述含有会话级信息和媒体级信息.会话级信息应用于整个会话.例如:它能成为会话始发者或者会话的名字.媒体级信息作用于特殊的媒体流.例如:它能作为一个编码器给音频流编码或者是给视频流 ...
- Threejs 开发3D地图实践总结
前段时间连续上了一个月班,加班加点完成了一个3D攻坚项目.也算是由传统web转型到webgl图形学开发中,坑不少,做了一下总结分享. 1.法向量问题 法线是垂直于我们想要照亮的物体表面的向量.法线代表 ...