Créer un mapper générique à plus de 2 niveaux

Version imprimable

Bonjour à tous,

Je voudrais approfondir la discussion suivante que j'ai commencé fin mars :
http://www.developpez.net/forums/d15...per-generique/.

Maintenant j'ai une 4ième classe héritant de la classe A.

Petit rappel:

1 classe racine R
2 classes A et B héritant de R
1 classe Z héritant de A (nouveauté)

Mais oublions B pour ne s'intéresser que la hiérarchie sur 3 niveaux : Z -> A -> R

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
package test.heritage2.model;
 
public class A extends R {
	private String ma1;
	private String ma2;
	private String ma3;
 
	@Override
	public String doSomething(String arg) {
		return "Class A (" + arg + ")";
	}
 
	public A loadFromA(A a) {
		ma1 = a.ma1;
		ma2 = a.ma2;
		ma3 = a.ma3;
		return this;
	}
 
	public String getMa1() {
		return ma1;
	}
 
	public void setMa1(String ma1) {
		this.ma1 = ma1;
	}
 
	public String getMa2() {
		return ma2;
	}
 
	public void setMa2(String ma2) {
		this.ma2 = ma2;
	}
 
	public String getMa3() {
		return ma3;
	}
 
	public void setMa3(String ma3) {
		this.ma3 = ma3;
	}
 
	@Override
	public String toString() {
		return "A [ma1=" + ma1 + ", ma2=" + ma2 + ", ma3=" + ma3 + ", " + super.toString() + "]";
	}
}

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
package test.heritage2.model;
 
public class R {
	private String mr1;
	private String mr2;
	private String mr3;
 
	public String doSomething(String arg) {
		return "Class R (" + arg + ")";
	}
 
	public R loadFromR(R r) {
		mr1 = r.mr1;
		mr2 = r.mr2;
		mr3 = r.mr3;
		return this;
	}
 
	public String getMr1() {
		return mr1;
	}
 
	public void setMr1(String mr1) {
		this.mr1 = mr1;
	}
 
	public String getMr2() {
		return mr2;
	}
 
	public void setMr2(String mr2) {
		this.mr2 = mr2;
	}
 
	public String getMr3() {
		return mr3;
	}
 
	public void setMr3(String mr3) {
		this.mr3 = mr3;
	}
 
	@Override
	public String toString() {
		return "R [mr1=" + mr1 + ", mr2=" + mr2 + ", mr3=" + mr3 + "]";
	}
}

La petite nouvelle ;)

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
package test.heritage2.model;
 
public class Z extends A {
	private String mz1;
	private String mz2;
	private String mz3;
 
	@Override
	public String doSomething(String arg) {
		return "Class Z (" + arg + ")";
	}
 
	public String getMz1() {
		return mz1;
	}
 
	public void setMz1(String mz1) {
		this.mz1 = mz1;
	}
 
	public String getMz2() {
		return mz2;
	}
 
	public void setMz2(String mz2) {
		this.mz2 = mz2;
	}
 
	public String getMz3() {
		return mz3;
	}
 
	public void setMz3(String mz3) {
		this.mz3 = mz3;
	}
 
	@Override
	public String toString() {
		return "Z [mz1=" + mz1 + ", mz2=" + mz2 + ", mz3=" + mz3 + ", " + super.toString() + "]";
	}
}

Et le mapping, qui correspond à la solution simple proposée par tchize_ et que j'ai adoptée.

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
package test.heritage2;
 
import test.heritage2.model.A;
import test.heritage2.model.Z;
import test.heritage2.model.R;
 
public class App {
 
	public static void main(String[] args) {
		R instR = createR();
		System.out.println(instR.toString());
 
		A instA = ceateA(instR);
		System.out.println(instA.toString());
 
		Z instZ = ceateZ(instA);
		System.out.println(instZ.toString());
 
		String str = instZ.doSomething("pipo des alpes");
		System.out.println(str);
	}
 
	private static R createR() {
		R instR = new R();
		instR.setMr1("rrr1");
		instR.setMr2("rrr2");
		instR.setMr3("rrr3");
		return instR;
	}
 
