[Thread] Serveur qui ne veut pas écouter

**CARNIBAL** · 13/01/2009, 12h03

Bonjour,

Je possède deux classes ( ClientIP et Serveur IP ) qui communiquent entre elles.

Dans ma classe ServeurIP j'ai une méthode recevoir() qui permet d'obtenir un String envoyé par le client.

J'ai donc deux problèmes.
Du point de vue de la conception, je ne vois pas comment transformé mon serveur, qui est actuellement mono-client, en multi-client ( je pense à un tableau de client, mais je ne sais pas quoi y mettre dedans) .
Et, je n'arrive pas à faire boucler le serveur sur la méthode recevoir() pour qu'il reste constemment en attente de reception de message mais que dès qu'il en recoit un, il puisse tout de même le traiter.

Pourriez-vous m'aider ?

Voici ma classe ClientIP :

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
import java.io.*;
import java.net.*;
 
public class ClientIP extends Thread {
private String host;
private int port;	
private BufferedReader cin;            // Buffer entree en mode caracteres
private PrintWriter    cout;           // Buffer sortie en mode caracteres
 
 
   // ---------------------------------------- *** Premier constructeur normal  
   //
   // Construction d'un client IP par defaut
   //
   public ClientIP (String nomThread) {
 
      super(nomThread);
      host= "localHost"; 
      port=8080;
   }
 
   // ---------------------------------------- *** Second constructeur normal  
   //
   // Construction d'un client IP
   //
   public ClientIP (String nomThread, String host, int port) {
 
   	 super(nomThread);
   	 this.host= host; 
   	 this.port= port;
   }
 
   // --------------------------------------------- *** Methode connecter  
   //
   private boolean connecter() {
 
   	  // Creer une connexion avec le serveur cible
   	  //
      Socket s= null;
   	  try{s= new Socket(host, port);}
   	  catch (Exception e){}
 
      // Initialiser les flux entrant et sortant de la connexion
   	  //
   	  return initFlux(s);
   }
 
   // --------------------------------------------- *** Methode initFlux  
   //
   private boolean initFlux(Socket s) {
   InputStream streamIn= null;
   InputStreamReader bufferIn;
   OutputStream streamOut= null;
   OutputStreamWriter bufferOut;
 
      // Controler l'existence de la socket support
      //
      if (s==null) return false;
 
      // Creer le flux d'entree
      //
      try{streamIn= s.getInputStream();}
      catch (Exception e) {return false;}
 
      bufferIn= new InputStreamReader(streamIn);
 
      // Creer le buffer d'entree
      //
      cin= new BufferedReader(bufferIn);
 
      // Creer le flux de sortie
      //
      try{streamOut= s.getOutputStream();}
      catch(Exception e){return false;}
 
      // Creer le flux de sortie
      //
      bufferOut= new OutputStreamWriter(streamOut);
      cout= new PrintWriter(new BufferedWriter(bufferOut), true);
 
      return true;
   }
 
   // --------------------------------------------- *** Methode envoyer  
   //
   public boolean envoyer (String msg) {
 
      // Controler la validite du flux de sortie
      //
      if (cout==null) return false;
 
      // Transferer le message dans le flux de sortie
      //
   	  cout.println(msg);
   	  return true;
   }
 
   // --------------------------------------------- *** Methode recevoir  
   //
   public String recevoir () {
   String msg="?";
      try{
      	   while (true) {
      	      msg= cin.readLine();
      	      if (!msg.equals("?")) break;
      	      Thread.currentThread().sleep(50);
      	   }
      }
      catch (Exception e){}
      return msg;
   }
 
   // --------------------------------------------- *** Methode fermer  
   //
   public void fermer () {
   	try{ cin.close();cout.close();}
   	catch(Exception e){}
   }
 
