关于后端:Mybatis系列教材-六-基础-多对多

41次阅读

共计 11106 个字符，预计需要花费 28 分钟才能阅读完成。

步骤 1: 定义多对多关系
步骤 2: 表构造
步骤 3: 导入数据
步骤 4: 先运行，看到成果，再学习
步骤 5: 模拟和排错
步骤 6: 实体类
步骤 7: 映射文件
步骤 8: 批改 mybatis-config.xml
步骤 9: 查问操作
步骤 10: 建设关系
步骤 11: 删除关系
步骤 12: 批改关系
步骤 13: 可运行的我的项目
步骤 14: 练习 - 删除订单时，删除对应的订单项
步骤 15: 答案 - 删除订单时，删除对应的订单项

步骤 1 : 定义多对多关系

本知识点是基于多对一的根底上进行。
在学习之前首先要理分明多对多的关系，这里以订单 Order 和产品 Product 为例：
一张订单里 能够蕴含多种产品
一种产品 能够呈现在多张订单里
这就是多对多关系
为了维系多对多关系，必须要一个两头表。在这里咱们应用订单项 (OrderItem) 表来作为两头表

本知识点解说如何 查问多对多关系 ， 建设多对多关系 ， 删除多对多关系。

步骤 2 : 表构造

create table order_ (id int(11) NOT NULL AUTO_INCREMENT,
        code varchar(32) DEFAULT NULL,
        PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

create table order_item_(id int(11) NOT NULL AUTO_INCREMENT,
        oid int ,
        pid int ,
        number int ,
        PRIMARY KEY(id)
)AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

步骤 3 : 导入数据

在一对多关系中筹备的数据里曾经有 Product 数据里，这里就只筹备订单数据和订单项数据：
1. 插入两个订单
2. 插入 6 条订单项数据，建设如下关系
2.1 订单 1 对应产品 1，2，3
2.2 订单 2 对应产品 2，3，4

INSERT INTO order_ VALUES (1,'code000A');
INSERT INTO order_ VALUES (2,'code000B');

INSERT INTO order_item_ VALUES (null, 1, 1, 100);
INSERT INTO order_item_ VALUES (null, 1, 2, 100);
INSERT INTO order_item_ VALUES (null, 1, 3, 100);
INSERT INTO order_item_ VALUES (null, 2, 2, 100);
INSERT INTO order_item_ VALUES (null, 2, 3, 100);
INSERT INTO order_item_ VALUES (null, 2, 4, 100);

步骤 4 : 先运行，看到成果，再学习

老规矩，先下载下载区 (点击进入) 的可运行我的项目，配置运行起来，确认可用之后，再学习做了哪些步骤以达到这样的成果。

步骤 5 : 模拟和排错

在确保可运行我的项目可能正确无误地运行之后，再严格照着教程的步骤，对代码模拟一遍。
模拟过程不免代码有出入，导致无奈失去冀望的运行后果，此时此刻通过比拟 正确答案 (可运行我的项目) 和本人的代码，来定位问题所在。
采纳这种形式，学习有成果，排错有效率，能够较为显著地晋升学习速度，跨过学习路上的各个槛。

举荐应用 diffmerge 软件，进行文件夹比拟。把你本人做的我的项目文件夹，和我的可运行我的项目文件夹进行比拟。
这个软件很牛逼的，能够晓得文件夹里哪两个文件不对，并且很显著地标记进去
这里提供了绿色装置和应用教程：diffmerge 下载和应用教程

步骤 6 : 实体类

实体类 Order 和 OrderItem

  • OrderItem.java
  • Order.java
package com.how2java.pojo;

public class OrderItem {
    private int id;
    private int number;
    private Order order;
    private Product product;
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public int getNumber() {return number;}
    public void setNumber(int number) {this.number = number;}
    public Order getOrder() {return order;}
    public void setOrder(Order order) {this.order = order;}
    public Product getProduct() {return product;}
    public void setProduct(Product product) {this.product = product;}

}
package com.how2java.pojo;

import java.util.List;

public class Order {
    private int id;
    private String code;

    List<OrderItem> orderItems;

    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public String getCode() {return code;}
    public void setCode(String code) {this.code = code;}
    public List<OrderItem> getOrderItems() {return orderItems;}
    public void setOrderItems(List<OrderItem> orderItems) {this.orderItems = orderItems;}

}

步骤 7 : 映射文件

对于映射文件的 sql 语句阐明在后续测试的时候会解说

  • Order.xml
  • Product.xml
  • OrderItem.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="com.how2java.pojo">
    <resultMap type="Order" id="orderBean">
        <id column="oid" property="id" />
        <result column="code" property="code" />

        <collection property="orderItems" ofType="OrderItem">
            <id column="oiid" property="id" />
            <result column="number" property="number" />
            <association property="product" javaType="Product">
                <id column="pid" property="id"/>
                <result column="pname" property="name"/>
                <result column="price" property="price"/>
            </association>
        </collection>
    </resultMap>

    <select id="listOrder" resultMap="orderBean">
            select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
                from order_ o
                left join order_item_ oi    on o.id =oi.oid
                left join product_ p on p.id = oi.pid
        </select>

    <select id="getOrder" resultMap="orderBean">
            select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
                from order_ o
                left join order_item_ oi on o.id =oi.oid
                left join product_ p on p.id = oi.pid
            where o.id = #{id}
        </select>
</mapper>
        <?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="com.how2java.pojo">
<resultMap type="Product" id="productBean">
    <id column="pid" property="id" />
    <result column="pname" property="name" />
    <result column="price" property="price" />

    <!-- 多对一的关系 -->
    <!-- property: 指的是属性名称, javaType：指的是属性的类型 -->
    <association property="category" javaType="Category">
        <id column="cid" property="id"/>
        <result column="cname" property="name"/>
    </association>
</resultMap>

<select id="listProduct" resultMap="productBean">
            select c.*, p.*, c.id 'cid', p.id 'pid', c.name 'cname', p.name 'pname'
                from category_ c
                left join product_ p on c.id = p.cid
        </select>
<select id="getProduct" resultMap="productBean">
            select c.*, p.*, c.id 'cid', p.id 'pid', c.name 'cname', p.name 'pname'
                from category_ c
                left join product_ p on c.id = p.cid
            where p.id = #{id}
        </select>
</mapper>
        <?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="com.how2java.pojo">

<insert id="addOrderItem" parameterType="OrderItem">
            insert into order_item_
                values(null,#{order.id},#{product.id},#{number})
        </insert>
<insert id="deleteOrderItem" parameterType="OrderItem">
            delete from order_item_
                where oid = #{order.id} and pid = #{product.id}
        </insert>

</mapper>

步骤 8 : 批改 mybatis-config.xml

增加对于 Order.xml 和 OrderItem 的映射

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.how2java.pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/how2java?characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="admin"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/how2java/pojo/Category.xml"/>
        <mapper resource="com/how2java/pojo/Product.xml"/>
        <mapper resource="com/how2java/pojo/Order.xml"/>
        <mapper resource="com/how2java/pojo/OrderItem.xml"/>
    </mappers>
</configuration>

步骤 9 : 查问操作

如图所示，查问出所有的订单，而后遍历每个订单下的多条订单项，以及订单项对应的产品名称，价格，购买数量

通过 Order.xml 的 listOrder 对应的 sql 语句进行查问：

<select id="listOrder" resultMap="orderBean">
    select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
    from order_ o
    left join order_item_ oi    on o.id =oi.oid
    left join product_ p on p.id = oi.pid
</select>

联结 order_, order_item_, product_ 三张表进行查问

<resultMap type="Order" id="orderBean">
    <id column="oid" property="id" />
    <result column="code" property="code" />

    <collection property="orderItems" ofType="OrderItem">
        <id column="oiid" property="id" />
        <result column="number" property="number" />
        <association property="product" javaType="Product">
            <id column="pid" property="id"/>
            <result column="pname" property="name"/>
            <result column="price" property="price"/>
        </association>
    </collection>
</resultMap>

查问后果 id 和 code 字段放在 Order 对象里，而后通过一对多的 <collection> 标签把 oiid 和 number 放在 OrderItem 对象里，最初把 pid,pname,price 放进 Product 对象里。

package com.how2java;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

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 com.how2java.pojo.Order;
import com.how2java.pojo.OrderItem;
import com.how2java.pojo.Product;

public class TestMybatis {public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();

        listOrder(session);

        session.commit();
        session.close();}

    private static void listOrder(SqlSession session) {List<Order> os = session.selectList("listOrder");
        for (Order o : os) {System.out.println(o.getCode());
            List<OrderItem> ois= o.getOrderItems();
            for (OrderItem oi : ois) {System.out.format("\t%s\t%f\t%d%n", oi.getProduct().getName(),oi.getProduct().getPrice(),oi.getNumber());
            }
        }
    }
}

步骤 10 : 建设关系

如图所示，建设了让订单 000A 和产品 z 建设了关系
首先通过 id 别离获取 Order 对象和 Product 对象，而后创立一个新的 OrderItem 对象，接着设置 Order，设置 Product，设置数量，最初调用 ”addOrderItem” 对应的 sql 语句插入数据。

Order o1 = session.selectOne("getOrder", 1);
Product p6 = session.selectOne("getProduct", 6);
OrderItem oi = new OrderItem();
oi.setProduct(p6);
oi.setOrder(o1);
oi.setNumber(200);
session.insert("addOrderItem", oi);

addOrderItem 调用 insert into 语句插入一条 OrderItem 记录

<insert id="addOrderItem" parameterType="OrderItem">
    insert into order_item_
    values(null,#{order.id},#{product.id},#{number})
</insert>


package com.how2java;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

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 com.how2java.pojo.Order;
import com.how2java.pojo.OrderItem;
import com.how2java.pojo.Product;

public class TestMybatis {public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();

        addOrderItem(session);
        listOrder(session);

        session.commit();
        session.close();}

    private static void addOrderItem(SqlSession session) {Order o1 = session.selectOne("getOrder", 1);
        Product p6 = session.selectOne("getProduct", 6);
        OrderItem oi = new OrderItem();
        oi.setProduct(p6);
        oi.setOrder(o1);
        oi.setNumber(200);

        session.insert("addOrderItem", oi);
    }

    private static void listOrder(SqlSession session) {List<Order> os = session.selectList("listOrder");
        for (Order o : os) {System.out.println(o.getCode());
            List<OrderItem> ois = o.getOrderItems();
            for (OrderItem oi : ois) {System.out.format("\t%s\t%f\t%d%n", oi.getProduct().getName(), oi.getProduct().getPrice(),
                        oi.getNumber());
            }
        }
    }
}
步骤 11 : 删除关系

步骤 11 : 删除关系

如图所示，删除了订单 00A 和产品 z 的关系，再次查问，就看不到产品 z 了。
删除关系的时候，通过订单 id(1)和产品 id(6)进行删除。
其实所谓的删除关系，就是删除掉 OrderItem 记录。

package com.how2java;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

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 com.how2java.pojo.Order;
import com.how2java.pojo.OrderItem;
import com.how2java.pojo.Product;

public class TestMybatis {public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();

        deleteOrderItem(session);
//        addOrderItem(session);
        listOrder(session);

        session.commit();
        session.close();}

    private static void deleteOrderItem(SqlSession session) {Order o1 = session.selectOne("getOrder",1);
        Product p6 = session.selectOne("getProduct",6);
        OrderItem oi = new OrderItem();
        oi.setProduct(p6);
        oi.setOrder(o1);
        session.delete("deleteOrderItem", oi);
    }

    private static void addOrderItem(SqlSession session) {Order o1 = session.selectOne("getOrder",1);
        Product p6 = session.selectOne("getProduct",6);
        OrderItem oi = new OrderItem();
        oi.setProduct(p6);
        oi.setOrder(o1);
        oi.setNumber(200);

        session.insert("addOrderItem", oi);
    }

    private static void listOrder(SqlSession session) {List<Order> os = session.selectList("listOrder");
        for (Order o : os) {System.out.println(o.getCode());
            List<OrderItem> ois= o.getOrderItems();
            for (OrderItem oi : ois) {System.out.format("\t%s\t%f\t%d%n", oi.getProduct().getName(),oi.getProduct().getPrice(),oi.getNumber());
            }
        }
    }
}

步骤 12 : 批改关系

多对多不存在批改关系的做法，就是删除旧的，而后新增一条即达到批改的成果。

步骤 13 : 可运行的我的项目

在下载区 (点击进入) 有本知识点对应的可运行我的项目下载

更多内容，点击理解：https://how2j.cn/k/mybatis/mybatis-many-to-many/1091.html

正文完
后端
发表至： 后端
2020-08-07
 0
关于后端:调试利器-gospew
关于后端:多进程和多线程应用场景
关于后端:dump基础
关于后端:超实用的14个-Spring-MVC-隐藏技巧用了都说好