	private static A ceateA(R instR) {
		A instA = new A();
		instA.setMa1("aaa1");
		instA.setMa2("aaa2");
		instA.setMa3("aaa3");
 
		instA = (A) instA.loadFromR(instR);
		return instA;
	}
 
	private static Z ceateZ(A instA) {
		Z instZ = new Z();
		instZ.setMz1("zzz1");
		instZ.setMz2("zzz2");
		instZ.setMz3("zzz3");
 
		instZ = (Z) instZ.loadFromA(instA);
		return instZ;
	}
 
}

Mais je n'obtiens pas cette fois-ci le résultat que j'attends.

Code:

1
2
3
4
R [mr1=rrr1, mr2=rrr2, mr3=rrr3]
A [ma1=aaa1, ma2=aaa2, ma3=aaa3, R [mr1=rrr1, mr2=rrr2, mr3=rrr3]]
Z [mz1=zzz1, mz2=zzz2, mz3=zzz3, A [ma1=aaa1, ma2=aaa2, ma3=aaa3, R [mr1=null, mr2=null, mr3=null]]]
Class Z (pipo des alpes)

Puisque l'instance de la classe Z a bien hérité de l'instance de la classe A, mais pas de l'instance de la classe R. :calim2:

Est-ce que cette solution est toujours applicable ?

Comment solutionner ce problème tout en gardant une solution simple et propre ?

Merci.

Personellement, je ferais ça pour commencer:

Code:

1
2
3
4
5
6
7
8
 
	public A loadFromA(A a) {
		loadFromR(a);
		ma1 = a.ma1;
		ma2 = a.ma2;
		ma3 = a.ma3;
		return this;  
	}

Ensuite, tu peux améloirer:

Code:

1
2
3
4
5
6
7
8
9
10
public class R {
   R loadFrom(Object other){
       if (other instanceof R){
          R r = (R) other;
          r1=r.r1;
//etc
      }
      return this;
   }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public class A {
   @override
   A loadFrom(Object other){
       super.loadFrom(other);
       if (other instanceof A){
          A r = (A) other;
          ma1=a.ma1;
//etc
      }
      return this;
   }
}

}

Je viens de trouver une solution. Elle se situe au niveau des méthodes loadFromXxx().

La voici dans R:

Code:

