Mybatis - 多表查询

其他 2020-03-19 22:47:46 阅读次数: 0

Mybatis的多表查询

1. 一对多

现在以用户和账户为例子，一个用户可以有多个账户，一个账户只能属于一个用户

创建用户表

# 创建用户表
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','女','北京修正');

创建账户表，外键为uid，关联用户表的id

# 创建账户表，外键为uid，关联用户表的id
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);

账户实体类 Account

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

用户实体类User

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

我们希望在查询Account的时候把账户对应的User也查询出来，我们的sql语句应该这样写

SELECT U.*, a.id AS aid, a.uid, a.money from account a, user u WHERE a.uid = u.id;

同时对账户实体类 Account 增加成员变量 User 来接收查询出的用户信息（从表实体应该包含一个主表实体的对象引用）

@Data
public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //从表实体应该包含一个主表实体的对象引用
    private User user;
}

接口方法

public interface AccountMapper {
    /**
     * 查询所有账户，带有用户信息
     *
     * @return
     */
    List<Account> listAllAcounts();
}

Mapper映射

<?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.minifull.mapper.AccountMapper">
    <!-- 定义可以封装带有User的Account的 resultMap -->
    <resultMap id="AccountWithUserMap" type="com.minifull.pojo.Account">
        <id property="id" column="aid"/>
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
        <!-- 关联 User 对象 -->
        <association property="user" javaType="com.minifull.pojo.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="sex" column="sex"/>
            <result property="birthday" column="birthday"/>
            <result property="address" column="address"/>
        </association>
    </resultMap>
    <!-- 配置查询所有账户，带有用户信息 -->
    <select id="listAllAccounts" resultMap="AccountWithUserMap">
        SELECT U.*, a.id AS aid, a.uid, a.money from account a, user u WHERE a.uid = u.id
    </select>
</mapper>

那如果返过来要在查询用户的时候，如果用户拥有账户，那么也要把账户信息展示出来。那么又该如何实现？

对用户实体类 User 进行修改，为其增加成员变量 accounts 来接收查询出的账户信息（主表实体应该包含从表实体的集合引用）

@Data
public class User implements Serializable {
    // 其他成员省略不展示...

    /**
     * 一对多关系映射：主表实体应该包含从表实体的集合引用
     */
    private List<Account> accounts;

修改映射文件

<mapper namespace="com.minifull.mapper.UserMapper">
    <!-- 配置 resultMap ，完成实体类与数据库表的映射 -->
    <resultMap id="UserWithAccountsMap" type="com.minifull.pojo.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="sex" column="sex"/>
        <result property="birthday" column="birthday"/>
        <result property="address" column="address"/>
        <!-- 配置user对象中accounts集合的映射 -->
        <collection property="accounts" ofType="com.minifull.pojo.Account">
            <id property="id" column="aid"/>
            <result property="uid" column="uid"/>
            <result property="money" column="money"/>
        </collection>
    </resultMap>
    <!-- 配置查询所有用户，并且带有账户信息 -->
    <select id="listAllUsers" resultMap="UserWithAccountsMap">
        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 ></collection > 用于一对多映射，其中的 property 属性表示要关联的集合，ofType 表示集合中的实体类的全限定类名

2. 多对多

以用户和角色为例子，一个用户可以有多个角色，一个角色可以赋予多个用户
需求：

  • 查询用户的时候可以把用户所拥有的角色信息展示出来
  • 查询角色的时候可以把角色所赋予的用户信息展示出来

role角色表

# 创建角色表
DROP TABLE IF EXISTS `role`;
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;
# 添加角色数据
insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');

中间表

DROP TABLE IF EXISTS `user_role`;
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;
# 添加用户角色数据
insert  into `user_role`(`uid`,`rid`) values (41,1),(45,1),(41,2);

修改用户实体类 User ，并添加角色实体类 Role，为了能体现出多对多的关系，两个实体类都必须包含对方的一个集合引用（多对多关系其实我们看成是双向的一对多关系）

@Data
public class User implements Serializable {
    /**
     * 多对多关系映射：包含对方的集合引用
     */
    private List<Role> roles;


@Data
public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;
    /**
     * 多对多关系映射：持有对方集合引用
     */
    private List<User> users;
}

第一个需求：查询用户的时候可以把用户所拥有的角色信息展示出来，那么这样子的话 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 ur.rid = r.id;

编写接口层和映射文件

/**
 * 查询所有用户信息，包含用户所拥有的角色信息
 * @return
 */
List<User> listUsersWithRoles();


<mapper namespace="com.minifull.mapper.UserMapper">
    <resultMap id="UserWithRolesMap" type="com.minifull.pojo.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="sex" column="sex"/>
        <result property="birthday" column="birthday"/>
        <result property="address" column="address"/>
        <!-- 配置user对象中roles集合的映射 -->
        <collection property="roles" ofType="com.minifull.pojo.Role">
            <id property="roleId" column="rid"/>
            <result property="roleName" column="role_name"/>
            <result property="roleDesc" column="role_desc"/>
        </collection>
    </resultMap>
    <!-- 查询所有用户，并且带有角色信息 -->
    <select id="listUsersWithRoles" resultMap="UserWithRolesMap">
        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 ur.rid = r.id
    </select>
</mapper>

第二个需求是查询角色的时候可以把角色所赋予的用户信息展示出来，其实一样的操作，只不过是 SQL 语句发生了变化，上个需求是确保用户信息全部展示，而这个需求是确保所有角色全部展示，所以这里应该用 role 表作为左表来连接另外两张表

接口层代码及映射文件如下

public interface RoleMapper {
    /**
     * 查询所有角色，带有用户信息
     *
     * @return
     */
    List<Role> listAllRoles();
}

<mapper namespace="com.minifull.RoleMapper">

    <resultMap id="RoleWithUsersMap" type="com.minifull.pojo.Role">
        <id property="roleId" column="rid"/>
        <result property="roleName" column="role_name"/>
        <result property="roleDesc" column="role_desc"/>
        <!-- 配置role对象中users集合的映射 -->
        <collection property="users" ofType="com.minifull.pojo.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="sex" column="sex"/>
            <result property="birthday" column="birthday"/>
            <result property="address" column="address"/>
        </collection>
    </resultMap>

    <!-- 查询所有角色，并且带有用户信息 -->
    <select id="listAllRoles" resultMap="RoleWithUsersMap">
        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 ur.uid = u.id
    </select>
</mapper>
今天又学java了
发布了167 篇原创文章 · 获赞 3 · 访问量 5401
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_43907800/article/details/104883646
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022