JPA多对多关联映射与中介表处理：以发票信息为例-java教程-PHP中文网

JPA多对多关联映射与中介表处理：以发票信息为例

本文旨在深入探讨jpa中如何高效处理一个表作为中介，关联另外两个核心表的场景，尤其关注多对多关系的实现。我们将通过一个具体的发票与产品关联的示例，详细阐述如何利用jpa的`@onetomany`和`@manytoone`注解来建立实体间的双向关系，并演示如何通过级联操作（`cascadetype.all`）实现关联数据的同步持久化，确保数据操作的完整性与一致性。

1. 理解多对多关系与中介表

在关系型数据库设计中，当两个实体之间存在多对多关系时（例如，一张发票可以包含多个产品，一个产品也可以出现在多张发票中），通常会引入一个第三张表作为“中介表”或“连接表”来存储这种关系。这张中介表通常包含两个外键，分别指向两个关联实体的主键，并且可以包含额外的属性来描述这段关系（例如，产品在发票中的数量、折扣等）。

在本示例中，Invoice（发票）和Product（产品）之间就是多对多关系，而InvoiceInfo（发发票详情）表则充当了中介。InvoiceInfo表通过invoice_id关联Invoice，通过product_id关联Product。

2. JPA实体映射的优化

为了在JPA中正确地表示这种关系并实现数据持久化，我们需要对现有的实体类进行改造，使其能够反映出这种双向关联。

2.1 优化 InvoiceInfo 实体

InvoiceInfo是中介表，它不再直接存储product_id和invoice_id，而是通过@ManyToOne注解直接引用Product和Invoice实体对象。

import javax.persistence.*;

@Entity
@Table(name = "invoice_info")
public class InvoiceInfo {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "item_id")
    private Long id; // 统一使用Long类型ID

    // Many-to-one relationship with Product
    @ManyToOne(fetch = FetchType.LAZY) // 懒加载，提高性能
    @JoinColumn(name = "product_id", nullable = false) // 对应数据库中的外键列名
    private Product product;

    // Many-to-one relationship with Invoice
    @ManyToOne(fetch = FetchType.LAZY) // 懒加载
    @JoinColumn(name = "invoice_id", nullable = false) // 对应数据库中的外键列名
    private Invoice invoice;

    // 可以添加额外的属性，例如产品在发票中的数量
    @Column(name = "quantity")
    private int quantity;

    // 构造函数
    public InvoiceInfo() {}

    public InvoiceInfo(Product product, Invoice invoice, int quantity) {
        this.product = product;
        this.invoice = invoice;
        this.quantity = quantity;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public Product getProduct() { return product; }
    public void setProduct(Product product) { this.product = product; }
    public Invoice getInvoice() { return invoice; }
    public void setInvoice(Invoice invoice) { this.invoice = invoice; }
    public int getQuantity() { return quantity; }
    public void setQuantity(int quantity) { this.quantity = quantity; }

    // 建议重写equals和hashCode方法，特别是在Set中使用时
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        InvoiceInfo that = (InvoiceInfo) o;
        return id != null && id.equals(that.id);
    }

    @Override
    public int hashCode() {
        return 31; // 对于使用数据库生成ID的实体，可以简化hashCode，但需谨慎
    }
}

登录后复制

2.2 优化 Product 实体

Product实体与InvoiceInfo实体之间是一对多关系（一个产品可以出现在多条发票详情中）。

喵记多

喵记多 - 自带助理的 AI 笔记

查看详情

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

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

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Column(name = "family_id")
    private long familyId;
    @Column(name = "product_name")
    private String productName;
    @Column(name = "product_category")
    private String productCategory;
    @Column(name = "product_quantity") // 这是库存数量，不是发票中的数量
    private int productQuantity;

    // One-to-many relationship with InvoiceInfo
    // mappedBy指向InvoiceInfo中关联Product的字段名
    // cascade = CascadeType.ALL表示对Product的操作会级联到InvoiceInfo
    // orphanRemoval = true表示当InvoiceInfo从集合中移除时，对应的实体也会被删除
    @OneToMany(mappedBy = "product", cascade = CascadeType.ALL, orphanRemoval = true)
    private Set<InvoiceInfo> invoiceInfos = new HashSet<>();

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public long getFamilyId() { return familyId; }
    public void setFamilyId(long familyId) { this.familyId = familyId; }
    public String getProductName() { return productName; }
    public void setProductName(String productName) { this.productName = productName; }
    public String getProductCategory() { return productCategory; }
    public void setProductCategory(String productCategory) { this.productCategory = productCategory; }
    public int getProductQuantity() { return productQuantity; }
    public void setProductQuantity(int productQuantity) { this.productQuantity = productQuantity; }
    public Set<InvoiceInfo> getInvoiceInfos() { return invoiceInfos; }
    public void setInvoiceInfos(Set<InvoiceInfo> invoiceInfos) { this.invoiceInfos = invoiceInfos; }

    // 辅助方法，用于维护双向关系
    public void addInvoiceInfo(InvoiceInfo invoiceInfo) {
        this.invoiceInfos.add(invoiceInfo);
        invoiceInfo.setProduct(this);
    }

    public void removeInvoiceInfo(InvoiceInfo invoiceInfo) {
        this.invoiceInfos.remove(invoiceInfo);
        invoiceInfo.setProduct(null);
    }
}

