Client/serveur JAVA "petite messagerie" locale

Version imprimable

Bonjour,
j'ai un Serveur TestServeurUDP et deux clients TestClientUDP1 et TestClientUDP2 et j'arrive bien à me connecter via les clients sur le serveur et a renvoyer bonjour "nom saisi sur chaque client" sur chaque client, mais je n'arrive pas à envoyer les infos saisies sur TestClientUDP1 su TestClientUDP2.
Merci de votre aide.

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
package othello;
 
import java.io.*;
import java.net.*;
 
public class TestServeurUDP {
 
  final static int port = 9632;
  final static int port2 = 9638;
  final static int taille = 1024;
  final static int taille2 = 1024;
  static byte buffer[] = new byte[taille];
  static byte buffer2[] = new byte[taille2];
 
  public static void main(String argv[]) throws Exception {
    DatagramSocket socket = new DatagramSocket(port);
    DatagramSocket socket2 = new DatagramSocket(port2);
    String donnees = "";
    String donnees2 = "";
    String message = "";
    String message2 = "";
    int taille = 0;
    int taille2 = 0;
 
    System.out.println("Lancement du serveur");
    while (true) {
      DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);
      DatagramPacket paquet2 = new DatagramPacket(buffer2, buffer2.length);
      DatagramPacket envoi = null;
      DatagramPacket envoi2 = null;
 
      System.out.println("receive paquet");
      socket.receive(paquet);
      System.out.println("receive paquet2");
      socket2.receive(paquet2);
 
      System.out.println("\n"+paquet.getAddress());
      System.out.println("\n"+paquet2.getAddress());
 
      taille = paquet.getLength();
      taille2 = paquet2.getLength();
      donnees = new String(paquet.getData(),0, taille);
      donnees2 = new String(paquet2.getData(),0, taille2);
 
      System.out.println("Donnees reÃ§ues = "+donnees);
      System.out.println("Donnees reÃ§ues = "+donnees2);
 
      message = "Bonjour  client1 : "+donnees;
      message2 = "Bonjour client2 :  "+donnees2;
      System.out.println("Donnees envoyees = "+message);
      System.out.println("Donnees envoyees = "+message2);
      envoi = new DatagramPacket(message.getBytes(), 
        message.length(), paquet.getAddress(), paquet.getPort()); // modif 1 en 2
      envoi2 = new DatagramPacket(message2.getBytes(), 
                message2.length(), paquet2.getAddress(), paquet2.getPort());
      //socket.send(envoi); // modif en 2
      //socket2.send(envoi2);
 
      System.out.println("envoi socket avec envoi2 = "+paquet2.getAddress()+"      "+paquet2.getPort());
      socket2.send(envoi2); // modif en 2
      System.out.println("envoi socket avec envoi = "+paquet.getAddress()+"       "+paquet.getPort());
      socket.send(envoi);
 
 
    }
  }
}

// *************** les clients

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
package othello;
 
import java.io.*;
import java.net.*;
import java.util.Scanner;
 
public class TestClientUDP1 {
 
  final static int port = 9632;
  final static int taille = 1024;
  static byte buffer[] = new byte[taille];
 
  public static void main(String argv[]) throws Exception {
      while (true) {
    try {
      //InetAddress serveur = InetAddress.getByName(argv[0]);
    InetAddress serveur = InetAddress.getLocalHost(); 
      //int length = argv[1].length();
    //int length = 20;
 
      //byte buffer[] = argv[1].getBytes();
 
    System.out.println("Client 1 :  Saisissez un Nom :");
    Scanner sc = new Scanner(System.in);
    String str = sc.nextLine()+" client1 : ";
    int length = str.length();
 
       buffer = str.getBytes();
      DatagramSocket socket = new DatagramSocket();
      DatagramPacket donneesEmises = new DatagramPacket(buffer, length, serveur, port);
      DatagramPacket donneesRecues = new DatagramPacket(new byte[taille], taille);
 
      socket.setSoTimeout(30000);
      socket.send(donneesEmises);
      socket.receive(donneesRecues);
      //socket.close();
 
      System.out.println("Message : " + new String(donneesRecues.getData(), 
        0, donneesRecues.getLength()));
      System.out.println("de : " + donneesRecues.getAddress() + ":" + 
        donneesRecues.getPort());
    } catch (SocketTimeoutException ste) {
      System.out.println("Le delai pour la reponse a expire");
    } catch (Exception e) {
      e.printStackTrace();
    }
      }
  }
}

// **********************

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
package othello;
 
import java.io.*;
import java.net.*;
import java.util.Scanner;
 
public class TestClientUDP2 {
 
