Problème de cache java EE.

Salut à tous!

En effet je fait une appli java EE utilisant les EJBs. Mais lorsque je fais de modifications à la main sur la base de données. Elle ne sont prise en compte par l'application que lorsque je redéplois l'application. J'ignore vraiment pourquoi mais je soupçonne un problème de cache seulement je ne sais comment vidé celui ci! J'utilise glasfish, eclipslink et netbeans.

Merci d'avance.

Bonjour.
Si tu réintérroges ta base de données quand tu rafraîchis ta page, tu devrais avoir les données à jour.
Tu voudrais que ta page s'actualise automatiquement ?

si je recharge les données depuis la base de données au chargement de la page mais les modification effectués dans le SGBD ne sont pas prises en compte.

Bonjour,

Je pense que les modifications que tu as faits directement dans la base n'a pas été comitées, donc pas prise en compte sur les autres connexions. Si tu redémarres ton serveur de bd, tu retrouves les modifications après?

A+.

au redémarrage du SGBD je retrouve bien les modification vue que je l'ai effectue avec une requête sql en console. mais elle ne sont prisent en compte par l'application que lorsque je redéploie (recompile) l'application.

lorsque je redémarre glasfish je retrouve les modifications. du coup je pense a un problème de cache.

Peux tu nous montrer un peu de ton code ?
La manière dont ta vue récupère les données, la manière dont tu récupères les données en base.
Merci.

Bonjour,

1- Tu peux rafraîchir ton entité avec la méthode refresh de ton EntityManager si l'entité est déjà chargé.
2- Tu peux aussi forcer la lecture à la base,

Code:

em.setProperty("javax.persistence.cache.retrieveMode", CacheRetrieveMode.BYPASS);

Mais, le mieux c'est que tu nous montres ton code comme disait fr1man pour voir.

A+.

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
 
//Entité
 
import java.io.Serializable;
import java.math.BigInteger;
import java.util.Date;
import java.util.List;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
 
@Entity
@Table(name = "student")
@XmlRootElement
public class Student implements Serializable {
 
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "id_student")
    private Integer idStudent;
    @Basic(optional = false)
    @Column(name = "stud_mat", length = 14)
    private String studMat;
    @Basic(optional = false)
    @Column(name = "stud_name", length = 255)
    private String studName;
    @Basic(optional = false)
    @Column(name = "stud_date_birth")
    @Temporal(TemporalType.DATE)
    private Date studDateBirth;
    @Basic(optional = false)
    @Column(name = "stud_place_birth", length = 100)
    private String studPlaceBirth;
    @Basic(optional = false)
    @Column(name = "stud_sex", length = 2)
 @JoinColumn(name = "id_dept", referencedColumnName = "id_dept")
    @ManyToOne(fetch = FetchType.LAZY)
    private Department department;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "student", fetch = FetchType.LAZY)
    private List<Studentcourse> studentcourseList;
    @OneToOne(mappedBy = "student", fetch = FetchType.LAZY)
    private Utilisateur utilisateur;
 
    public Student() {
    }
 
    //Date d = new Date();
    //int a= d.getYear(), b=d.getMonth(),c=d.getDate();
 
    public Student(Integer idStudent) {
        this.idStudent = idStudent;
    }
//..... getter et setter
 
  @XmlTransient
    public List<Studentcourse> getStudentcourseList() {
        return studentcourseList;
    }
//.....
 
}
 
 
 
import java.io.Serializable;
import java.util.List;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
 
@Entity
@Table(name = "studentcourse")
@XmlRootElement
public class Studentcourse implements Serializable {
 
    private static final long serialVersionUID = 1L;
    @EmbeddedId
    protected StudentcoursePK studentcoursePK;
    @Basic(optional = false)
    @Column(name = "academic_year", length = 10)
    private String academicYear;
    @Basic(optional = false)
    @Column(name = "exam_session", length = 20)
    private String examSession;
    // @Max(value=?)  @Min(value=?)//if you know range of your decimal fields consider using these annotations to enforce field validation
    @Column(name = "ca_mark")
    private Float caMark;
    @Column(name = "exam_mark")
    private Float examMark;
    @Column(name = "anonymity", length = 15)
    private String anonymity;
    @JoinColumn(name = "id_course", referencedColumnName = "id_course", insertable = false, updatable = false)
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private Course course;
    @JoinColumn(name = "id_student", referencedColumnName = "id_student", insertable = false, updatable = false)
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private Student student;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "studentcourse", fetch = FetchType.LAZY)
    private List<Journal> journalList;
 
    public Studentcourse() {
    }
 
    public Studentcourse(StudentcoursePK studentcoursePK) {
        this.studentcoursePK = studentcoursePK;
    }
 
    public Studentcourse(StudentcoursePK studentcoursePK, String academicYear, String examSession) {
        this.studentcoursePK = studentcoursePK;
        this.academicYear = academicYear;
        this.examSession = examSession;
    }
 
    public Studentcourse(int idCourse, int idStudent) {
        this.studentcoursePK = new StudentcoursePK(idCourse, idStudent);
    }
 
    public StudentcoursePK getStudentcoursePK() {
        return studentcoursePK;
    }
 
    public void setStudentcoursePK(StudentcoursePK studentcoursePK) {
        this.studentcoursePK = studentcoursePK;
    }
 
    public String getAcademicYear() {
        return academicYear;
}
// ... getter et setter
 
}
 
