Discussion :

[xelif]

bonjour a tous,

donc voila pendant mes tp d'info sur une initiation au sockets on a du creer un serveur d'echo, je m'explique, le serveur capte le flux d'un client l'affiche a l'ecran et le renvoi au client afin qu'il l'affiche egalement avec le prefixe "echo: "

ce programme marche tres bien quand il est non "Threadé", ce qui est un peu débile car on ne peut conencter qu'un seul client...

alors j'ai voulu optimiser en creant un Thread qui me permettait de connecter plusieurs client, a ce moment la, les infos arrivent bien jusqu'au serveur mais les clients ne reçoivent jamais l'echo...

classe du 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
 
import java.io.*;
import java.net.*;
 
public class Serveur {
   static final int port = 8080;
 
   public static void main(String[] args) throws Exception {
        ServerSocket s = new ServerSocket(port);
        Serveur serveur = new Serveur();
 
        while(true)
            {
            new ThreadClient(s.accept(),serveur);
            }
   }
}

classe 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
42
43
 
import java.io.*;
import java.net.*;
/** Le processus client se connecte au site fourni dans la commande
 *   d'appel en premier argument et utilise le port distant 8080.
 */
public class Client {
   static final int port = 8080;
 
   public static void main(String[] args) throws Exception {
        Socket socket = new Socket(args[0], port);
        System.out.println("SOCKET = " + socket);
 
        BufferedReader plec = new BufferedReader(
                               new InputStreamReader(socket.getInputStream())
                               );
 
                 PrintWriter pred = new PrintWriter(
                             new BufferedWriter(
                                new OutputStreamWriter(socket.getOutputStream())),
                             true);
 
 
 
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String str = in.readLine();
 
 
        while(!str.equals("quit"))
        {
                    pred.println(str);          // envoi d'un message
                    str = plec.readLine();      // lecture de l'écho
                    System.out.println("Echo : "+str);
                    str = in.readLine();        // saisie du mot
        }
        System.out.println("END");     // message de terminaison
        pred.println("END") ;
        plec.close();
        pred.close();
        in.close();
        socket.close();
   }
}

classe du Thread s'occupant des clients :

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
 
import java.net.*;
import java.io.*;
 
class ThreadClient implements Runnable{
    private Thread t; // contiendra le thread du client
    private Socket s; // recevra le socket liant au client
    private PrintWriter out; // pour gestion du flux de sortie
    private BufferedReader in; // pour gestion du flux d'entrée
    private Serveur serveur; // pour utilisation des méthodes de la classe principale
 
 
    ThreadClient(Socket soc, Serveur serv){
        serveur = serv;
        s = soc;
 
        try
        {
                        System.out.println("socket du client venant de s'être connecté : "+soc);
            out = new PrintWriter(s.getOutputStream());    // flux de sortie
            in = new BufferedReader(new InputStreamReader(s.getInputStream()));    // flux d'entrée
        }
        catch (IOException e){ System.out.println("erreur lors de la creation des flux"); }
 
        t = new Thread(this); // instanciation du thread
        t.start(); // demarrage du thread, la fonction run() est ici lancée
    }
 
    public void run(){
        String message = ""; // déclaration de la variable qui recevra les messages du client
    // on indique dans la console la connection d'un nouveau client
 
        try
        {while(true)
                {
                message = in.readLine();
                if (message.equals("END")) break;
                System.out.println("message : "+message);
                out.println(message);
                }
        }
        catch (Exception e){ System.out.println("problème");}
        finally // finally se produira le plus souvent lors de la deconnexion du client
        {
            try
            {
            // on indique à la console la deconnexion du client
            System.out.println("Le client s'est deconnecte");
            s.close(); // fermeture du socket si il ne l'a pas déjà été (à cause de l'exception levée plus haut)
            }
            catch (IOException e){ }
        }
    }
 
}

dois je partager une chaine de caractere entre tous les Thread qui viendront la lire et la renvoyer? je suis un peu perdu avec ces histoires de flux moi...

[Baptiste Wicht]

J'ai pas tout à fait compris la manière dont tu as fais ca...

Moi j'avais un fait un mini-chat en local aussi avec les sockets, et j'avais procédé ainsi :

• Une interface principale sur laquelle on lancait un serveur ou on se connectait à un serveur.
  • En lancant le serveur, ca lancait un simple thread qui attendait la connexion de client et à chaque connexion lancait une nouveau thread Client et lui passait une référence sur une liste qui allait contenir tous les streams de sortie
  • En se connectant au serveur, ca créait une sorte de thread écouteur qui prenait tous les messages pour les mettre sur son l'interface
• les threads (qui sont lancés à chaque connexion) sont aussi des threads écouteurs, à chaque message qu'un client, envoie, il parcout la liste des streams et envoie le message sur chacun des threads

[xelif]

Attention, ce n'est pas un chat, c'est un serveur qui capte les flux entrant sur le serveur et les renvoie au client...

Donc je cré un nouveau Thread a chaque nouvelle connection d'un client afin de lui renvoyer le flux de donnée qu'il a prealablement envoyé au serveur

donc il capte le mesage et est censé les re-envoyer avec ces trois lignes de code la :

Code :

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

1
2
3
4
5
6
message = in.readLine();
                if (message.equals("END")) break;
                System.out.println("message : "+message);
                out.println(message);

apparement le serveur envoie un message mais le client ne le recoit pas... et se bloque donc j'aimerai savoir si quelqu'un pouvait m'aider un peu...

[iohack]

Après le out.println, il faut faire un out.flush(), ou bien passer "true" dans le constructeur du printWriter pour lui dire autoflush=true.

[xelif]

ok ok

CA MARCHE !!!!!

merci beaucoup

tu fais de moi le plus heureux des hommes

P.S. je n'oublie pas le tag [Resolu] :lol

[Nihad Tahiri]

Xelif , s'il te plait tu peux m'envoyer tous le code de ce projet chat , c'est urgent plz

[xelif]

en plus de déterrer un sujet de plus de 6ans, tu me demandes les sources alors qu'elles sont présentes... prends le temps de lire et de comprendre ça sera le seul moyen d'apprendre et de retenir le fonctionnement des threads, en l'occurence il ne manquait que l'appel à la méthode flush qui permettait de forcer l'envoi d'un message par un socket...

Dans ce genre de cas, ouvre un nouveau sujet, pose ta question, il y a pleins de gens compétents sur ce forums qui se feront une joie de t'aider...

Et des codes sources doivent être disponible en faisant une simple recherche google

Bonne soirée et bon courage