Discussion :

[EricStephane]

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]

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]

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]

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 :

1. création d'un Scanner sur System.in (unique, surtout pas à chaque itération)
2. connexion au serveur et ouverture des flux
3. tant que pas fin
   
   1. lire message
   2. envoyer message au serveur
   3. lire réponse serveur
   4. afficher réponse
4. fin tant que
5. 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) :

1. création d'un Scanner sur System.in (unique, surtout pas à chaque itération)
2. 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
3. fin tant que

[EricStephane]

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]

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.