Discussion :

[casafa]

Bonjour,

Pour mes applications en réseaux, du côté client, j'ai souvent une thread qui écoute les messages du serveur et ensuite je fait plein plein de if, comme ceci :

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
 
while(true)
{
	String msg = socket.recoitMessage();
	if(msg.equals("connecter")
	{
		//...
	}else if(msg.equals("deconnecte")
	{
		//....
	}else if(msg.equals("commence")
	{
		//....
	}else if(msg.equals("fini")
	{
		//....
	} //etc....
}

Bref.... du code super beau
N'y a t-il pas une solution pour rendre cela encore plus beau ?

Merci d'avance...

[gifffftane]

À ce niveau là moi je n'ai rien trouvé de mieux non plus

[jowo]

Bonjour,

Une possibilité serait de définir une interface et une classe par réponse. Puis de "collectionner" les réponses dans un objet Map.

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
 
/* Contexte d'une action*/
class Context {
}
 
/* Definition interface d'une réponse */
interface Response {
  void process(Context ctxt);
}
 
/* Implementation des réponses de chaque action */
class Connecter implements Response {
  void process(Context ctxt) {
  }
}
 
class Deconnecter implements Response {
  void process(Context ctxt) {
  }
}
 
class Commencer implements Response {
 {
  void process(Context ctxt) {
  }
}
 
class Finir implements Response {
  void process(Context ctxt) {
  }
}
 
 
/* */
class Processing {
  public static final String ACTION_CONNECTER = "connecter";
  public static final String ACTION_DECONNECTER = "deconnecter";
  public static final String ACTION_COMMENCER = "commencer";
  public static final String ACTION_FINIR = "finir";
 
  Map actions = new HashMap();
 
  public Processing() {
    /* On instancie chaque réponse */
    actions.put(ACTION_CONNECTER, new Connecter());
    actions.put(ACTION_DECONNECTER, new DeConnecter());
    actions.put(ACTION_COMMENCER, new Commencer());
    actions.put(ACTION_FINIR, new Finir());
  }
 
  /* On traite les actions */
  public process() {
    Context ctxt = new Context(ctxt);
 
    while (true) {
      String msg = socket.recoitMessage();
      Response response = (Response)actions.get(msg);
      if (response != null) {
        response.process(ctxt);
      }
    }
  }

J'en conviens que c'est un peu lourd... Mais il se peut qu'il existe un pattern pour ce problème.

[casafa]

Merci pour vos réponses,

Je trouve l'idée assez bonne. Si quelqu'un à quelque chose de moins lourd, je suis preneur...

[cisco]

pour faire du "beau" il y a mina d'apache
http://mina.apache.org/

Ton "connecter", "deconnecte", .. c'est l'état de la session TCP?
Parce que si oui le "state pattern" pourrait être utile
design pattern (en anglais)
http://www.vincehuston.org/dp/state.html

diagrame de classe:

[casafa]

Merci, je vais regarder ton lien, je ne connait pas dutout.

Pour ce qui est du "connecter", "deconnecter", je ne sais pas ce que ça représente S'était juste un exemple comme ça inventé en 5 sec

[Napalm51]

Salut,

pour ma part à la place des Strings et des if/else j'utiliserais (si tu peux coder en 1.5) les enums.

Code :

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

1
2
 
enum PROTOCOLE {CONNECT, QUIT, SEND, RECEIVE ...}

et dans ta boucle tu utilises un :

Code :

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

1
2
3
4
5
6
7
switch (action) {
  case CONNECT : // on connect
    break;
  case QUIT : // on quit
    break;
  ...
}

Bon ça n'améliore pas des masses le code, mais ça évite les if/else à répétition avec des string.

[cisco]

si c'est pour faire du décodage de message, on passe généralement par un "factory" qui générère un objet correspondant au message.
Et dans le factory il y a soit des

Code :

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

1
2
3
4
5
6
7
 
if(msg.equals("connecter")
{
	return new Connecter(buf);
}
else if(msg.equals("deconnecte")
...

Ou alors la solution de jowo (qui n'est pas si lourde que ça puisque de toute façon il y a une classe par type de message)

Le pattern "state" c'est plus pour gérer l'état de la connection.

[dinobogan]

Ou faire de l'introspection ? Niveau performance, ça plombe un peu, encore qu'il faudrait faire des tests pour le prouver dans ce cas la...
Et eventuellement mapper les Method pour ne pas faire une nouvelle instance à chaque fois, et aussi dissocier l'action demandée et le nom de la méthode par un mapping, histoire de sécuriser un peu le procédé.
Je trouve ça propre, concis et élégant, mais c'est évidemment subjectif

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
 
while(true)
{
	String msg = socket.recoitMessage();
	traiter( msg );
}
 
void traiter( String action ) throws Exception
{
	Method m = this.getClass().getMethod( action, null );
	m.invoke( this, null );
}
 
void connecter()
{
	System.out.println( "connecter" );
}
 
void deconnecter()
{
	System.out.println( "deconnecter" );
}