mybatis的多表查询（一对一，一对多，多对多）

mybatis多表查询

表之间的关系有几种：
一对多
多对一
一对一
多对多
举例：
用户和订单就是一对多
订单和用户就是多对一
一个用户可以下多个订单
多个订单属于同一个用户

​ 人和身份证号就是一对一
​ 一个人只能有一个身份证号
​ 一个身份证号只能属于一个人

​ 老师和学生之间就是多对多
​ 一个学生可以被多个老师教过
​ 一个老师可以交多个学生

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

mybatis中的多表查询

	示例：用户和账户
		一个用户可以有多个账户
		一个账户只能属于一个用户（多个账户也可以属于同一个用户）
	步骤：
		1、建立两张表：用户表，账户表
			让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加
		2、建立两个实体类：用户实体类和账户实体类
			让用户和账户的实体类能体现出来一对多的关系
		3、建立两个配置文件
			用户的配置文件
			账户的配置文件
		4、实现配置：
			当我们查询用户时，可以同时得到用户下所包含的账户信息
			当我们查询账户时，可以同时得到账户的所属用户信息

Mybatis多表查询之一对多

本次案例主要以最为简单的用户和账户的模型来分析 Mybatis 多表关系。用户为 User 表，账户为Account表。一个用户（User）可以有多个账户（Account）。具体关系如下：

一对一查询(多对一)

查询一个账单下的用户

需求

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

注意：

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

AccountDao.xml配置文件：

 <!--查询所有account和相应的用户的名字和地址-->
    <select id="findAccountUser" resultType="accountuser">
      select u.*,a.ID as aid,a.UID,a.MONEY  from user u,account a where a.UID=u.id;
       <!--   select *  from user u,account a where a.UID=u.id; -->
    </select>

注意sql语句的书写

定义 AccountUser 类

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

package com.itheima.domain;

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

    //先调用父类的toString，将Account中的信息先打印出来，在打印其对应用户信息
    @Override
    public String toString() {
        return super.toString()+"             "+"AccountUser{" +
                "username='" + username + '\'' +
                ", address='" + 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;
    }
}

测试类：

 @Test
    /*查询所有account和相应的用户的名字和地址*/
    public void testfindAccountUser(){
        //执行方法
        List<AccountUser> accountUser = accountDao.findAccountUser();
        for (Account au : accountUser) {
            System.out.println(au);
        }

    }

测试类全部，包含前期初始化和后期销毁

package com.itheima.test;


import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.domain.AccountUser;
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.IOException;
import java.io.InputStream;
import java.util.List;

public class AccountTest {
    private InputStream is;
    private SqlSession sqlSession;
    private AccountDao accountDao ;
    @Before
    public void init() throws Exception {
        //创建输入流获得数据
        is= Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建构建者和工厂
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(is);
        //创建Sqlsession对象
         sqlSession=factory.openSession();
         //使用上个对象获得dao代理对象
        accountDao = sqlSession.getMapper(AccountDao.class);
    }

    @After
    public void destroy() throws IOException {
        //提交事务
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        is.close();

    }

    /*查询所有account*/
    @Test
    public void testFindAllAccount(){
        //执行方法
        List<Account> accounts = accountDao.findAllAccount();
        for (Account account : accounts) {
            System.out.println(account);
        }

    }
    @Test
    /*查询所有account和相应的用户的名字和地址*/
    public void testfindAccountUser(){
        //执行方法
        List<AccountUser> accountUser = accountDao.findAccountUser();
        for (Account au : accountUser) {
            System.out.println(au);
        }

    }
}

实现一对一关系的另一种方法：

查询一个账单下的用户（一对一）

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

1、先在Account实体中定义一个User实体的对象的引用

 private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

2、在配置文件AccountDao.xml里写sql语句，并对结果进行封装

sql语句：

 <!--查询所有account下的用户-->
    <select id="findAllAccount" resultMap="accountUserMap">
       select u.*,a.ID as aid,a.UID,a.MONEY  from user u,account a where a.UID=u.id;
    </select>

对结果的封装：

<!--将结果封装为一个resultMap-->
    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="account">
        <!--colum是数据库中的列名，property是java程序中的-->
        <id property="ID" column="aid"></id>
        <result property="UID" column="UID"></result>
        <result property="MONEY" column="MONEY"></result>
        <!--一对一的关系映射：封装user的内容-->
        <!-- javaType用于提示封装的那个对象-->
        <association property="user" column="id" javaType="user">
            <id column="username" property="username"></id>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </association>
    </resultMap>

