JPA J2SE Problème de logique Service/Model ?

**Yro** · 25/02/2015, 11h35

Bonjour,

Situation:
J'ai deux classes "entity" PosUser et PosUserProfil.
J'ai une classe "UserService" qui me permet de faire les recherches, création, suppression, .....
J'ai une classe UserTableModel qui me permet de gérer l'affichage de la liste des utilisateurs dans une JTable.
J'ai une classe UserListPanel qui étend JPanel avec ma Jtable dedans.

Problème
Je souhaite mettre par défaut FetchType=LAZY sur le champ "Profil" dans mon entité PosUser. Car en général, je n'aurai pas besoin de cette info.
Malheureusement lorsque je fait cela, j'ai un beau message d'erreur lorsque je souhaite afficher ma liste d'utilisateur.

Je pense avoir compris pourquoi mais dès lors je me pose la question si je n'ai pas un problème de logique.

Mon UserTableModel utilise le service UserService pour récupérer la liste des utilisateurs (etant donné que Profil est en LAZY, il ne me récupère pas les infos.)
Quand je fais donc un users.get(rowIndex).getProfil().getLibelle(); il est pas content.

Ma question
Dois-je gérer les entityManager au niveau du Model ou au niveau du service comme maintenant? Je suppose que le soucis provient que l'entity Manager est fermé lorsque j'essaie de récupérer les infos du profil utilisateur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package poscaisse.common.entity;
 
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.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
 
@Entity
@NamedQueries({ @NamedQuery(name = "PosUser.getAll", query = "SELECT u FROM PosUser u")
              , @NamedQuery(name = "PosUser.getByLogin", query = "SELECT u FROM PosUser u WHERE u.login = :login") })
public class PosUser {
 
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
 
	@Column(nullable = false, unique = true)
	private String login;
 
	private String nom;
	private String prenom;
 
	@ManyToOne(fetch=FetchType.LAZY)
	private PosUserProfil profil;
 
	public int getId() {
		return id;
	}
 
	public String getLogin() {
		return login;
	}
 
	public void setLogin(String login) {
		this.login = login;
	}
 
