Discussion :

[amminou]

Je suis entrain de développer une application de messagerie instantanée en utilisant les sockets le transfert de donnée entre client et serveur est parfait
mon problème est que j'arrive pas mettre à jour la liste des utilisateurs connectés
pouvez vous m'indiquer une idée pour résoudre ce problème

[Uther]

Il faudrait que tu sois plus précis. Qu'est ce qui te poses problème dans la mise à jour de la liste des utilisateurs connectés?

[dinobogan]

Et surtout il nous faut ton code. On ne connais rien de ton application

[amminou]

voila mon code repartie en deux packages client et 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
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/**
 * @author @mine
 *
 * Classe de gestion du client.
 */
package MIAI_Client;
 
import java.net.*;
import java.io.*;
import java.util.*;
 
 
public class Client implements Runnable
{
	/**
         * Chaine contenant l'adresse du serveur.
         */
	private String adresse;
 
	/**
         * Entier contenant le port du serveur.
         */
	private int port=5000;
 
	/**
         * Chaine contenant le pseudo de l'utilisateur.
         */
	private String pseudo;
 
	/**
         * Socket de connexion.
         */
	private Socket sock;
 
	/**
         * Flux d'entrée des messages (Buffer).
         */
	private BufferedReader in;
 
	/**
         * Flux de sortie des messages.
         */
	private PrintStream out;
 
	/**
         * Vector contenant les messages recus.
         */
	public Vector messages = new Vector();
     public Vector user = new Vector();
 
	/**
         * Constructeur de client.
         * @param adresse chaine contenant l'adresse du serveur.
         * @param port entier contenant le port du serveur.
         * @param pseudo chaine contenant le pseudo de l'utilisateur.
         */
 
    public Client(String adresse,  String pseudo)
	{
		System.out.println(pseudo+" est connecté avec l'adresse :"+adresse+" sur le port:"+port);
		this.adresse = adresse;
 
		this.pseudo = pseudo;
        ajouterClient();
	}
 
    public String getPseudo()
    {
        return pseudo;
    }
 
 
 
    /**
         * Méthode permettant de se connecter au serveur.
         *
         */
	public void connexion()
	{
		try
		{
			sock = new Socket(adresse, port);
			in = new BufferedReader(new InputStreamReader(sock.getInputStream()));
			out = new PrintStream(sock.getOutputStream());
 
			out.println(pseudo + " est connecté ");
			out.flush();
 
			new Thread(this).start();
		}
		catch (IOException ioe)
		{
			System.out.println("Client fermé");
			System.exit(1);
		}
	}
public void ajouterClient(){user.addElement(pseudo);}
	/**
         * Thread gérant la reception des messages.
         */
	public void run()
	{
		try
		{
			while (true)
			{
				String recu = in.readLine();
				messages.addElement(recu);
 
 
 
 
			}
		}
		catch (IOException ioe)
		{
			System.out.println("Probleme de reception client");
		}
	}
 
	/**
         * Méthode permettant l'envoi d'un message.
         * @param message chaine contenant le message à envoyer.
         */
	public void envoyer(String message)
	{
		out.println(pseudo+" dit : "+message);
		out.flush();
 
 
	}
 
	/**
         * Méthode permettant la fermeture du client.
         *
         */
	public void quitter()
	{
		try
		{
			if (sock != null)
			{
 
				out.println(pseudo + " a quitté !");
				out.flush();
 
				out.println("[quit]");
				out.flush();
 
				sock.close();
			}
		}
		catch (IOException ioe)
		{
			System.out.println("Probleme de fermeture client");
			System.exit(2);
		}
	}
}

[Djobird]

Mais que veux tu faire ? Ou est ce que tu veux mettre la liste des personnes connecté à jour ? Sur le serveur, sur les clients ?

[amminou]

à chaque fois qu un client se connecte son login apparait dans la liste des utilisateurs connectés à l'application

[nouknouk]

Il y a un souci de conception au moins du côté de ton serveur:

