ManyToMany-Beziehung mit JPA mit Hibernate Anbieter ist nicht zum erstellen von Primärschlüsseln
Habe ich zwei JPA-Entitäten (Kunde, InstrumentTraded) mit Hibernate als provider, die eine ManyToMany-Beziehung. Nach dem loslassen Hibernate erzeugen der Tabellen für die MySQL-es scheint, dass die ManyToMany-Beziehung Tabelle nicht enthalten primärer Schlüssel für die beiden foreign-keys. Dies ermöglicht die doppelte Datensätze in der viele-zu-viele-Tabelle, die nicht das gewünschte Ergebnis.
Tabellen generiert:
client(id,name)
instrument_traded(id,name)
client_instrument_traded(FK client_id, FK instrument_traded_id)
Am günstigsten gelegene Tabelle:
client_instrument_traded(PK,FK client_id, PK,FK instrument_traded_id)
Personen:
@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;
}
...
}
Nachdem ich einige der Forschung es sieht aus wie die einzige Lösung für die Zuordnung eines join-Tabelle mit zusätzlichen Spalten mit @OneToMany
@IdClass
und eine zusammengesetzte primary key-Klasse, wenn ich don ' T müssen zusätzliche Spalten. Ist dies die einzige Lösung neben der, den ich habe in dem obigen code, die mit einem @UniqueConstraint
mit den beiden foreign-key-Spalten auf der @ManyToMany
mapping? Es scheint ein bisschen lächerlich, die Menge der Arbeit benötigt, die für einen gemeinsamen Szenario wie dieses. Danke!
- stackoverflow.com/questions/1212058/...
- Auch die Werte zu überprüfen, wenn Sie versehentlich nicht hinzufügen, einen Eintrag zweimal, passiert mir das, so
list.add(x); list.add(x);
Ergebnisse Duplikate in Listen.
Du musst angemeldet sein, um einen Kommentar abzugeben.
Ich hatte ein ähnliches problem. Alles, was ich Tat, war, dass ich änderte den collection-Typ von der Liste zu Setzen:
zu
Und irgendwie Hibernate erzeugt nun die primäre Schlüssel für die join-Tabelle.
list.add(x); list.add(x);
Ergebnisse Duplikate in Listen.Hier ist ein Weg, um das problem zu lösen:
Client.java:
Dies ist für die unidirektionale Zuordnung. Wenn Sie möchten, eine bidirektionale Beziehung, ändern Sie die Zuordnung in
InstrumentTraded.class
den gleichen.Dein mapping sieht seltsam aus (insbesondere die
joinColumn
Teil der@JoinTable
annotation). Ich würde erwarten, dass so etwas wie dieses:Aber es sei denn, Sie wollen, um die Standardwerte zu überschreiben (und ich denke, Sie tun), würde ich einfach überspringen Sie die
@JoinTable
.joinColumn
(oder mit der oben ein)?Oder teilen Sie Ihre @ManyToMany in die @OneToMany - @ManyToOne Beziehung Sehen hier wie Sie dies erreichen können mapping -