使用JPA和Hibernate提供程序的多个关系没有创建主键

我已经使用Hibernate创建了两个JPA实体（客户机，InstrumentTrade），它们作为具有多个关系的提供者。在让Hibernate为MySQL生成表之后，ManyToMany关系表似乎不包含两个外键的主键。这允许在多对多表中重复记录，这不是期望的结果

生成的表格：

client(id,name)  
instrument_traded(id,name)  
client_instrument_traded(FK client_id, FK instrument_traded_id)

client_instrument_traded(PK,FK client_id, PK,FK instrument_traded_id)

首选表格：

client(id,name)  
instrument_traded(id,name)  
client_instrument_traded(FK client_id, FK instrument_traded_id)

client_instrument_traded(PK,FK client_id, PK,FK instrument_traded_id)

实体：

@Entity
public class Client extends AbstractEntity<Integer> {

    private static final long serialVersionUID = 1L;

    @Basic(optional = false)
    @Column(nullable = false, length = 125)
    private String name;

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(joinColumns = {
        @JoinColumn}, inverseJoinColumns = {
        @JoinColumn(name = "instrument_traded_id")}, uniqueConstraints =
    @UniqueConstraint(name = "UK_client_instruments_traded_client_id_instrument_traded_id",
    columnNames = {"client_id", "instrument_traded_id"}))
    @ForeignKey(name = "FK_client_instruments_traded_client_id",
    inverseName = "FK_client_instruments_traded_instrument_traded_id")
    private List<InstrumentTraded> instrumentsTraded;

    public Client() {
    }

    public List<InstrumentTraded> getInstrumentsTraded() {
        return instrumentsTraded;
    }

    public void setInstrumentsTraded(List<InstrumentTraded> instrumentsTraded) {
        this.instrumentsTraded = instrumentsTraded;
    }

    ...
}



@Entity
@Table(uniqueConstraints = {
    @UniqueConstraint(name = "UK_instrument_traded_name", columnNames = {"name"})})
public class InstrumentTraded extends AbstractEntity<Integer> {

    private static final long serialVersionUID = 1L;

    @Basic(optional = false)
    @Column(nullable = false, length = 50)
    private String name;

    @ManyToMany(mappedBy = "instrumentsTraded", fetch = FetchType.LAZY)
    private List<Client> clients;

    public InstrumentTraded() {
    }

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

    public void setClients(List<Client> clients) {
        this.clients = clients;
    }

    ...

}

@实体
公共类客户端扩展抽象实体{
私有静态最终长serialVersionUID=1L；
@基本（可选=假）
@列（nullable=false，长度=125）
私有字符串名称；
@ManyToMany（fetch=FetchType.LAZY）
@JoinTable（JointColumns={
@JoinColumn}，inverseJoinColumns={
@JoinColumn（name=“instrument\u traded\u id”）}，唯一约束=
@UniqueConstraint（name=“英国客户工具交易客户id工具交易id”，
columnNames={“客户id”、“工具id”}）
@ForeignKey（name=“FK\U客户\工具\交易\客户\ id”，
inverseName=“FK\客户\交易工具\交易工具\ id”）
私人名单；
公共客户机（）{
}
公共列表getStraded（）{
回程跨接；
}
公共无效集合仪表盘（列表仪表盘）{
this.instrumentsTraded=instrumentsTraded；
}
...
}
@实体
@表（唯一约束={
@UniqueConstraint（name=“UK_instrument_traded_name”，columnNames={“name”}）}）
公共类工具扩展了抽象实体{
私有静态最终长serialVersionUID=1L；
@基本（可选=假）
@列（nullable=false，长度=50）
私有字符串名称；
@ManyToMany（mappedBy=“instrumentsTraded”，fetch=FetchType.LAZY）
私人名单客户；
公营机构（）{
}
公共列表getClients（）{
返回客户；
}
公用客户机（列出客户机）{
这个。客户=客户；
}
...
}

在做了一些研究之后，看起来唯一的解决方案是在不需要额外列的情况下使用

@OneToMany

@IdClass

和复合主键类。除了我在上面的代码中包含的解决方案之外，这是唯一的解决方案吗？该解决方案使用了

