Socket et protocole

Version imprimable

Socket et protocole

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:

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 :aie:
N'y a t-il pas une solution pour rendre cela encore plus beau ?

Merci d'avance...

17/12/2007, 09h07
gifffftane

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

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:

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.

20/12/2007, 21h31
casafa

Merci pour vos réponses,

Je trouve l'idée assez bonne. Si quelqu'un à quelque chose de moins lourd, je suis preneur...
20/12/2007, 22h35
cisco

1 pièce(s) jointe(s)

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:
Pièce jointe 23188
20/12/2007, 22h44
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 :mrgreen: S'était juste un exemple comme ça inventé en 5 sec :P
21/12/2007, 10h20
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:

1 2 enum PROTOCOLE {CONNECT, QUIT, SEND, RECEIVE ...}
et dans ta boucle tu utilises un :
Code:

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.
21/12/2007, 11h06
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:

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.

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 :mrgreen:
Code:

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" ); }