AI 助理
备案控制台
开发者社区 数据库 文章 正文

Mybatis多表查询分析+示例（一对多、多对多）

2022-04-18 951
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Mybatis多表查询分析+示例（一对多、多对多）

1 Mybatis一对多查询


这里用一个例子来演示说明一对多查询，【老规矩，代码在文末】。用户为User 表，账户为Account表。一个用户（User）可以有多个账户（Account）。具体关系如下：

30.png


两张表通过用户的id值相关联。


相应的sql：


DROP TABLE IF EXISTS `user`;
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;
insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(42,'小二王','2018-03-02 15:09:37','女','北京金燕龙'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');
DROP TABLE IF EXISTS `account`;
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;
insert  into `account`(`ID`,`UID`,`MONEY`) values (1,46,1000),(2,45,1000),(3,46,2000);


1.1 一对一查询(多对一)


需求：


查询所有账户信息，关联查询下的单用户信息。


SELECT 
    account.*, 
    user.username, 
    user.address 
FROM 
    account, 
    user 
WHERE account.uid = user.id

31.png


注意：


因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。


1.1.1 方式一：创建一个新类存储两个表之间的对应关系（了解）


定义账户信息的实体类Account：


package domain;
public class Account {
    private Integer id;
    private Integer uid;
    private Double money;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getUid() {
        return uid;
    }
    public void setUid(Integer uid) {
        this.uid = uid;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                '}';
    }
}


AccountUser类：


为了能够封装上面SQL语句的查询结果，定义 AccountCustomer类中要包含账户信息同时还要包含用户信息，所以我们要在定义AccountUser类时可以继承User类。


package domain;
public class AccountUser extends Account {
    private String username;
    private String address;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return super.toString() + " AccountUser{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}


定义domain.AccountDao.java：


package dao;
import domain.Account;
import java.util.List;
public interface AccountDao {
    /**
     * 查询所有账户
     * @return
     */
    List<Account> findAll();
    /**
     * 查询所有账户，并带有用户名称和地址信息
     * @return
     */
    List<AccountUser> findAllAccount();
}


定义AccountDao.xml文件中的查询配置信息：


<select id="findAllAccount" resultType="domain.AccountUser">
    select a.*,u.username,u.address from account a, user u where a.uid = u.id;
</select>


测试类 AccountTest.java：


@Test
public void testFindAllAccountUser() {
    // 使用代理对象执行dao中的方法
    List<AccountUser> accounts = accountDao.findAllAccount();
    for (AccountUser account : accounts) {
        System.out.println(account);
    }
}


1.1.2 方式二：使用resultMap（常用）


使用resultMap，定义专门的resultMap用于映射一对一查询结果。


通过面向对象的(has a)关系可以得知，我们可以在Account类中加入一个User类的对象来代表这个账户是哪个用户的。


为Account类添加User类型的私有变量：


private User user; // 表示该账户是哪个用户的
public User getUser() { return user; } 
public void setUser(User user) { this.user = user; }


修改AccountDao.java：


List<Account> findAll();


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


重新定义 AccountDao.xml：


column是数据库表的列名，property是java程序中类的属性名


<resultMap id="accountUserMap" type="account">
    <!--account的-->
    <id property="id" column="aid"></id>
    <result property="uid" column="uid"></result>
    <result property="money" column="money"></result>
    <!--一对一的关系映射，配置封装user的内容-->
    <!--column表示是通过哪个字段获取到user的-->
    <association property="user" column="uid" javaType="domain.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>
    </association>
</resultMap>
<!--查询所有账户的同时包含对应的用户名和地址信息-->
<select id="findAll" resultMap="accountUserMap">
    select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid = u.id;
</select>


测试方法：


@Test
public void testFindAll() {
    // 使用代理对象执行dao中的方法
    List<Account> accounts = accountDao.findAll();
    for (Account account : accounts) {
        System.out.println("------------每个account信息----------");
        System.out.println(account);
        System.out.println(account.getUser());
    }
}


1.2 一对多查询


需求：


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


分析：


用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到了左外连接查询比较合适。


一对多查询的话，不管用户有没有账户都应该显示出来，所以应该使用左外连接，使得左表无论如何都查询出来。


SELECT 
    u.*, acc.id id, 
    acc.uid, acc.money 
FROM 
    user u 
LEFT JOIN account acc ON u.id = acc.uid


User类中加入List<Account>：


// 用户所持有的账户数
private List<Account> accounts;
public List<Account> getAccounts() {
    return accounts;
}
public void setAccounts(List<Account> accounts) {
    this.accounts = accounts;
}


UserDao.java中加入查询方法：


List<User> findAll();


UserDao.xml文件配置：


<!--定义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集合的映射-->
    <!--ofType指集合中元素的类型-->
    <collection property="accounts" ofType="domain.Account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
    </collection>
</resultMap>
<!-- 配置查询所有操作，查询结果封装在User类里 -->
<select id="findAll" resultMap="userAccountMap">
    select u.*,a.id as aid ,a.uid,a.money from user u left outer join account a on u.id =a.uid
</select>


collection：


定义了用户关联的账户信息。表示关联查询结果集


property="accounts"：


关联查询的结果集存储在User对象的上哪个属性。


ofType="domain.Account"：


指定关联查询的结果集中的对象类型（即List中的对象类型）。此处可以使用别名，也可以使用全限定名。


测试方法：


@Test
public void testFindAll() {
    // 使用代理对象执行dao中的方法
    List<User> users = userDao.findAll();
    for (User user : users) {
        System.out.println("--------------每个用户的信息--------------");
        System.out.println(user);
        System.out.println(user.getAccounts());
    }
}


2 Mybatis多对多查询

2.1 实现“角色”到“人”的多对多


用户可以有多个角色，角色也可以赋予多个用户。


多对多关系其实我们看成是双向的一对多关系。



步骤：


1、建立两张表：用户表，角色表


让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。


2、建立两个实体类：用户实体类和角色实体类


让用户和角色的实体类能体现出来多对多的关系


各自包含对方一个集合引用


3、建立两个配置文件


用户的配置文件


角色的配置文件


4、实现配置：


当我们查询用户时，可以同时得到用户所包含的角色信息


当我们查询角色时，可以同时得到角色的所赋予的用户信息


2.1.1 用户与角色的关系模型


32.png


在MySQL 数据库中添加角色表，用户角色的中间表。


角色表：


33.png


用户角色中间表：


34.png


2.1.2 业务要求及实现SQL


需求：


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


分析：


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


以下是SQL语句：

35.png


SELECT 
    r.*,u.id uid, 
    u.username username, 
    u.birthday birthday, 
    u.sex sex, 
    u.address address 
FROM 
    ROLE r 
INNER JOIN 
   USER_ROLE ur 
ON ( r.id = ur.rid) 
INNER JOIN 
    USER u 
ON (ur.uid = u.id);

2.1.3 具体实现


编写和角色表对应的角色实体类：


package domain;
import java.io.Serializable;
import java.util.List;
public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;
    // 多对多的关系映射，一个角色可以赋予多个用户
    private List<User> users;
    public List<User> getUsers() {
        return users;
    }
    public void setUsers(List<User> users) {
        this.users = users;
    }
    public Integer getRoleId() {
        return roleId;
    }
    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }
    public String getRoleName() {
        return roleName;
    }
    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
    public String getRoleDesc() {
        return roleDesc;
    }
    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }
    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}


