Banyak ke Banyak di dalam Meja Banyak ke Banyak

Ini sebenarnya adalah pertanyaan bagus yang layak untuk diteliti dan dicoba. Ada banyak cara untuk melakukan pemetaan. Muncul dengan desain yang lebih baik sebenarnya akan tergantung pada kebutuhan aplikasi Anda. Tapi inilah cara yang menurut saya akan menjadi cara yang efektif untuk mengimplementasikan pemetaan:

Saya akan memiliki 3 entitas terpisah untuk Order , Product dan Address .

Kami tidak akan menerapkan hubungan banyak ke banyak yang biasa antara 2 entitas, Order dan Product , di mana masing-masing sisi memiliki koleksi yang lain. Sebagai gantinya, saya akan membuat entitas lain untuk mewakili hubungan antara Order dan Product , dan beri nama ProductOrder . Berikut bagaimana hubungan mereka dipetakan:

• Order memiliki hubungan satu-ke-banyak dengan ProductOrder .
• ProductOrder memiliki hubungan banyak-ke-satu dengan Order .
• Product memiliki hubungan satu-ke-banyak dengan ProductOrder .
• ProductOrder memiliki hubungan banyak-ke-satu dengan Product .

ProductOrder kunci utama akan terdiri dari kunci utama Order dan kunci utama Product - jadi ini akan menjadi kunci komposit. Oleh karena itu kita perlu menggunakan @IdClass untuk memetakan kunci komposit.

Sekarang, inilah trik untuk mencapai banyak-ke-banyak dalam hubungan banyak-ke-banyak:

ProductOrder memiliki hubungan banyak-ke-banyak dengan Address .

Lihat kode contoh untuk setiap entitas yang disebutkan di atas:

ENTITAS PESANAN

@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>();
...
}

ENTITAS PRODUK

@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>();
...
}

ENTITAS ALAMAT

@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>();
...
}

ENTITAS PRODUKTOR

@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")},
            [email protected](name="ADDRESS_ID", referencedColumnName="ADDRESS_ID"))
    private List<Address> addressList = new ArrayList<Address>();
...
}

@IdClass untuk entitas ProductOrder

public class ProductOrderId {

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

Berikut adalah contoh kode untuk membuat entitas dan mempertahankannya:

    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();

Berikut cara skema dibuat di database 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)