Client / Serveur Multithread

Version imprimable

Bonjour à tous !
Débutant en Java je viens vers vous pour une petite question que je n'arrive pas a résoudre :
Je fais actuellement communiquer deux programmes java ultra basique pour tester la communication client/serveur en multithread. Seulement voilà, je souhaites qu'à chaque réception d'une "requête", mon serveur crée un nouveau Thread mais impossible de le faire.

Mon code coté serveur (deux classes) :

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
 
import java.io.*;
import java.net.*;
 
class ServeurUDP
{
      public static void main(String args[]) throws Exception{
 
            //while(true){
                  ServeurUDP serveurUDP = new ServeurUDP();
                  serveurUDP.ServeurUDP();
           // }
 
      }
 
 
      public void ServeurUDP() throws Exception{            
 
                  DatagramSocket serverSocket = new DatagramSocket(7777);
 
                  //while(true){
                        ThreadServeurUDP monThreadServeurUDP = new ThreadServeurUDP(serverSocket); 
                        monThreadServeurUDP.start();
                  //}      
         }
   }

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
63
64
65
66
 
import java.io.*;
import java.net.*;
 
public class ThreadServeurUDP extends Thread 
{
 
      DatagramSocket serverSocket;
 
 
   public ThreadServeurUDP(DatagramSocket pserverSocket){
      try{
 
            serverSocket = pserverSocket;
      }
      catch(Exception e){}
 
   }
 
 
      public void run(){
 
 
            try{
 
                  //DatagramSocket serverSocket = new DatagramSocket(7777);
 
                  byte[] receiveData = new byte[1024];
                  byte[] sendData = new byte[1024];
 
                  while(true)
                     {
 
                        receiveData = new byte[1024];
                        sendData = new byte[1024];
 
                        // on créer un datagrampacket 
                        DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
                        serverSocket.receive(receivePacket);
 
                        String message = new String( receivePacket.getData());
                        int port = receivePacket.getPort();
 
                        System.out.println("Chaine recue de UDP :" +  port + " : " + message.trim());
                        System.out.println(" --- Thread serv name: " +  this.getName() + "    - " );
                        System.out.println(" --- Thread serv state1 : " +  this.getState() + "    - " );
 
 
                        InetAddress IPAddress = receivePacket.getAddress();
                        String reponsemessage = message.trim();
                        sendData = reponsemessage.getBytes();
 
                        DatagramPacket sendPacket =
                              new DatagramPacket(sendData, sendData.length, IPAddress, port);
                        serverSocket.send(sendPacket);
 
                        System.out.println(" --- Thread serv state2 : " +  this.getState() + "    - " );
 
 
 
                     }
               }
            catch(Exception e){}
 
   }
}

Actuellement tout fonctionne sur un thread, ce qui est normal sachant que j'ai bouclé à l'interieur de ce thread.
J'ai essayé de bouclé ailleurs (les while en commentaire) mais j'ai eu l'erreur suivante à chaque fois lors de l'execution (la compilation passe sans broncher) :

Code:

1
2
3
4
5
6
7
8
9
10
11
Exception in thread "main" java.net.BindException: Address already in use: Canno
t bind
        at java.net.DualStackPlainDatagramSocketImpl.socketBind(Native Method)
        at java.net.DualStackPlainDatagramSocketImpl.bind0(Unknown Source)
        at java.net.AbstractPlainDatagramSocketImpl.bind(Unknown Source)
        at java.net.DatagramSocket.bind(Unknown Source)
        at java.net.DatagramSocket.<init>(Unknown Source)
        at java.net.DatagramSocket.<init>(Unknown Source)
        at java.net.DatagramSocket.<init>(Unknown Source)
        at ServeurUDP.ServeurUDP(ServeurUDP.java:18)
        at ServeurUDP.main(ServeurUDP.java:10)

Si quelqu'un aurait une solution, merci d'avance de la partager :D

18/06/2012, 19h18
rmaker

L'erreur me parait explicite: tu ne fermes jamais ta connection, donc la deuxième fois que tu alloues une socket, la première est toujours connectée au port, d'où l'erreur.
18/06/2012, 20h54
Dadar

Merci pour ta réponse !
Je ferme la connexion dans la boucle while de la méthode ServeurUDP() mais j'ai toujours l'erreur.

