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