Mybatis的多表查询

一、示例1：用户和账户       

          * 一个用户可以有多个账户

         * 一个账户只能属于一个用户（多个账户也可以属于同一个用户） 

        注：Mybatis就把多对一看成了一对一。

      1.主配置文件

         请看：https://www.cnblogs.com/cqyp/p/12491801.html

      2.一对一（查询出一个账户所对应一个用户）

          1）创建Account的实体类以及接口：              

    private Integer id;
    private Integer uid;
    private Double money;
    //从表实体应该包含一个主表实体的对象引用
    private User user;
 
//set、get方法

        2）创建user的实体类以及接口：

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

//set、get方法

       3）配置IAccountDao.xml文件       

<mapper namespace="com.li.dao.IAccountDao">
    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="aid"></id>
        <result column="uid" property="uid"></result>
        <result property="money" column="money"></result>
        <!--一对一的关系映射，配置封装user内容
         property:要封装的属性名称,和实体类中的名称一致
         column:通过uid去查找
         javaType:封装到那个实体
        -->
        <association property="user" column="uid" javaType="user">
            <id property="id" column="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>
        </association>
    </resultMap>
<!--查询所有-->
<!--resultType：封装到那个结果集，返回值的类型-->
    <select id="findAll" resultMap="accountUserMap">
       SELECT u.*,a.id AS aid,a.uid,a.money FROM account a,USER u WHERE a.uid=u.id;
    </select>

       4）测试        

 @Test
    public void testFindAll() {
        //5.执行查询所有的方法
        List<Account> accounts = accountDao.findAll();
        accounts.forEach(account -> 
        {
            System.out.println("-------------");
            System.out.println(account);
            System.out.println(account.getUser());
        });
    }

     3.一对多（查询出一个用户以及所对应的多个账户）

        1）创建Account的实体类：       

  private Integer id;
    private Integer uid;
    private Double money;

//set、get方法

        2）创建User的实体类

private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

//一对多映射：主表实体应该包含从表实体的集合引用

private List<Account> accounts //set、get方法

       3）配置IAccountDao.xml文件

<mapper namespace="com.li.dao.IUserDao">
    <!--定义User的resultMap-->
    <resultMap id="userAccountMap" type="user">
        <id property="id" column="id"/>
        <result column="username" property="username"/>
        <result column="address" property="address"/>
        <result column="sex" property="sex"/>
        <result column="birthday" property="birthday"/>
        <!--配置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>
    </resultMap>


    <!--查询所有-->
    <!--resultType：封装到那个结果集，返回值的类型-->
    <select id="findAll" resultMap="userAccountMap">
        select * from user u left join account a on u.id = a.uid
    </select>
</mapper>

        4)测试        

@Test
    public void findAllTest(){
        List<User> userList= userDao.findAll();
        userList.forEach(user -> {

            System.out.println(user);
            System.out.println(user.getAccounts());
        });

    }

二、示例2：用户和角色

                一个用户可以有多个角色

               一个角色可以赋予多个用户

           注意：需要有中间表

       1.多对多（用户角色关系）

           1）创建角色的实体类以及接口             

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

          2）创建用户的实体另外i以及接口

          

 private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;
    //多对多的关系映射：一个用户具备多个角色
    private List<Role> roles;

           3）从角色到用户（查询所有角色对应的用户）

   

<mapper namespace="com.li.dao.IRoleDao">
    <resultMap id="roleMap" type="role">
        <id property="roleId" 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="address" column="address"/>
            <result property="sex" column="sex"/>
            <result property="birthday" column="birthday"/>
        </collection>
    </resultMap>
    <select id="findAll" resultMap="roleMap">
    select u.*,r.id as rid,r.role_name,r.role_desc from role r
    left join user_role ur on r.id=ur.rid
    left join user u on u.id=ur.uid
    </select>
</mapper>

       4）从用户到角色（查询所有用户对应的角色）

<mapper namespace="com.li.dao.IUserDao">
    <resultMap id="userMap" type="user">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="address" column="address"/>
        <result property="sex" column="sex"/>
        <result property="birthday" column="birthday"/>
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"/>
            <result property="roleName" column="role_name"/>
            <result property="roleDesc" column="role_desc"/>
        </collection>
    </resultMap>
    <!--查询所有-->
    <!--resultType：封装到那个结果集，返回值的类型-->
    <select id="findAll" resultMap="userMap">
        select u.*,r.id as rid,r.role_name,r.role_desc from user u
        left join user_role ur on u.id=ur.uid
        left join role r on r.id=ur.rid
    </select>
</mapper>