MyBatis07：MyBatis嵌套查询

-- 先查询订单 
SELECT * FROM orders; 

-- 再根据订单uid外键，查询用户 
SELECT * FROM `user` WHERE id = #{订单的uid};

     /*
        一对一嵌套查询：
        查询所有订单，与此同时还要查询出每个订单所属的用户信息
     */

    public List<Orders> findAllWithUser2();

    <resultMap id="orderMap2" type="com.zwt.domain.Orders">
        <id property="id" column="id"/>
        <result property="ordertime" column="ordertime"/>
        <result property="total" column="total"/>
        <result property="uid" column="uid"/>

        <!--
            根据订单中uid外键，查询用户表
            property：属性名
            javaType：属性类型
            select：子查询语句的statementId
            column: 子查询参数 所对应的列名 
         -->
        <association property="user" javaType="com.zwt.domain.User"
                     select="com.zwt.mapper.UserMapper.findById" 
                     column="uid" />
    </resultMap>

    <!--一对一嵌套查询-->
    <select id="findAllWithUser2" resultMap="orderMap2">
        SELECT * FROM orders
    </select>

    /*
         根据id查询用户
     */
    public User findById(Integer id);

    <!--
       根据id查询用户
    -->
    <select id="findById" resultType="com.zwt.domain.User" 
            parameterType="int">
        SELECT * FROM user WHERE id = #{id}
    </select>

    /*
        一对一嵌套查询：查询所有订单及关联的用户信息
    */
    @Test
    public void test4() throws IOException {

        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);

        List<Orders> allWithUser2 = mapper.findAllWithUser2();

        for (Orders orders : allWithUser2) {
            System.out.println(orders);
        }

        sqlSession.close();
    }

-- 先查询用户 
SELECT * FROM `user`; 

-- 再根据用户id主键，查询订单列表 
SELECT * FROM orders where uid = #{用户id};

    /*
        一对多嵌套查询：
        查询所有的用户，同时还要查询出每个用户所关联的订单信息
     */
    public List<User> findAllWithOrder2();

 <!-- 一对多嵌套查询：
      查询所有的用户，同时还要查询出每个用户所关联的订单信息 -->

    <resultMap id="userOrderMap" type="com.zwt.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>

        <!--根据用户id，查询订单表-->
        <collection property="ordersList" ofType="com.zwt.domain.Orders" 
             column="id" select="com.zwt.mapper.OrderMapper.findByUid" >
        </collection>

    </resultMap>

    <select id="findAllWithOrder2" resultMap="userOrderMap">
        SELECT * FROM USER
    </select>

    /*
        根据uid查询对应订单
     */
    public List<Orders> findByUid(Integer uid);

    <select id="findByUid" parameterType="int" 
       resultType="com.zwt.domain.Orders">
        SELECT * FROM orders WHERE uid = #{uid}
    </select>

    /*
       一对多嵌套查询：查询所有用户及关联的订单信息
   */
    @Test
    public void test5() throws IOException {

        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List<User> allWithOrder2 = mapper.findAllWithOrder2();

        for (User user : allWithOrder2) {
            System.out.println(user);
        }

        sqlSession.close();
    }

-- 先查询用户 
SELECT * FROM `user`; 

-- 再根据用户id主键，查询角色列表 
SELECT * FROM role r 
INNER JOIN user_role ur ON r.`id` = ur.`rid`
WHERE ur.`uid` = #{用户id};

    /*
        多对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的角色信息
     */
    public List<User> findAllWithRole2();

    <resultMap id="userRoleMap2" type="com.zwt.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>

        <!--根据用户id，查询角色列表-->
        <collection property="roleList" ofType="com.lagou.domain.Role" 
             column="id" select="com.zwt.mapper.RoleMapper.findByUid">
        </collection>

    </resultMap>

    <!--
        多对多嵌套查询：
        查询所有的用户，同时还要查询出每个用户所关联的角色信息
    -->
    <select id="findAllWithRole2" resultMap="userRoleMap2">
        SELECT * FROM USER
    </select>

    /*
        根据用户id查询对应角色
     */
    public List<Role>  findByUid(Integer uid);

    <select id="findByUid" resultType="com.zwt.domain.Role" 
            parameterType="int">
        SELECT * FROM sys_role r 
        INNER JOIN sys_user_role ur ON ur.roleid = r.id
        WHERE ur.userid = #{uid}
    </select>

   /*
      多对多嵌套查询：查询所有用户及关联的角色信息
    */
    @Test
    public void test6() throws IOException {

        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List<User> allWithRole2 = mapper.findAllWithRole2();

        for (User user : allWithRole2) {
            System.out.println(user);
        }

        sqlSession.close();

    }