Discussion :

[Saokore91]

Bonjour,

Après avoir lu plusieurs cours sur les bases des sockets, j'ai voulu m'attaquer à ces petites bebetes ! Et elles sont trop puissantes pour moi en ce moment.

Alors j'aimerais comprendre comment communiquer avec mon serveur en utilisant toujours le même Socket. Est-ce possible ?

Je vous présente mon code (fier d'avoir réussir à faire tout ça ) :

J'exécute le fichier Serveur en premier qui va me créer un thread pour mon serveur. Dans le run du serveur, il y aura une boucle infinie pour laisser "allumé" le serveur. Ensuite j'exécute le fichier Client qui permet de dialoguer avec le serveur. Actuellement, le dialogue se fait sans soucis, mais à chaque fois je créer un nouveau Socket.

Est-ce une bonne idée ?

J'aurais aimé comprendre comment avoir un Socket par Connexion. C'est à dire je me connecte en client. Puis je communique avec un seul Socket.

C'est peut être réalisable ?

Auriez vous des pistes à me proposer ?

Merci par avance

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
public class Serveur {
 
	public static void main(String[] args) {
		try {
			ServerSocket serveur = new ServerSocket(2000);
 
			Thread tServeur = new Thread(new ConnexionClient(serveur));
 
			tServeur.start();
		}
		catch (IOException e) {
			e.printStackTrace();
		}
 
	}
 
}

ConnexionClient :

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
public class ConnexionClient implements Runnable{
 
	private ServerSocket sServeur;
	private Socket sockDuServeur;
 
	//Construction de la connexion
	public ConnexionClient(ServerSocket sServeur){
		this.sServeur = sServeur;
	}
 
	//Mon thread
	public void run() {
		int nbre_co = 0;
		JFrame Serveur = new JFrame("Serveur");
		Serveur.setVisible(true);
 
		while (true) {
			try {
				System.out.println("Serveur: Attente de connexion");
				sockDuServeur = sServeur.accept();
				nbre_co += 1;
 
				System.out.println("\t Connexion n°" + nbre_co);
 
				BufferedReader in = new BufferedReader(new InputStreamReader(sockDuServeur.getInputStream()));
				PrintWriter out = new PrintWriter(sockDuServeur.getOutputStream());
 
				String msg_client = in.readLine();
				System.out.println("Client: " + msg_client);
				String msg_servToClient = "\t Serveur: " + msg_client.toUpperCase();
 
				out.println(msg_servToClient);
				out.flush();
 
			}
			catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
 
}

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
public class Client {
 
	public static void main(String[] args) {
 
		boolean statut = true;
		Scanner saisie = new Scanner(System.in);
		BufferedReader in;
		PrintWriter out;
		Socket socketCli;
 
		try {
 
			System.out.println("Discutez avec le serveur:");
			System.out.println("1: oui ||| 2: non");
 
			int reponse = Integer.parseInt(saisie.nextLine());
 
			if(reponse == 1){
				while(statut){
 
					socketCli = new Socket("localhost",2000);
 
					out = new PrintWriter(socketCli.getOutputStream()); //permet l'envoi de message
					in = new BufferedReader(new InputStreamReader(socketCli.getInputStream())); //lit les messages
 
					System.out.println("Discutez:");
 
					String message = saisie.nextLine();
 
					if(!message.equals("leave")){
 
						out.println(message); //envoi du message
						out.flush();
 
						message = null;
 
						String msg_serv = in.readLine(); //reception du message
						JOptionPane.showMessageDialog(null), msg_serv);
 
						socketCli.close();
					}
					else {
						if(socketCli != null) {
							socketCli.close();
						}
						statut = false;
					}
 
					//quitte la boucle si le statut change
					if (!statut){
						JOptionPane.showMessageDialog(null, "Déconnexion automatique du client");
						break;
					}
				}
			}
		}
		catch (IOException e) {
			e.printStackTrace();
		}
	}
 
}

[dinobogan]

Côté serveur, il faut démarrer un nouveau thread à chaque nouveau client. Tu lui transmet la socket obtenue depuis accept.
Ensuite, il te faut construire un protocole de communication pour savoir comment ton client va dialoguer avec son thread coté serveur. Il peut être très basique : le thread du serveur affiche en sortie standard tout ce qu'il reçoit du client.
Tu vas pouvoir augmenter les commandes possibles en commençant par une commande spéciale interprétée par le thread serveur lui indiquant de fermer la connexion avec le client par exemple.

[Saokore91]

Bonsoir,
avant tout merci pour ta réponse.

Cependant, quand tu parles de protocole je ne comprends pas. Pour moi les protocoles c'est TCP/IP.

A moins que part protocole tu entends : je choisis par quoi le client doit passer pour éventuellement laisser un message sur le serveur ?

Une autre question vient s'ajouter à la première, comment savoir quand il faut utiliser un Thread ?

Merci d'avance pour vos réponse !

Et pour ceux qui essayent d'envoyer des messages avec les sockets faites attention. Si vous utilisez un BufferedWriter il faut faire comme ça :

Code :

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

1
2
3
4
5
6
BufferedWriter out;
 
//Ici pensez à récupérer le flux de votre Socket
 
out.write("une chaine\n"); //Ne surtout pas oublier le \n j'en ai subis les conséquences 
out.flush();

Alors que si vous utilisez un PrintWriter c'est plus simple et pas de risque d'oublie:

Code :

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

1
2
3
4
5
6
PrintWriter out;
 
//Ici pensez à récupérer le flux de votre Socket
 
out.println("une chaine");
out.flush();

[dinobogan]

Le protocole est la "langue parlée" entre le client et le serveur : quelles sont les commandes envoyées par le client ? Comment le serveur y réponds ? ...