Discussion :

[LaCartouche]

Bonjour, je m'amuse en ce moment à coder un petit logiciel de chat et j'ai un soucis qui me prend maintenant la tête depuis quelques heures.

J'ai un pseudo par défaut pour les utilisateurs qui viennent de se connecter et j'ai rajouter un champ afin qu'ils puissent le modifier à leur guise. Seulement voila, impossible de mettre à jour le pseudo de l'utilisateur, le pseudo par défaut revient constamment et je ne comprend vraiment pas pouquoi.

Lorsque j'affiche le contenu de ma variable client dans ma classe Client, le pseudo à bien été modifié.
Lorsque je revérifie le contenu de cette même variable, dans la classe Server, après l'envoi des données, le pseudo par défaut s'affiche...

Voici le code du serveur et du client


SERVER:

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
import java.io.*;
import java.net.*;
import java.util.Vector;
 
import javax.swing.JFrame;
import javax.swing.JTextField;
 
 
public class Server {
 
	private ServerSocket server;
	private Socket socket;
	//private Channel generalChan;
	private int totalClients;
 
	// Contiendra les différents threads gérant les clients
	private Vector vecThread;
 
	public Server (int port) {
 
		//generalChan = new Channel("General");
		totalClients = 0;
 
		vecThread = new Vector();
 
		try {
			this.server = new ServerSocket(port);
			System.out.println("Server listening...");
 
			while (true) {
				socket = server.accept();
 
				totalClients++;
				System.out.println("New user connected : " + socket.getInetAddress() + " " + totalClients + " user(s) now connected");
				vecThread.add(new HandleAClient(socket, this));
			}
		}
		catch (BindException e) {
			e.printStackTrace();
		}
		catch (IOException e) {
			e.printStackTrace();
		}
	}
 
	public void send(String msg) {
		HandleAClient thread;
		for (int i=0; i<vecThread.size(); i++) {
			thread = (HandleAClient) vecThread.elementAt(i);
			thread.send(msg);
		}
	}
 
	public void clientExit(HandleAClient handler) {
		int indice = vecThread.indexOf(handler);
		vecThread.removeElementAt(indice);
		totalClients--;
		handler.destroy();
	}
 
	public static void main(String[] args) {
		new Server(8000);
	}
 
	private class HandleAClient extends Thread {
 
		private Socket socket;
		private ObjectInputStream objectIn;
		private ObjectOutputStream objectOut;
		private Server server;
 
		public HandleAClient (Socket socket, Server server) {
			this.socket = socket;
			this.server = server;
			this.start();
		}
 
		public void send (String msg) {
			try {
				objectOut.writeObject(socket.getInetAddress() + " " + new String(msg));
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
 
		public void run () {
			try {
				objectOut = new ObjectOutputStream(socket.getOutputStream());
				objectOut.flush();
				objectIn = new ObjectInputStream(socket.getInputStream());
 
				User client = (User)objectIn.readObject();
				String msg;
 
				// Un ChannelManager sera indispensable par la suite
				//generalChan.addClientToChannel(client);
 
				while (true) {
					Object objectRcvd = objectIn.readObject();
					if (objectRcvd instanceof User) {
						User user = (User) objectRcvd;
						System.out.println(user.getPseudo());
						client = user;
					} else {
						msg = client.getPseudo() + " " + (String)objectRcvd;
						server.send(msg);
					}
				}
 
			} catch (IOException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e1) {
				e1.printStackTrace();
			}
		}
 
		public void destroy() {
			try {
				objectIn.close();
				objectOut.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
 
		}
	}
}

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
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
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.net.*;
 
import javax.swing.*;
 
public class Client extends JFrame{
 
	private JTextField jtf = new JTextField();
	private JTextField pseudo = new JTextField();
	private JTextArea jta = new JTextArea();
 
	private User client = new User("Default", "Default", "Default");
	private ObjectInputStream objectIn;
	private ObjectOutputStream objectOut;
 
	public static void main(String[] args) {
		new Client();
	}
 
	public Client() {
		JFrame frame = new JFrame("MultiChat");
		frame.setTitle("MultiChat client");
		frame.setSize(400,400);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		frame.setLayout(new BorderLayout());
 
		frame.add(pseudo, BorderLayout.NORTH);
		frame.add(jta, BorderLayout.CENTER);
		frame.add(jtf, BorderLayout.SOUTH);
 
		SetPseudoListener setPseudoListener = new SetPseudoListener();
		pseudo.addActionListener(setPseudoListener);
 
		SendMessageListener sendMsgField = new SendMessageListener();
		jtf.addActionListener(sendMsgField);
 
		frame.setVisible(true);
 
		try {
			Socket socket = new Socket("localhost", 8000);
 
			objectOut = new ObjectOutputStream(socket.getOutputStream());
			objectOut.flush();
			objectIn = new ObjectInputStream(socket.getInputStream());
 
			objectOut.writeObject(client);
			objectOut.flush();
 
			while (true) {
				try {
					String msgReceived = (String)objectIn.readObject();
					jta.append(msgReceived);
				} catch (ClassNotFoundException e) {
					e.printStackTrace();
				}
			}
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
 
	}
 
	private class SetPseudoListener implements ActionListener {
 
		public void actionPerformed(ActionEvent e) {
			try {
				client.setPseudo(pseudo.getText());
				System.out.println(client.getPseudo());
				pseudo.setText("");
				objectOut.writeObject(client);
				System.out.println(client.getPseudo());
				objectOut.flush();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}
 
	}
 
	private class SendMessageListener implements ActionListener {
 
		public void actionPerformed(ActionEvent e) {
			try {
				objectOut.writeObject(jtf.getText()+"\n");
				jtf.setText("");
				objectOut.flush();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
 
		}
 
	}
 
}

Et la classe USER:

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
import java.io.Serializable;
 
 
public class User implements Serializable{
 
	private String pseudo;
	private String nom;
	private String prenom;
	private int latency;
 
	public void setPseudo(String pseudo) {
		this.pseudo = pseudo;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
 
	public void setLatency(int latency) {
		this.latency = latency;
	}
 
	public String getPseudo() {
		return pseudo;
	}
 
	public String getNom() {
		return nom;
	}
 
	public String getPrenom() {
		return prenom;
	}
 
	public int getLatency() {
		return latency;
	}
 
	public User(String pseudo, String nom, String prenom) {
		this.pseudo = pseudo;
		this.nom = nom;
		this.prenom = prenom;
		latency = estimateLatency();
	}
 
	private int estimateLatency() {
		return 0;
	}
}

Merci par avance de votre aide !

[dinobogan]

Peux-tu donner également le code de la classe User ?

[LaCartouche]

Ajouté .

[professeur shadoko]

J'ai pas lu tout le code ....
mais ça sent le renvoi d'un même objet.
explication: un ObjectStream "mémorise" les objets qui passent (cela permet d'envoyer des cycles de références).
Donc si un objet est déjà passé, si ensuite tu modifies son état et tu le renvoie une deuxième fois, à l'autre bout tu récupères toujours l'état initial!
plusieurs solutions: writeUnshared ou plutot gérer des instances différentes (entre parenthèses tu utilises un anti-pattern: créer un modèle d'objet par défaut pour le remplir ensuite ... mais ceci est une autre histoire).

[LaCartouche]

Merci beaucoup ! Je ne suis que débutant et j'ignorais totalement le comportement d'ObjectOutputStream. Je vais enfin pouvoir régler ça.