J'ai essayé de faire différemment en créant le Thread après le docket.receive(), cependant j'ai maintenant une autre erreur : un Datapacket passé en argument entraîne un "java.lang.NullPointerException".
Le code en question mis à jour :

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
import java.io.*;
import java.net.*;
 
class ServeurUDP
{
      public static void main(String args[]) throws Exception{
                  ServeurUDP serveurUDP = new ServeurUDP();
                  serveurUDP.ServeurUDP();
      }
 
      public void ServeurUDP() throws Exception{   
				byte[] receiveData = new byte[1024];  
				DatagramSocket serverSocket = new DatagramSocket(7777);
				DatagramPacket receivePacket; 
 
					while(true){
						System.out.println("Entre dans while");
 
						receivePacket = new DatagramPacket(receiveData, receiveData.length);
						serverSocket.receive(receivePacket);          
						System.out.println("Apres receilv");
 
						ThreadServeurUDP monThreadServeurUDP = new ThreadServeurUDP(receivePacket);
						System.out.println("Apré crea thread");						
						monThreadServeurUDP.start();
						System.out.println("Apré  thread");
						}      
         }
   }

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
 
import java.io.*;
import java.net.*;
 
public class ThreadServeurUDP extends Thread 
{   
      DatagramSocket serverSocket;
	  DatagramPacket receivePacket;
	  byte[] sendData; 
 
   public ThreadServeurUDP(DatagramPacket pReceivePacket ){
      try{
            serverSocket = new DatagramSocket(7777);
			this.receivePacket = pReceivePacket;//receiveData = new byte[1024];
            sendData = new byte[1024];
      }
      catch(Exception e){}            
   }
 
	public void run(){            
            try{
			System.out.println("TRY");
 
                  //DatagramSocket serverSocket = new DatagramSocket(7777);
                  while(true)
                     {                   
                         // on créer un datagrampacket 
 
                        int port = this.receivePacket.getPort();
 
						System.out.println(" --- PORT -->" +  port);
 
						String message = new String( this.receivePacket.getData());
 
						System.out.println(" --- MESSAGE -->" +  message);
 
                        System.out.println("Chaine recue de UDP :" +  port + " : " + message.trim());
                        System.out.println(" --- Thread serv name: " +  this.getName() + "    - " );
						System.out.println(" --- Thread serv ID: " +  this.getId() + "    - " );
 
                        InetAddress IPAddress = this.receivePacket.getAddress();
                        String reponsemessage = message.trim();
						sendData = new byte[1024];
						sendData = reponsemessage.getBytes();
                        DatagramPacket sendPacket =
                              new DatagramPacket(sendData, sendData.length, IPAddress, port);
                        serverSocket.send(sendPacket);
                     }
               }
            catch(Exception e){ System.out.println(" --- Exe -->" +  e.toString());}
   }
}

Une petite idée ?

Merci !

19/06/2012, 14h05
wax78

Quelle ligne pose problème ?
19/06/2012, 14h29
Dadar

ici c'est lors du passage dans
int port = this.receivePacket.getPort();
que l'exception est levée
19/06/2012, 14h30
wax78

Je dirais que deja au moment de

Code:

this.receivePacket = pReceivePacket;//receiveData = new byte[1024];

pReceivePacket est null non ?

En remontant encore plus haut

Code:

serverSocket.receive(receivePacket);

Avant et apres que raconte receivePacket, null ou pas ?
19/06/2012, 15h37
Dadar

Même en l'initialisant j'ai la même erreur.
J'ai également essayé de passer en paramètre le DatagramSocket pour reconsitituer le DatagramPacket mais même erreur au même endroit...
19/06/2012, 15h39
wax78

Dommage que tu n'aies pas mis le code du client j'aurais put l'essayer et débugger :)
20/06/2012, 08h27
zo1odMSQr5Fy

Dans le catch du constructeur de ThreadServeurUDP ajout un printstacktrace(). Je sens une exception lors de : serverSocket = new DatagramSocket(7777);

Bonjour ! Merci encore pour vos réponses !
Bon en fait pour palier à ce problème j'ai essaye de tout mettre dans une seule classe (la classe thread étant une classe dans la classe serveur).

Le multithread fonctionne seulement j'ai un autre problème :

lorsque j'envoi la chaine "AA" depuis le client, le serveur me répond "AA OK".
Le problème est que les réponses sont décalées.
Je m'explique :

Normalement ma console client devrait afficher (en simplifiant) :

Code:

