SSM(一对一、一对多、多对多的嵌套查询)

一对一：

背景：

一个订单对应一个用户，要根据订单里面的uid，把对应的用户给查询出来。

OrdersMapper:

    /**
     * 查询订单和其对应的用户 是一对一的关系
     * @return
     */
    List<Orders>findAllOrders2();

OrdersMapper.xml:

因为是一对一的，而且Order属性里面有一个User对象，是单个的，不是集合，因此咱们用的是resultMap标签里面的association标签。

association标签里面多了个select属性，以及column属性。可以理解为先把Orders表里面的uid作为参数调用UserMapper里面的findUserById()这个方法。返回的也是User,这个User就会给到Orders里面的User。

    <resultMap id="ordersMap3" type="com.findyou.entity.Orders">
        <id column="id" property="id"/>
        <result column="ordertime" property="ordertime"/>
        <result column="total" property="total"/>
        <result column="uid" property="uid"/>

        <association property="user" javaType="com.findyou.entity.User" select="com.findyou.mapper.UserMapper.findUserById" column="uid"/>
    </resultMap>

    <select id="findAllOrders2" resultMap="ordersMap3">
        select * from orders;
    </select>

UserMapper：

    /**
     * 根据userid查询用户
     * @param id
     * @return
     */
    User findUserById(int id);

UserMapper.xml:

    <!--一对一的循环嵌套-->
    <!--要是参数是int类型或者是String类型的话 是可以省略掉parameterType-->
    <select id="findUserById" parameterType="int" resultType="com.findyou.entity.User">
        select * from user where id = #{uid};
    </select>

测试和运行结果：

    /**
     * 一对一的嵌套查询
     */
    @Test
    public void test04() {
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(); /*默认的是手动的提交 如果里面的参数是true的话 就为自动提交了*/
        // 这个是获取mapper对象
        OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
        List<Orders> allOrders2 = ordersMapper.findAllOrders2();
        for (Orders orders : allOrders2) {
            System.out.println(orders);
        }
        sqlSession.close();
    }

运行流程图：

一对多：

背景：

一个用户有多个订单。

UserMapper:

    /**
     * 查询每个用户的全部订单
     * @return
     */
    List<User> findAllWithOrders2();

UserMapper.xml:

需要注意的是：user对应的订单是集合，因此用的是collection标签。

    <resultMap id="userMap2" type="com.findyou.entity.User">
        <!--这个是属性是集合的 其他对象-->
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <!--这里是一对多 属性是集合类别的 因此 用的是 collection -->
        <collection property="ordersList" ofType="com.findyou.entity.Orders"
                    select="com.findyou.mapper.OrdersMapper.findAllOrdersByUid" column="id">
        </collection>
    </resultMap>

    <select id="findAllWithOrders2" resultMap="userMap2" >
        select * from user;
    </select>

OrdersMapper:

    /**
     * 根据用户id去查询其对应的全部的订单
     * @param uid
     * @return
     */
    List<Orders>findAllOrdersByUid(int uid);

OrdersMapper.xml:

    <!--根据用户的id查询对应的全部订单-->
    <select id="findAllOrdersByUid"  parameterType="int" resultType="com.findyou.entity.Orders">
        select * from orders where uid = #{id};
    </select>

测试和运行的结果：

    /**
     * 一对多的嵌套查询
     */
    @Test
    public void test05() {
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(); /*默认的是手动的提交 如果里面的参数是true的话 就为自动提交了*/
        // 这个是获取mapper对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.findAllWithOrders2();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

 运行流程图：

多对多：

多对多可以理解为两个一对多。

背景：

查询每个用户对应的职位，职位可能是多个。多对多的嵌套查询。

UserMapper:

    /**
     * 查询全部的用户其对应的职位
     * @return
     */
    List<User>findAllWithOccupation2();

UserMapper.xml:

    <resultMap id="occupationMap2" type="com.findyou.entity.User">
        <!--这个是属性是集合的 其他对象-->
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <collection property="occupationList" ofType="Occupation"
                    select="com.findyou.mapper.OccupationMapper.findAllOccupationByUid" column="id">
        </collection>
    </resultMap>

    <select id="findAllWithOccupation2" resultMap="occupationMap2">
        select * from user;
    </select>

OccupationMapper:

    /**
     * 根据用户id查找他的职位
     * @param uid
     * @return
     */
    List<Occupation>findAllOccupationByUid(int uid);

 OccupationMapper.xml:

    <select id="findAllOccupationByUid" resultType="com.findyou.entity.Occupation" parameterType="int">
        select o.* from occupation o left join user_occupation uo on o.id = uo.occupation_id
        where uo.userid = #{uid};
    </select>

测试和运行的结果：

    /**
     * 多对多的嵌套查询
     */
    @Test
    public void test06() {
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(); /*默认的是手动的提交 如果里面的参数是true的话 就为自动提交了*/
        // 这个是获取mapper对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList= userMapper.findAllWithOccupation2();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

运行流程图：