Kann mir jemand erklären, mappedBy im Ruhezustand?
Ich bin neu in hibernate und verwenden müssen, um eins-zu-viele und viele-zu-eins-Beziehungen. Es ist eine bi-direktionale Beziehung, in der meine Objekte, so dass ich die traverse aus beiden Richtungen. mappedBy
ist der empfohlene Weg, um darüber zu gehen, aber ich konnte es nicht verstehen. Kann sich das jemand erklären:
- was ist der empfohlene Weg, es zu benutzen?
- welchen Zweck hat es zu lösen?
Wegen meiner Beispiel, hier sind meine Klassen mit Annotationen:
Airline
BESITZT vieleAirlineFlights
- Viele
AirlineFlights
gehören EINEAirline
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;
}
}
AirlineFlights:
@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);
}
}
EDIT:
Datenbank-schema:
AirlineFlights hat die idAirline als ForeignKey und die Fluggesellschaft hat keine idAirlineFlights. Das macht AirlineFlights als Eigentümer/identifizierende Entität ?
Theoretisch hätte ich wie airline-Besitzer, airlineFlights.
Du musst angemeldet sein, um einen Kommentar abzugeben.
Durch die Angabe der
@JoinColumn
auf beide Modelle, die Sie nicht haben, eine zwei-Wege-Beziehung. Sie haben zwei one-way-Beziehungen, und eine sehr verwirrende Zuordnung der stellen. Sie sagen, beide Modelle, die Sie "besitzen" die IDAIRLINE Spalte. Wirklich nur einer von Ihnen tatsächlich sollte! Die "normale" Sache ist, die@JoinColumn
aus der@OneToMany
Seite völlig, und anstatt hinzufügen mappedBy der@OneToMany
.Erzählt, dass Hibernate "Geh mal rüber auf die bean-Eigenschaft mit dem Namen 'airline' auf die Sache, ich habe eine Sammlung, die Konfiguration zu finden."
@ManyToOne
Seite, richtig?MappedBy-Signale hibernate, dass der Schlüssel für die Beziehung ist, auf der anderen Seite.
Dies bedeutet, dass obwohl Sie link 2 Tische zusammen, nur 1 der Tabelle eine foreign key-Einschränkung auf die andere. MappedBy können Sie noch den link von der Tabelle enthält nicht die Einschränkung auf die andere Tabelle.
mappedBy
eher als definieren eines bi-direktional (mit foreign_key Einschränkungen auf jeder Seite)?mappedby
spricht für sich, es sagt, dass hibernate nicht anzeigen in diesem Feld. es ist bereits abgebildet in das Feld [name="Feld"].Feld ist in der anderen Einheit
(name of the variable in the class not the table in the database)
..so müssen wir sagen, hibernate zu tun, die Zuordnung in nur einer Seite und die Koordinierung zwischen Ihnen.
mappedby="Objekt der Entität der gleichen Klasse erstellt in einer anderen Klasse"
Hinweis:-die Zugeordnet verwendet werden, können nur in einer Klasse, weil die eine Tabelle enthalten muss, foreign key-Einschränkung. wenn abgebildet angewendet werden können, auf beiden Seiten, dann entfernen Fremdschlüssel aus Tabelle und ohne foreign key-es ist in keinem Verhältnis b/w zwei Tabellen.
Hinweis:- es kann verwendet werden für folgende Anmerkungen:-
1.@OneTone
2.@OneToMany
3.@ManyToMany
Hinweis---Es kann nicht sein, verwenden Sie für die folgenden Anmerkungen :-
1.@ManyToOne
In eins-zu-eins :- Führen Sie auf jeder Seite der Zuordnung, sondern führen nur zu einer Seite .
Es wird entfernen Sie die zusätzliche Spalte der foreign key-Einschränkung für die Tabelle, auf die Klasse angewendet wird.
ZB . Wenn wir zugeordnet, indem Sie in der Employee-Klasse, die auf Mitarbeiter-Objekt dann Fremdschlüssel aus Employee-Tabelle entfernt werden.
Begann Sie mit ManyToOne-mapping , dann setzen Sie OneToMany-mapping als auch für die Bidirektionale Art und Weise.
Dann bei OneToMany-Seite (in der Regel der übergeordneten Tabelle/Klasse), Sie haben zu schweigen "mappedBy" (Zuordnung geschieht durch und in der Kind-Tabelle/Klasse), so dass hibernate keine EXTRA mapping-Tabelle in der DB (wie TableName = parent_child).