Discussion :

[Myogtha]

Voilà j'ai un soucis je n'arrive pas à faire que mon serveur ecoute et recois les messages sans se fermer au bout d'une fois et qu'il ferme bien quand je lui envoie "fin". j'ai du oublier quelques chose mais quoi ?
merci d'avance jm

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
import java.net.*;
import java.io.*;
public class Serveur  
{
	public static void main(String[]args)
		{
		try	{
 
			ServerSocket servSock = new ServerSocket(20025);			
			System.out.println("Serveur en attente de message.....");
			Socket so = servSock.accept();
			String chaine;
			do
			{
			InputStream is = so.getInputStream(); // is=octet
			InputStreamReader isr = new InputStreamReader(is); //is->isr=caractere
			BufferedReader br = new BufferedReader(isr); // isr->br=caracteres en memoire tampon 
			chaine = br.readLine(); // br->Chaine=String
			System.out.println("le message suivant a ete recu "+chaine);
			PrintStream ps = new PrintStream(so.getOutputStream());
			ps.println("j'ai bien recu "+chaine);			
			servSock.accept();
			}
			while(chaine != "fin");
			so.close();
			}
		catch(IOException e)
			{
			System.out.println("erreur"+e.toString());
			}
		}
}

[yann2]

bonjour,

dans ton while essaie avec :

Code :

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

1
2
 
while(!chaine.equals("fin"));

voilà.

[Myogtha]

Code :

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

 erreurjava.net.SocketException : Connection Rest

Toujours l'erreur au bout de l'envoie d'un message
lors de l'envoie tout va bien puis lorsquon en renvoie un ça fais ça

[bulbo]

Il faut que tu mettes une boucle autour de ton accept pour accepter une nouvelle connexion a la fin de la premiere ..

Moi ce que je ferais c'est un thread qui ferait le traitement d'un client
En gros voici l'algo
Accept une connexion
Creation d'un thread qui va utiliser la socket
retour au accept

Et dans le thread tu fait le traitement que tu as deja dans ton programme..

Sinon il faut que tu fasses une boucle qui commence juste avant le accept et se termine juste apres le close, l'ennui avec ce systeme c'est que le client suivant doit attendre la fin de la requete du client precedent..

Bulbo

[Myogtha]

Comme ceci ?
ça marche toujours pas comme ça

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
import java.net.*;
import java.io.*;
public class Serveur  
{
	public static void main(String[]args)
		{
		try	{
 
			ServerSocket servSock = new ServerSocket(20025);			
			System.out.println("Serveur en attente de message.....");
			Socket so = servSock.accept();
			String chaine;
			do
			{
			InputStream is = so.getInputStream(); // is=octet
			InputStreamReader isr = new InputStreamReader(is); //is->isr=caractere
			BufferedReader br = new BufferedReader(isr); // isr->br=caracteres en memoire tampon permettant de le traduire en chaine ensuite
			chaine = br.readLine(); // br->Chaine=String
			System.out.println("le message suivant a ete recu "+chaine);
			PrintStream ps = new PrintStream(so.getOutputStream());
			ps.println("j'ai bien recu "+chaine);			
			servSock.accept();
			}
			while(!chaine.equals("fin"));
			so.close();
			}
		catch(IOException e)
			{
			System.out.println("erreur"+e.toString());
			}
		}
}

message edité : je l'ai testé aussi avec le "so.close();" aprés "servSock.accept();"

[bulbo]

Essaie plutot ca:

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
 
import java.net.*; 
import java.io.*; 
public class Serveur  
{ 
   public static void main(String[]args) 
      { 
      try   { 
 
         ServerSocket servSock = new ServerSocket(20025);          
         System.out.println("Serveur en attente de message.....");
         while(true)
         {
         Socket so = servSock.accept(); 
         String chaine; 
         InputStream is = so.getInputStream(); // is=octet 
         InputStreamReader isr = new InputStreamReader(is); //is->isr=caractere 
         BufferedReader br = new BufferedReader(isr); // isr->br=caracteres en memoire tampon permettant de le traduire en chaine ensuite 
         PrintStream ps = new PrintStream(so.getOutputStream()); 
         do 
         { 
         chaine = br.readLine(); // br->Chaine=String 
         System.out.println("le message suivant a ete recu "+chaine); 
         ps.println("j'ai bien recu "+chaine);          
         } 
         while(!chaine.equals("fin")); 
         so.close(); 
         }
         } 
      catch(IOException e) 
         { 
         System.out.println("erreur"+e.toString()); 
         } 
      } 
}

Par contre une petite question tu ecris des messages a destination du client, c'est bien mais le client il les lit ces messages ??

Bulbo

[Myogtha]

