java - mappedby - onetomany hibernate ejemplo

¿Alguien puede explicar mappedBy in hibernate?

Question

Soy nuevo para hibernar y necesito usar relaciones uno a muchos y muchos a uno. Es una relación bidireccional en mis objetos, por lo que puedo atravesar desde cualquier dirección. mappedBy es la forma recomendada de hacerlo, sin embargo, no pude entenderlo. ¿Puede alguien explicarme por favor?

• ¿Cuál es la forma recomendada de usarlo?
• ¿Qué propósito soluciona?

Por el bien de mi ejemplo, aquí están mis clases con anotaciones:

• Airline POSEE muchos AirlineFlights
• Muchos AirlineFlights pertenecen a ONE Airline

Aerolínea :

@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;
}
}

Vuelos de aerolínea:

@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);
}
}

EDITAR:

Esquema de la base de datos:

AirlineFlights tiene idAirline como ForeignKey y Airline no tiene idAirlineFlights. Esto hace que AirlineFlights sea el propietario / entidad identificadora.

Teóricamente, me gustaría que la aerolínea sea la propietaria de los vuelos aéreos.

Answer 1

Al especificar @JoinColumn en ambos modelos, no tiene una relación bidireccional. Tienes dos relaciones unidireccionales, y un mapeo muy confuso de eso. Le está diciendo a ambos modelos que son "dueños" de la columna IDAIRLINE. ¡Realmente solo uno de ellos debería! Lo ''normal'' es quitar @JoinColumn del lado @OneToMany por completo, y en su lugar agregar mappedBy al @OneToMany .

@OneToMany(cascade = CascadeType.ALL, mappedBy="airline")
public Set<AirlineFlight> getAirlineFlights() {
return airlineFlights;
}

Eso le dice a Hibernate "Ve a ver la propiedad de bean llamada ''airline'' en la que tengo una colección para encontrar la configuración".

Answer 2

Comenzó con el mapeo de ManyToOne, luego puso el mapeo de OneToMany también para el modo BiDirectional. Luego, en OneToMany side (generalmente su tabla / clase principal), debe mencionar "mappedBy" (la asignación se realiza por y en la tabla / clase hijo), por lo que hibernate no creará una tabla de asignación EXTRA en DB (como TableName = parent_child).

Answer 3

Las señales MappedBy hibernan que la clave para la relación está en el otro lado.

Esto significa que aunque vincula 2 tablas juntas, solo una de esas tablas tiene una restricción de clave externa para la otra. MappedBy te permite seguir enlazando desde la tabla que no contiene la restricción a la otra tabla.

Answer 4

mappedby = "objeto de la entidad de la misma clase creada en otra clase"

Nota: -Mapped by se puede usar solo en una clase porque una tabla debe contener una restricción de clave externa. si se puede aplicar el mapa por ambos lados, se eliminará la clave foránea de ambas tablas y, sin clave externa, no habrá relación b / w dos tablas.

Nota: - se puede usar para las siguientes anotaciones: - 1. @ OneTone 2. @ OneToMany 3. @ ManyToMany

Nota --- No se puede utilizar para la siguiente anotación: - 1. @ ManyToOne

En uno a uno: - Realice en cualquier lado del mapeo, pero realice en un solo lado. Eliminará la columna adicional de la restricción de clave externa en la tabla en la que se aplica la clase.

Por ej. Si aplicamos mapeado por en la clase Empleado en el objeto empleado, se eliminará la clave externa de la tabla Empleado.

Answer 5

mappedby por él mismo, diga hibernate no mappedby este campo, todo está listo mapeado por este campo [name = "field"].
campo está en la otra entidad (name of the variable in the class not the table in database) .

Si no lo haces, hibernate mapeará estas dos relaciones ya que no tiene la misma relación

así que tenemos que decir hibernate hacer el mapeo en un solo lado y coordinar entre ellos.