java - ejemplo - @OneToMany mappedBy maps to_____

onetomany spring

Question

¿Qué hace mappedBy map to ? O, mejor dicho, ¿a qué debería corresponder?

El campo de headers debajo de los mapas a @Entity Foo según @OneToMany docs ? Y entonces Foo sería un contenedor para javax.mail.Header ?

package net.bounceme.dur.usenet.model;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.mail.Header;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.persistence.*;
@Entity
public class Articles implements Serializable {
private static final long serialVersionUID = 1L;
private static final Logger LOG = Logger.getLogger(Articles.class.getName());
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column
private String subject;
@OneToMany(mappedBy="foo") //a wrapper for Header is needed?
private List<Header> headers = new ArrayList<>();
public Articles() {
}
public Articles(Message message) {
try {
subject = message.getSubject();
} catch (MessagingException ex) {
Logger.getLogger(Articles.class.getName()).log(Level.SEVERE, null, ex);
}
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Override
public int hashCode() {
int hash = 0;
hash += (id != null ? id.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
// TODO: Warning - this method won''t work in the case the id fields are not set
if (!(object instanceof Articles)) {
return false;
}
Articles other = (Articles) object;
if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
return false;
}
return true;
}
@Override
public String toString() {
return subject;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
}

Answer 1

Sí, se necesita wrapper para javax.mail.Header, en general no se pueden persistir directamente las clases arbitrarias, especialmente las que no son serializables. Tampoco pueden ser elementos de la lista que diseñe la relación entre entidades.

Valor de mappedBy es el nombre del campo que posee el lado de la relación bidireccional. A modo de ejemplo, supongamos que la entidad Article tiene una relación uno a muchos con la entidad Foo:

@OneToMany(mappedBy="article")
private List<Foo> headers;

Ahora sabemos que debe haber otro extremo de esta relación, y es un atributo, que se ubica a la entidad Foo, tiene Artículo como tipo y se llama artículo :

@Entity
public class Foo {
...
@ManyToOne
Article article;
}

El lado propietario (en este caso el artículo en Foo) se usa cuando la relación bidireccional se mantiene en la base de datos. En la especificación JPA 2.0 esto se cuenta con las siguientes palabras:

Las relaciones bidireccionales entre entidades gestionadas se mantendrán en función de las referencias mantenidas por el lado propietario de la relación. Es responsabilidad del desarrollador mantener las referencias en memoria retenidas en el lado propietario y las retenidas en el lado inverso coherentes entre sí cuando cambian. En el caso de las relaciones unidireccionales uno a uno y uno a muchos, es responsabilidad del desarrollador asegurarse de que se cumpla la semántica de las relaciones.

Answer 2

Compruebe aquí: documentation

La parte relevante es:

 mappedBy
The field that owns the relationship.

Es algo que se explica por sí mismo. ¿Quieres ejemplos?

Si su Article tiene muchos objetos de Header , por ejemplo, el Article es el propietario de la relación ya que el artículo tiene muchos encabezados.