Petite Application Client - Server qui ne fonctionne pas totalement - besoin d'explications

**EricStephane** · 06/02/2018, 12h03

Bonjour,

J'ai juste voulu m'amuser à créer une Simple Application Client-Server pour communiquer avec mes camarades. Sauf qu'elle fonctionne partiellement car le server peut lire le premier flux de la socket mais lorsque la socket envoie un deuxième flux cela n'arrive plus au niveau du serveur.

Je suis perdu

Merci d'avance pour vos conseils.

Voici le code :

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
 
public class ClientArmel  extends Thread{
 
 
	Socket s=null; 
	public ClientArmel()  {
	super(); 
 
	try {
		this.s=new Socket("localhost",300);
		System.out.println("vous etes connecte au server!!!");
		Thread th= new Thread(this);
		th.start();
	} catch (UnknownHostException e) {
 
	} catch (IOException e) {
		System.out.println("Impossible de se connecter au server");
 
	}
 
 
 
	}
 
 
 
 
	 public void run() {
 
			try {
				OutputStream os  = s.getOutputStream();
				PrintWriter pw= new PrintWriter(os,true);
 
 
				InputStream in= s.getInputStream() ;
				InputStreamReader isr= new InputStreamReader(in);
				BufferedReader br = new BufferedReader(isr);
				String message = null; 
				String rep =null; 
 
				while(true) {
 
					Scanner entre= new Scanner(System.in);
					message = entre.nextLine(); 
 
					System.out.println(message);
					pw.println(message);
					pw.flush();
				  while( (rep=br.readLine())!=null ) {
 
					   System.out.println(rep);  
 
				  }	
				  entre.close();
				  br.close();
				  pw.close();
 
				}
 
			}catch(Exception ex) {
 
				System.out.println("  Le client ne recoit pass le fluss !!");
 
 
 
			}
 
 
 
	}
	         public static void main(String[] args) {
                    new ClientArmel(); 
}
}

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
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
 
 
 
 
	import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
 
import org.omg.CORBA.portable.OutputStream;
 
public class ServerArmel extends Thread {
	ServerSocket serverSocket ;
	Socket client ; 
    static ServerArmel serverArmel ; 
	public ServerArmel() {
		super();
		 serverArmel=this; 
		 Thread thread = new Thread(this);
		 thread.start();
 
 
 
	}
 
	public void run() {
 
		try {
	    serverSocket = new ServerSocket(300);
 
		System.err.println("Le server est Connecte'");
		}catch(Exception ex) {
 
		System.err.println("Impossible de connecter le Server");
		}
		while(true) {
			try {
			client = serverSocket.accept();
			System.err.println("le server attend une requtte ");
			}catch(Exception ex) {
 
			System.err.println("Problem de Connection  avec le Client");
			}
 
			Thread thread = new Thread(new Conversation(client));
		    thread.start();
		}
 
 
 
	}
 
	public static void main(String[] args) {
		new ServerArmel ();
 
	}
    class Conversation extends Thread 
    {
    	Socket  s =null; 
    	public Conversation(Socket s) {
 
    		this.s=s; 
    	}
 
    	public void run() {
 
    		boolean start= false; 
    		while(!start) {
 
    		try {
 
 
    			InputStream in = s.getInputStream(); 
    			InputStreamReader isr = new InputStreamReader(in);
    			BufferedReader br = new BufferedReader(isr);
    			java.io.OutputStream os = s.getOutputStream();
 
 
    			PrintWriter pw= new PrintWriter(os,true);
    			String message =null; 
    			 Scanner rep=null;;
    			while(true) {
    				 while( (message = br.readLine())!=null ) {
    					   System.out.println("la socket a envoye un message");
    				       System.out.println( s.getRemoteSocketAddress().toString()+"  :"+message); 
    				       rep = new Scanner (System.in); 
    				       String reponse = rep.nextLine();
    				       pw.println(reponse);
    				       pw.flush();
    				 }
 
    				br.close();
    				pw.close();
    				rep.close();
    				s.close();
 
 
    			}
 
    		}catch(Exception ex) {
 
    		System.out.println("Le server ne recoit pas le fluss !!!");
    		}
 
    		}
    	}
 
    }
}

