@OneToMany mappedBy maps a _____

Question

Che cosa significa mappedBy mappa a? O, piuttosto, su cosa dovrebbe mappare?

Il headers campo sottostante mappe per @EntityFoo secondo @OneToManydocs? E quindi Foo sarebbe un wrapper per 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ì wrapper per javax.mail.Header è necessario, in generale non è possibile mantenere classi arbitrarie direttamente, in particolare non quelle che non sono serializzabili. Inoltre non possono essere elementi di lista che progettano la relazione tra entità.

Il valore di mappedBy è il nome del campo che possiede il lato della relazione bidirezionale. Per un fare un esempio, supponiamo che un'entità articolo non avere uno-a-molti a Foo entità:

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

ora sappiamo che ci deve essere altro termine di questo rapporto, ed è l'attributo, che è situato a Foo entità, ha l'articolo come un tipo e prende il nome articolo:

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

possedere lato (in questo caso articolo Foo) viene utilizzato quando relazione bidirezionale viene mantenuto al database. Nella specifica JPA 2.0 questo è raccontato con queste parole:

rapporti bidirezionali tra entità gestite saranno persistenti sulla base di riferimenti detenute dal lato possessore della relazione. È la responsabilità dello sviluppatore di mantenere i riferimenti in memoria trattenuti sul lato proprietario e quelli mantenuti sul lato inverso in modo coerente con quando cambiano. Nel caso delle relazioni unidirezionali e one-to-one, è responsabilità dello sviluppatore di assicurare che la semantica delle relazioni sia rispettata.

Answer 2

Controllare qui:documentation

La parte rilevante è:

 mappedBy 
     The field that owns the relationship. 

E 'sorta di auto-esplicativo. Vuoi degli esempi?

Se il Article ha molte Header oggetti, ad esempio, allora Article è possedere la realationship in quanto l'art ha molte intestazioni.