Mybatis_09多表查询之多对多

最新推荐文章于 2022-12-29 22:53:00 发布
最新推荐文章于 2022-12-29 22:53:00 发布
阅读量174 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42390340/article/details/107776297
版权

文章目录

第一步：编写角色到用户一对多

1、引入

问题： 查询角色获取角色下的用户信息

实现： Role 到 User 多对多

需求： 实现查询所有角色并且加载它所分配的用户信息。

分析： 查询角色我们需要用到Role表，但角色分配的用户信息我们不能直接找到用户信息而是要通过中间表(user_role表)才能关联到用户信息。

编写步骤

1、建立两张表：用户表，角色表
	让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，
	在中间表中是外键。
2、建立两个实体类：用户实体类和角色实体类
	让用户和角色的实体类能体现出多对多的关系
	各自包含对方一个集合引用
	
	代码部分：添加属性角色实体类包含用户实体类
		//多对多的关系映射：一个角色可以赋予多个用户
		private List<User> users;
		public void setUsers(List<User> users) {
			this.users = users;
		}
		public List<User> getUsers() {
			return users;
		}
		/
3、建立两个配置文件
	用户的配置文件
	角色的配置文件（角色配置中包含用户配置信息，利用collection标签包含）
	<!-- 定义Role的resultMap -->
	<resultMap id="roleMap" type="role">
		<id property="roleId" column="rid"></id>
		<result property="roleName" column="role_name"></result>
		<result property="roleDesc" column="role_desc"></result>
		<collection property="users" ofType="user">
			<id column="id" property="id"/>
			<result column="username" property="username"/>
			<result column="birthday" property="birthday"/>
			<result column="address" property="address"/>
			<result column="sex" property="sex"/>
			
		</collection>
	</resultMap>

4、实现配置
	当我们查询用户时，可以同时得到用户所包含的角色信息
	当我们查询角色时，可以同时得到角色的所赋予的用户信息（采用左连接将三个表连接起来）
	<!-- 查询所有 -->
	<select id="findRolelAll" resultMap="roleMap">
		select u.*,r.id as rid,r.role_name,r.role_desc from role r left outer join user_role ur on r.id=ur.rid 
		left outer join user u on u.id=ur.uid
	</select>

2、编写实体类

public class User implements Serializable{
	private Integer id;
	private String username;
	//private	Date birthday;
	private String sex;
	private String address;
					···//
}

public class Role implements Serializable{
	private Integer roleId;
	private String roleName;
	private String roleDesc;
	
	//多对多的关系映射：一个角色可以赋予多个用户
	private List<User> users;
	public void setUsers(List<User> users) {
		this.users = users;
	}
	public List<User> getUsers() {
		return users;
	}								...//
}

3、编写持久层接口

/**
 * @author 
 *	用户的持久层接口
 *	mybatis的映射配置文件位置必须和dao接口的包结构相同
 */
public interface IRoleDao {
	/**
	 * 	查询所有Role角色
	 * @return
	 */

	List<Role> findRolelAll();

}

4、编写IRoleDao.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="com.song.dao.IRoleDao">
	<!-- 配置查询所有 -->
	
	<!-- 定义Role的resultMap -->
	<resultMap id="roleMap" type="role">
		<id property="roleId" column="rid"></id>
		<result property="roleName" column="role_name"></result>
		<result property="roleDesc" column="role_desc"></result>
		<collection property="users" ofType="user">
			<id column="id" property="id"/>
			<result column="username" property="username"/>
			<!--<result column="birthday" property="birthday"/> -->
			<result column="address" property="address"/>
			<result column="sex" property="sex"/>
			
		</collection>
	</resultMap>
	
	<!-- 查询所有 -->
	<select id="findRolelAll" resultMap="roleMap">
		select u.*,r.id as rid,r.role_name,r.role_desc from role r left outer join user_role ur on r.id=ur.rid 
		left outer join user u on u.id=ur.uid
	</select>
</mapper>

在这里插入图片描述

5、编写测试类

package com.song.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.song.dao.IRoleDao;

import com.song.domain.Role;

