SSM之MyBatis系列（六）---- Mybatis 多表查询

Mybatis 多表查询

• 在说多表查询之前，首先要了解表之间的关系共有以下几种：
  • 一对一 ： 人和身份证就是一对一的关系。一个人只能有一个身份证号，而一个身份证号只能属于一个人。
  • 多对一（一对多）：用户和订单就是多对一（一对多）的关系。一个用户可以下多个订单。多个订单属于同一个用户。
  • 多对多 ： 学生和任课老师就是多对多的关系。一个学生可以有多个任课老师，而一个任课老师可以有多个学生。

特例：如果拿出每一个订单，它都只能属于同一个用户。
所以MyBatis就把多对一看成了一对一。

多表查询之多对一（一对多）

• 现在以用户和账户为例子，一个用户可以有多个账户，一个账户只能属于一个用户（多个账户也可以属于同个用户）。

先来看看大概的步骤：

1. 建立两张表：用户表、账户表
    让用户表和账户表之间具备一对多的关系：需要外键在账户表中添加。

2. 建立两个实体类：用户实体类和账户实体类
    让用户和账户的实体类能体现出来一对多的关系
3. 建立两个配置文件：用户的配置文件和账户的配置文件
4. 实现配置：
  当我们查询用户时，可以同时得到用户下所包含的账户信息。   当我们查询账户时，可以同时得到账户所属的用户信息。

大家开始下面的时候，最后将QueryVo类删掉，用户接口和映射文件也只保留查询所有用户和根据id查询用户两个方法，在user类中的属性名更改跟数据库一样。这样看的比较清晰，嫌麻烦的就可以继续用之前的。

• 建立两张表：
  用户表：

# 创建用户表
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
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

package com.domain;

import java.io.Serializable;

/**
 * 账户实体类
 * @author zhang
 */
public class Account implements Serializable {
    
    
    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 +
                '}';
    }
}

• 添加账户实体类对应的 Dao 接口 AccountDao以及映射文件 AccountDao.xml

package com.Dao;

import com.domain.Account;

import java.util.List;

public interface AccountDao {
    
    

    /**
     * 查询所有账户
     * @return
     */
    List<Account> finaAll();

}

<?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.Dao.AccountDao">
    <!-- 配置查询所有   -->
    <select id="findAll" resultType="account">
        select *  from account
    </select>
</mapper>

• 创建 AccountTest 测试类及运行结果:

package com.test;

import com.Dao.AccountDao;
import com.Dao.UserDao;
import com.domain.Account;
import com.domain.User;
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 java.io.InputStream;
import java.util.List;

public class AccountTest {
    
    
    private InputStream in;
    private SqlSession sqlSession;
    private AccountDao accountDao;

    /**
     * 测试之前执行，用于初始化
     */
    @Before
    public void init() throws Exception {
    
    
        //1. 读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2. 创建SqlSessionFactory工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3. 获取SqlSession对象
        sqlSession = factory.openSession();
        //4. 使用SqlSession创建Dao的代理对象
        accountDao = sqlSession.getMapper(AccountDao.class);
    }
    /**
     * 测试结束执行，用于提交事务和释放资源
     */
    @After
    public void destroy() throws Exception{
    
    
        //提交事务
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
    
    
        List<Account> accounts = accountDao.findAll();
        for (Account account : accounts){
    
    
            System.out.println(account);
        }
    }
}

运行到这里，我们可以发现，虽然可以查询出账户信息，但是这个结果并没有和用户产生关联，而我们想要的效果是查询出账户信息的同时，把所属用户信息也一并展示。那么我们该如何修改呢？

• 首先编写 SQL 语句，如果想要达到上述效果，那么 SQL 语句可以这样写：

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

为了可以接收这条语句的查询结果，那么我们应该对账户实体类Account进行修改，为其增加成员变量 User来接收查询出的用户信息（从表实体应该包含一个主表实体的对象引用）：

package com.domain;

import java.io.Serializable;
import java.util.List;

/**
 * 账户实体类
 * @author zhang
 */
public class Account implements Serializable {
    
    
	// 其他成员不展示...
    /**
     * 账户对应的用户信息,从表实体应该包含一个主表实体的对象引用
     */
    private User user;

    public User getUser() {
    
    
        return user;
    }

    public void setUser(User user) {
    
    
        this.user = user;
    }
	// 其他setter()/getter()不展示...
    @Override
    public String toString() {
    
    
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                ", user=" + user +
                '}';
    }
}

• 因为此时账户实体类 Account 已经发生了变化，所以我们应该在映射文件定义用于封装带有User信息的 Account的映射集合resultMap

<?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.Dao.AccountDao">
    <!-- 定义可以封装带有User的Account的 resultMap -->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一的关系映射：配置封装user的内容 -->
        <association property="user" column="uid" javaType="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="findAll" resultMap="accountUserMap">
        select a.*,u.username,u.address from account a , user u where u.id = a.uid;
    </select>
</mapper>

