MyBatis第四天（多表查询）

当有多个mapper.xml的时候

错误写法

<mappers>
        <mapper resource="com/daniel/dao/IUserDao.xml"/>
        <mapper resource="com/daniel/dao/IAccountDao.xml"/>
 </mappers>

正确写法

 <!--指定映射配置文件的位置，映射配置文件指的是每个dao配置的文件-->
    <mappers>
        <package name="com.daniel.dao"></package>
    </mappers>

大致的demo的框架

一对一的关系映射

查询所有账户的时候同时获得当前账户的所有信息（多表查询常用方法）

sql 语句

sql 语句查询所有账户的时候同时获得当前账户的所有信息 findAll

select u.*,a.id as aid,a.uid,a.money from account a ,user u where u.id=a.uid;

sql 语句查询所有账户的时候同时获得当前账户的所地址和姓名

 select a.*,u.username,u.address from account a ,user u where u.id=a.uid;

1. 从表实体应该包含一个主表实体的对象引用

在Account类中

//从表实体应该包含一个主表实体的对象引用
    private User user;

    public User getUser() {
        return user;
    }

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

2.AccountDao的接口中

 //查询所有账户
    List<Account> findAll();

3.AccountDao的mapper中

<!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="Account">
        <id property="id" column="aid"></id>

        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>

        <!--一对一的关系映射，account配置封装user的内容 column中指名从表的外键 property="user"指的是单个实体类的引用 -->
        <association property="user" column="uid" javaType="User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
            <result property="birthday" column="birthday"></result>
        </association>
    </resultMap>

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

注意事项中的 javaType=“User” 一定要指名主体表的实体类名 然后column中指名从表的外键！！

<association property="user" column="uid" javaType="User">

4.AccountDao的测试类中

 @Test
    public void findAll(){
        List<Account> accounts = accoutDao.findAll();
        for (Account account:
             accounts) {
            System.out.println("每一个account的信息");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

5.成功运行（实现上诉功能）

第二种方法是创建一个AccountUser类

由于不常用就不细叙了

一对多的关系映射

主表实体中应该包含从表实体的集合引用

sql语句

select * from user u left outer join account a on u.id = a.uid

left join（左连接）是 left outer join的简写，返回左表中所有记录和右表中连接字段相等的记录，即返回的记录数和左表的记录数一样

1.主表实体中应该包含从表实体的集合引用

User类中

 //主表实体中应该包含从表实体的集合引用
    private List<Account> accounts;

2.UserDao的接口中

//  查询所有用户
 List<User> findAll();

3.UserDao的mapper中

 <!--定义封装user和account的resultMap type主表实体类-->
    <resultMap id="userAccountMap" type="User">

        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <result property="birthday" column="birthday"></result>

        <!--一对多的关系映射，配置user封装accounts的内容-->
        <!--其中的property指的是从表的集合引用 ofType从表实体类-->
        <collection property="accounts" ofType="Account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>
    </resultMap>

    <!--配置查询所有  其中id不能乱写必须是dao接口中的方法  -->
    <select id="findAll" resultMap="userAccountMap">
       select * from user u left outer join account a on u.id = a.uid
    </select>

4.UserDao的测试类中

//查询所有（一个用户下的账号信息）
    @Test
    public  void findAll( ) throws Exception {

        List<User> users = userDao.findAll();
        for (User user:users
             ) {
            System.out.println("每个用户的信息");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }

    }

5.成功运行（实现上诉功能）

多对多的关系映射

需要实现的功能

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

注意其中每行末尾的空格
分析 从role表中 为准的 左表( role r)中所有记录和右表（user_role ur）中连接字段相等的记录，即返回的记录数和左表的记录数一样(而且还可以输出不关联的行)再以此合并的表为基础( role r user_role ur )中连接和右表( user u )中连接字段相等的记录

多表外链接查询语句

use+数据库

select+查询列名

from+表1

left/right　(outer) join +表2

on 表2的列=表1的列

1.一个实体表中包含另一个实体表的集合引用

由于是多对多的关系所有不分从表和主表

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

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

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

2.RoleDao的接口中定义该方法

List<Role> findAll();

3.RoleDao的mapper中

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


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

4.RoleDao的测试类中

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

5.成功运行（实现上诉功能）

=同理可得功能二===

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 r.id=ur.rid

6.一个实体表中包含另一个实体表的集合引用

private List<Role> roles;

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

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

7.UserDao的接口中定义该方法

  //  查询所有
    List<User> findAll();

8.UserDao的mapper中

 <resultMap id="userMap" 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>


        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>
    </resultMap>


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

9.UserDao的测试类中

 @Test
    public  void findAll( ) throws Exception {

        List<User> users = userDao.findAll();
        for (User user:users
             ) {
            System.out.println("====每个用户的信息====");
            System.out.println(user);
            System.out.println(user.getRoles());
        }

    }

10.成功运行（实现上诉功能）