@UniqueConstraint

，在

@manytomy

映射上有两个外键列？像这样的常见场景所需的工作量似乎有点荒谬。谢谢

您的映射看起来很奇怪（尤其是

@JoinTable

注释的

joinColumn

部分）。我希望这样：

@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(
    joinColumns= 
        @JoinColumn(name="CLIENT_ID", referencedColumnName="ID"), 
    inverseJoinColumns=
        @JoinColumn(name="instrument_traded_id", referencedColumnName="ID"),
    uniqueConstraints=
        @UniqueConstraint(
            name="UK_client_instruments_traded_client_id_instrument_traded_id",
            columnNames = {"client_id", "instrument_traded_id"}
        )
)
@ForeignKey(name = "FK_client_instruments_traded_client_id",
inverseName = "FK_client_instruments_traded_instrument_traded_id")
private List<InstrumentTraded> instrumentsTraded;

@ManyToMany（fetch=FetchType.LAZY）
@可接合(
joinColumns=
@JoinColumn（name=“CLIENT\u ID”，referencedColumnName=“ID”），
反向连接柱=
@JoinColumn（name=“instrument\u traded\u id”，referencedColumnName=“id”），
唯一约束=
@唯一约束(
name=“英国客户工具交易客户id工具交易id”，
columnNames={“客户id”、“工具id”}
)
)
@ForeignKey（name=“FK\U客户\工具\交易\客户\ id”，
inverseName=“FK\客户\交易工具\交易工具\ id”）
私人名单；

---

但是，除非您想覆盖默认值（我想您也会这样做），否则我只想跳过

@JoinTable
或将@manytomy拆分为@OneToMany-@manytomone关系看看如何完成此映射以下是解决问题的方法：

Client.java：

 @ManyToMany(fetch = FetchType.EAGER,cascade = CascadeType.ALL)
 @JoinTable(
        joinColumns = {@JoinColumn(name = "client_id")},
        inverseJoinColumns = {@JoinColumn(name = "instrument_traded_id")},
        uniqueConstraints = {@UniqueConstraint(
            columnNames = {"client_id", "instrument_traded_id"})}
)
 private List<InstrumentTraded> instrumentsTraded;

@ManyToMany（fetch=FetchType.EAGER，cascade=CascadeType.ALL）
@可接合(
joinColumns={@JoinColumn（name=“client_id”）}，
inverseJoinColumns={@JoinColumn（name=“instrument\u traded\u id”）}，
uniqueConstraints={@UniqueConstraint(
columnNames={“客户id”，“工具id”}
)
私人名单；

这是用于单向映射的。如果需要双向关系，请将
instrumenttrade.class
中的映射更改为相同的映射。
我遇到了类似的问题。我所做的只是将集合类型从列表更改为集合：

private List<InstrumentTraded> instrumentsTraded;

private-List-stradded；

到

private-Set-instrumented；

不知何故，Hibernate现在为联接表生成主键。
我确实希望覆盖默认值，因为它使工具交易id（工具交易id）的值多元化。我有一个自定义命名策略，如果外键末尾不存在“\u id”，则添加“\u id”。我可以删除joinColumns=@JoinColumn。您是否有一个多人在多人表中创建包含两个外键的主键的工作示例？@Dukethrah:
您是否有一个多人在多人表中创建包含两个外键的主键的工作示例？
如果注释正确，这是默认行为。您是否尝试过不使用
joinColumn
（或使用上面的一个）？是的，我尝试了您的（referencedColumn实际上是referencedColumnName除外），但它仍然没有生成主键。我甚至在上面添加了以下内容，只是想看看这是否会改变什么@ManyToMany（fetch=FetchType.LAZY，mappedBy=“instrumentsTraded”）私有列表客户端；同样值得检查的是，如果您两次不小心没有添加记录，这发生在我身上，所以
list.add（x）；增加（x）结果在列表中重复。“所有伟大的事情都很简单…”是吗？或者只是Java集合在内存上工作？如果您两次不小心没有添加记录，那么值得检查一下，这发生在我身上，所以
list.add（x）；增加（x）结果在列表中重复。@ViniciusPires，它确实创建了一个复合pr