Discussion :

[ifsera]

Salut,

Voilà mon archi de façon réduite:

j'ia une vue

j'ai un bean et une classe pour le traitement du bean

et j'ai une classe dao.

Dans ce contexte, j'arrive à quelque chose, à faire tourner.

Mais j'ai vu qu'il serai bon d'utiliser une interface, comme quoi que ma classe traitement devrait passer par l'interface et non directement par le dao.

Mais je vois pas comment on fait. Mon dao implemente l'interface. Je sais encore les créer. Mais derrière, je vois pas comment en faire quelque chose via la classe qui faite le traitement puisque non instanciable.

Du coup je m'en remets à vous.
Merci.
Sinon si quelqu'un peut m'expliquer le duo interface dao et son utilisation.

[RomSupSup]

Salut,

Si j'ai bien compris ton problème tu crées deux interfaces:

Code :

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

1
2
3
4
5
public interface Observable {
	public void addObservateur(Observateur obs);
	public void updateObservateur();
	public void deleteObservateur();
}

et

Code :

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

1
2
3
public interface Observateur {
	public void update(String infoUpdate);
}

Ta classe qui évolue et susceptible de changements implements Observable.
Ta classe de traitement est un Observateur

Lorsque tu crées ta classe instanciée observable, tu lui affecte un nouvel Observateur avec addObservateur(). Concrètement cet Observateur sera ta classe de traitement de données

Lorsque ta classe qui implements Observable change, tu lui dis d'updater son Observateur

De son coté ton instance d'observation va recevoir l'info update, et effectuer le code de ta méthode update().

Voici ce que ca va te donner

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
class MaClasseQuiEvolue implements Observable{
 
private String someData;
private ArrayList<Observateur> listeObs = new ArrayList<Observateur>();
 
public MaClasseQuiEvolue(Observateur obs){
addObservateur(obs);
}
 
//methode qui enregistre un changement d'état
public void maWonderfulMethode(){
if(thereIsANewEvent){
this.updateObservateur();
}
}
 
public void addObservateur(Observateur obs){
this.listeObs.add(obs);
}
 
public void updateObservateur(){
for(Observateur obs : listeObs){
obs.update(someData);
}
}
 
public void deleteObservateur(){
this.listeObs = new ArrayList<Observateur>();
}
 
}

et l'observateur:

Code :

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

1
2
3
4
5
6
7
8
 
class maClasseDeTraitementDeDonnees implements Observateur{
 
update(String info){
//do sthg useful with info
}
 
}

[Maine13]

Bonjour,

Je pense que tu dois encore préciser l'environnement sur lequel tu es entrain de travailler pour qu'on puisse mieux t'aider.
Mais sinon une classe DAO implémente une interface, l'interface ne contient que des prototypes de méthodes qui vont être implémenté dans tes classe DAO. Puis tu n'as qu'a consommer tes méthodes via les interfaces qu tu viens de définir. comment ??? et bien c'est ce que je voulais te dire au début, c'est qu'il faut préciser l'environnement. Si ce sont des EJB par exemple tu n'a qu'a les injectés dans ton Bean à travers l'annnotation

Code :

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

1
2
3
4
5
6
7
8
9
 
...
@EJB
TonInterface tonInterface;
 
public void test(){
tonInteface.methode();
}
...

[SamusStrife]

Bonjour,

Je pense que ton problème est que tu ne maîtrise pas totalement le polymorphisme. Donc je te conseillerai de (re)voir les cours sur ce procédé

Sinon, comme l'a dit Maine13, si tu veux plus d'aide, tu dois nous préciser l'environnement et être plus précis sur ce que tu veux faire réellement. (Montres nous ce que tu as déjà fait, comment tu comptes le faire etc...)