Mybatis深入学习（5）多表查询

多表查询中的一般关系

一对一
一对多
多对多

使用配置文件建立多表查询的步骤

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

按照步骤，首先建立两张表
建立两个实体类
用户实体类

package com.tianqicode.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.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;

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

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

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

账户实体类

package com.tianqicode.domain;

public class Account {

    private Integer id;
    private Integer uid;
    private Double money;
    private User user;

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public User getUser() {
        return user;
    }

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

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                '}';
    }
}

建立配置文件
用户的配置文件

<?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">

<!-- namespace中填写UserDao的全限定类名 -->
<mapper namespace="com.tianqicode.dao.UserDao">

    <resultMap id="userAccountMap" type="user">
    	<!-- id标签代表表中的主键 -->
    	<!-- property属性中填写实体类中的对应属性，column对应查询结果的列名 -->
        <id property="id" column="id"/>
        <result property="userName" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <!--一对多的关系映射，配置user封装accounts的内容，使用collection标签-->
        <!--其中的property指的是从表的集合引用 ofType从表实体类-->
        <collection property="accounts" ofType="account">
        <!-- 由于在上面定义了一个column="id"了，所以在这里要给这个id起一个别名column="aid" -->
            <id property="id" column="aid"/>
            <result property="uid" column="uid"/>
            <result property="money" column="money"/>
        </collection>
    </resultMap>

    <!-- 配置查询所有，id属性的取值必须与dao接口的方法同名,resultType属性指明返回类型 -->
    <!-- resultType属性中准备返回类型的全限定类名 -->
    <select id="findAll" resultMap="userAccountMap">
        select * from user u left outer join account a on u.id = a.uid
    </select>
</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.tianqicode.dao.AccountDao">

    <resultMap id="accountUserMap" type="account">
        <id property="id" column="id"/>
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
        <!--一对一的关系映射，配置封装user的内容 column中指名从表的外键 property="user"指的是单个实体类的引用，使用association标签-->
        <association property="user" column="uid" javaType="user">
            <!-- 由于在上面定义了一个column="id"了，所以在这里要给这个id起一个别名column="uid" -->
            <id property="id" column="uid"/>
            <result property="userName" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
        </association>
    </resultMap>

    <select id="findAll" resultMap="accountUserMap">
        select a.*,u.* from account a,user u where a.uid=u.id;
    </select>

    <select id="findAllAccount" resultMap="accountUserMap">
        select a.*,u.username,u.address from account a,user u where u.id=a.id;
    </select>
</mapper>

dao接口
用户的dao接口

package com.tianqicode.dao;

import com.tianqicode.domain.User;

import java.util.List;

public interface UserDao {

    List<User> findAll();
}

账户的dao接口

package com.tianqicode.dao;

import com.tianqicode.domain.Account;

import java.util.List;

public interface AccountDao {

    List<Account> findAll();

    List<Account> findAllAccount();
}

测试类

package com.tianqicode;