  final static int port = 9638;
  final static int taille = 1024;
  static byte buffer[] = new byte[taille];
 
  public static void main(String argv[]) throws Exception {
      while (true) {
    try {
      //InetAddress serveur = InetAddress.getByName(argv[0]);
    InetAddress serveur = InetAddress.getLocalHost(); 
      //int length = argv[1].length();
    //int length = 20;
 
      //byte buffer[] = argv[1].getBytes();
 
 
    //*******
 
    System.out.println("Client 2 :  Saisissez un Nom :");
    Scanner sc = new Scanner(System.in);
    String str = sc.nextLine()+"  client2 : ";
    int length = str.length();
 
       buffer = str.getBytes();
      DatagramSocket socket = new DatagramSocket();
      //socket.close();
      DatagramPacket donneesEmises = new DatagramPacket(buffer, length, serveur, port);
      DatagramPacket donneesRecues = new DatagramPacket(new byte[taille], taille);
 
      socket.setSoTimeout(30000);
      socket.send(donneesEmises);
      socket.receive(donneesRecues);
 
      System.out.println("Message : " + new String(donneesRecues.getData(), 
        0, donneesRecues.getLength()));
      System.out.println("de : " + donneesRecues.getAddress() + ":" + 
        donneesRecues.getPort());
    } catch (SocketTimeoutException ste) {
      System.out.println("Le delai pour la reponse a expire");
    } catch (Exception e) {
      e.printStackTrace();
    }
      }
    //*****************
  }
}

30/10/2023, 17h46
thelvin

Hello,

tu dis que tu n'y arrives pas, mais dans ce code je ne te vois pas essayer.

Par exemple dans le code du serveur, le serveur envoie la variable envoi2 à socket2 et la variable envoi à socket.
Il n'essaie absolument pas de réunir les données qu'il envoie aux différents clients.

Client/seveurs

en fait g déjà essayé socket.send(envoie2) et socket2.send(envoie), mais ça ne fonctionne pas.
merci de ta réponse.