1
2
3
4
5
6
7
8
Chaine a envoyer : AA
Chaine recue : AA OK
 
Chaine a envoyer : BB
Chaine recue : BB OK
 
Chaine a envoyer : CC
Chaine recue : CC OK

hors j'ai :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
Chaine a envoyer : AA
 
Chaine a envoyer : BB
Chaine recue : AA OK
 
Chaine a envoyer : CC
Chaine recue : BB OK
 
Chaine a envoyer : DD
 
Chaine a envoyer : EE
Chaine recue : CC OK

Donc il y a un décalage qui "augmente d'un cran" parfois...

Le code en question :

Client :

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
63
64
65
66
67
68
import java.io.*;
import java.net.*;
 
class ClientUDP
{   
   String host = "localhost";
   int port = 7777;
   String message = "";
 
   public static void main(String args[]) throws Exception
   {						   
	  ClientUDP testClient = new ClientUDP();
	   testClient.ClientUDP();   
	}      
 
	   public void ClientUDP() throws Exception{
 
			 System.out.print("Chaine a envoyer : ");
 
			 while(true)
							{
								BufferedReader saisie =   new BufferedReader(new InputStreamReader(System.in));
								message = saisie.readLine();
								ThreadClientUDP monThreadClientUDP = new ThreadClientUDP(); 
								monThreadClientUDP.start(); 							   
							} 
	   } 
 
					   class ThreadClientUDP extends Thread 
					{					
					   public ThreadClientUDP(){  }
 
					   public void run(){
						  try{
 
						  // ENVOI DES DONNEES						  
 
							 // on créer le socket qui contiendra les données à envoyer
							 DatagramSocket clientSocket = new DatagramSocket();
							 // on récupère l'adresse de la machine
							 InetAddress IPAddress = InetAddress.getByName(host);
 
							 // deux tableaux de bytes contiendront les informations des messages transmis et reçus
							 byte[] sendData = new byte[1024];         
 
							 // on met le message dans un tableau de bytes (obligatoire pour être inséré dans un DatagramPacket)
							 sendData = message.getBytes();
 
							 // on créer le DatagramPacket qu'on envoie
							 DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
							 clientSocket.send(sendPacket);
 
							 // RECEPTION DES DONNEES
							// on créer un DatagramePacket qui attend une réponse du serveur
							 byte[] receiveData = new byte[1024]; 
 
							 DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
							 clientSocket.receive(receivePacket);
 
							 String responseServeur = new String(receivePacket.getData());
 
							 System.out.println("Chaine recue de UDP :" +  receivePacket.getPort() + " : " + responseServeur.trim() + " OK ");
							 clientSocket.close();
						  }
						  catch(Exception e){}
					   }
					}
}

et Serveur

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
import java.io.*;
import java.net.*;
 
class ServeurUDP
{
		DatagramSocket serverSocket;		
		DatagramPacket receivePacket;
 
		int port = 0;
 
		byte[] receiveData = new byte[1024];
		byte[] sendData = new byte[1024];
 
      public static void main(String args[]) throws Exception{
 
                  ServeurUDP serveurUDP = new ServeurUDP();
                  serveurUDP.ServeurUDP(); 
      }
 
 
      public void ServeurUDP() throws Exception{            
 
                  serverSocket = new DatagramSocket(7777);
                  while(true){
							// on créer un datagrampacket 
						receiveData = new byte[1024];
						receivePacket = new DatagramPacket(receiveData, receiveData.length);
						serverSocket.receive(receivePacket);
                        ThreadServeurUDP monThreadServeurUDP = new ThreadServeurUDP(); 
                        monThreadServeurUDP.start();
                  }      
         }
 
				class ThreadServeurUDP extends Thread 
				{
				   public ThreadServeurUDP(){ }
 
					  public void run(){
							try{
										sendData = new byte[1024];
										String message = new String( receivePacket.getData());
										port = receivePacket.getPort();
 
										System.out.println("Chaine recue de UDP :" +  port + " : " + message.trim());
										InetAddress IPAddress = receivePacket.getAddress();
										String reponsemessage = message.trim();
										sendData = reponsemessage.getBytes();
 
										DatagramPacket sendPacket =
											  new DatagramPacket(sendData, sendData.length, IPAddress, port);
										serverSocket.send(sendPacket);
							   }
							catch(Exception e){}
				   }
				}
}

Merci encore pour votre temps et votre aide !!