06 Mybatis 多表查询

一、 一对一查询

建立user与account表之间的关联

public class Account implements Serializable {
    private Integer id;
    private Integer uid;  //用户的id
    private Double money;
  //getter setter
}

sql实现查询

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

定义一个实体类来接受连表查询结果集,

方式一 直接继承他们当中的一个类，如何添加另外一个类中需要的信息

public class AccountUser extends Account implements Serializable {
    private String username;
    private String address;
  //getter setter
}

List<AccountUser> findAll();

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

注意：因为上面查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型returnType的值设置为 AccountUser 类型，这样就可以接收账户信息和用户信息了。
测试

@Test
    public void testFindAll(){
        List<AccountUser> accountUsers = accountDao.findAll();
        for(AccountUser au : accountUsers){
            System.out.println(au);
        }
    }

方式二 使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个User 类的对象来代表这个账户是哪个用户的。
在account的实体类中添加user的属性

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

List<Account> findAll2();

<!-- 建立对应关系 column 中用了as -->
    <resultMap  id="accountUserMap" type="account">
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!-- 一对一的关系映射，配置封装user的内容 column：account的uid与id关联，javaType关联的实体类 -->
        <association property="user" column="uid"  javaType="user">
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="birthday" property="birthday"/>
            <result column="address" property="address"/>
        </association>
    </resultMap>

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

注意：这里的接受是用了自定义 resultMap

二、一对多查询

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

因此根据情况，可在User实体类中加入List<Account>

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

 List<User> finUserLeftJoinAccount();

<resultMap id="userAccountMap" type="user">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="address" property="address"/>
        <result column="sex" property="sex"/>
        <result column="birthday" property="birthday"/>
        <!-- collection 是用于建立一对多中集合属性的对应关系
        ofType 用于指定集合元素的数据类型-->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"/>
            <result column="uid" property="uid"/>
            <result column="money" property="money"/>
        </collection>
</resultMap>

<select id="finUserLeftJoinAccount" 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：关联查询的结果集存储在 User 对象的上哪个属性 accounts。
ofType：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

三、多对多查询

用户与角色的多对多关系模型如下：

image.png

在 MySQL 数据库中添加角色表，用户角色的中间表。
需求：实现查询所有对象并且加载它所分配的用户信息。
sql：角色表与用户角色表连接 根据角色 id -> 再与用户表连接 根据用户id

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);

编写角色实体类，里面添加用户属性

public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射：一个角色可以赋予多个用户
    private List<User> users;

    //getter setter
}

List<Role> findAll();

 <!--定义 role 表的 ResultMap-->
    <resultMap id="roleMap" type="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 column="id" property="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="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>

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

此时已经完成了三张表连接时，Role和User的一对多查询结果封装

User 到 Role的多对多

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

做法与Role 到 User 的一对多相同
首先在User实体类中，添加List<Role>