Ich bin neu im Winterschlaf und muss One-to-Many- und Many-to-One-Beziehungen verwenden. Es ist eine bidirektionale Beziehung in meinen Objekten, so dass ich aus beiden Richtungen verfahren kann. mappedBy
ist der empfohlene Weg, um darüber zu gehen, aber ich konnte es nicht verstehen. Kann jemand erklären:
Im Interesse meines Beispiels hier meine Klassen mit Anmerkungen:
Airline
OWNS viele AirlineFlights
AirlineFlights
gehören zuONEAirline
Fluggesellschaft :
@Entity
@Table(name="Airline")
public class Airline {
private Integer idAirline;
private String name;
private String code;
private String aliasName;
private Set<AirlineFlight> airlineFlights = new HashSet<AirlineFlight>(0);
public Airline(){}
public Airline(String name, String code, String aliasName, Set<AirlineFlight> flights) {
setName(name);
setCode(code);
setAliasName(aliasName);
setAirlineFlights(flights);
}
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="IDAIRLINE", nullable=false)
public Integer getIdAirline() {
return idAirline;
}
private void setIdAirline(Integer idAirline) {
this.idAirline = idAirline;
}
@Column(name="NAME", nullable=false)
public String getName() {
return name;
}
public void setName(String name) {
this.name = DAOUtil.convertToDBString(name);
}
@Column(name="CODE", nullable=false, length=3)
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = DAOUtil.convertToDBString(code);
}
@Column(name="ALIAS", nullable=true)
public String getAliasName() {
return aliasName;
}
public void setAliasName(String aliasName) {
if(aliasName != null)
this.aliasName = DAOUtil.convertToDBString(aliasName);
}
@OneToMany(fetch=FetchType.LAZY, cascade = {CascadeType.ALL})
@JoinColumn(name="IDAIRLINE")
public Set<AirlineFlight> getAirlineFlights() {
return airlineFlights;
}
public void setAirlineFlights(Set<AirlineFlight> flights) {
this.airlineFlights = flights;
}
}
AirlineFlüge:
@Entity
@Table(name="AirlineFlight")
public class AirlineFlight {
private Integer idAirlineFlight;
private Airline airline;
private String flightNumber;
public AirlineFlight(){}
public AirlineFlight(Airline airline, String flightNumber) {
setAirline(airline);
setFlightNumber(flightNumber);
}
@Id
@GeneratedValue(generator="identity")
@GenericGenerator(name="identity", strategy="identity")
@Column(name="IDAIRLINEFLIGHT", nullable=false)
public Integer getIdAirlineFlight() {
return idAirlineFlight;
}
private void setIdAirlineFlight(Integer idAirlineFlight) {
this.idAirlineFlight = idAirlineFlight;
}
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="IDAIRLINE", nullable=false)
public Airline getAirline() {
return airline;
}
public void setAirline(Airline airline) {
this.airline = airline;
}
@Column(name="FLIGHTNUMBER", nullable=false)
public String getFlightNumber() {
return flightNumber;
}
public void setFlightNumber(String flightNumber) {
this.flightNumber = DAOUtil.convertToDBString(flightNumber);
}
}
BEARBEITEN:
Datenbankschema:
AirlineFlights hat die idAirline als ForeignKey und Airline hat keine idAirlineFlights. Macht AirlineFlights als Eigentümer/Identifizierer?
Theoretisch möchte ich, dass die Fluggesellschaft Eigentümerin von airlineFlights ist.
Durch die Angabe von @JoinColumn
bei beiden Modellen haben Sie keine wechselseitige Beziehung. Sie haben zwei Einwegbeziehungen und eine sehr verwirrende Abbildung davon. Sie sagen beiden Modellen, dass sie die IDAIRLINE-Säule "besitzen". Eigentlich sollte eigentlich nur einer von ihnen! Die 'normale' Sache ist, den @JoinColumn
vollständig von der @OneToMany
-Seite zu entfernen und stattdessen mappedBy zum @OneToMany
hinzuzufügen.
@OneToMany(cascade = CascadeType.ALL, mappedBy="airline")
public Set<AirlineFlight> getAirlineFlights() {
return airlineFlights;
}
Das sagt Hibernate: "Schauen Sie sich die Bohnensiedlung namens" airline "an, um die Konfiguration herauszufinden."
MappedBy-Signale überwintern, dass der Schlüssel für die Beziehung auf der anderen Seite liegt.
Dies bedeutet, dass, obwohl Sie 2 Tabellen miteinander verknüpfen, nur eine dieser Tabellen eine Fremdschlüsseleinschränkung für die andere hat. Mit MappedBy können Sie immer noch von der Tabelle, die die Einschränkung enthält, eine Verknüpfung zu der anderen Tabelle herstellen.
mappedby
es spricht für sich selbst, es sagt dem Ruhezustand. Dieses Feld ist nicht bereit. Es ist bereits fertig mit diesem Feld [name = "field"] zugeordnet.
Feld befindet sich in der anderen Entität (name of the variable in the class not the table in database)
..
Wenn Sie diesen Ruhezustand nicht ausführen, werden diese beiden Beziehungen zugeordnet, da es nicht .__ ist. die gleiche Beziehung
daher müssen wir dem Hibernate mitteilen, dass das Mapping nur auf einer Seite erfolgen soll, und sich zwischen ihnen koordinieren.
mappedby = "Objekt einer Entität derselben Klasse, die in einer anderen Klasse erstellt wurde"
Anmerkung: -Mapped by kann nur in einer Klasse verwendet werden, da eine Tabelle eine Fremdschlüsseleinschränkung enthalten muss. Wenn mapped by auf beide Seiten angewendet werden kann, wird der Fremdschlüssel aus beiden Tabellen entfernt. Ohne Fremdschlüssel gibt es keine Beziehung zwischen zwei und zwei Tabellen.
Hinweis: - Kann für folgende Anmerkungen verwendet werden: - 1. @ OneTone 2. @ OneToMany 3. @ ManyToMany
Hinweis --- Kann nicht für folgende Anmerkungen verwendet werden: - 1. @ ManyToOne
Eins zu eins: - Führen Sie auf einer beliebigen Seite des Mappings aus, aber nur auf einer Seite .. _. Dadurch wird die zusätzliche Spalte der Fremdschlüsseleinschränkung in der Tabelle, für die sie angewendet wird, entfernt.
Für zB Wenn wir die Zuordnung in der Employee-Klasse auf das Employee-Objekt anwenden, wird der Fremdschlüssel aus der Employee-Tabelle entfernt.
Sie haben mit dem ManyToOne-Mapping angefangen, dann setzen Sie das OneToMany-Mapping auch für die BiDirectional-Methode ein ..__ Auf der OneToMany-Seite (normalerweise Ihre übergeordnete Tabelle/Klasse) müssen Sie "mappedBy" erwähnen (das Mapping erfolgt durch und in untergeordneten Tabellen/Klasse), so erzeugt der Ruhezustand keine EXTRA-Zuordnungstabelle in DB (wie TableName = parent_child).