• <association></association>用于一对一映射，其中的property 属性表示要关联的属性，javaType 表示待关联的实体类的全限定类名。
• 注意，因为 SQL 语句中为 account 表的id字段起了别名 uid ，所以在定义 resultMap 的时候，记得主字段写 column="uid"，而不是 column="id"。

• 此处重新运行测试代码，可以发现查询的账户已经带有了用户信息

测试代码记得加上：System.out.println(account.getUser());

此时，假如又有了一个新的需求，就是查询用户的时候，如果用户拥有多个账户，那么也要把账户信息展示出来。那么又该如何实现？

首先还是思考 SQL 语句如何编写，由于有的用户并没有账户，所以如果采用内连接的方式查询（也就是上面的查询方式），那么会把没有账户的用户筛选掉，像下面这样：

• 因此，我们应该采用外连接的方式，使得没有账户的用户也可以查询出来：

SELECT u.*, a.id AS aid, a.uid, a.money FROM user u LEFT OUTER JOIN account a ON u.id = a.uid;

• 为了可以接收这条语句的查询结果，那么我们应该对用户实体类User 进行修改，为其增加成员变量 accounts来接收查询出的账户信息（主表实体应该包含从表实体的集合引用）：

package com.domain;

import javafx.scene.chart.PieChart;
import javafx.scene.chart.XYChart;
import java.io.Serializable;
import java.util.Date;
import java.util.List;

/**
 * @author zhang
 */
public class User implements Serializable {
    
    
    // 其他成员省略不展示...
    /**
     * 一对多关系映射：主表实体应该包含从表实体的集合引用
     */
    private List<Account> accounts;

    public List<Account> getAccounts() {
    
    
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
    
    
        this.accounts = accounts;
    }

   // 其他setter()/getter()省略不展示...
    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                ", accounts=" + accounts +
                '}';
    }
}

• 修改用户映射文件UserDao.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.Dao.UserDao">
    <!--定义user的resultMap-->
    <resultMap id="userAccountMap" type="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="account">
            <id property="id" column="aid"/>
            <result property="uid" column="uid"/>
            <result property="money" column="money"/>
        </collection>
    </resultMap>
    <!-- 配置查询所有   -->
    <select id="findAll" resultMap="userAccountMap">
        SELECT * FROM user u LEFT OUTER JOIN account a ON u.id = a.uid;
    </select>
    <!--  根据ID查询用户  -->
    <select id="findById" parameterType="java.lang.Integer" resultType="user">
        select * from user where id = #{uid}
    </select>
</mapper>

<collection ></collection >用于一对多映射，其中的property属性表示要关联的集合，ofType 表示集合中的实体类的全限定类名。

• 测试代码及运行结果如下：

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAllUser(){
    
    
        List<User> users = userDao.findAll();
        for (User user : users){
    
    
            System.out.println("每个用户的信息");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }

多表查询之多对多

• 现在以用户和角色为例子，一个用户可以有多个角色，一个角色可以赋予多个用户。
• 还是一样的需求：
  • 查询用户的时候可以把用户所拥有的角色信息展示出来。
  • 查询角色的时候可以把角色所赋予的用户信息展示出来。

步骤跟上面的一样。

1. 建立两张表：用户表、角色表
    让用户表和账户表之间具备多对多的关系：需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
2. 建立两个实体类：用户实体类和角色实体类
    让用户和角色的实体类能体现出来多对多的关系
    各自包含对方一个集合引用
3. 建立两个配置文件：用户的配置文件和角色的配置文件
4. 实现配置：
  当我们查询用户时，可以同时得到用户下所包含的角色信息。   当我们查询角色时，可以同时得到角色所赋予的用户信息。

• 搭建相关环境，由于是多对多关系，所以需要借助第三张表，导入所需数据库表：

# 创建角色表
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,'校长','管理整个学校');

# 创建用户角色表，也就是中间表
# uid 和 rid是复合主键，同时也是外键
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，为了能体现出多对多的关系，两个实体类都必须包含对方的一个集合引用（多对多关系其实我们看成是双向的一对多关系）

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

    public List<Role> getRoles() {
    
    
        return roles;
    }

    public void setRoles(List<Role> roles) {
    
    
        this.roles = roles;
    }
    
    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                ", accounts=" + accounts +
                ", roles=" + roles +
                '}';
    }

Role实体类：

package com.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 + '\'' +
                ", users=" + 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;

• 添加账户实体类对应的Dao接口RoleDao以及映射文件 RoleDao.xml

package com.Dao;

import com.domain.Role;

import java.util.List;

public interface RoleDao {
    
    
    /**
     * 查询所有角色
     * @return
     */
    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.Dao.RoleDao">
    <!--定义role表的resultMap-->
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="id"/>
        <result property="roleName" column="role_name"/>
        <result property="roleDesc" column="role_desc"/>
        <collection property="users" ofType="user">
            <id property="id" column="uid"></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="findAll" resultMap="roleMap">
        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>