ManyToMany JPA fetch

Question

Salut J'ai un problème pour aller chercher les compétences du volontaire. pour une raison quelconque je n'obtenir la liste lorsque vous utilisez cette méthode

public Volunteer getVolunteer(int id){ 

Volunteer vo; 

Query q; 

q = em.createNamedQuery("Volunteer.findById").setParameter("id", id); 
vo = (Volunteer) q.getSingleResult(); 

for(Skill s: vo.getSkills()){ 
    System.out.println(s); 
} 

return vo; 

} 

la liste est vide si l'extraction ne semble pas fonctionner.

Im en utilisant JPA EclipseLink et Glassfish

Toute aide appréciée!

L'entité de compétences:

@Entity 
@Table(name="skill") 
@NamedQueries({ 
    @NamedQuery(name = "Skill.findAll", query = "SELECT s FROM Skill s"), 
    @NamedQuery(name = "Skill.findById", query = "SELECT s FROM Skill s WHERE s.id = :id"), 
    @NamedQuery(name = "Skill.findBySkillDescription", query = "SELECT s FROM Skill s WHERE s.skillDescription = :skillDescription")}) 
public class Skill implements Serializable { 
@Override 
public String toString() { 
    return "Skill [id=" + id + ", skillDescription=" + skillDescription 
    + "]"; 
} 

private static final long serialVersionUID = 1L; 

@Id 
@GeneratedValue(strategy=GenerationType.IDENTITY) 
@Column(unique=true, nullable=false) 
private int id; 

@Column(name="skill_description", length=130) 
private String skillDescription; 

//bi-directional many-to-many association to Volunteer 
    @ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER) 
@JoinTable(
    name="skill_volunteer" 
    , joinColumns={ 
    @JoinColumn(name="skill_id", nullable=false) 
    } 
    , inverseJoinColumns={ 
    @JoinColumn(name="volunteer_id", nullable=false) 
    } 
) 
private List<Volunteer> volunteers; 

    public Skill() { 
    } 

public int getId() { 
    return this.id; 
} 

public void setId(int id) { 
    this.id = id; 
} 

public String getSkillDescription() { 
    return this.skillDescription; 
} 

public void setSkillDescription(String skillDescription) { 
    this.skillDescription = skillDescription; 
} 

public List<Volunteer> getVolunteers() { 
    return this.volunteers; 
} 

public void setVolunteers(List<Volunteer> volunteers) { 
    this.volunteers = volunteers; 
} 

} 

Et l'entité bénévole:

@Entity 
@Table(name="volunteer") 
@NamedQueries({ 
    @NamedQuery(name = "Volunteer.findAll", query = "SELECT v FROM Volunteer v"), 
    @NamedQuery(name = "Volunteer.findById", query = "SELECT v FROM Volunteer v WHERE v.id = :id"), 
    @NamedQuery(name = "Volunteer.findByPhone", query = "SELECT v FROM Volunteer v WHERE v.phone = :phone"), 
    @NamedQuery(name = "Volunteer.findByEmail", query = "SELECT v FROM Volunteer v WHERE v.email = :email"), 
    @NamedQuery(name = "Volunteer.findByFirstName", query = "SELECT v FROM Volunteer v WHERE v.firstName = :firstName"), 
    @NamedQuery(name = "Volunteer.findByLastName", query = "SELECT v FROM Volunteer v WHERE v.lastName = :lastName")}) 
public class Volunteer implements Serializable { 
@Override 
public String toString() { 
    return "Volunteer [id=" + id + ", email=" + email + ", firstName=" 
    + firstName + ", lastName=" + lastName + ", phone=" + phone 
    + "]"; 
} 

private static final long serialVersionUID = 1L; 

@Id 
@GeneratedValue(strategy=GenerationType.IDENTITY) 
@Column(unique=true, nullable=false) 
private int id; 

@Column(length=255) 
private String email; 

@Column(name="first_name", length=255) 
private String firstName; 

@Column(name="last_name", length=255) 
private String lastName; 

@Column(length=255) 
private String phone; 

//bi-directional many-to-many association to Event 
@ManyToMany(mappedBy="volunteers") 
private List<Event> events; 

//bi-directional many-to-many association to Skill 
@ManyToMany(mappedBy="volunteers", cascade=CascadeType.ALL, fetch=FetchType.EAGER) 
private List<Skill> skills; 

    public Volunteer() { 
    } 

public int getId() { 
    return this.id; 
} 

public void setId(int id) { 
    this.id = id; 
} 

public String getEmail() { 
    return this.email; 
} 

public void setEmail(String email) { 
    this.email = email; 
} 

public String getFirstName() { 
    return this.firstName; 
} 

public void setFirstName(String firstName) { 
    this.firstName = firstName; 
} 

public String getLastName() { 
    return this.lastName; 
} 

public void setLastName(String lastName) { 
    this.lastName = lastName; 
} 

public String getPhone() { 
    return this.phone; 
} 

public void setPhone(String phone) { 
    this.phone = phone; 
} 

public List<Event> getEvents() { 
    return this.events; 
} 

public void setEvents(List<Event> events) { 
    this.events = events; 
} 

public List<Skill> getSkills() { 
    return this.skills; 
} 

public void setSkills(List<Skill> skills) { 
    this.skills = skills; 
} 

} 

Answer 1

la liste est vide si l'extraction ne semble pas fonctionner.

Obtenir une liste vide ne permet pas de conclure que « aller chercher » ne fonctionne pas et si vous utilisez un LAZY ou un type chercher Eager, vous devriez obtenir des documents de compétences à un volontaire donné s'il y a lieu.

Et parce que la cartographie semble correct, je commencerais en regardant le SQL généré et l'exécuter contre la base de données pour confirmer

1. que le SQL généré est le résultat attendu
2. que les données sont correctes .

Pour ce faire, définissez les propriétés suivantes dans le persistence.xml:

<property name="eclipselink.logging.level" value="FINEST" /> 
    <property name="eclipselink.logging.level.sql" value="FINEST" /> 

Ensuite, trouver les requêtes SQL pour le findById et le getSkills et les exécuter sur la base de données.

Et s'il vous plaît mettre à jour la question avec le résultat obtenu pour un ID donné (à la fois le SQL généré et la confirmation que les données sont ok).

Answer 2

Essayez d'utiliser em.flush(), c'est un travail pour moi;

Query q = em.createNamedQuery("Volunteer.findById").setParameter("id", id); 
vo = (Volunteer) q.getSingleResult(); 
em.flush(); 
for(Skill s: vo.getSkills()){ 
    System.out.println(s); 
} 

Answer 3

Le problème le plus courant des relations bi-directionnelle lorsque les utilisateurs ne maintiennent pas les deux côtés - entités JPA sont des objets java simples, et JPA ne résout pas les relations pour vous comme EJB 2.0 utilisé pour. Lorsque vous ajoutez un volontaire à une compétence, vous devez également ajouter l'habileté au volontaire afin que le cache reste synchronisé avec les modifications que vous indiquez dans la base de données.