public class RoleTest {
	private InputStream in;
	private SqlSessionFactory factory;
	private SqlSession sqlSession;
	private IRoleDao roleDao;
	
	@Before
	public void init() throws IOException {
		//1、读取配置文件
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2、创建SqlSessionFactory工厂（工厂模式）
		factory= new SqlSessionFactoryBuilder().build(in);
		//3、使用工厂生产SqlSesson对象
		sqlSession = factory.openSession(true);//手动将事务提交方式改为自动提交
		//4、使用SqlSession创建Dao接口的代理对象
		
		roleDao = sqlSession.getMapper(IRoleDao.class);
	}
	@After//用于在测试方法执行之后执行
	public void destory() throws Exception {
		//提交事务
		//sqlSession.commit();
		//6、释放资源
		sqlSession.close();
		in.close();
	}
	
	/**
	 * 查询所有角色
	 */
	@Test
	public void testfindAll() {
		List<Role> roles = roleDao.findRolelAll();
		for(Role role:roles) {
			System.out.print("这是一条记录：");
			System.out.print(role);
			System.out.println(role.getUsers());
			
		}
	}
}

6、测试结果

一个角色对应多个用户，一个用户对应多个角色。
在这里插入图片描述

第二步：编写用户到角色一对多

1、引入

问题： 查询用户获取角色信息

实现： User到 Role 多对多

需求： 实现查询所有对象并且加载它所分配的用户信息。

分析： 查询角色我们需要用到Role表，但角色分配的用户信息我们不能直接找到用户信息而是要通过中间表(user_role表)才能关联到用户信息。

编写步骤

1、建立两张表：用户表，角色表
	让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，
	在中间表中是外键。
2、建立两个实体类：用户实体类和角色实体类
	让用户和角色的实体类能体现出多对多的关系
	各自包含对方一个集合引用
	
	代码部分：添加属性用户实体类包含角色实体类
		//多对多的关系映射：一个角色可以赋予多个用户
		//多对多的关系映射：一个用户可以是多个角色
		private List<Role> roles;
		public void setRoles(List<Role> roles) {
			this.roles = roles;
		}
		public List<Role> getRoles() {
			return roles;
		}
3、建立两个配置文件
	用户的配置文件（用户配置中包含角色配置信息，利用collection标签包含）
	<!-- 配置查询所有 -->
	<resultMap type="user" id="userMap">
		<id column="id" property="id"></id>
		<result column="birthday" property="birthday"/>
		<result column="sex" property="sex"/>
		<result column="address" property="address"/>
		<result column="username" property="username"/>
		<collection property="roles" ofType="role">
			<id column="rid" property="roleId"></id>
			<result column="role_name" property="roleName"/>
			<result column="role_desc" property="roleDesc"/>
		</collection>
	</resultMap>	
	角色的配置文件

4、实现配置
	当我们查询用户时，可以同时得到用户所包含的角色信息（采用左连接将三个表连接起来）
	<!-- 查询所有 -->
	<select id="findAll" resultMap="userMap">
		select u.*,r.id as rid,r.role_name,r.role_desc from role r left outer join user_role ur on r.id=ur.rid 
		left outer join user u on u.id=ur.uid
	</select>
	当我们查询角色时，可以同时得到角色的所赋予的用户信息

2、编写实体类

public class Role implements Serializable{
	private Integer roleId;
	private String roleName;
	private String roleDesc;
	
	//多对多的关系映射：一个角色可以赋予多个用户
	private List<User> users;
	public void setUsers(List<User> users) {
		this.users = users;
	}
	public List<User> getUsers() {
		return users;
	}
					···//
}

public class User implements Serializable{
	
	private Integer id;
	private String username;
	private	Date birthday;
	private String sex;
	private String address;
	
	//多对多的关系映射：一个用户可以是多个角色
	private List<Role> roles;
	public void setRoles(List<Role> roles) {
		this.roles = roles;
	}
	public List<Role> getRoles() {
		return roles;
	}
									...//
}

3、编写持久层接口

public interface IRoleDao {
	/**
	 * 	查询所有Role角色
	 * @return
	 */

	List<Role> findRolelAll();

}