相应的dao层接口 RoleDao.java：


package dao;
import domain.Role;
import java.util.List;
public interface RoleDao {
    /**
     * 查询所有角色
     * @return
     */
    List<Role> findAll();
}


映射文件 RoleDao.xml：


<mapper namespace="dao.RoleDao">
    <!--定义role表的resultMap-->
    <resultMap id="roleMap" type="domain.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 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>
        </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());
    }
}

2.2 实现从User到Role的多对多


从User出发，我们也可以发现一个用户可以具有多个角色，这样用户到角色的关系也还是一对多关系。这样我们就可以认为User与Role的多对多关系，可以被拆解成两个一对多关系来实现。


相应的sql：


SELECT u.*,r.id AS rid,r.role_name,r.role_desc FROM USER u 
LEFT OUTER JOIN user_role ur ON u.id = ur.uid 
LEFT OUTER JOIN role r ON r.id = ur.rid


给User类添加私有属性roles：


// 多对多的关系映射，一个用户可以有多个角色
private List<Role> roles;
public List<Role> getRoles() {
    return roles;
}
public void setRoles(List<Role> roles) {
    this.roles = roles;
}


映射文件UserDao.xml：


<resultMap id="userMap" 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>
    <!--配置角色集合的映射-->
    <collection property="roles" ofType="domain.Role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
    </collection>
