Discussion :

[Nertios]

Bonjour,

J'ai un problème lors d'un fetch join sur une collection, qui me renvoie une liste de deux éléments : un null et un objet Droit. Or, seul l'objet devrait être retourné.

J'ai vérifié mon jeu de test => OK.
J'ai testé mon DAO avec un Criteria et une Query HQL au cas où, mais le résultat est le même.

Est-ce un problème de mapping ? Ou au niveau de ma requête ?

Cordialement.


Classe Module :

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
@Entity
public class Module implements Serializable
{
	/** Identifiant. */
	@Id
	@SequenceGenerator(name = "seq_module", sequenceName = "seq_module", allocationSize = 1)
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "seq_module")
	private Integer id;
 
	/** Libellé. */
	@Basic
	private String libelle;
 
	/** Liste des droits rattachés au module. */
	@OneToMany(mappedBy = "module")
	@IndexColumn(name = "id")
	private List<Droit> droits;
 
	[...]
 
	/** {@inheritDoc} */
	@Override
	public boolean equals(Object other)
	{
		if (other == null)
		{
			return false;
		}
		if (other == this)
		{
			return true;
		}
		if (!(other instanceof Module))
		{
			return false;
		}
 
		Module cast = (Module) other;
		if (this.id == null ? cast.id != this.id : !this.id.equals(cast.id))
		{
			return false;
		}
 
		return true;
	}
 
	/** {@inheritDoc} */
	@Override
	public int hashCode()
	{
		return id.hashCode();
	}
}

Classe Droit :

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
@Entity
public class Droit implements Serializable
{
	/** Identifiant. */
	@Id
	@SequenceGenerator(name = "seq_droit", sequenceName = "seq_droit", allocationSize = 1)
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "seq_droit")
	private Integer id;
 
	/** Libellé du droit. */
	@Basic
	private String libelle;
 
	/** Code du droit. */
	@Basic
	private String code;
 
	/** Module applicatif auquel est rattaché le droit. */
	@ManyToOne
	private Module module;
 
	[...]
 
	/** {@inheritDoc} */
	@Override
	public boolean equals(Object other)
	{
 
		if (other == null)
		{
			return false;
		}
		if (other == this)
		{
			return true;
		}
		if (!(other instanceof Droit))
		{
			return false;
		}
 
		Droit cast = (Droit) other;
		if (this.id == null ? cast.id != this.id : !this.id.equals(cast.id))
		{
			return false;
		}
 
		return true;
	}
 
	/** {@inheritDoc} */
	@Override
	public int hashCode()
	{
		return id.hashCode();
	}
}

Méthode DAO :

Code :

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

1
2
3
4
5
6
public List<Module> loadAllWithDroits()
{
	DetachedCriteria criteria = DetachedCriteria.forClass(Module.class);
	criteria.setFetchMode("droits", FetchMode.JOIN);
	return (List<Module>) getHibernateTemplate().findByCriteria(criteria);
}

[Nertios]

En fait, le résultat est "pire" que ce que j'avais initialement vu, puisque ça me retourne une liste avec des doublons.

Avec ce jeu de test :

Table module :

Code :

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

1
2
3
4
5
id	libelle
==================
1	'module 1'
2	'module 2'
3	'module 3'

Table droit :

Code :

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

1
2
3
4
5
6
7
id	code	libelle		module_id
=========================================
1	'c1'	'droit 1'	    1
2	'c2'	'droit 2'	    1
3	'c3'	'droit 3'	    1
4	'c4'	'droit 4'	    2
5	'c5'	'droit 5'	    2

Requête SQL générée par Hibernate :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
select
      this_.id as id1_1_,
      this_.libelle as libelle1_1_,
      droits2_.module_id as module4_1_3_,
      droits2_.id as id3_,
      droits2_.id as id0_0_,
      droits2_.code as code0_0_,
      droits2_.libelle as libelle0_0_,
      droits2_.module_id as module4_0_0_
   from
      Module this_
      left outer join Droit droits2_ on this_.id=droits2_.module_id

Résultat de la requête :

Code :

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

1
2
3
4
5
6
7
8
id1_1_ | libelle1_1_ | module4_1_3_ | id3_ | id0_0_ | code0_0_ | libelle0_0_ | module4_0_0_
===========================================================================================
  1    | 'module 1'  |       1      |  3   |   3    |   'c3'   |  'droit 3'  |      1
  1    | 'module 1'  |       1      |  2   |   2    |   'c2'   |  'droit 2'  |      1
  1    | 'module 1'  |       1      |  1   |   1    |   'c1'   |  'droit 1'  |      1
  2    | 'module 2'  |       2      |  5   |   5    |   'c5'   |  'droit 5'  |      2
  2    | 'module 2'  |       2      |  4   |   4    |   'c4'   |  'droit 4'  |      2
  3    | 'module 3'  |              |      |        |          |             |

Dans ma liste de Module, je récupère 6 éléments.
Les éléments aux indices 0, 1 et 2 sont les mêmes objets, i.e. même référence (= module 1).
Les éléments aux indices 3 et 4 sont les mêmes objets, i.e. même référence (= module 2).
La liste de Droit de module 1 : null, droit 1, droit 2, droit 3.
La liste de Droit de module 2 : null, null, null, null, droit 4, droit 5.
Le module 3 (6e élément) est OK, avec une liste de Droit vide.


Pour ce qui est des doublons, je peux toujours utilisé un HashSet.
Et pour les collections de Droit, supprimer les éléments null.
Sauf que je ne suis pas sûr que ce qui est valable ici, le sera dans tous les cas.