	public String getNom() {
		return nom;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public String getPrenom() {
		return prenom;
	}
 
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
 
	public PosUserProfil getProfil() {
		return profil;
	}
 
	public void setProfil(PosUserProfil profil) {
		this.profil = profil;
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		return result;
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof PosUser))
			return false;
		PosUser other = (PosUser) obj;
		if (id != other.id)
			return false;
		return true;
	}
 
	@Override
	public String toString() {
		return "[" +this.login + "]" + this.nom + " " + this.prenom;
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package poscaisse.common.entity;
 
import java.util.Collection;
 
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
 
import poscaisse.common.entity.enumeration.PosUserPermission;
 
@Entity
@NamedQueries({ @NamedQuery(name = "PosUserProfil.getAll", query = "SELECT ut FROM PosUserProfil ut"),
		@NamedQuery(name = "PosUserProfil.getByLibelle", query = "SELECT ut FROM PosUserProfil ut WHERE ut.libelle = :libelle") })
public class PosUserProfil {
 
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
 
	@Column(nullable = false, unique = true)
	private String libelle;
 
	@ElementCollection(targetClass = PosUserPermission.class)
	@Enumerated(EnumType.STRING)
	private Collection<PosUserPermission> permissions;
 
	public String getLibelle() {
		return this.libelle;
	}
 
	public void setLibelle(String libelle) {
		this.libelle = libelle;
	}
 
	public int getId() {
		return this.id;
	}
 
	/**
         * @return the permissions
         */
	public Collection<PosUserPermission> getPermissions() {
		return this.permissions;
	}
 
	/**
         * @param permissions
         *            the permissions to set
         */
	public void setPermissions(Collection<PosUserPermission> permissions) {
		this.permissions = permissions;
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		return result;
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof PosUserProfil))
			return false;
		PosUserProfil other = (PosUserProfil) obj;
		if (id != other.id)
			return false;
		return true;
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return this.libelle;
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/**
 * 
 */
package poscaisse.backoffice.model;
 
import java.util.List;
 
import javax.swing.table.AbstractTableModel;
 
import poscaisse.backoffice.service.UserService;
import poscaisse.common.entity.PosUser;
 
/**
 * 
 *
 */
public class UserTableModel extends AbstractTableModel {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
	private final String[] entetes = { "Id", "Login", "Nom", "Prénom", "Groupe" };
	private UserService userService;
	private List<PosUser> users;
 
	/**
         * 
         */
	public UserTableModel() {
		userService = UserService.getInstance();
		users = userService.getAllUsers();
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see javax.swing.table.TableModel#getColumnCount()
	 */
	@Override
	public int getColumnCount() {
		return entetes.length;
	}
 
	@Override
	public String getColumnName(int columnIndex) {
		return entetes[columnIndex];
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see javax.swing.table.TableModel#getRowCount()
	 */
	@Override
	public int getRowCount() {
		return users.size();
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see javax.swing.table.TableModel#getValueAt(int, int)
	 */
	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		switch (columnIndex) {
		case 0: // Id
			return users.get(rowIndex).getId();
		case 1: // Login
			return users.get(rowIndex).getLogin();
		case 2: // Nom
			return users.get(rowIndex).getNom();
		case 3: // Prénom
			return users.get(rowIndex).getPrenom();
		case 4: // Groupe
			return users.get(rowIndex).getProfil().getLibelle();
		default:
			throw new IllegalArgumentException();
		}
	}
 
	public List<PosUser> getUsers() {
		return users;
	}
 
	public void addUser(PosUser user) {
		users.add(user);
		fireTableRowsInserted(users.size() - 1, users.size() - 1);
	}
 
	public void removeUser(int rowIndex) {
		users.remove(rowIndex);
		fireTableRowsDeleted(rowIndex, rowIndex);
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
package poscaisse.backoffice.service;
 
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
 
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.TypedQuery;
 
import poscaisse.common.entity.PosUser;
import poscaisse.common.entity.PosUserProfil;
import poscaisse.common.entity.enumeration.PosUserPermission;
import poscaisse.common.exception.IllegalValueException;
import poscaisse.common.exception.MandatoryValueException;
import poscaisse.common.util.JPAUtil;
 
 
 
/**
 * 
 *
 */
public class UserService {
 
	private static UserService instance;
 
	private UserService() {
		super();
	}
 
	/**
         * Classe singleton.
         * 
         * @return l'instance du service.
         */
	public static synchronized UserService getInstance() {
		if (instance == null) {
			instance = new UserService();
		}
		return instance;
	}
 
	/**
         * Recherche l'ensemble des utilisateurs du système.
         * 
         * @return Liste de tout les utilisateurs
         */
	public List<PosUser> getAllUsers() {
		EntityManager em = JPAUtil.getEntityManager();
		List<PosUser> users = null;
		try {
			TypedQuery<PosUser> query = em.createNamedQuery("PosUser.getAll", PosUser.class);
			users = query.getResultList();
		} catch (NoResultException ex) {
			return null;
		} finally {
			if (em != null && em.isOpen()) {
				em.close();
			}
		}
		return users;
	}
 
	/**
         * Recherche d'un utilisateur a partir de son identifiant.
         * 
         * @param id
         *            identifiant a rechercher.
         * @return Utilisateur ou null si non trouvé
         */
	public PosUser getUserById(int id) {
		PosUser foundUser = null;
		EntityManager em = JPAUtil.getEntityManager();
		foundUser = em.find(PosUser.class, id);
		em.close();
		return foundUser;
	}
 
	/**
         * Recherche d'un utilisateur a partir de son login
         * 
         * @param login
         *            login de l'utilisateur a rechercher
         * @return Utilisateur ou null si non trouvé
         */
	public PosUser getUserByLogin(String login) {
		PosUser foundUser = null;
		EntityManager em = JPAUtil.getEntityManager();
 
		try {
			TypedQuery<PosUser> query = em.createNamedQuery("PosUser.getByLogin", PosUser.class);
			query.setParameter("login", login);
			foundUser = query.getSingleResult();
		} catch (NoResultException ex) {
			return null;
		} finally {
			if (em != null && em.isOpen()) {
				em.close();
			}
		}
		return foundUser;
	}
 
	/**
         * Recherche d'un type d'utilisateur (UserType) a partir de son libellé
         * 
         * @param libelle
         *            libelle du type d'utilisateur a rechercher
         * @return Type d'utilisateur ou null si non trouvé
         */
	public PosUserProfil getUserTypeByLibelle(String libelle) {
		PosUserProfil foundUserType = null;
		EntityManager em = JPAUtil.getEntityManager();
 
		try {
			TypedQuery<PosUserProfil> query = em.createNamedQuery("PosUserProfil.getByLibelle", PosUserProfil.class);
			query.setParameter("libelle", libelle);
			foundUserType = query.getSingleResult();
		} catch (NoResultException ex) {
			return null;
		} finally {
			if (em != null && em.isOpen()) {
				em.close();
			}
		}
		return foundUserType;
	}
 
	/**
         * Recherche d'un type d'utilisateur a partir de son identifiant
         * 
         * @param id
         *            identifiant du type d'utilisateur a rechercher
         * @return Type d'utilisateur ou null si non trouvé
         */
	public PosUserProfil getUserTypeById(int id) {
		PosUserProfil foundUserType = null;
		EntityManager em = JPAUtil.getEntityManager();
		foundUserType = em.find(PosUserProfil.class, id);
		em.close();
		return foundUserType;
	}
 
	/**
         * Validation des données de l'utilisateur
         * 
         * @param user
         *            utilisateur a valider
         * @return true si toutes les données sont correctes
         * @throws MandatoryValueException
         *             si un champs obligatoire n'est pas renseigné
         * @throws IllegalValueException
         *             si la valeur d'un champ n'est pas correcte
         * @throws IllegalArgumentException
         *             si on tente de tester un utilisateur null
         */
	public boolean validateUser(PosUser user) throws MandatoryValueException, IllegalValueException {
		PosUser userResult = null;
 
		if (user == null)
			throw new IllegalArgumentException("UserService.validateUser : Null exception !");
 
		if (user.getLogin() == null || user.getLogin().isEmpty())
			throw new MandatoryValueException("Login est un champ obligatoire");
 
		userResult = getUserByLogin(user.getLogin());
		if (userResult != null && !userResult.equals(user))
			throw new IllegalValueException("Login déjà attribué a un autre utilisateur");
 
		if (user.getProfil() == null)
			throw new MandatoryValueException("Profil utilisateur est un champ obligatoire");
 
		return true;
	}
 
	/**
         * Validation des données de l'utilisateur
         * 
         * @param userType
         *            type d'utilisateur a valider
         * @return true si toutes les données sont correctes
         * @throws MandatoryValueException
         *             si un champs obligatoire n'est pas renseigné
         * @throws IllegalValueException
         *             si la valeur d'un champ n'est pas correcte
         * @throws IllegalArgumentException
         *             si on tente de tester un type d'utilisateur null
         */
	public boolean validateUserType(PosUserProfil userType) throws MandatoryValueException, IllegalValueException {
		if (userType == null)
			throw new IllegalArgumentException("UserService.validateUserType : Null exception !");
 
		if (userType.getLibelle() == null || userType.getLibelle().isEmpty())
			throw new MandatoryValueException("Libellé est un champ obligatoire");
 
		PosUserProfil userTypeResult = getUserTypeByLibelle(userType.getLibelle());
		if (userTypeResult != null && !userTypeResult.equals(userType))
			throw new IllegalValueException("Libellé déjà attribué a un autre type d'utilisateur");
 
		return true;
	}
 
	/**
         * Sauvegarde d'un utilisateur (Insert ou update)
         * 
         * @param user
         *            Utilisateur a enregistrer
         * @return l'utilisateur (User)
         * @throws MandatoryValueException
         *             si un champs obligatoire n'est pas renseigné
         * @throws IllegalValueException
         *             si la valeur d'un champ n'est pas correcte
         */
	public PosUser saveOrUpdate(PosUser user) throws MandatoryValueException, IllegalValueException {
		EntityManager em = JPAUtil.getEntityManager();
		validateUser(user);
		em.getTransaction().begin();
		if (user.getId() == 0)
			em.persist(user);
		else
			em.merge(user);
 
		em.getTransaction().commit();
		em.close();
 
		return user;
	}
 
	/**
         * Sauvegarde d'un type d'utilisateur (Insert ou update)
         * 
         * @param userTypeType
         *            d'utilisateur a enregistrer
         * @return le type d'utilisateur (UserType)
         * @throws MandatoryValueException
         *             si un champs obligatoire n'est pas renseigné
         * @throws IllegalValueException
         *             si la valeur d'un champ n'est pas correcte
         */
 
	public PosUserProfil saveOrUpdate(PosUserProfil userType) throws MandatoryValueException, IllegalValueException {
		validateUserType(userType);
 
		EntityManager em = JPAUtil.getEntityManager();
		em.getTransaction().begin();
		em.persist(userType);
		em.getTransaction().commit();
		em.close();
		return userType;
	}
 
	/**
         * Ajout d'une permission à un type d'utilisateur
         * 
         * @param userType
         *            Type d'utilisateur
         * @param userPermission
         *            permission a ajouter
         */
	public void addUserTypePermission(PosUserProfil userType, PosUserPermission userPermission) {
		if (!userType.getPermissions().contains(userPermission)) {
			HashSet<PosUserPermission> permissions = (HashSet<PosUserPermission>) userType.getPermissions();
			permissions.add(userPermission);
		}
	}
 
	/**
         * Suppression d'une permission à un type d'utilisateur
         * 
         * @param userType
         *            Type d'utilisateur
         * @param userPermission
         *            permission a supprimer
         */
	public void removeUserTypePermission(PosUserProfil userType, PosUserPermission userPermission) {
		if (userType.getPermissions().contains(userPermission)) {
			HashSet<PosUserPermission> permissions = (HashSet<PosUserPermission>) userType.getPermissions();
			permissions.remove(userPermission);
		}
	}
 
	public void setUserTypePermission(PosUserProfil userType, Collection<PosUserPermission> permissions) {
		userType.setPermissions(permissions);
	}
 
	public List<PosUserProfil> getAllUserTypes() {
		EntityManager em = JPAUtil.getEntityManager();
		List<PosUserProfil> usertypes = null;
		try {
			TypedQuery<PosUserProfil> query = em.createNamedQuery("PosUserProfil.getAll", PosUserProfil.class);
			usertypes = query.getResultList();
		} catch (NoResultException ex) {
			return null;
		} finally {
			if (em != null && em.isOpen()) {
				em.close();
			}
		}
		return usertypes;
	}
 
}

**OButterlin** · 25/02/2015, 12h09

C'est le problème récurrent avec le lazy loading, dès que l'entity est détachée, on ne peut plus accéder aux propriétés lazy non chargées.

Le pattern facade est une bonne réponse à la problèmatique, ta façade aura des méthodes de chargement liées à tes vues.
Dans la recherche qui n'a pas besoin du Profil, rien ne change...
Dans l'autre, il suffit de faire un "[left] join fetch" sur la propriété

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Query query = entityManager.createQuery("select a from PosUser a join fetch a.profil where ...");

**Yro** · 25/02/2015, 14h54

Merci pour ta réponse.

Donc si je comprend bien au niveau de la classe UserService, je dois créer deux méthodes distincte:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public List<PosUser> getAllUsers() {
		EntityManager em = JPAUtil.getEntityManager();
		List<PosUser> users = null;
		try {
			TypedQuery<PosUser> query = em.createNamedQuery("PosUser.getAll", PosUser.class);
			users = query.getResultList();
		} catch (NoResultException ex) {
			return null;
		} finally {
			if (em != null && em.isOpen()) {
				em.close();
			}
		}
		return users;
	}
 
public List<PosUser> getAllUsersFullInfo() {
		EntityManager em = JPAUtil.getEntityManager();
		List<PosUser> users = null;
		try {
			TypedQuery<PosUser> query = em.createNamedQuery("PosUser.getAllFullInfo", PosUser.class);
			users = query.getResultList();
		} catch (NoResultException ex) {
			return null;
		} finally {
			if (em != null && em.isOpen()) {
				em.close();
			}
		}
		return users;
	}

Est-ce bien cela?
Est ce pas redondant?

**OButterlin** · 25/02/2015, 17h03

Oui, c'est le principe...
Pour la redondance, dans ton cas, oui, certes... mais il y a moyen de faire plus simple, surtout en passant par des NamedQuery, tu pourrais par exemple utiliser un paramètre pour ta méthode... j'dis ça, j'dis rien

**Yro** · 26/02/2015, 09h12

Bien vu

Merci.

JPA J2SE Problème de logique Service/Model ?

JPA Java

Discussions similaires

Partager

Partager