/**
 * 
 * @author 宋强
 *	用户的持久层接口
 *
 *mybatis的映射配置文件位置必须和dao接口的包结构相同
 */
public interface IUserDao {
	/**
	 * 	查询所有操作：同时获取 用户
	 */
	List<User> findAll();
}

4、编写IUserDao.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="com.song.dao.IUserDao">
	<!-- 配置查询所有 -->
		
	<!-- 定义一个User的resultMap -->
	<resultMap id="userAccountMap" type="user">
		<id property="id" column="id"></id>
		<result property="username" column="username"></result>
		<result property="address" column="address"></result>
		<result property="sex" column="sex"></result>
		<result property="birthday" column="birthday"></result>
		<!-- 配置user对象中accounts集合的映射 -->
		<collection property="accounts" ofType="account">
			<id property="id" column="aid"></id>
			<result property="uid" column ="uid"></result>
			<result property="money" column ="money"></result>
		</collection>
	</resultMap>
	
	<!-- 查询所有 -->
	<select id="findAll" resultMap="userAccountMap">
		select user.*,account.money,account.uid,account.id as aid from user left outer join account on user.id=account.uid
	</select>
	
</mapper>

编写IRoleDao.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="com.song.dao.IRoleDao">
	<!-- 配置查询所有 -->
	
	<!-- 定义Role的resultMap -->
	<resultMap id="roleMap" type="role">
		<id property="roleId" column="rid"></id>
		<result property="roleName" column="role_name"></result>
		<result property="roleDesc" column="role_desc"></result>
		<collection property="users" ofType="user">
			<id column="id" property="id"/>
			<result column="username" property="username"/>
			<result column="birthday" property="birthday"/>
			<result column="address" property="address"/>
			<result column="sex" property="sex"/>
			
		</collection>
	</resultMap>
	<!-- 查询所有 -->
	<select id="findRolelAll" resultMap="roleMap">
		select u.*,r.id as rid,r.role_name,r.role_desc from role r 
		left outer join user_role ur on r.id=ur.rid 
		left outer join user u on u.id=ur.uid
	</select>
	
</mapper>

5、编写测试类

测试类UserTest

package com.song.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.song.dao.IUserDao;
import com.song.domain.User;

public class UserTest {
	private InputStream in;
	private SqlSessionFactory factory;
	private SqlSession sqlSession;

	private IUserDao userDao;
	
	@Before
	public void init() throws IOException {
		//1、读取配置文件
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2、创建SqlSessionFactory工厂（工厂模式）
		factory= new SqlSessionFactoryBuilder().build(in);
		//3、使用工厂生产SqlSesson对象
		sqlSession = factory.openSession(true);//手动将事务提交方式改为自动提交
		//4、使用SqlSession创建Dao接口的代理对象
		
		userDao = sqlSession.getMapper(IUserDao.class);
	}
	@After//用于在测试方法执行之后执行
	public void destory() throws Exception {
		//提交事务
		//sqlSession.commit();
		//6、释放资源
		sqlSession.close();
		in.close();
	}
	
	/**
	 * 查询账户所有
	 */
	@Test
	public void testfindAllcount() {
		List<User> users = userDao.findAll();
		for(User user:users) {
			System.out.print("这是一条记录：");
			System.out.println(user);
			System.out.println(user.getAccounts());
		}
	}
}

测试结果：
一个用户对应多个角色，一个角色对应多个用户。
在这里插入图片描述

测试类RoleTest

public class RoleTest {
	private InputStream in;
	private SqlSessionFactory factory;
	private SqlSession sqlSession;
	private IRoleDao roleDao;
	
	@Before
	public void init() throws IOException {
		//1、读取配置文件
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2、创建SqlSessionFactory工厂（工厂模式）
		factory= new SqlSessionFactoryBuilder().build(in);
		//3、使用工厂生产SqlSesson对象
		sqlSession = factory.openSession(true);//手动将事务提交方式改为自动提交
		//4、使用SqlSession创建Dao接口的代理对象
		
		roleDao = sqlSession.getMapper(IRoleDao.class);
	}
	@After//用于在测试方法执行之后执行
	public void destory() throws Exception {
		//提交事务
		//sqlSession.commit();
		//6、释放资源
		sqlSession.close();
		in.close();
	}
	