</resultMap>
<!-- 配置查询所有操作，查询结果封装在User类里 -->
<select id="findAll" resultMap="userMap">
    SELECT u.*,r.id AS rid,r.role_name,r.role_desc FROM USER u
    LEFT OUTER JOIN user_role ur ON u.id = ur.uid
    LEFT OUTER JOIN role r ON r.id = ur.rid
</select>


测试类：


@Test
public void testFindAll() {
    // 使用代理对象执行dao中的方法
    List<User> users = userDao.findAll();
    for (User user : users) {
        System.out.println("--------------每个用户的信息--------------");
        System.out.println(user);
        System.out.println(user.getRoles());
    }
}


36.png


源码地址：


https://download.csdn.net/download/HNU_Csee_wjw/12684505


文章标签：
Java
SQL
关系型数据库
MySQL
mybatis
数据库
存储
数据库连接
关键词：
MyBatis一对多
MyBatis分析
MyBatis多表查询
MyBatis一对多多对多
MyBatis多对多
小王曾是少年
目录
相关文章
1176112968452250
|
10天前
|
SQL XML Java
mybatis-源码深入分析(一)
mybatis-源码深入分析(一)
1176112968452250
28 2
杀死一只知更鸟debug
|
7天前
|
SQL XML Java
mybatis复习04高级查询 一对多，多对一的映射处理，collection和association标签的使用
文章介绍了MyBatis中高级查询的一对多和多对一映射处理，包括创建数据库表、抽象对应的实体类、使用resultMap中的association和collection标签进行映射处理，以及如何实现级联查询和分步查询。此外，还补充了延迟加载的设置和用法。
杀死一只知更鸟debug
12 1
mybatis复习04高级查询 一对多，多对一的映射处理，collection和association标签的使用
渐暖
|
5月前
|
SQL 缓存 Java
mybatis 一对多查询
mybatis 一对多查询
渐暖
82 0
热爱技术的小郑
|
2月前
|
Java 数据库连接 mybatis
后端框架的学习----mybatis框架（9、多对一处理和一对多处理）
这篇文章介绍了在MyBatis框架中如何处理多对一和一对多的关联查询，通过定义`<resultMap>`和使用`<association>`与`<collection>`元素来实现对象间的关联映射。
热爱技术的小郑
26 1
爱你三千遍斯塔克
|
3月前
|
Java 数据库连接 mybatis
mybatis包扫描环境分析，最简单的环境准备
mybatis包扫描环境分析，最简单的环境准备
爱你三千遍斯塔克
19 0
爱你三千遍斯塔克
|
3月前
|
Java 数据库连接 Maven
Private method ‘getVideoList()‘ is never used，mybatis必须指定Mapper文件和实体目录，在参考其他人写的代码，要认真分析别人的代码，不要丢失
Private method ‘getVideoList()‘ is never used，mybatis必须指定Mapper文件和实体目录，在参考其他人写的代码，要认真分析别人的代码，不要丢失
爱你三千遍斯塔克
31 0
好奇的菜鸟
|
4月前
|
Java 数据库连接 mybatis
Mybatis基于注解的一对一和一对多查询
Mybatis基于注解的一对一和一对多查询
好奇的菜鸟
39 0
好奇的菜鸟
|
4月前
|
SQL Java 数据库连接
Mybatis中一对多mapper配置
Mybatis中一对多mapper配置
好奇的菜鸟
32 0
请回答1024
|
5月前
|
Java 关系型数据库 数据库连接
MyBatis 执行流程分析
MyBatis 执行流程分析
请回答1024
47 2
1529723250799936
|
5月前
|
Java 数据库连接 mybatis
mybatis的一对多
mybatis的一对多
1529723250799936
40 0