Java 在Hibernate的许多实体中使用级联是一种好的做法吗？

我有2类，客户和股票（代码如下）。他们之间有着千丝万缕的联系。两者都有

cascade={CascadeType.PERSIST，CascadeType.MERGE}

我已经测试过，它工作正常。我只是想知道这是一个好的做法吗 往这边走

客户端类：

import com.sun.javafx.beans.IDProperty;

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

@Entity
@Table(name = "client_table")
public class Client {
    @Id
    @Column(name = "id")
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator = "client_seq_generator")
    @SequenceGenerator(name = "client_seq_generator", sequenceName = "client_seq", allocationSize = 3)
    private int id;

    @Column(name = "name")
    private String name;

    @OneToMany(
            mappedBy = "client",
            cascade = CascadeType.ALL,
            orphanRemoval = true
    )
    private List<Contribution> contributions = new ArrayList<Contribution>();

    @ManyToMany(
            cascade = {CascadeType.PERSIST, CascadeType.MERGE}
    )
    @JoinTable(
            name="client_stock_table",
            joinColumns = @JoinColumn(name = "client_id"),
            inverseJoinColumns = @JoinColumn(name = "stock_id")
    )
    private Set<Stock> stocks = new HashSet<Stock>();

    public Client() {}

    public Client(String name)
    {
        this.name = name;
    }



    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Contribution getContribution(int id) {
        return contributions.get(id);
    }

    public void addContributions(Contribution contribution) {
        contribution.setClient(this);
        this.contributions.add(contribution);
    }

    public void removeContributions(Contribution contribution) {
        if(contribution != null && contributions.contains(contribution))
        {
            contribution.setClient(null);
            this.contributions.remove(contribution);
        }

    }

    public Set<Stock> getStocks() {
        return stocks;
    }

    public void addStock(Stock stock)
    {
        if(stock != null)
        {
            stocks.add(stock);
            stock.getClients().add(this);
        }
    }

    public void removeStock(Stock stock)
    {
        if(stock != null)
        {
            stocks.remove(stock);
            stock.getClients().remove(this);
        }
    }

}

import com.sun.javafx.beans.IDProperty；
导入javax.persistence.*；
导入java.util.ArrayList；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
@实体
@表（name=“client\u Table”）
公共类客户端{
@身份证
@列（name=“id”）
@GeneratedValue（策略=GenerationType.SEQUENCE，generator=“客户端序列生成器”）
@SequenceGenerator（name=“client\u seq\u generator”，sequenceName=“client\u seq”，allocationSize=3）
私有int-id；
@列（name=“name”）
私有字符串名称；
@独身癖(
mappedBy=“客户端”，
cascade=CascadeType.ALL，
孤立删除=真
)
私有列表贡献=新的ArrayList（）；
@许多(
cascade={CascadeType.PERSIST，CascadeType.MERGE}
)
@可接合(
name=“客户库存表”，
joinColumns=@JoinColumn（name=“client_id”），
inverseJoinColumns=@JoinColumn（name=“stock\u id”）
)
私有集合stocks=newhashset（）；
公共客户端（）{}
公共客户端（字符串名称）
{
this.name=名称；
}
公共int getId（）{
返回id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共贡献getContribution（int id）{
返回贡献。获取（id）；
}
公共捐款（捐款）{
setClient（this）；
本.供款.添加（供款）；
}
公共无效删除贡献（贡献）{
if（contribution！=null&&contributions.contains（contribution））
{
contribution.setClient（null）；
本.供款.删除（供款）；
}
}
公共集合股票（）{
返回股票；
}
公开作废股票（股票）
{
如果（库存！=null）
{
股票。添加（股票）；
stock.getClients（）.add（此）；
}
}
公开作废移除库存（库存）
{
如果（库存！=null）
{
库存。移除（库存）；
stock.getClients（）.remove（此）；
}
}
}

股票类别：

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


@Entity
@Table(name = "stock_table")
public class Stock {
    @Id
    @GeneratedValue(strategy= GenerationType.SEQUENCE, generator = "stock_seq_generator")
    @SequenceGenerator(name = "stock_seq_generator", sequenceName = "stock_seq", allocationSize = 1)
    private int id;

    @Column(name = "name")
    private String name;

    @ManyToMany(
            mappedBy = "stocks",
            cascade = {CascadeType.PERSIST, CascadeType.MERGE}
    )
    private Set<Client> clients = new HashSet<Client>();

    public Stock() {}

    public Stock(String name)
    {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Client> getClients() {
        return clients;
    }

    public void addClient(Client client)
    {
        if(client != null)
        {
            clients.add(client);
            client.getStocks().add(this);
        }
    }

    public void removeClient(Client client)
    {
        if(client != null)
        {
            clients.remove(client);
            client.getStocks().remove(this);
        }
    }

}

import javax.persistence.*；
导入java.util.HashSet；
导入java.util.Set；
@实体
@表（name=“库存表”）
公开股{
@身份证
@GeneratedValue（策略=GenerationType.SEQUENCE，生成器=“股票序列生成器”）
@SequenceGenerator（name=“stock\u seq\u generator”，sequenceName=“stock\u seq”，allocationSize=1）
私有int-id；
@列（name=“name”）
私有字符串名称；
@许多(
mappedBy=“股票”，
cascade={CascadeType.PERSIST，CascadeType.MERGE}
)
private Set clients=new HashSet（）；
公共股票（）{}
公开股票（字符串名称）
{
this.name=名称；
}
公共int getId（）{
返回id；
}
公共无效集合id（内部id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共集getClients（）{
返回客户；
}
公共无效添加客户端（客户端）
{
如果（客户端！=null）
{
客户。添加（客户）；
client.getStocks（）.add（此）；
}
}
public void removeClient（客户端）
{
如果（客户端！=null）
{
客户。删除（客户）；
client.getStocks（）.remove（此）；
}
}
}

我认为这不是一个方便的方法

Client

（可能还有

Stock

）是一个参考表。可以存在引用

客户机
表作为参考表的其他表

您不能使用Hibernate合法地使用join

client\u stock\u table

table。我的意思是，没有

客户

或

股票

那么好

---

从

Client

和

Stock

中删除

@manytomy

关联，并将其他持久类

ClientStocks

与

@ManyToMany

关联一起使用。

完全由您决定。请记住，任何在最受影响的层中没有明确说明的内容，例如您的服务实现，都有可能出现破坏性和不必要的回归。我见过这样的案例，级联删除是破坏性的，让整个团队整夜都在恢复损坏。在这里发布更合适。话虽如此，我看不出有什么问题。@Fallacoulibal我认为这个问题在这里是合适的。这是一个细致入微的问题（有一些编辑可以概括这个问题），应该得到细致入微的回答