	/**
	 * 查询所有角色
	 */
	@Test
	public void testfindAll() {
		List<Role> roles = roleDao.findRolelAll();
		for(Role role:roles) {
			System.out.print("这是一条记录：");
			System.out.print(role);
			System.out.println(role.getUsers());
			
		}
	}
}

测试结果
一个role对应多个用户，一个用户有多个role
在这里插入图片描述

strongsix
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mybatis多对多映射关系详解
NULL
03-23 6119
首先数据库的创建    如图user表属性orders表属性进行主外键关联如图创建ordersdemo表进行主外键关联 如图创建item表这样数据库就设计好了 测试一下 需求: 查询用户及购买商品的信息 由于用户没有和商品没有直接的关系,关系是建立在orders和orderdemo中 创建bean类 User.javapackage com.hp.bean; import java.util.L...
java配合MyBatis 多条件查询及动态SQL
06-16
在我们平常使用的时候，会出现多条件查询的情况，为了适应这种情况，我们便出现了多条件查询，作为一款优秀的orm框架——MyBatis自然是支持的。 其实，实现多条件查询的方式就是Mybatis的特色——动态SQL 动态sql ...
Mybatis 多表查询之多对多
qq_44893422的博客
09-02 140
在多对多关系中用用户和角色模型来模拟 一个用户可以用多个角色 一个角色可以被多人拥有 角色表： 用户表： 用户与角色的中间表 这里使用另外一种方法resultMap，定义专门的 resultMap 用于映射一对一查询结果。 创建用户Role的实体类 拥有属性 private int roleId; private String roleName; private String roleDesc; private List<User> users; 创建持.
mybatis关联映射（多表查询多对多）
全栈测试笔记
12-29 221
准备测试数据 教师表 SET FOREIGN_KEY_CHECKS=0; -- ---------------------------- -- Table structure for teacher -- ---------------------------- DROP TABLE IF EXISTS `teacher`; CREATE TABLE `teacher` ( `t_id`...
MyBatis多表操作-----多对多操作
qq_45325217的博客
06-23 226
MyBatis多表操作-----多对多操作 多对多操作较之前没有太大的变化，搭配好环境之后进行查询 与之前相比在Mapper层内容有一些增加 由于是多对多的关系，相对于每一个表中的数据都是一对多的关系，那么在增加字段时需要使用@Many @Result(property = "teas",column = "sid",javaType = List.class, many = @Many(select = "com.ryh.test.mapper.TeaMapper
Mybatis 多表查询（一对一，一对多，多对多）
你好，摆渡人的博客
06-29 1807
Mybatis 多表查询 一对一查询(多对一) 需求 查询所有账户信息，关联查询下单用户信息。 注意： 因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如 果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。 方式一 定义账户信息的实体类 /** * * <p>Title: Account</p> * <p>Description: 账户的实体类</p> */ public class
mybatis_test09_mybatis_Mine!_
10-04
本项目“mybatis_test09_mybatis_Mine!”显然是一份关于个人学习MyBatis的资料，旨在帮助用户深入理解和实践MyBatis的核心特性。 首先，MyBatis的安装与配置是入门的第一步。通常，我们需要在项目的pom.xml文件中...
09_MYBATIS.rar
12-22
通过对这个 "09_MYBATIS.rar" 源码的学习，你可以了解到 MyBatis 在实际项目中的应用，如何将数据库操作与业务逻辑解耦，以及如何通过注解或 XML 方式实现 SQL 的灵活编写。此外，还可以学习到如何配置 MyBatis 的...
Mybatis结果生成键值对的实例代码
08-31
在处理结果集时，MyBatis提供了多种方式将查询结果映射到Java对象，其中一种常见的方式是将结果映射为键值对（Key-Value Pair）的Map集合。本文将深入探讨如何在MyBatis中实现这一功能。 首先，要生成键值对的结果...
09_Mybatis.rar
08-29
缺点：对于复杂SQL和多表联查支持相对较弱，且不支持存储过程的参数化返回。 以上是对MyBatis框架的全面介绍，涵盖了其基本概念、使用方法以及核心特性。在实际开发中，熟练掌握MyBatis能显著提升数据库操作的效率...
mybatis系列三：一对多双向关联
08-10
NULL 博文链接：https://yuanleilei628.iteye.com/blog/2209753
mybatis多对多配置
努力明天会更好的博客
02-26 4288
mybatis多对多配置数据库配置相关配置xml配置文件和mapper、javabean 数据库配置相关配置 user表： role表： 中间表：user_role xml配置文件和mapper、javabean role.xml &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;!DOCTYPE mapper PUBLIC &
MyBatis——多对多
xingcsdnboke的博客
09-27 144
【代码】MyBatis——多对多。
mybatis的多表操作，多对多的关系配置实现
hkm的博客
01-06 216
现有两个实体类：角色类，用户类 现有三个表：角色表，用户表，角色用户关系表 其模型： 需求:使用mybatis查询所有用户的所有角色 SELECT * FROM USER u,sys_user_role ur,sys_role r WHERE u.id=ur.userId AND ur.roleId=r.id 所以在，mybatis的Mappersql.xml中的配置为： <resultMap id="userRoleMap" type="user"> <!
mybatis 一对多，多对一
JKxiaoxing的博客
08-14 1956
本文主要讲了使用Mybatis实现关联查询，分为一对一和一对多两种情况，最后并对ResultMap进行一个简要说明。 一、创建表、分析 下面是两表，一个是顾客表，一个是车票表。一个顾客可以对应多张车票，但是一张车票只能对应一个顾客 t_customer：顾客表，一个顾客可以对应多张车票 t_ticket：车票表，一张车票只能对应一个顾客 1、创建数据表及插入初始数据
Mybatis3.X的resultMap和一对多，多对多关系实例
超超超的博客
12-29 230
目前正在学习Java，想把一些学习过程中的点点滴滴记录下来，一个原因是方便自己以后使用，另一个原因是巩固一下自己的学习成果和大家分享！！ 下面我把Mybatis3.X中的复杂Sql查询给大家进行分享！ 第1集 MyBatis3.X的resultMap你知道多少 简介：讲解Mybatis的resultMap讲解 Mybatis的SQL语句返回结果有两种： resultType：查询出的字段在相...
Mybatis 中的一对一，一对多，多对多的配置原则
manleo的博客
03-02 2881
表：market_plan(营销计划(关联了用户)) market_plan_product(产品关联营销计划) market_plan_label(标签关联营销计划) market_plan_ideadata(创意素材关联营销计划) user_ideadata_activity(活动关联用户，活动关联创意素材表) user(用户表) 配置原则：A关联B，将A的resultMap关联(
MyBatis框架
weixin_45450987的博客
07-01 172
2. MyBatis框架 2.1. 作用 解决持久层数据处理的问题，主要是基于JDBC技术的原生代码比较繁琐，没有经过任何优化，开发甚至执行效率低下！ 使用MyBatis框架时，不必关心JDBC技术如何实现，只需要编写需要执行的操作的抽象方法，例如User findById(Integer id)，然后，为这个方法映射所需执行的SQL语句即可。 2.2. 第1次使用MyBatis插入数据 前提：在数据库系统中创建tedu_ums数据库，且存在t_user表 步骤1：创建项目 创建时，Artifact Id为
MyBatis 的一对一，多对多
ChineseSoftware的博客
03-16 5581
一、概述 MyBatis 中的一对多、多对一和多对多，主要就是 resultMap 中： association：一个复杂的类型关联。许多结果将包成这种类型（一对多） collection：复杂类型的集合（多对一） 这2个属性的使用，而一对多和多对一都是相互的，只是站的角度不同。 实例： 这个实例只说这2个属性的使用方法。 首先是数据库，以员工管理系统的数据库为例。 实体类： 这里只列要实现映射功能用到的类 user、role、department。 department 和 user，是一对多关
mybatis模糊查询带参数
最新发布
07-28
- *1* *2* [mybatis之模糊查询方法](https://blog.csdn.net/u013013790/article/details/122052896)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值