**joel.drigo** · 06/02/2018, 14h08

Salut,

Je commence pas le plus évident (ce n'est pas l'unique problème) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
java.io.OutputStream os = s.getOutputStream(); // ouverture du flux
PrintWriter pw= new PrintWriter(os,true); // wrapping du flux dans un helper pour écrire du texte dans le flux
 
while(true) {  // boucle infinie -> pas bien : tu devrais prévoir un mot spécial pour quitter la boucle (genre exit par exemple)
 
      pw.println(message); // écriture dans le flux
 
     pw.close(); // fermeture du flux...
 
}

En simplifiant le code (pour ne garder que l'envoi de message), on voit bien que le programme fait une ouverture de flux, écrit dans le flux, le ferme, puis boucle, puis réessaye d'écrire dans le flux, qui est fermé ! On ne peut pas écrire dans un flux fermé !

**EricStephane** · 06/02/2018, 14h48

Code :

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

1
2
3
4
5
6
7
8
9
10
java.io.OutputStream os = s.getOutputStream(); // ouverture du flux
PrintWriter pw= new PrintWriter(os,true); // wrapping du flux dans un helper pour écrire du texte dans le flux
 
while(true) {  // boucle infinie -> pas bien : tu devrais prévoir un mot spécial pour quitter la boucle (genre exit par exemple)
 
      pw.println(message); // écriture dans le flux
 
     pw.close(); // fermeture du flux...
 
}

merci pour la reponse

en fait je comprend exactement les instructions .
fermeture de Flux ouvretures et tout le reste et je sais aussi que je pouvais utliser un booelan pour prevoir l'arret
just que mon programme fonction en parti comme j'ai dis plus haut le client envoie le message la premiere fois le server lit et revoie le message
mais apres le server ne recoit plus de Fluss du client je sais pas si c' est du au fait que les ferme' Les ressources
merci encore pour ton aide

**joel.drigo** · 06/02/2018, 15h40

Envoyé par EricStephane

mais apres le server ne recoit plus de Fluss du client je sais pas si c' est du au fait que les ferme' Les ressources

Bah, si, tu le sais, parce que je t'ai dit qu'on ne pouvait pas écrire dans un flux fermé. Il y a peut-être d'autres raisons, mais déjà il faut commencer par ça.

La création de ton client doit suivre cette procédure :

création d'un Scanner sur System.in (unique, surtout pas à chaque itération)
connexion au serveur et ouverture des flux
tant que pas fin
1. lire message
2. envoyer message au serveur
3. lire réponse serveur
4. afficher réponse
fin tant que
fermeture des flux

ou, ce qui rend plus souple la communication (si le serveur tombe, ou la liaison se coupe, le client peut continuer à tourner jusqu'à ce que le serveur soit de nouveau accessible) :

création d'un Scanner sur System.in (unique, surtout pas à chaque itération)
tant que pas fin
1. connexion au serveur et ouverture des flux
2. lire message
3. envoyer message au serveur
4. lire réponse serveur
5. afficher réponse
6. fermeture des flux
fin tant que

**EricStephane** · 06/02/2018, 16h26

Merci Merci!!!!!!

Jai trouve l'erreur grace a vous vraiment merci en fait le Scanner que j'utulissait n'etait pas unique .
donc a chaque Iteration j'avais une nouvelle instance de scanner j'ai donc declare le Scanner hors de ma boucle !
ca fonctionne !!!!!!J'ai utlise cette fois les DataStream !!
Voici le code

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
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
 
public class ServerData {
 
	ServerSocket server = null;
	Socket socket = null;
 
	public ServerData(int port) {
		try {
			server = new ServerSocket(port);
			System.out.println("Le  Server est connecte!");
		} catch (Exception ex) {
 
			System.out.println("Echec de Connection du Server!	 ");
		}
	}
 
	public void runing() {
            Scanner in = new Scanner(System.in);
            boolean start= false;
		while (!start) {
			System.out.println("Le server Attend une connection	!");
			try {
				socket = server.accept();
				System.out.println("le local port du client  est  :" + socket.getLocalPort());
				DataInputStream dataInput = new DataInputStream(socket.getInputStream());
				DataOutputStream dataOutput = new DataOutputStream(socket.getOutputStream());
                                System.out.print(socket.getRemoteSocketAddress()+"  :");
 
				String message = dataInput.readUTF();
				System.out.println(message);
				String rep = in.nextLine();
				dataOutput.writeUTF(rep);
 
 
			} catch (IOException e) {
 
				System.out.println("Le Server n'a pas recu le fluss de la socket !!!");
 
			}
 
		}
 
	}
 
	public static void main(String[] args) {
 
		ServerData data = new ServerData(50);
		data.runing();
	}
 
}

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
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
 
public class ClientData {
 
    Socket socket = null;
 
    public ClientData(String Ip, int port) {
 
        try {
            socket = new Socket(Ip, port);
        } catch (Exception ex) {
 
            System.out.println("Echec de Connection Avec Le Server !!");
 
        }
    }
 
    public void running() {
        Scanner in = new Scanner(System.in);
        boolean start = false; 
        while (!start) {
            try {
                System.out.println("Connecte au Server");
                DataOutputStream dataOut = new DataOutputStream(socket.getOutputStream());
                DataInputStream dataIn = new DataInputStream(socket.getInputStream());
                System.out.print(socket.getRemoteSocketAddress() + "   ");
                String message = in.nextLine();
 
                dataOut.writeUTF(message);
 
                System.out.println(dataIn.readUTF());
 
            } catch (UnknownHostException e) {
 
            } catch (IOException e) {
                System.out.println("Echec de Connection Avec Le Server !!");
            }
 
        }
    }
 
    /**
     *
     * @param argc
     */
    public static void main(String[] argc) {
 
        ClientData client = new ClientData("localhost", 50);
        client.running();
 
    }
}

**thelvin** · 06/02/2018, 17h21

Envoyé par EricStephane

Jai trouve l'erreur grace a vous vraiment merci en fait le Scanner que j'utulissait n'etait pas unique .

Oui et du coup comme tu le fermais juste après la première lecture/écriture, les suivantes ne risquaient pas de marcher...
Et c'était exactement la même chose avec tes BufferedReader et PrintWriter que tu fermais aussi juste après cette même première lecture/écriture !

Bref rien à voir avec Scanner en fait, seulement avec la manière dont tu comprends le début et la fin d'utilisation d'une ressource.

Là ton nouveau programme, le serveur ne peut pas accepter plus d'un message par client -_-°. Il y a encore du chemin à faire. En général l'usage est de créer un thread par client, disons que c'est le plus simple au début.

**EricStephane** · 06/02/2018, 21h52

Exactement cequi s'est passé en fait j'ai cru que ça avait marché pourtant je Server a juste pu lire le premier Fluss de la Socket lorsque la Socket envoie le deuxieme le sever ne lit plus je ne comprend plus rien 😐
J'Ai pourtant mi une boucle infinie pourqu'il puisse toujours lire un message du Client jai utulisé un Thread !vraiment merci d'avance pour votre aide

J'ai eu Idee de creer au Niveau du Server 2 Thread un pour attendre le Fluss et Le 2ieme pour faire la Discutions

Et au Niveau du Client un Thread pour là Discutions sais pas si ça va marcher 😥

**thelvin** · 06/02/2018, 22h26

Ta boucle elle sert à accepter des nouvelles sockets - et effectivement il en faut une.

Mais elle ne sert pas à boucler sur une socket qui a été acceptée et qui parle avec un client. Forcément c'est une autre boucle qu'il faut pour ça.

Tu dis que tu as des threads, mais moi je n'en vois pas.

**EricStephane** · 07/02/2018, 16h05

merci vraiment meme comme j'arrive pas a essourdre le probleme voila j'ai utulise les Thread comme Vous avez demande
mais ca resoud pas vraimnt le probleme je recois une exception comme quoi le server n ' a pas pu lire la socket

vraiment la je comprend plus rien :
Voici mon Code Dessole j'ai voulu le faire dans plussieurs classe pour mieux le comprendre coucoup un peu long :
Merci d'avance pour Vos conseils

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
package com.Arml.Sever;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
 
public class ServerData {
 
	ServerSocket server = null;
	Socket socket = null;
	DataInputStream dataIn = null;
	DataOutputStream dataOut = null;
	Scanner in = new Scanner(System.in);
 
	public ServerData(int port) {
		try {
			server = new ServerSocket(port);
			System.out.println("Server Connecte");
 
				socket = server.accept();
 
				System.out.println("Server attend la connction !");
 
				Thread lire = new Thread(new LireSocket(socket));
				lire.start();
				Thread ecrire = new Thread(new EcrireSocket(socket));
				ecrire.start();
 
 
		} catch (Exception ex) {
			System.out.println("Probleme de Connection Avec la Socket !");
		}
	}
 
	public static void main(String[] args) {
         new ServerData(50);
	}
}

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
package com.Arml.Sever;
 
import java.io.DataInputStream;
 
import java.net.Socket;
 
class LireSocket extends Thread {
	Socket s = null;
	DataInputStream dataIn = null;
 
	public LireSocket(Socket s) {
 
		this.s = s;
		try {
			dataIn = new DataInputStream(s.getInputStream());
			System.out.println("Server a rcu le Fluss du client !!");
 
			Thread.sleep(1000);
		} catch (Exception ex) {
			System.out.println("Inpoibl de recevoir le fluss du Client");
		}
	}
 
	public void run() {
		String message = null;
 
		while (true) {
			try {
				message = dataIn.readUTF();
				System.out.println("Client  :" + message);
 
			} catch (Exception e) {
 
				System.out.println("Impossibl de lire le Fluss du 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
package com.Arml.Sever;
 
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;
 
public class EcrireSocket extends Thread {
 
 
		Socket s = null;
		DataOutputStream dataOut=null;
		Scanner in = new Scanner (System.in);
 
		public EcrireSocket(Socket s) {
			this.s = s;
			try {
				dataOut= new DataOutputStream(s.getOutputStream());
 
			} catch (IOException e1) {
 
			}
		}
 
		public void run() {
			String message = null;
 
			while (true) {
				try {
					message = in.nextLine();
					dataOut.writeUTF(message);
                    dataOut.flush();
				} catch (Exception e) {
					System.out.println("ImPossible d'envoyer le Message!");
				}
 
			}
 
		}
 
	}

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
 
package com.Arml.Sever;
 
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
 
public class Client {
 
	Socket s = null;
 
	public Client(String host, int port) {
		try {
			s = new Socket(host, port);
			System.out.println("connecte au server");
			while (true) {
				Thread ecrire = new Thread(new EcrireClient(s));
				Thread lire = new Thread(new LireClient(s));
				ecrire.start();
				lire.start();
 
			}
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
	}
 
	public static void main(String[] args) {
 
	 new Client("localhost", 50);
	}
 
}

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
package com.Arml.Sever;
 
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;
 
public class EcrireClient extends  Thread {
    Socket s=null; 
 
    DataOutputStream dataOut=null; 
    Scanner in= null; 
    public EcrireClient(Socket s) {
    	this.s=s; 
 
    	in= new Scanner(System.in);
    	try {
			dataOut= new DataOutputStream(s.getOutputStream());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
 
 
 
	@Override
	public void run() {
		String message=null; 
		while(true) {
 
			message= in.nextLine(); 
			try {
				dataOut.writeUTF(message);
				dataOut.flush();
			} catch (IOException e) {
				System.out.println("Le clint n'arrive pas a envoyer le Fluss!!!");
				e.printStackTrace();
			}
		}
 
	}
 
}

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
package com.Arml.Sever;
 
import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
 
 
public class LireClient extends Thread {
    Socket s=null; 
    DataInputStream dataIn=null; 
 
    public LireClient(Socket s) {
    	this.s=s; 
 
    	try {
			dataIn= new DataInputStream(s.getInputStream());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
	@Override
	public void run() {
		String message=null; 
		while(true) {
 
 
			try {
				message=dataIn.readUTF();
				System.out.println( "Server  :"+message);
			} catch (IOException e) {
				System.out.println("Le clint n'arrive pas a envoyer le Fluss!!!");
				e.printStackTrace();
			}
		}
 
	}
 
}

**joel.drigo** · 13/02/2018, 15h30

Salut,

On t'a parlé du fait qu'un serveur s'attend à ce que plusieurs clients se connectent à lui, donc qu'il faut qu'il y ait une boucle pour ça (tant que le serveur est online, il prend des connexions). On a parlé aussi du fait que pour que chaque client puisse communiquer avec le serveur en même temps que les autres clients (sans attendre que le précédent client connecté ait fini) il faut que chacun de ces clients communiquent avec le serveur dans son propre thread (côté serveur).

L'instruction socket = server.accept(); est justement l'instruction qui attend qu'un client se connecte : elle bloque le thread qui l'invoque jusqu'à ce qu'un client soit connecté. L'instance de Socket retournée par la méthode accept est ce qui permet de communiquer avec le client.

Il te faut donc une structure de ce type

Code :

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

1
2
3
4
5
6
7
8
9
while ( leserveurfonctionne ) { // un booléen qui est à true tant qu'on veut que le serveur traite des connexions
 
    Socket socket = server.accept(); // cette instruction attend qu'un client se connecte
 
    // à ce niveau un client s'est connecté et pour communiquer avec lui, on utilise socket 
    lancerUnThreadPourCommuniquerAvecLeClient(socket);
 
 
}

Ensuite la communication entre un élément et un autre repose sur:

un envoi de données, par exemple, envoi par le client d'une requête au serveur
une réception de données(), par exemple, réception de la réponse que fait le serveur à la requête envoyée par le client

On peut envisager une communication bidirectionnelle simultanée (donc un thread pour chacun des deux appels, comme tu as tenté de faire), mais ce sera plus simple pour toi à mon avis de faire ça en deux étapes successives. Donc l'envoi et la réception successivement dans un seul thread.
Par exemple, un seul côté client du type :

Code :

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

1
2
3
4
5
 
    je lis un message au clavier (par exemple)
    j'envoie le message au serveur (j'écris dans l'outputstream d'une socket)
    je réceptionne la réponse fait par le serveur (je lis l'inputstream d'une socket)
    j'affiche la réponse

Et côté serveur, il faut l'inverse du coup :

Code :

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

1
2
3
je reçois un message du client (je lis dans l'inputstream d'une socket)
je détermine ce que je dois faire de ce message et en déduis une réponse
j'envoie la réponse au client (ou à un autre client éventuellement, par exemple, dans le cas d'un chat, ou à tous les autres utilisateurs dans le cas d'un canal type irc) (j'écris dans l'outputstream d'une socket)

Il y a plusieurs façons d'envisager globalement la communication entre client et serveur :
1. Le client se connecte au serveur et échange tant qu'il a envie avec le serveur puis se déconnecte
2. Le client se connecte, fait un échange, et se déconnecte. Il fait cette séquence tant qu'il a envie. Cela me semble plus simple de gérer un système envoi/réception non simultané comme ça.
Quand ce qui précède fonctionne, tu peux complexifier en faisant différents échanges simultanés (donc des processus dans plusieurs threads différents) :
1. un par exemple qui sert au client à envoyer au serveur un message que l'utilisateur a tapé au clavier à destination des autres utilisateurs (ou d'un utilisateur en particulier)
2. un par exemple qui sert au client à récupérer des messages que d'autres utilisateurs lui ont envoyés (polling)

**EricStephane** · 13/02/2018, 15h49

Merci beaucoup pour votre aide. Vos conseils m'ont vraiment aidé à enfin trouver le problème. Je pense que justement le problème était dû au fait que je n'ai pas bouclé l'instruction qui attend une Socket. Et ça fonctionne.

Mais désolé, j'ai une question : pourquoi doit on forcément fermer une ressource. C'est un problème pour moi, parce que je sais qu'on doit fermer la ressource, mais, du coup, lorsque je la ferme, je ne peux plus communiquer avec le flux. Pourtant je veux avoir la possibilité de toujours communiquer avec la Socket étant donné que la discussion entre le serveur et Le client doit toujours être disponible.

Merci d' avance.

**joel.drigo** · 13/02/2018, 16h05

Envoyé par EricStephane

pourquoi on doit forcément fermer une ressource ?

Un tel type de ressource peut bloquer d'autres ressources (logicielles ou matérielles). Par exemple, une Socket va bloquer un port TCP (elle en a besoin pour communiquer) : tant que la socket n'est pas fermée, le port est bloqué. Les ressources sur une machine physique étant limitées, ne pas les fermer, c'est risque d'arriver à épuisement, et donc d'empêcher d'autres programmes qui en aurait besoin de démarrer ou de planter. Dans certains cas, l'ouverture de la ressource peut nécessiter une occupation mémoire importante ou la réservation d'un handle système, ou l'ouverture d'un fichier : la non libération de ce type de ressource peut empêcher certains programmes de se lancer (parce qu'il n'y a pas assez de mémoire ou plus de handle système, ou gérer des composants d'ui, fenêtres, boutons, tout ça). Lorsque la ressource sert à accéder au système de fichier, la fermeture permet également de garantir la libération propre du fichier, ce que le système peut attendre pour permettre à d'autres programmes d’accéder au fichier : ne pas fermer un FileOutputStream peut signifie que le fichier ne sera pas accessible par d'autres programmes (y compris le système d'exploitation). Si tu fermes pas une connexion à une base de données après t'en être servie, le serveur ne pourra pas savoir que tu as fini de bosser et continuera à te réserver cette connexion : lorsque le nombre maximal de connexion sera atteinte, plus personne ne pourra se connecter à la base et tu seras obligé de la redémarrer, ce qui peut être gênant si des personnes travaillent en continu avec.

**EricStephane** · 14/02/2018, 10h56

Merci merci pour les explications c'est Claire 🙄maintenant.
Dans un cas de figure où je veux just lire sur un Fichier je peux fermer la Ressource apres la lecture . Mais je me demande comment je peux fermer la Ressource dans le cas d'un server qui a tjr Bessoin de la Socket ouverte pour communiquer . Sais pas s'il faudrait forcement que je donne le nombre maximal de connection donner la condition que si le sever ateind ce nombre maximum alors je ferme les ressources En fait je sais pas trop á quel niveau je dois fermer les ressources dans le cas dunt server ! 😐

**thelvin** · 14/02/2018, 11h35

Côté serveur il faudrait pas confondre :

- La socket qui écoute pour recevoir de nouvelles connexions, sur un port connu des clients et du serveur.
- Les sockets qui ont été ouvertes pour communiquer avec chaque client qui s'est connecté à la socket serveur d'écoute.

La première, effectivement, elle est un peu la raison d'être de ton serveur. Si elle est fermée, ton serveur n'a pas de raison de continuer de s'exécuter. Si ton serveur est en train de tourner, il n'y a pas de raison que cette socket ne soit pas ouverte et fonctionnelle.

Donc à la limite, c'est pas forcément utile de s'assurer que tu la fermes bien, puisque de toute façon le moment où tu la fermes c'est quand tu arrêtes le serveur, et donc quand ton programme s'arrête, il libérera toutes ses ressources prises de toute façon. Ce serait différent si, par exemple, lorsque tu éteints le serveur, il doit continuer à travailler pendant trois jours pour vérifier qu'il n'y a pas d'incohérence dans les fichiers sur lesquels il a travaillé ou quelque chose de ce genre. Pendant ces trois jours, ce n'est pas une bonne idée qu'il continue d'écouter sur la socket serveur.

Les secondes, il faut les fermer dès lors que la communication avec le client est terminée.

**EricStephane** · 15/02/2018, 18h21

Merci beaucoup j'ai vraiment beaucoup apris de vous ! 😉 bien que j'ai tjr des questions ...

Je sais ça ne cardre devrais peu être faire un autre poste .
Bref jaimerais m'interreser au Web sans toute fois utuliser PHP mais plutôt JAVA EE je sais pas si vous pouvez me donner les Avantages ou inconvenient de le faire en JAVA E E plutôt qu'avec PHP
🙄j'ai regarder un tuto et j'ai vu il etait possible d ' utuliser les Servlet pour communiquer avec SQL
Je sais pas s'il est mieux pour moi d'apprendre PHP ou JAVA EE
Merci d'avance

Petite Application Client - Server qui ne fonctionne pas totalement - besoin d'explications

avec Java

Discussions similaires

Partager

Partager