//servlet 
 
public class StudentManagement extends HttpServlet {
 
    @EJB
    private StudentFacadeLocal studentFacade;
 
    public static final String PROFILE_STUDENT = "/WEB-INF/student/studentProfile.jsp";
 
       @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
     String idStudent = request.getParameter("idStudent");
 
                    Student student = studentFacade.find(Integer.parseInt(idStudent));
 
                    String idDept = request.getParameter("idDept");
 
                    String level = request.getParameter("level");
 
                    String academicYear = request.getParameter("academicYear");
 
                    String examSession = request.getParameter("examSession");
 
                    request.setAttribute("student", student);
                    request.setAttribute("idDept", idDept);
                    request.setAttribute("level", level);
                    request.setAttribute("academicYear", academicYear);
                    request.setAttribute("examSession", examSession);
 
                    this.getServletContext().getRequestDispatcher(PROFILE_STUDENT).forward(request, response);
}
}
 
// Interface EJB généré via netbeans
 
import com.appmate.entities.Student;
import java.util.List;
import javax.ejb.Local;
 
@Local
public interface StudentFacadeLocal {
 
    void create(Student student);
 
    void edit(Student student);
 
    void remove(Student student);
 
    Student find(Object id);
}
 
// Implementation EJB
import com.appmate.entities.Student;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
 
 
@Stateless
public class StudentFacade extends AbstractFacade<Student> implements StudentFacadeLocal {
 
    @PersistenceContext(unitName = "APPMATE.-ejbPU")
    private EntityManager em;
 
    @Override
    protected EntityManager getEntityManager() {
        return em;
    }
 
    public StudentFacade() {
        super(Student.class);
    }
}
 
 
// vue JSP
 
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>STUDENT PROFILE</title>
    </head>
    <body>
        Reg. Number: ${student.studMat}<br/>
        Name : ${student.studName} <br>
        Department : ${student.department.deptName}<br/>
        Level : ${student.studLevel} <br/><br/>
        <table class="table table-bordered table-striped">
            <thead>
                <tr>
                    <th>Course Title</th>
                    <th>Course Credit</th>
                    <th>CA Mark / 30</th>
                    <th>Exam Mark / 70</th>
                    <th>Total / 100</th>
            </tr>
            </thead>
            <tbody>
            <c:forEach items="${student.studentcourseList}" var="studentCourse">
                <c:if test="${level==studentCourse.course.courseLevel and studentCourse.examSession == examSession and studentCourse.academicYear==academicYear}">
                    <tr>
                        <td>${studentCourse.course.courseTitle}</td>
                        <td>${studentCourse.course.courseCredit}</td>
                        <td>${studentCourse.caMark}</td> // une modification effectué sur cette valeur par exemple depuis le SGBD n'est pas prise en compte par l'application
                        <td>${studentCourse.examMark}</td>
                        <td><fmt:formatNumber maxFractionDigits="2" value="${studentCourse.caMark + studentCourse.examMark}"/></td>
                     </tr>
                </c:if> 
            </c:forEach>
            </tbody>
        </table>
    </body>
</html>

c'est bon merci beaucoup pour votre aide. j'ai du rafraîchi la liste contenu dans l'entité student a la recupération de student.
ce qui donne ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 @Override
    public Student find(Object id) {
        Student student;
        try {
            student = (Student) em.createQuery("SELECT s FROM Student s WHERE s.idStudent = :id").setParameter("id", id).getSingleResult();
        } catch (NoResultException ex) {
            return null;
        }
         for(int i=0;i< student.getStudentcourseList().size();i++)
                    em.refresh(student.getStudentcourseList().get(i));
        return student;
    }

Le problème vient du fait, à mon avis, que ta collection est en mode Lazy, le mode normal de fonctionnement, c'est à dire que quand tu récupères tes étudiants, la collection de cours associée n'est jamais chargée.
Si tu veux la charger explicitement à partir d'une requête comme tu le fais, il faut charger ta collection:
Code:

1 2 SELECT s FROM Student s left join fetch s. studentcourseList WHERE s.idStudent = :id
Attention pour éviter les problèmes de performances, il ne faut charger explicitement qu'une collection par requête, d'ailleurs je pense que tu auras une exception dans le cas contraire.

Les modifications ne sont toujours pas prise en compte même avec la jointure lorsque je ne rafraichi pas la collection de cours.