知识点：

1、colum里面写的是数据库的列名或者是你起的别名，property代表的是程序中的实体类中所写

2、一对一关系的映射使用 < association> < /association>,里面对应的javaType 用于提示封装的那个对象

3、编写测试类

@Test
    public void testFindAllAccount(){
        //执行方法
        List<Account> accounts = accountDao.findAllAccount();
        for (Account account : accounts) {
            System.out.println(account);
            System.out.println(account.getUser());
        }

    }

查询一个用户下对应的多个account（一对多）

1、一对多关系映射，主表实体应该包含从表实体的集合引用

private List<Account> accounts;

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

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

2、编写配置文件UserDao.xml里的sql语句，以及对结果进行封装

sql语句：

<!--查找所有用户下的所有account-->
    <select id="findAll" resultMap="userAccountMap">
         SELECT * FROM USER u LEFT OUTER JOIN account a ON a.`UID`= u.`id`;
    </select>

sql语句：left outer join … on …

表示left左边的表可以全部打印，而右边的表只打印符合条件的

封装结果：

 <!--对用户和account一对多关系的查询结果进行封装-->
    <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集合的映射-->
        <!--property集合名，ofType 集合中的类型-->
        <collection property="accounts" ofType="account">
            <!--column是数据库列名或者是起的别名， property是实体类中的-->
            <id column="aid" property="ID"></id>
            <result column="UID" property="UID"></result>
            <result column="MONEY" property="MONEY"></result>
        </collection>
    </resultMap>

知识点：

1、一对多关系映射的配置使用 < collection>< /collection>,property集合名，ofType 集合中的类型

3、编写测试类

 /*查询所有用户下的所有account*/
    @Test
    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、建立两张表：用户表和角色表

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

​ 2、建立两个实体类：用户实体类和角色实体类
让用户和角色的实体类能体现出来多对多的关系
各自包含对方一个集合引用

​ 3、建立两个配置文件
用户和角色的配置文件

4、实现配置：
当我们查询用户时，可以同时得到用户所包含的角色信息， 当我们查询角色时，可以同时得到角色所包含的用户信息

多对多其实就是两个一对多关系的组合

实现查询用户下的角色信息

1、在User实体类中引入Role的集合

 /*多对多关系，包含另一个集合引用,即一个用户可以具有多个角色*/
    private List<Role> roles;

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

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

2、在UserDao.xml中写sql查询语句，并且对结果进行封装

sql语句：

<!--查找所有用户下的roles信息-->
    <select id="findAll" resultMap="userRoleMap" >
          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>

先实现用户表user和user_role表的拼接，让user表全显示出来，再根据user_role表和role表id相等的条件，再将两者拼接起来，最后将中间表忽略不打印出来即可

封装配置

<!--配置返回结果-->
    <resultMap id="userRoleMap" type="user">
        <!--先对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="role">
            <!--property实体类中的名称， column数据库中的列名或别名（windows不区分大小写）-->
            <id property="roleId" column="rid"></id>
            <result property="roleName"  column="role_name"></result>
            <result property="roleDesc"  column="role_desc"></result>
        </collection>
    </resultMap>

3、编写测试类

  /*查询所有用户下的所有roles*/
    @Test
    public void testFindAll(){
        //执行方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("-------------------");
            System.out.println(user);
            System.out.println(user.getRoles());

        }


    }

实现查询角色下的用户信息

1、在Role实体类中引入User集合

*多对多关系，包含另一个集合引用*/
    private List<User> users;

    public List<User> getUsers() {
        return users;
    }
    public void setUsers(List<User> users) {
        this.users = users;
    }

2、在RoleDao.xml中写sql查询语句，并且对结果进行封装

sql语句：

 <!--查询所有roles下的用户信息-->
    <select id="findRoles" resultMap="roleMap">
    SELECT u.*,r.* 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>

封装配置

 <!--定义role表的ResultMap-->
    <resultMap id="roleMap" type="role">
        <!--property实体类中的名称， column数据库中的列名（windows不区分大小写）-->
        <id property="roleId" column="id"></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>

3、编写测试类

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

    }