import com.tianqicode.dao.AccountDao;
import com.tianqicode.dao.UserDao;
import com.tianqicode.domain.Account;
import com.tianqicode.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 test {

    private SqlSession session;
    private UserDao userDao;
    private AccountDao accountDao;
    private InputStream in;
    
    @Before
    public void init() throws Exception{
        //1、读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2、创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3、使用工厂生产SqlSession对象
        session = factory.openSession();
        //4、使用SqlSession创建Dao代理对象
        userDao = session.getMapper(UserDao.class);
        accountDao = session.getMapper(AccountDao.class);
    }

    @After
    public void destroy() throws Exception{
        //6、释放资源
        session.close();
        in.close();
    }

    @Test
    public void testSelect() {

        System.out.println("########查询所有########");
        List<User> users = userDao.findAll();

        for (User user : users) {
            System.out.println("--------每个用户信息--------");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }

    @Test
    public void testAccountFindAll() {

        List<Account> accounts = accountDao.findAll();
        for (Account account : accounts) {
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

    @Test
    public void testAccountFindAllAccount() {
        List<Account> accounts = accountDao.findAllAccount();
        for (Account account : accounts) {
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

}

大致总结一下思路
首先有两个有一对多关系的表，我们需要完成查询一个表的同时得到这个表的从表或主表的对应信息。
这时候首先应该想到，需要建立两个表的对应实体类。同时实体类中要体现出从表或者主表的映射关系。
那么我们如何将映射关系对象封装到相应的实体类中呢？
这时候就需要在配置文件中使用resultMap标签配置映射对象的相应信息。
配置完成后，就只需要写出sql语句将数据从数据库中查询出来，并使用resultMap属性指定resultMap标签的id，Mybatis就可以把查询到的数据封装到实体类对象以及对应的映射对象中。我们也就实现了查询一个表的同时得到这个表的从表或主表的对应信息。

多对多关系

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

准备role实体类，添加与user的多对多映射

package com.tianqicode.domain;

import java.util.List;

public class Role {

    private Integer id;
    private String roleName;
    private String roleDesc;

    //添加与user的多对多映射
    private List<User> users;

    public List<User> getUsers() {
        return users;
    }

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

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    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{" +
                "id=" + id +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}

配置roleDao接口

package com.tianqicode.dao;

import com.tianqicode.domain.Role;

import java.util.List;

public interface RoleDao {

    List<Role> findAll();
}

接下来是mapper配置文件，对多的关系使用collection其他的与一对多类似

<?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.tianqicode.dao.RoleDao">

    <resultMap id="roleUserMap" type="role">
        <!-- 给结果列起一个别名，跟下面的id区分开 -->
        <id property="id" column="rid"/>
        <result property="roleName" column="role_name"/>
        <result property="roleDesc" column="role_desc"/>
        <collection property="users" ofType="user">
            <id property="id" column="id"/>
            <result property="userName" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="roleUserMap">
        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>

单独说一下sql语句

 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

第一行是查询了user和role两个表的全部内容，因为我们不需要中间表的信息
第二行与user_role进行左外联，限定条件是 r.id = ur.rid
第三行再与user表进行左外联，限定条件是 u.id = ur.uid
这些都准备完毕之后，就可以测试了

@Test
    public void testRoleFindAll() {
        List<Role> roles= roleDao.findAll();
        for (Role role : roles) {
            System.out.println(role);
            System.out.println(role.getUsers());
        }
    }

测试结果正常，user对象也都封装进去了
下面是user的配置
在user实体类中添加role映射

//添加与role的多对多映射
    private List<Role> roles;

添加一个查询的方法

List<User> findAllAndRole();

配置文件

<?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">

<!-- namespace中填写UserDao的全限定类名 -->
<mapper namespace="com.tianqicode.dao.UserDao">

    <resultMap id="userAccountRoleMap" type="user">
        <id property="id" column="id"/>
        <result property="userName" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <!--一对多的关系映射，配置user封装accounts的内容-->
        <!--其中的property指的是从表的集合引用 ofType从表实体类-->
        <collection property="accounts" ofType="account">
            <id property="id" column="aid"/>
            <result property="uid" column="uid"/>
            <result property="money" column="money"/>
        </collection>
        <!-- 直接添加一个对多的关系映射 -->
        <collection property="roles" ofType="role">
            <!-- 给结果列起一个别名，跟上面的id区分开 -->
            <id property="id" column="rid"/>
            <result property="roleName" column="role_name"/>
            <result property="roleDesc" column="role_desc"/>
        </collection>
    </resultMap>

    <!-- 配置查询所有，id属性的取值必须与dao接口的方法同名,resultType属性指明返回类型 -->
    <!-- resultType属性中准备返回类型的全限定类名 -->
    <select id="findAll" resultMap="userAccountRoleMap">
        select * from user u left outer join account a on u.id = a.uid
    </select>

    <select id="findAllAndRole" resultMap="userAccountRoleMap">
          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>

</mapper>

这里的sql语句与上面的差不多，就不详细记录了
测试一下

@Test
    public void testFindAllAndRole() {
        List<User> users = userDao.findAllAndRole();
        for (User user : users) {
            System.out.println("--------用户信息--------");
            System.out.println(user);
            System.out.println(user.getRoles());
        }
    }

正常封装