   // --------------------------------------------- *** Methode run  
   //
   public void run() {
   boolean flag= false;
 
      // Etablir la connexion avec le serveur cible
      //
      connecter(); 
 
      // Envoyer un message au serveur cible
      //
      String message= new String("DECLARER xxxx");
      flag= envoyer(message);
 
      // Visualiser le message envoye
      //
      if (flag) {
         System.out.println("Client  / Message envoye : " + message);
      }	
   }
}

Voici ma classe ServeurIP:

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
import java.io.*;
import java.net.*;
 
public class ServeurIP extends Thread {
private int port;	
private BufferedReader cin;            // Buffer entree en mode caracteres
private PrintWriter    cout;           // Buffer sortie en mode caracteres
 
 
   // --------------------------------------- *** Premier constructeur normal  
   //
   // Construction d'un serveur IP par defaut
   //
   public ServeurIP (String nomThread){
 
      super(nomThread);
      port= 8080;
   }
 
   // --------------------------------------- *** Second constructeur normal  
   //
   // Construction d'un serveur IP
   //
   public ServeurIP (String nomThread, int port) {
 
      super(nomThread);
      this.port= port;
   }
 
   // --------------------------------------------- *** Methode accepter  
   //
   private boolean accepter() {
 
      // Creer la socket serveur
      //
      ServerSocket serveur;
      try {serveur= new ServerSocket(port);}
      catch (Exception e){return false;}
 
      // Attendre la connexion du client
      //
      Socket s;
      try{s= serveur.accept();}
      catch (Exception e){return false;}
 
      return initFlux(s);
   }
 
   // --------------------------------------------- *** Methode initFlux  
   //
   private boolean initFlux(Socket s) {
   InputStream streamIn= null;
   InputStreamReader bufferIn;
   OutputStream streamOut= null;
   OutputStreamWriter bufferOut;
 
      // Creer le flux d'entree
      //
      try{streamIn= s.getInputStream();}
      catch (Exception e) {return false;}
 
      bufferIn= new InputStreamReader(streamIn);
 
      // Creer le buffer d'entree
      //
      cin= new BufferedReader(bufferIn);
 
      // Creer le flux de sortie
      //
      try{streamOut= s.getOutputStream();}
      catch(Exception e){return false;}
 
      // Creer le flux de sortie
      //
      bufferOut= new OutputStreamWriter(streamOut);
      cout= new PrintWriter(new BufferedWriter(bufferOut), true);
 
      return true;
   }
 
   // --------------------------------------------- *** Methode envoyer  
   //
   public void envoyer (String msg) {
 
      // Controler la validite du flux de sortie
      //
      if (cout==null) return;
 
      // Transferer le message dans le flux de sortie
      //
      cout.println(msg);
   }
 
 
   // --------------------------------------------- *** Methode recevoir  
   //
   public String recevoir () {
   String msg="?";
 
      try {
         while (true) {
      	    msg= cin.readLine();
      	    if (!msg.equals("?")) break;
      	    Thread.currentThread().sleep(50);
      	 }
      }
      catch (Exception e){}
      return msg;
   }
 
   // --------------------------------------------- *** Methode fermer  
   //
   public void fermer () {
   	  try{cin.close();cout.close();}
   	  catch(Exception e){}
   }
 
   // --------------------------------------------- *** Methode run  
   //
   public void run() {
   String message= null;
 
      // Attendre la connexion du client unique
      //
      accepter();
 
      // Recevoir un message depuis le client connecte
      //
      message= recevoir();
 
      // Visualiser le message recu
      //
      if (message != null) {
         System.out.println("Serveur / Message recu : " + message);
      }
   }
}

Merci par avance

carnibal

**ninow** · 13/01/2009, 13h36

Pour que ton serveur soit "multi-client", il faudrait dédier un thread à ta methode "accepter" (un thread qui ne ferait qu'accepter les connexions). Une fois la connection établie, un nouveau thread doit être créer pour chaque client connecté. J'espère que je suis assez clair (j'ai comme un doute)...