Discussion :

[spring.time]

Bonjour,
j'utilise le pattern Dao, pour implémenter la couche d'accès aux données, j'ai donc créé une interface générique comme ceci:

Code :

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

1
2
3
4
5
6
7
8
 
public interface GenericDAO<T, PK extends Serializable> {
 
	 /** Persist the newInstance object into database */
    void create(T newInstance);
 
...
}

une implémentation de cette interface en utilisant le framework Hibernate:

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
 
public  class GenericDAOImpl<T, Pk extends Serializable> implements GenericDAO<T, Pk >{
 
	private Class<T> type;
	private Session session;
 
 
	public GenericDAOImpl(Class<T> classe) {
		this.type = classe;
	}
 
 
	@Override
	public void create(T newInstance) {
		try{
			this.session = HibernateUtil.getSession();
			this.session.beginTransaction();
			this.session.save(newInstance);
			this.session.getTransaction().commit();
			System.out.print("oui");
		}
		catch (HibernateException e){
			System.out.print(e.getMessage());
		}
	}
 
...}

mais je ne comprends pas la différence entre Class<T> et T ? parce que j'ai fait ceci,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public T read(Pk id) {
		try {
			this.session = HibernateUtil.getSession();
			this.session.beginTransaction();
			this.type = (Class<T>)this.session.get(this.type, id);
 
 
		} catch (HibernateException e) {
			System.out.print(e.getMessage());
		}
		return (T) this.type;		
	}

mais malheureusement, le read ne marche pas:

Code :

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

1
2
3
4
5
GenericDAO<Projet,Integer> genericDAO = new GenericDAOImpl<Projet, Integer>(null);
Projet projet2 = new Projet();
	projet2 = genericDAO.read(2);
	System.out.print(projet2.getNom());

je ne comprends ce 'null'.

pourquoi c'est permis de faire:

Code :

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

1
2
3
4
5
6
 
private  Class<Projet> projet;
private  ProjetDAO projetDAO =  new ProjetDAOImp(projet );
Projet p = new Projet();
p.setNom("projet1");
projetDAO.create(p);

et merci d'avance.

[Gugelhupf]

Bonsoir,

mais je ne comprends pas la différence entre Class<T> et T ?

Class est une classe générique du standard Java. On s'en sert lorsqu'on fait de l'instrospection (ou "reflexivité").
T est ton type générique.

mais malheureusement, le read ne marche pas:

Ce n'est pas très précis comme erreur
Tu récupères un Class<T>, et tu veux le caster en T ? C'est comme si tu essayais de caster un String en Integer...

En fait je pense que tu t'y prends un peu mal à cette ligne :

Code :

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

this.type = (Class<T>)this.session.get(this.type, id);

Ça devrait plus ressembler à :

Code :

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

T valReturn = this.session.get(this.type, id);

Enfin je pense...

[joel.drigo]

Salut,

T représente un type (une classe) quelconque dans ton cas, et Class<T> représente une instance de Class d'un object de type T.

Quand tu écris :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public  class GenericDAOImpl<T, Pk extends Serializable> implements GenericDAO<T, Pk >{
 
	private Class<T> type;
	private Session session;
 
 
	public GenericDAOImpl(Class<T> classe) {
		this.type = classe;
	}
 
       ...

tu crées une classe, appelée GenericDAOImpl, qui est paramétrée par 2 types, T et Pk. T est de type quelconque, et Pk est un type qui implémente Serializable.

Le constructeur de cette classe a un paramètre, dont le type est la classe T. Si tu crées une instance de cette classe, tu devras indiquer pour quel type, et tu devras passer la classe correspondante en argument du constructeur.

Par exemple :

Code :

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

new GenericDAOImpl<Integer, String>(Integer.class);

Ou

Code :

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

new GenericDAOImpl<ArrayList, Integer>(ArrayList.class);

Il ne faut pas passer null en paramètre, si tu te sers de la variable type de GenericDAO, pour éviter une NullPointerException. Si tu ne t'en sers pas, autant la supprimer (ce qui n'est pas le cas apparemment).

En tout cas, tu ne peux pas écrire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public T read(Pk id) {
		try {
			this.session = HibernateUtil.getSession();
			this.session.beginTransaction();
			this.type = (Class<T>)this.session.get(this.type, id);
 
 
		} catch (HibernateException e) {
			System.out.print(e.getMessage());
		}
		return (T) this.type;		
	}

Si type est du type Class<T>, tu ne pourras pas le caster en T. Je n'y connais rien en hibernate mais, à mon avis, le code devrait être :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public T read(Pk id) {
          T value = null;
		try {
			this.session = HibernateUtil.getSession();
			this.session.beginTransaction();
			value = this.session.get(this.type, id);
 
 
		} catch (HibernateException e) {
			System.out.print(e.getMessage());
		}
		return value;	
	}

La méthode T get(Class<T>, Pk) de session doit permettre de lire un bean de classe T, et pour pouvoir instancier ce bean, on lui fournit un object, qui est un objet de classe Class<T>, et qui représente la classe de ce bean.

[spring.time]

Salut
je vous remercie beaucoup pour vos explications, ça devient plus clair
Donc;
T est n'importe quel type de classe.
class<T> est une instante d'une classe de type T.

oui j'ai pu régler le problème de read grace à vous:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public T read(Pk id) {
		T value= null;
		try {
			this.session = HibernateUtil.getSession();
			this.session.beginTransaction();
			value = (T) this.session.get(this.type, id);
 
 
		} catch (HibernateException e) {
			System.out.print(e.getMessage());
		}
		return value;	
	}

et le test:

Code :

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

1
2
3
4
5
 
GenericDAO genericDAO = new GenericDAOImpl<Projet ,Integer >(Projet.class);
	Projet projet = new Projet();
	projet = (Projet) genericDAO.read(2);
	System.out.print(projet.getNom());

maintenant j'ai une classe ProjetDAOImp étendant de la précedente classe
GenericDAOImpl comme ceci;

Code :

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

1
2
 
public  class ProjetDAOImp extends GenericDAOImpl<Projet, Integer> implements ProjetDAO {

son constructeur :

Code :

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

1
2
3
4
5
 
public ProjetDAOImp(Class<Projet> classe) {
		super(classe);
		// TODO Auto-generated constructor stub
	}

si je fais comme cela pour instancier ProjetDAOImp

Code :

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

1
2
3
4
 
ProjetDAO projetDAO = new ProjetDAOImp(Projet.class);
projet = projetDAO.read(2);
	System.out.print(projet.getNom());

cela revient au même, c'est correct ?

[tchize_]

class<T> est une instante d'une classe de type T.

non, une instance d'une classe de type java.lang.Class

[spring.time]

une question "Gugelhupf", s'il vous plait
"
Class est une classe générique du standard Java. On s'en sert lorsqu'on fait de l'instrospection (ou "reflexivité").

"
je n'ai pas bien compris, que voulez vous dire par ces 2 mots:
l'instrospection, reflexivité

Merci

[tchize_]

Grosso modo, quand on veux explorer ce qu'est une instance précise, mais qu'on en a pas la moindre idée lors de la compilation. Il existe une série de choses, comme java.lang.Class qui permettent de faire cette exploration, déterminer les méthodes disponibles, les propriétés, la hierarchie des parents, etc.

[spring.time]

je n'ai jamais pensé à cela :
"
Grosso modo, quand on veux explorer ce qu'est une instance précise, mais qu'on en a pas la moindre idée lors de la compilation
"

ça peut arriver ?