多对多里面的多对多 Table

Question

我有一个 Table Orders，其中包含 Products 的列表。对于与特定订单对应的每个 Products，我需要存储一个 Addresses 列表，其中单个产品（每个订单每个产品的基础）应该是交付给

+----------------+------------+
|    Order_ID    | Product_ID |
+----------------+------------+
| 1              |       1000 |
| 2              |       1000 |
| 2              |       1001 |
+----------------+------------+

所以我有这个 table，它在 Orders 和 Products 上是多对多的，我需要的是映射以上 table 中的每个条目到 地址列表 。所以我需要像

这样的东西

|PK|Order_ID |Product_ID |    
| 1|    1    |  1000     |
| 2|    2    |  1000     |
| 3|    2    |  1001     |

并将上面 table 中的条目映射到地址列表我需要另一个多对多 table 上面的 PK 和地址 ID（我地址的主键 table)

|PK_Order_Product |Address_ID|
|    1            |  1       |
|    2            |  1       |
|    2            |  3       |

这里PK_Order_Product是前一个table的主键(PK)上的外键我正在使用 JPA 持久化到我的 MYSQL 数据库如果我的设计 correct.How 使用 JPA 注释

在 Java 中执行此操作，请帮助我提供代码片段

Answer 1

这实际上是一个值得研究和试验的好问题。有很多方法可以进行映射。提出更好的设计实际上取决于您的应用程序需求。但我认为这是实现映射的有效方法：

我将为 Order、Product 和 Address 提供 3 个单独的实体。

我们不会在两个实体 Order 和 Product 之间实现通常的多对多关系，其中每一方都有另一方的集合。相反，我将创建另一个实体来表示 Order 和 Product 之间的关系，我们将其命名为 ProductOrder。他们的关系是这样映射的：

Order 与 ProductOrder.
ProductOrder 与 Order.
Product 与 ProductOrder.
ProductOrder 与 Product.

ProductOrder 的主键将由 Order 的主键和 Product 的主键组成 - 因此这将是一个组合键。因此我们需要使用 @IdClass 来映射复合键。

现在，这是在多对多关系中实现多对多的技巧：

ProductOrder 与 Address.

存在多对多关系

查看上述每个实体的示例代码：

订单实体

@Entity
@Table(name = "ORDERS")
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ORDER_ID")
    private Long id;

    private int quantity;

    @OneToMany(mappedBy = "order")
    private List<ProductOrder> productOrderList = new ArrayList<ProductOrder>();
...
}

产品实体

@Entity
@Table(name="PRODUCT")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "PRODUCT_ID")
    private Long id;

    private String name;

    @OneToMany(mappedBy = "product")
    private List<ProductOrder> productOrderList = new ArrayList<ProductOrder>();
...
}

地址实体

@Entity
@Table(name="ADDRESS")
public class Address {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ADDRESS_ID")
    private Long id;

    private String state;

    @ManyToMany(mappedBy = "addressList")
    private List<ProductOrder> productOrderList = new ArrayList<ProductOrder>();
...
}

生产订单实体

@Entity
@Table(name="PRODUCT_ORDER")
@IdClass(ProductOrderId.class)
public class ProductOrder {

    @Id
    @ManyToOne
    @JoinColumn(name="ORDER_ID")
    private Order order;

    @Id
    @ManyToOne
    @JoinColumn(name="PRODUCT_ID")
    private Product product;

    @ManyToMany
    @JoinTable(name="PRODUCT_ORDER_ADDRESS",
            joinColumns={@JoinColumn(name="ORDER_ID", referencedColumnName="ORDER_ID"),
                    @JoinColumn(name="PRODUCT_ID", referencedColumnName="PRODUCT_ID")},
            inverseJoinColumns=@JoinColumn(name="ADDRESS_ID", referencedColumnName="ADDRESS_ID"))
    private List<Address> addressList = new ArrayList<Address>();
...
}

@IdClass for ProductOrder 实体

public class ProductOrderId {

    private Long order;
    private Long product;
...
}

下面是创建实体并保存它们的示例代码：

    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();

    Order order = new Order();
    order.setQuantity(10);
    em.persist(order);

    Product product = new Product();
    product.setName("Coffee");
    em.persist(product);

    Address address = new Address();
    address.setState("CA");
    em.persist(address);

    ProductOrder productOrder = new ProductOrder();
    productOrder.setOrder(order);
    productOrder.setProduct(product);

    productOrder.getAddressList().add(address);
    address.getProductOrderList().add(productOrder);

    em.persist(productOrder);

    em.getTransaction().commit();

以下是在 MySQL 数据库中生成架构的方式：

Hibernate: 
    create table ADDRESS (
        ADDRESS_ID bigint not null auto_increment,
        state varchar(255),
        primary key (ADDRESS_ID)
    )
Hibernate: 
    create table ORDERS (
        ORDER_ID bigint not null auto_increment,
        quantity integer not null,
        primary key (ORDER_ID)
    )
Hibernate: 
    create table PRODUCT (
        PRODUCT_ID bigint not null auto_increment,
        name varchar(255),
        primary key (PRODUCT_ID)
    )
Hibernate: 
    create table PRODUCT_ORDER (
        ORDER_ID bigint,
        PRODUCT_ID bigint,
        primary key (ORDER_ID, PRODUCT_ID)
    )
Hibernate: 
    create table PRODUCT_ORDER_ADDRESS (
        ORDER_ID bigint not null,
        PRODUCT_ID bigint not null,
        ADDRESS_ID bigint not null
    )
Hibernate: 
    alter table PRODUCT_ORDER 
        add constraint FK_sl39bwx60xjbvoiujpaes74ty 
        foreign key (ORDER_ID) 
        references ORDERS (ORDER_ID)
Hibernate: 
    alter table PRODUCT_ORDER 
        add constraint FK_n0i7uxq6rxsc0mcred1cds4m9 
        foreign key (PRODUCT_ID) 
        references PRODUCT (PRODUCT_ID)
Hibernate: 
    alter table PRODUCT_ORDER_ADDRESS 
        add constraint FK_kad6crei9lgrv1nuuuff42vs8 
        foreign key (ADDRESS_ID) 
        references ADDRESS (ADDRESS_ID)
Hibernate: 
    alter table PRODUCT_ORDER_ADDRESS 
        add constraint FK_hpx0e467dvpqi5i6kxmujns2b 
        foreign key (ORDER_ID, PRODUCT_ID) 
        references PRODUCT_ORDER (ORDER_ID, PRODUCT_ID)

多对多里面的多对多 Table

Many to Many inside Many to Many Table

java

mysql

many-to-many

hibernate

jpa