MyBatis--06--多表查询

原创 于 2020-07-14 09:34:58 发布 · 435 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了ORM中的一对一、一对多、多对多关联映射方法，包括实体类设计、MyBatis配置文件编写及SQL语句优化，帮助读者深入理解并掌握ORM在实际项目中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

示例：用户与账户

一个用户可以有多个账户。
一个账户只能属于一个用户（多个账户也可以属于一个用户）。

步骤：

  1. 建立两张表：用户表和账户表
    让用户表和账户表之间具备一对多的关系：在账户表中添加外键。
  2. 建立两个实体类：用户实体类和账户实体类
  3. 建立两个配置文件：用户配置文件、账户配置文件
  4. 实现配置：
    查询用户时，同时得到该用户下所包含账户信息。
    查询账户时，同时得到账户所属用户信息。

1、 创建表：

CREATE TABLE `account` (
  `ID` INT(11) NOT NULL COMMENT '编号',
  `UID` INT(11) DEFAULT NULL COMMENT '用户编号',
  `MONEY` DOUBLE DEFAULT NULL COMMENT '金额',
  PRIMARY KEY  (`ID`),
  KEY `FK_Reference_8` (`UID`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2、实体类

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

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
}

一对一（多对一）

方法一（不常用）：

定义AccountUser 类

public class AccountUser extends Account {
    private String username;
    private String address;
}

接口

public interface IAccountDao {
	//查询所有账户，同时获取账户的所属用户名称以及它的地址信息
	List<AccountUser> findAllAccount();
}

配置文件
IAccountDao.xml：
因为查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型设置为 AccountUser 类型，这样就可以接收账户信息和用户信息了。

<?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.jess.dao.IAccountDao">
    <!--查询所有账户同时包含用户名和地址信息-->
    <select id="findAllAccount" resultType="accountuser">
        select a.*,u.username,u.address from account a , user u where u.id = a.uid;
    </select>
</mapper>

创建 AccountTest 测试类

public class AccountTest {
	private InputStream in ;
	private SqlSessionFactory factory;
	private SqlSession session;
	private IAccountDao accountDao;
	@Test
	public void testFindAll() {
	//执行操作
	List<AccountUser> accountusers = accountDao.findAll();
	for(AccountUser au : accountusers) {
		System.out.println(au);
	}
}

方法二

使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的

public class Account implements Serializable {
	private Integer id;
	private Integer uid;
	private Double money;
	private User user;  //加入User属性
}

修改接口：
注意：第二种方式，将返回值改为了 Account 类型。
因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息。

public interface IAccountDao {
	/**
	* 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
	*/
	List<Account> findAll();
}

重新定义 AccountDao.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.jess.dao.IAccountDao">
	<!-- 建立对应关系 -->
	<resultMap type="account" id="accountMap">
		<id column="aid" property="id"/>
		<result column="uid" property="uid"/>
		<result column="money" property="money"/>
		<!-- 它是用于指定从表方的引用实体属性的 -->
		<association property="user" javaType="user">
			<id column="id" property="id"/>
			<result column="username" property="username"/>
			<result column="sex" property="sex"/>
			<result column="birthday" property="birthday"/>
			<result column="address" property="address"/>
		</association>
	</resultMap>
	<select id="findAll" resultMap="accountMap">
		select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id;
	</select>
</mapper>

在 AccountTest 类中加入测试方法

@Test
public void testFindAll() {
	List<Account> accounts = accountDao.findAll();
	for(Account au : accounts) {
		System.out.println(au);
		System.out.println(au.getUser());
	}
}

一对多

查询所有用户信息及用户关联的账户信息。

User 类加入 List

public class User implements Serializable {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
	private List<Account> accounts;
}

用户Dao 接口加入方法

List<User> findAll();

用户持久层 Dao 映射文件配置

<?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.jess.dao.IUserDao">
	<resultMap type="user" id="userMap">
		<id column="id" property="id"></id>
		<result column="username" property="username"/>
		<result column="address" property="address"/>
		<result column="sex" property="sex"/>
		<result column="birthday" property="birthday"/>
		<!-- collection 是用于建立一对多中集合属性的对应关系
		ofType 用于指定集合元素的数据类型
		-->
		<collection property="accounts" ofType="account">
			<id column="aid" property="id"/>
			<result column="uid" property="uid"/>
			<result column="money" property="money"/>
		</collection>
	</resultMap>
	<!-- 配置查询所有操作 -->
	<select id="findAll" resultMap="userMap">
		select u.*,a.id as aid ,a.uid,a.money from user u left outer join account
		a on u.id =a.uid
	</select>
</mapper>

collection：定义了用户关联的账户信息。表示关联查询结果集
property="" ：关联查询的结果集存储在 User 对象的上哪个属性。
ofType=“account” ：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

测试方法：

public void testFindAll() {
	//执行操作
	List<User> users = userDao.findAll();
	for(User user : users) {
		System.out.println("-------每个用户的内容---------");
		System.out.println(user);
		System.out.println(user.getAccounts());
	}
}

多对多

示例：用户与角色

一个用户可以有多个角色，一个角色属于多个用户

1、在MySQL 数据库中添加角色表，用户表
（多对多的关系需要使用中间表，中间表中包含各自的主键，其在中间表中是外键）

中间表
CREATE TABLE `user_role` (
  `UID` int(11) NOT NULL COMMENT '用户编号',
  `RID` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`UID`,`RID`),
  KEY `FK_Reference_10` (`RID`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `role` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
  `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
  PRIMARY KEY  (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

实现Role到User的多对多

建立实体类，都包含对方一个集合引用

public class Role implements Serializable {
	private Integer roleId;
	private String roleName;
	private String roleDesc;
	//多对多的关系映射：一个角色可以属于多个用户
	private List<User> users;
}

public interface IRoleDao {
	//查询所有角色
	List<Role> findAll();
}

编写配置文件

<?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.jess.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"></id>
			<result column="username" property="username"></result>
			<result column="address" property="address"></result>
			<result column="sex" property="sex"></result>
			<result column="birthday" property="birthday"></result>
		</collection>
	</resultMap>
	<!--查询所有-->
	<select id="findAll" 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>

测试

@Test
public void testFindAll(){
	List<Role> roles = roleDao.findAll();
	for(Role role : roles){
		System.out.println("---每个角色的信息----");
		System.out.println(role);
		System.out.println(role.getUsers());
	}
}

实现User到Role的多对多与上述方法一样，只是要注意sql语句

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值