tu fais une attente active, c'est à dire que pour relayer un message, régulièrement tu regardes si un autre client a ajouté quelque chose dans ta liste de message. S'il n'y a rien de nouveau, tu fais un sleep(1) et tu recommenceras quelques millisecondes plus tard.
Même si ça marche, c'est un énorme gaspillage de ressources : il faudrait que tu réfléchisses à une autre méthode:

- Une classe serveur qui contient la liste des clients (ie. la liste des instances de Connexions).

- Chaque instance de Connexion a son propre thread (comme actuellement) pour lire les données entrantes sur la socket.

- Par contre, pas de thread pour voir s'il y a des messages à retransmettre. A la place, lorsqu'une Connexion reçoit un nouveau message, elle appelle une fonction de Serveur. Cette fonction itérera sur chaque connexion et lui demandera d'envoyer le nouveau message.

L'autre avantage c'est que ta classe Serveur pourra maintenant jouer le chef d'orchestre: c'est en effet elle qui aura en permanence la liste à jour de tous les utilisateurs connectés.

Donc une fois que la première partie est faite, ta classe Serveur pourra:

- prévenir de la même manière chacune des instances de Connexion déjà existantes lorsqu'un nouveau client est connecté, genre en envoyant un message 'le client <pseudo> est connecté'.

- même principe lors d'une déconnexion d'un client.

- enfin, il ne faut pas oublier que lorsqu'un nouveau client se connecte, il faut commencer par lui envoyer un message avec la liste des utilisateurs déjà connectés.

Si tu veux du code à partir duquel t'inspirer, je te propose ce post. Tu y trouveras

- la classe TcpFrameSocket qui correspondra à peu près à ta nouvelle classe Connexion (anciennement Connexion + Recepteur)

- les classes ConnexionPool qui recense la liste des utilisateurs et ServerSocket qui représente la socket server qui écoute sur un port. Tu peux mixer ces deux classes pour élaborer ta nouvelle classe Serveur.

Plus globalement, au niveau des threads du dois avoir :

- un thread pour le ServerSocket.accept(). Lorsqu'une nouvelle connexion est acceptée, il itère sur la liste de clients déjà connectés pour envoyer un message "un nouveau client est connecté" ; il ajoute ensuite une entrée dans la liste de Clients correspondant au nouveau client ; enfin il envoie un message au nouveau client avec la liste des autres clients connectés.

- un thread par Socket client pour faire le socket.readLine(). Quand un nouveau message est reçu, il le transmet à la classe Serveur qui se chargera d'itérer sur la liste de client connectés et envoyer sur chacune de leur sockets le message à relayer. Il n'y a donc pas un thread supplémentaire par socket pour gérer l'envoi des messages !

- enfin, quand le thread Socket client détecte une déconnexion, il prévient l'instance de Serveur pour qu'il envoie un message de déconnexion à tous les autres clients et pour supprimer le client qui vient de se déconnecter de la liste.

[jiddou]

Un Timer pourra régler ton problème.
Tu crée une méthode niveau serveur qui retourne une chaine contenant l'ensemble des logins concatenés( séparés par ":" par exemple) et la niveau client il y ' a un Timer qui te permet de faire une requête vers le serveur de façon périodique.
J'espère que je me suis bien fait comprendre .

[nouknouk]

Un Timer pourra régler ton problème.

Le timer n'est pas vraiment idéal, car ça veut dire que tous les clients vont régulièrmenet demander la liste des utilisateurs connectés même si rien n'a changé depuis la dernière demande. Ca générera donc une consommation inutile de la bande passante.

De plus, si le timer est réglé sur 30 secondes et qu'un client x se connecte au serveur 1 seconde après la requête d'un client y déjà connecté, le client y ne verra x que 29 secondes après.

Evoyer la liste des utilisateurs à la connexion d'un client et envoyer une notification par le serveur à chaque changement de la liste (nouveau connecté / client déconnecté) me parait bien plus propre.

[amminou]

merci pour votre aide, je suis entrain de faire les modifications nécessaire et je vous informerai des résultats obtenues.