je sais pas encore trop bien ce que je veux je cherche à faire du client serveur mais c vague encore pour moi, ce que je recherche pour l'instant ce la possibilité d'envoyé d'un poste avec un programme client avec ça :

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
if(e.getSource()==b1)
			{
			try	{
				Socket so = new Socket(t1.getText(),20025);
				PrintStream ps = new PrintStream(so.getOutputStream());
				ps.println(t2.getText());
 
				InputStream is = so.getInputStream(); // is=octet
				InputStreamReader isr = new InputStreamReader(is); //is->isr=caractere
				BufferedReader br = new BufferedReader(isr); // isr->br=caracteres en memoire tampon permettant de le traduire en chaine ensuite
				String chaine = br.readLine(); // br->Chaine=String
				System.out.println("le message a ete envoye"+chaine);
				}
			catch(IOException f)
				{
				System.out.println("erreur"+f.toString());
				}
			}

à un serveur et que le serveur ne s'arréte pas aprés un message mais qu'il lise tout les message que je lui envoie, une sorte de log qui s'afficherai sous das

le nouveau serveur plante aussi àprés le 1er message plus exactement des qu'on essaie de lui en envoyé maintenant avec le new programme il rame à fond pendant l'envoie du 2eme message jusqu'a dire connection refused : connect

message édité : je viens de testé en lui envoyant que des "fin" il close jamais et si je lui mets un"eregf" à un moment aprés je peux plus rien lui envoyé il me met chez le serveur message null envoyé connection refused

[bulbo]

C'est ce que je t'avais dis, si la premiere requete prend du temps (et apparemment elle en prend) la seconde est bloquee tout ce temps (d'ou l'impression que ca rame et le timeout)

Pour eviter ca il faut utiliser un Thread par requete ...


Autre chose lorsque le serveur accepte une connexion, cette connexion n'est valide que pour un client..
Pour accepter plusieurs connexions (a la fois ou une apres l'autre), il faut boucler sur le accept et utiliser la socket retourne par le accept..

Cette socket n'est valable que pour une connexion avec un seul et meme client et n'est plus valide si refermee d'un cote ..

Bulbo

[Myogtha]

je connais pas le thread, je l'ai pas vi en cours et j'aimerai bien faire sans si c possible sinon je vais regarder avec, c'est compliqué ? ça va changer mon code ?
Un seul est même client me va j'ai que deux postes chez moi et ça ira très bien comme ça
en tout cas merci Bulbo

[bulbo]

Voici le code d'un serveur qui utilise un thread par connexion.
Les actions effectuees sont celles de ton exemple
la reception du mot fin provoque la fermeture de la socket..

J'ai tester ce serveur avec deux clients simultanes et ca marche sans probleme. (J'ai utilise un telnet sur le port 20025 comme 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
63
64
65
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
 
public class DummyTest
{
 
  public static void main(String[] argv)
  {
    try
    {
      ServerSocket servSock = new ServerSocket(20025);
      System.out.println("Serveur en attente de message.....");
      while (true)
      {
        final Socket so = servSock.accept();
 
        Thread t = new Thread()
        {
          public void run()
          {
            try
            {
              String chaine;
              BufferedReader br = new BufferedReader(new InputStreamReader(so.getInputStream()));
              PrintStream ps = new PrintStream(so.getOutputStream());
              while ((chaine = br.readLine()) != null)
              {
                System.out.println("le message suivant a ete recu " + chaine);
                ps.println("j'ai bien recu " + chaine);
                if (chaine.equals("fin"))
                {
                  break;
                }
              }
            }
            catch (Exception e)
            {
              e.printStackTrace();
            }
            finally
            {
              try
              {
                so.close();
              }
              catch (Exception e)
              {
              }
            }
          }
        };
        t.start();
      }
    }
 
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }
}

Si tu as encore des erreurs poste la trace de l'erreur que l'on puisse savoir ou ca plante exactement ...

Bulbo

[Myogtha]

j'ai testé ça marche bien le seul soucis maintenant c que quand j'ecris "fin" il ferme pas le serveur
En tout cas Re-merci bulbo

[bulbo]

Ca c'est normal, lorsque tu ecris fin il ferme la connexion avec le client qui lui a envoye "fin", si tu ne veux pas se comportement dans ce cas au lieu de faire break lorsque tu recoit "fin" tu fais un System.exit(0);

Enfin tu as l'air toujours paume entre les sockets, les serverSocket et tout ca ..

Regarde l'exemple que je t'ai donne et essaye de comprendre pourquoi il marche ..

A quoi correspond une socket: communication bidirectionnel entre un client et un serveur, si elle est fermee une nouvelle doit etre ouverte
A quoi correspond un ServerSocket: ouverture d'un port TCP et ecoute des demandes de connexion a ce port avec la methode accept

Bulbo

[Myogtha]

ah oky je vais comprendre le programme
merci je changerai en system.exit
c'est un bon début
merci bulbo