1
2
3
4
5
6
7
8
9
10
11
public class R {
...
	public R loadFromR(R r) {
		// R
		setMr1(r.getMr1());
		setMr2(r.getMr2());
		setMr3(r.getMr3());
		//
		return this;
	}
...

et aussi dans A:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class A extends R {
...
	public A loadFromA(A a) {
		// A
		setMa1(a.getMa1());
		setMa2(a.getMa2());
		setMa3(a.getMa3());
		// R
		setMr1(a.getMr1());
		setMr2(a.getMr2());
		setMr3(a.getMr3());
		//
		return this;
	}
...

Ce qui donne le résultat attendu suivant:

Code:

1
2
3
4
R [mr1=rrr1, mr2=rrr2, mr3=rrr3]
A [ma1=aaa1, ma2=aaa2, ma3=aaa3, R [mr1=rrr1, mr2=rrr2, mr3=rrr3]]
Z [mz1=zzz1, mz2=zzz2, mz3=zzz3, A [ma1=aaa1, ma2=aaa2, ma3=aaa3, R [mr1=rrr1, mr2=rrr2, mr3=rrr3]]]
Class Z (pipo des alpes)

Mais la solution n'est hélas pas très générique.

Dans le cas éventuel d'un ajout d'un niveau supplémentaire sur 4 niveaux : Y -> Z -> A -> R, il va falloir modifier beaucoup trop de choses.

Est-il possible de rendre cela plus générique ?
Merci.

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
package test.mapping.model;
 
public class Y extends Z {
	private String my1;
	private String my2;
	private String my3;
 
	public String getMy1() {
		return my1;
	}
 
	public void setMy1(String my1) {
		this.my1 = my1;
	}
 
	public String getMy2() {
		return my2;
	}
 
	public void setMy2(String my2) {
		this.my2 = my2;
	}
 
	public String getMy3() {
		return my3;
	}
 
	public void setMy3(String my3) {
		this.my3 = my3;
	}
 
	@Override
	public String toString() {
		return "Y [my1=" + my1 + ", my2=" + my2 + ", my3=" + my3 + ", " + super.toString() + "]";
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Z extends A {
...
	public Z loadFromZ(Z z) {
		// Z
		setMz1(z.getMz1());
		setMz2(z.getMz2());
		setMz3(z.getMz3());
		// A
		setMa1(z.getMa1());
		setMa2(z.getMa2());
		setMa3(z.getMa3());
		// R
		setMr1(z.getMr1());
		setMr2(z.getMr2());
		setMr3(z.getMr3());
		//
		return this;
	}
...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class App {
 
	public static void main(String[] args) {
		...
		Y instY = createY(instZ);
		System.out.println(instY.toString());
	}
...
	private static Y createY(Z instZ) {
		Y instY = new Y();
		instY.setMy1("yyy1");
		instY.setMy2("yyy2");
		instY.setMy3("yyy3");
 
		instY = (Y) instY.loadFromZ(instZ);
		return instY;
	}
}

Citation:

Envoyé par tchize_

Personellement, je ferais ça pour commencer...

Merci encore pour ton aide. :lol:

Ca simplifie beaucoup en effet et cela évite de se poser trop de question.

Est-t-il possible (je pense à la généricité) d'éviter ces instanceOf ?

Une des classes modifiée:

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
package test.mapping.model;
 
public class A extends R {
	private String ma1;
	private String ma2;
	private String ma3;
 
	@Override
	public A loadFrom(Object other) {
		super.loadFrom(other);
		if (other instanceof A) {
			A instA = (A) other;
			setMa1(instA.getMa1());
			setMa2(instA.getMa2());
			setMa3(instA.getMa3());
		}
		return this;
	}
 
	public String getMa1() {
		return ma1;
	}
 
	public void setMa1(String ma1) {
		this.ma1 = ma1;
	}
 
	public String getMa2() {
		return ma2;
	}
 
	public void setMa2(String ma2) {
		this.ma2 = ma2;
	}
 
	public String getMa3() {
		return ma3;
	}
 
	public void setMa3(String ma3) {
		this.ma3 = ma3;
	}
 
	@Override
	public String toString() {
		return "A [ma1=" + ma1 + ", ma2=" + ma2 + ", ma3=" + ma3 + ", " + super.toString() + "]";
	}
}

14/05/2015, 19h07
tchize_
Citation:

Envoyé par domiq44

Est-t-il possible (je pense à la généricité) d'éviter ces instanceOf ?

Une des classes modifiée:

C'est compliqué. De plus si c'était possible, le compilateur ne pourrait plus garantir qu'il n'y aurait pas d'erreur.

Exemple, imaginons que THIS soit le type générique qu'on soit arrivé à définir tel que dans la classe A il représente A, dans la classe B il représente B

classe A,: public THiS loadFrom(THIS autre) -> autre est de type A j'ai accès aux propriétés de a
classe B extends A: public THiS loadFrom(THIS autre) -> autre est de type B j'ai accès aux propriétés de b

coté A et B aucun soucis, je peux créer mon code.

coté utilisation par contre:
Code:

1 2 3 A a = new A(); A a2 = new B(); a2.xyz(a);
execute xyz sur une instance de B qui s'attends à recevoir une autre instance de B en paramètre et ça foire.
Pourtant le compilateur a bien vérifié: a2.xyz, comme a2 est déclaré A, a2 prend en paramètre un A.....

Donc t'es coincé, si tu veux t'en sortir sans instanceOf, il faut oublier l'héritage de loadFrom et revenir à ton idée de départ du loadFromA, loardFromB, loadFromC,.....

C'est d'ailleurs pour ça que la méthode clone() est déclarée retournant un Object et non pas un générique: pas possible de définir ce générique.
15/05/2015, 19h40
domiq44

Citation:

Envoyé par tchize_

C'est compliqué. De plus si c'était possible, le compilateur ne pourrait plus garantir qu'il n'y aurait pas d'erreur.

Oui, effectivement. Je comprends.

De toute façon, le résultat est plus que satisfaisant.
Merci pour tout tchize_.