Mybatis多对多嵌套查询方式查询

表

1. tb_orders
2. tb_product
3. tb_ordersitem

多对多查询通常需要一个中间表来维护，中间表的id作为外键关联订单表的id，中间表的商品id作为外键关联商品表的id

我们需要在实体类Product中定义与订单相关的属性，
当然在实体类Orders中定义与产品相关的属性也是可以的，只需要知道在一个实体中定义另一个实体的属性的集合即可；
如：

public class Product {
    private Integer id;
    private String name;
    private Double price;
   // private List<Orders> orders;
//此处省略getter、setter以及toSting（）方法
}
//

又或者，你可以在Orders 实体中引入product相关属性的list集合：

public class Orders {
    private Integer id;
    private String number;
    private List<Product> productList;
    //此处省略getter、setter方法
    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", number='" + number + '\'' +
                ", productList=" + productList +
                '}';
    }
}

这里使用嵌套查询的方式实现；
接口层：（可不调用接口的方式实现，这里用@Test测试方法，接口的作用时同意了namespace的命名空间）
Mapper.UserMapper.xml如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="Mapper.UserMapper">
<!--多对多查询是实现 begin-->
    <select id="findProductById" parameterType="Integer"
            resultType="Pojo.Product">
        SELECT * from tb_product where id IN(
            SELECT product_id FROM tb_ordersitem WHERE orders_id=#{id}
        )
    </select>
    <resultMap id="OrdersWithProductResult" type="Pojo.Orders">
        <id property="id" column="id" />
        <result property="number" column="number"/>
        <collection property="productList" column="id" ofType="Pojo.Product"
                    select="Mapper.UserMapper.findProductById">
        </collection>
    </resultMap>
    <select id="findOrderWithProduct" parameterType="Integer" resultMap="OrdersWithProductResult">
        select * from tb_orders where id=#{id}
    </select>
    <!--多对多查询是实现 end-->
    
<!--多对多嵌套结果查询实现 begin-->
    <select id="findOrdersWithProduct2" resultMap="OrdersWithProductResult2"
            parameterType="Integer" >
        select o.*,p.id as pid,p.name,p.price
        from tb_orders o,tb_product p,tb_ordersitem oi
        where oi.orders_id=o.id
        and oi.product_id=p.id
        and o.id=#{id}

    </select>
    <resultMap id="OrdersWithProductResult2" type="Pojo.Orders">
        <id property="id" column="id"/>
        <result property="number" column="number"/>
        <collection property="productList" ofType="Pojo.Product">
            <id property="id" column="pid"/>
            <result property="name" column="name"/>
            <result property="price" column="price"/>
        </collection>
    </resultMap>

<!-- 多对多嵌套结果查询实现 end   -->
    </mapper>

测试代码

  @Test
    public void findOrderWithProduct(){
//        多对多查询实现
        SqlSession sqlSession = Mybatis.openSession();
        List<Orders> product=sqlSession.selectList("Mapper.UserMapper.findOrderWithProduct",1);
        System.out.println(product.toString());
        sqlSession.close();
    }

测试之前需要写一个工具类，用于建立会话工厂。
代码如下：

package Utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class Mybatis {
    static SqlSessionFactory factory;
    static {
        InputStream inputStream = null;
        String resources="mybatis-config.xml";//引入mybatis配置文件
        try{ inputStream = Resources.getResourceAsStream(resources);
            factory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace(); } }
    public static SqlSession openSession(){
        return factory.openSession();
    }}

效果