Qu'est-ce que mappedBy
mappe à ? Ou plutôt, à quoi devrait-il correspondre?
Le champ headers
ci-dessous correspond à @Entity
Foo
selon @OneToMany
documents ? Et puis Foo
serait un wrapper pour 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;
}
}
Oui, un wrapper pour javax.mail.Header est nécessaire, en général, vous ne pouvez pas conserver directement les classes arbitraires, en particulier celles qui ne sont pas sérialisables. Ils ne peuvent pas non plus être des éléments de liste qui conçoivent la relation entre les entités.
La valeur de mappedBy est le nom du champ propriétaire de la relation bidirectionnelle. Par exemple, supposons que l'entité Article ait une relation un-à-plusieurs avec l'entité Foo:
@OneToMany(mappedBy="article")
private List<Foo> headers;
Maintenant, nous savons qu'il doit y avoir une autre extrémité de cette relation, et son attribut, qui se trouve dans l'entité Foo, a l'article comme type et est nommé article:
@Entity
public class Foo {
...
@ManyToOne
Article article;
}
Le côté propriétaire (dans ce cas, l'article de Foo) est utilisé lorsque la relation bidirectionnelle est conservée dans la base de données. Dans la spécification JPA 2.0, cela est dit avec les mots suivants:
Les relations bidirectionnelles entre les entités gérées seront conservées en fonction des références détenues par le côté propriétaire de la relation. Il est de la responsabilité du développeur de conserver les références en mémoire conservées du côté propriétaire et celles conservées du côté inverse les unes par rapport aux autres lorsqu'elles changent. Dans le cas de relations unidirectionnelles un-à-un et un-à-plusieurs, il est de la responsabilité du développeur de s'assurer que la sémantique des relations est respectée.
Cochez ici: documentation
La partie pertinente est:
mappedBy The field that owns the relationship.
C'est assez explicite. Voulez-vous des exemples?
Si votre Article
possède de nombreux objets Header
par exemple, alors Article
est propriétaire de la propriété puisque l'article a de nombreux en-têtes.