Aussi g simplifié par un serveur (EnvoiMessage) qui envoie à 2 clients (ReceptionMessage et ReceptionMessage2 le même message saisi dans la console (EnvoiMessage) ça fonctionne tres bien.

Voici les codes pour information si d'aventure cela intéresse des gens, ma prochaine étape ets de saisir un message sur ReceptionMessage et de l'envoyer sur ReceptionMessage2 via le serveur EnvoiMessage

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
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
 
package blablaServ;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
 
class EnvoiMessage {
 
	static int port1 = 9700;
	static int port2 =9701;
	//int portacif = port1;
 
	public static void main(String[] arg) throws InterruptedException {
		int portDestinataire;
		InetAddress adresseIP;
		DatagramSocket socketUDP;
		DatagramPacket message;
		BufferedReader entree;
		String ligne;
		String lignesaisie;
		int longueur;
		byte[] tampon;
 
		try {
			socketUDP = new DatagramSocket();
			System.out.println
			("Port local : " + socketUDP.getLocalPort());
			//adresseIP = InetAddress.getByName(arg[0]);
			adresseIP = InetAddress.getLocalHost();;
			//portDestinataire = Integer.parseInt(arg[1]);
 
			entree = new BufferedReader
						(new InputStreamReader(System.in));
 
			portDestinataire = port1;
 
			while(true) {
				ligne = entree.readLine();
				lignesaisie = ligne;
 
				// ****** Gestion du 1 er PORT
				portDestinataire = port1;
 
				// on construit le paquet a envoyer
				tampon = ligne.getBytes();
				longueur = tampon.length;
				message = new DatagramPacket
						(	tampon, longueur, adresseIP, portDestinataire);
 
				System.out.println("On envoie : "+ligne+" sur port "+portDestinataire);
				socketUDP.send(message);
 
 
				// on attend un accuse de reception
				tampon = new byte[256];
				message = new DatagramPacket(tampon, tampon.length);
				socketUDP.receive(message);
				ligne = new String(tampon);
				ligne = ligne.substring(0, message.getLength());
				System.out.println("Du port " + message.getPort() +
						" de la machine " + message.getAddress().getHostName()
						+ " : " + ligne);
 
				//System.out.println("ligne = "+ligne);
 
				// ****** Gestion du 2 eme PORT 
				portDestinataire = port2;
				ligne = lignesaisie;
 
				tampon = ligne.getBytes();
				longueur = tampon.length;
				message = new DatagramPacket
						(	tampon, longueur, adresseIP, portDestinataire);
				System.out.println("On envoie : "+ligne+" sur port "+portDestinataire);
				socketUDP.send(message);
 
 
				// on attend un accuse de reception
				tampon = new byte[256];
				message = new DatagramPacket(tampon, tampon.length);
				socketUDP.receive(message);
				ligne = new String(tampon);
				ligne = ligne.substring(0, message.getLength());
				System.out.println("Du port " + message.getPort() +
						" de la machine " + message.getAddress().getHostName()
						+ " : " + ligne);
 
 
			}
		}
		catch(ArrayIndexOutOfBoundsException exc) {
			System.out.println("Avez-vous donne le nom de la " + 
			"machine destinatrice et le numero de port du client ?");
		}
		catch(UnknownHostException exc) {
			System.out.println("Destinataire inconnu");
		}
		catch(SocketException exc) {
			System.out.println("Probleme d'ouverture de la socket");
		}
		catch(IOException exc) {
			System.out.println("Probleme sur la reception" + 
			" ou l'envoi du message");
		}
		catch(NumberFormatException exc) {
			System.out.println("Le second argument doit etre un entier");
		}
	}
}

// ************** client 1

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
 
package blablaServ;
 
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
 
class ReceptionMessage {
	public static void main(String[] arg) {
		DatagramSocket socketUDP;
		DatagramPacket message;
		byte[] tampon;
		int portLocal;
		byte[] tamponAccuse = "accuse de reception".getBytes();
		int longueurAccuse = tamponAccuse.length;
		String texte ;
 
		try {
			//portLocal = Integer.parseInt(arg[0]);
			portLocal = 9700;
			socketUDP = new DatagramSocket(portLocal);
			while(true) {
				//socketUDP = new DatagramSocket(portLocal);
 
				// on se prepare a recevoir un datagramme
 
				tampon = new byte[256];
				message = new DatagramPacket(tampon, tampon.length);
				socketUDP.receive(message);
				InetAddress adresseIP = message.getAddress();
				int portDistant = message.getPort();
				texte = new String(tampon) ;
				texte = texte.substring(0, message.getLength());
				System.out.println("Reception du port " + portDistant
						+ " de la machine " + adresseIP.getHostName()
						+ " : " +texte);
				//socketUDP.close();
 
				//socketUDP = new DatagramSocket(portLocal);
 
 
				// On envoie un accuse de reception
				message = new DatagramPacket(tamponAccuse,
						longueurAccuse, adresseIP, portDistant);
				socketUDP.send(message);
			}
		}
 
		catch(ArrayIndexOutOfBoundsException exc) {
			System.out.println("Avez-vous donne le numero " + 
					"de port sur lequel vous attendez le message ?");
		}
		catch(SocketException exc) {
			System.out.println("Probleme d'ouverture du socket");
		}
		catch(IOException exc) {
			System.out.println("Probleme sur la reception " + 
					"ou l'envoi du message");
		}
	}
}

//*** client 2

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
 
package blablaServ;
 
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
 
class ReceptionMessage2 {
	public static void main(String[] arg) {
		DatagramSocket socketUDP;
		DatagramPacket message;
		byte[] tampon;
		int portLocal;
		byte[] tamponAccuse = "accuse de reception".getBytes();
		int longueurAccuse = tamponAccuse.length;
		String texte ;
 
		try {
			//portLocal = Integer.parseInt(arg[0]);
			portLocal = 9701;
			socketUDP = new DatagramSocket(portLocal);
			while(true) {
				// on se prepare a recevoir un datagramme
				//socketUDP = new DatagramSocket(portLocal);
				tampon = new byte[256];
				message = new DatagramPacket(tampon, tampon.length);
				socketUDP.receive(message);
				InetAddress adresseIP = message.getAddress();
				int portDistant = message.getPort();
				texte = new String(tampon) ;
				texte = texte.substring(0, message.getLength());
				System.out.println("Reception du port " + portDistant
						+ " de la machine " + adresseIP.getHostName()
						+ " : " +texte);
				//socketUDP.close();
 
				//socketUDP = new DatagramSocket(portLocal);
 
 
				// On envoie un accuse de reception
				message = new DatagramPacket(tamponAccuse,
						longueurAccuse, adresseIP, portDistant);
				socketUDP.send(message);
 
 
			}
		}
 
		catch(ArrayIndexOutOfBoundsException exc) {
			System.out.println("Avez-vous donne le numero " + 
					"de port sur lequel vous attendez le message ?");
		}
		catch(SocketException exc) {
			System.out.println("Probleme d'ouverture du socket");
		}
		catch(IOException exc) {
			System.out.println("Probleme sur la reception " + 
					"ou l'envoi du message");
		}
	}
}