Client / Serveur Multithread

**Dadar** · 18/06/2012, 19h32

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 :

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
 
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();
                  //}      
         }
   }

et

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

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

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

**rmaker** · 18/06/2012, 20h18

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.

**Dadar** · 18/06/2012, 21h54

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

**Dadar** · 19/06/2012, 14h53

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 :

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

et

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
 
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 !

**wax78** · 19/06/2012, 15h05

Quelle ligne pose problème ?

**Dadar** · 19/06/2012, 15h29

ici c'est lors du passage dans
int port = this.receivePacket.getPort();
que l'exception est levée

**wax78** · 19/06/2012, 15h30

Je dirais que deja au moment de

Code :

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

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

pReceivePacket est null non ?

En remontant encore plus haut

Code :

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

serverSocket.receive(receivePacket);

Avant et apres que raconte receivePacket, null ou pas ?

**Dadar** · 19/06/2012, 16h37

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...

**wax78** · 19/06/2012, 16h39

Dommage que tu n'aies pas mis le code du client j'aurais put l'essayer et débugger

zo1odMSQr5Fy · 20/06/2012, 09h27

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

**Dadar** · 20/06/2012, 12h07

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 :

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

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 :

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

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 :

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

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
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 !!

Client / Serveur Multithread

avec Java

Discussions similaires

Partager

Partager