Actualisation de données JPA

Bonsoir,

je reviens à la charge parce que je ne comprend toujours pas pourquoi je n'ai pas les données à jour.

Voici les @Identity

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@Entity
@Table(name = "affaire", catalog = "enregistrementaffaires", schema = "")
public class Affaire implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @Column(name = "IDAFFAIRE")
    private String idaffaire;
    @Column(name = "DATEDDP")
    @Temporal(TemporalType.DATE)
    private Date dateddp;
    @Column(name = "DATELIMITEREPONSE")
    @Temporal(TemporalType.DATE)
    private Date datelimitereponse;
    @Column(name = "DATEOFFRE")
    @Temporal(TemporalType.DATE)
    private Date dateoffre;
    @Column(name = "MONTANT")
    private Float montant;
    @Column(name = "NUMCOMMANDE")
    private String numcommande;
    @Basic(optional = false)
    @Column(name = "DESIGNATIONDDP")
    private String designationddp;
    @Column(name = "REFDDPCLIENT")
    private String refddpclient;
    @Column(name = "MONTANTCOMMANDE")
    private BigDecimal montantcommande;
    @Column(name = "COMMENTAIRE")
    private String commentaire;
    @JoinColumn(name = "IDCONTACT", referencedColumnName = "IDCONTACT")
    @ManyToOne(fetch = FetchType.LAZY)
    private Contact idcontact;
    @JoinColumn(name = "IDCLIENT", referencedColumnName = "IDCLIENT")
    @ManyToOne(fetch = FetchType.LAZY)
    private Client idclient;
    @JoinColumn(name = "IDCHARGEAFFAIRE", referencedColumnName = "IDCHARGEAFFAIRE")
    @ManyToOne(fetch = FetchType.LAZY,cascade=CascadeType.ALL)
    private ChargeAffaire idchargeaffaire;
 
    public Affaire() {
    }.......

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Entity
@Table(name = "chargeaffaire", catalog = "enregistrementaffaires", schema = "")
 
public class ChargeAffaire implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "IDCHARGEAFFAIRE")
    private Integer idchargeaffaire;
    @Basic(optional = false)
    @Column(name = "NOMCHARGEAFFAIRE")
    private String nomchargeaffaire;
    @Basic(optional = false)
    @Column(name = "PRENOMCHARGEAFFAIRE")
    private String prenomchargeaffaire;
    @OneToMany(mappedBy = "idchargeaffaire", fetch = FetchType.LAZY,cascade=CascadeType.ALL)
    private List<Affaire> affaireList;
 
    public ChargeAffaire() {
    }......

et les jpaController:
AffaireJpaController:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 public List<Affaire> findAffaireEntities() {
        return findAffaireEntities(true, -1, -1);
    }
 
    public List<Affaire> findAffaireEntities(int maxResults, int firstResult) {
        return findAffaireEntities(false, maxResults, firstResult);
    }
 
    private List<Affaire> findAffaireEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Affaire as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

ChargeAffaireJpaController:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
  public ChargeAffaire findChargeAffaire(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(ChargeAffaire.class, id);
        } finally {
            em.close();
        }
    }
public List<ChargeAffaire> findChargeAffaireEntities() {
        return findChargeAffaireEntities(true, -1, -1);
    }
 
    public List<ChargeAffaire> findChargeAffaireEntities(int maxResults, int firstResult) {
        return findChargeAffaireEntities(false, maxResults, firstResult);
    }
 
    private List<ChargeAffaire> findChargeAffaireEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from ChargeAffaire as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

la méthode getEntityManager(). Elle est identique pour toutes les classes jpaController.

Code:

1
2
3
public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

et voici mon main avec lequel j'ai testé mes accès:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 public static void main(String[] args) {
        AffaireJpaController jpaAffaire = new AffaireJpaController();
        ChargeAffaireJpaController jpaCharge = new ChargeAffaireJpaController();
        ChargeAffaire CA = jpaCharge.findChargeAffaire(3);
        for (Affaire aff : CA.getAffaireList()) {
            afficheAffaireUnknown(aff);
        }
 
        for (Affaire aff : jpaAffaire.findAffaireEntities()) {
            afficheAffaireUnknown(aff);
        }
 
        jpaCharge = new ChargeAffaireJpaController();
        CA = jpaCharge.findChargeAffaire(3);
        for (Affaire aff : CA.getAffaireList()) {
            afficheAffaireUnknown(aff);
        }
        for (Affaire aff : jpaAffaire.findAffaireEntities()) {
            afficheAffaireUnknown(aff);
        }
    }
 
    private static void afficheAffaireUnknown(Affaire aff) {
        if (aff.getIdaffaire().startsWith("UNKN")) {
            System.out.println(aff.getIdaffaire());
        }
    }

Je précise que j'ai mis des points d'arret à l'entrée de chaque for et qu'en parallèle je modifiais des enregistrements dans la base en direct.

Résultat lors du second CA.GetAffaireList(), j'ai toujours les mêmes données que lors du premier passage. Bien que je les avais modifiées à la fin de la première boucle et que ces modifications sont bien présentes lors du premier jpaAffaire.findAffaireEntities().

Je voudrais savoir comment se fait-il que dans ma méthode jpaCharge.findChargeAffaire() je ne réalise pas une mise à jour, puisque l'entityManager est vide, on vient de le recréer par EntityManagerFactory!!!

Au secours.
Merci