登录后复制

2.3 优化 Invoice 实体

Invoice实体与InvoiceInfo实体之间也是一对多关系（一张发票可以包含多条发票详情）。

import javax.persistence.*;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "invoice")
public class Invoice {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "invoice_id")
    private Long id;
    @Column(name = "provider_id")
    private Long providerId;
    @Column(name = "total")
    private int invoiceTotal;
    @Column(name = "date")
    private Date invoiceDate;

    // One-to-many relationship with InvoiceInfo
    // mappedBy指向InvoiceInfo中关联Invoice的字段名
    // cascade = CascadeType.ALL表示对Invoice的操作会级联到InvoiceInfo
    // orphanRemoval = true表示当InvoiceInfo从集合中移除时，对应的实体也会被删除
    @OneToMany(mappedBy = "invoice", cascade = CascadeType.ALL, orphanRemoval = true)
    private Set<InvoiceInfo> invoiceInfos = new HashSet<>();

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public Long getProviderId() { return providerId; }
    public void setProviderId(Long providerId) { this.providerId = providerId; }
    public int getInvoiceTotal() { return invoiceTotal; }
    public void setInvoiceTotal(int invoiceTotal) { this.invoiceTotal = invoiceTotal; }
    public Date getInvoiceDate() { return invoiceDate; }
    public void setInvoiceDate(Date invoiceDate) { this.invoiceDate = invoiceDate; }
    public Set<InvoiceInfo> getInvoiceInfos() { return invoiceInfos; }
    public void setInvoiceInfos(Set<InvoiceInfo> invoiceInfos) { this.invoiceInfos = invoiceInfos; }

    // 辅助方法，用于维护双向关系
    public void addInvoiceInfo(InvoiceInfo invoiceInfo) {
        this.invoiceInfos.add(invoiceInfo);
        invoiceInfo.setInvoice(this);
    }

    public void removeInvoiceInfo(InvoiceInfo invoiceInfo) {
        this.invoiceInfos.remove(invoiceInfo);
        invoiceInfo.setInvoice(null);
    }
}

登录后复制

3. 持久化新发票及关联产品

在完成实体映射后，插入新的发票及关联产品变得相对简单。我们只需要创建Invoice对象、Product对象（或从数据库加载现有产品），然后创建InvoiceInfo对象来连接它们，并最终保存Invoice对象。由于设置了CascadeType.ALL，InvoiceInfo实体将随之自动持久化。

3.1 示例服务层代码

假设我们有InvoiceRepository和ProductRepository。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;
import java.util.Optional;

@Service
public class InvoiceService {

    @Autowired
    private InvoiceRepository invoiceRepository;
    @Autowired
    private ProductRepository productRepository; // 假设存在Product的Repository

    @Transactional // 确保整个操作在一个事务中
    public Invoice createNewInvoiceWithProducts(Long providerId, List<ProductDetails> productDetailsList) {
        // 1. 创建新的发票实体
        Invoice invoice = new Invoice();
        invoice.setProviderId(providerId);
        invoice.setInvoiceDate(new Date());
        invoice.setInvoiceTotal(0); // 初始总金额，可后续计算或更新

        // 2. 遍历产品详情列表，创建InvoiceInfo并建立关系
        int totalAmount = 0; // 用于计算发票总金额，如果Product有价格字段
        for (ProductDetails details : productDetailsList) {
            // 从数据库中查找产品，确保产品存在
            Optional<Product> productOptional = productRepository.findById(details.getProductId());
            if (!productOptional.isPresent()) {
                throw new IllegalArgumentException("Product with ID " + details.getProductId() + " not found.");
            }
            Product product = productOptional.get();

            // 创建InvoiceInfo实体，链接发票和产品
            InvoiceInfo invoiceInfo = new InvoiceInfo(product, invoice, details.getQuantity());

            // 建立双向关系：将invoiceInfo添加到invoice的集合中
            // 此操作会通过invoice.addInvoiceInfo()方法同时设置invoiceInfo.setInvoice(invoice)
            invoice.addInvoiceInfo(invoiceInfo);

            // 如果Product实体有价格字段，可以在这里计算总金额
            // totalAmount += product.getPrice() * details.getQuantity();
        }

        // 3. 更新发票总金额（如果适用）
        invoice.setInvoiceTotal(totalAmount);

        // 4. 保存发票实体。由于设置了CascadeType.ALL，所有关联的InvoiceInfo实体也会被自动保存。
        return invoiceRepository.save(invoice);
    }

    // 辅助类，用于接收前端传入的产品详情
    public static class ProductDetails {
        private Long productId;
        private int quantity;

        public Long getProductId() { return productId; }
        public void setProductId(Long productId) { this.productId = productId; }
        public

登录后复制

以上就是JPA多对多关联映射与中介表处理：以发票信息为例的详细内容，更多请关注php中文网其它相关文章！