Mes premiers sockets : problème échange client serveur

**odsen.s** · 15/05/2010, 14h01

Bonjour à tous,

J'ai commencé le java cette année à l'école et j'ai un projet où un client et un serveur devront s'échanger des données dans le cadre de la réalisation d'un jeu. J'ai donc commencé à m'intéresser aux sockets grâce aux tutos de ce site et à créer une classe Client et une classe Serveur qui doivent s'échanger toutes les secondes un objet générique de classe T.

J'ai testé les classes grâce à une classe Test où le client et le serveur s'échangent des String jusqu'à ce que l'une d'entre elles vaille "quit".

Malheureusement je ne parviens pas à échanger des données, le client affiche "Connection reset" puis "Broken pipe". Sauriez-vous m'aider ? Je vous fournis ci-dessous les classes concernées, ainsi que les sorties.

- Classe 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
package reseau;
 
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
 
public class Client<T> extends Thread 
{		
	private Socket socket;
	private T myObject;		
	private T serverObject;
	private boolean fin;
 
	private final static int pause = 1000;
 
	public Client(Socket s) 
	{
		this.socket = s;
		this.myObject = null;
		this.serverObject = null;
		this.fin = false;
	}
 
	@SuppressWarnings("unchecked") // pour le type generique
	public void run() 
	{	
		while(!this.fin)
		{
			ObjectOutputStream oos = null;
 
			try
			{			
				// on envoie l'objet au serveur
				oos = new ObjectOutputStream(socket.getOutputStream());
				oos.writeObject(myObject);
 
				ObjectInputStream ois = null;				
				try
				{
					// on attend l'objet du serveur
					ois = new ObjectInputStream(socket.getInputStream());
					this.serverObject = (T) ois.readObject();
 
				}
				catch(Exception e)
				{
					System.out.println(e.getMessage());
				}
			}
			catch(Exception e)
			{
				System.out.println(e.getMessage());
			}
			finally
			{
				try 
				{
					// pause avant d'effectuer l'echange suivant
					sleep(pause);
				} 
				catch (InterruptedException e) 
				{
					System.out.println(e.getMessage());
				}
			}
		}
 
		// fermeture de la connexion
		try {
			this.socket.close();
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}
 
	public T getServerObject() 
	{
		return serverObject;
	}
 
	public void setMyObject(T myObject) 
	{
		this.myObject = myObject;
	}
 
	public void setFin(boolean fin) {
		this.fin = fin;
	}	
}

- Classe 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
package reseau;
 
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Serveur<T> extends Thread
{
	private ServerSocket serverSocket;
	private Socket socket;
	private T myObject;
	private T clientObject;
	private boolean fin;
 
	public Serveur(ServerSocket s) 
	{
		this.serverSocket = s;		
		try {
			this.socket = this.serverSocket.accept();
		} catch (IOException e) {
			e.getStackTrace();
		}		
 
		this.myObject = null;
		this.clientObject = null;
		this.socket = null;
		this.fin = false;
	}
 
	@SuppressWarnings("unchecked") // pour clientObject
	public void run()
	{			
		while(!this.fin)
		{
			ObjectInputStream ois = null;
			try // TODO : catch à chaque fois
			{
				// on attend l'envoi depuis le client
				ois = new ObjectInputStream(socket.getInputStream());
				this.clientObject = (T) ois.readObject();
 
				ObjectOutputStream oos = null;			
				try
				{
					// on envoie l'objet au client
					oos = new ObjectOutputStream(socket.getOutputStream());
					oos.writeObject(myObject);					
				}
				catch(Exception e)
				{					
					e.getStackTrace();
				}
			}
			catch(Exception e)
			{				
				e.getStackTrace();
			}
		}
 
		// fermeture de la connexion
		try {
			this.socket.close();
		} catch (IOException e) {
			e.getStackTrace();
		}
		try {
			this.serverSocket.close();
		} catch (IOException e) {
			e.getStackTrace();
		}
	} 
 
 
	public T getClientObject() 
	{
		return clientObject;
	}
 
	public void setMyObject(T myObject) 
	{
		this.myObject = myObject;
	}	
 
	public Socket getSocket()
	{
		return socket;
	}
 
	public void setFin(boolean fin) 
	{
		this.fin = fin;
	}	
}

- Classe Menu :

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
package menu;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public abstract class Menu 
{
	private static BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));
 
	public static String choixClientServeur() throws IOException
	{
		System.out.println("Voulez-vous : \n"
							+ "0. Creer une partie\n"
							+ "1. Rejoindre une partie");
 
		return entree.readLine();
	}
 
	public static String jouerEncore() throws IOException
	{
		System.out.println("Voulez-vous jouer encore ?\n"
							+ "0. Non\n"
							+ "1. Oui");
 
		return entree.readLine();
	}
}

- Classe Test :

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
package menu;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
 
import reseau.Client;
import reseau.Serveur;
 
public class Test 
{
	private static final int PORT = 30200;
	private static final String IP_SERVEUR = "127.0.0.1";
 
	public static void main(String[] args) 
	{
		String choix = new String("");
 
		/* l'utilisateur choisit d'etre client ou serveur */
		while(!(choix.contentEquals("0")) && !(choix.contentEquals("1")))
		{
			try {
				choix = Menu.choixClientServeur();
			} catch (IOException e) {
				System.out.println(e.getMessage());
			}
		}
 
		/* on lance un client ou un serveur en fonction du choix */
		if(choix.contentEquals("0"))
		{
			/* try/catch pour ServerSocket */
			try 
			{				
				String s = new String("");
				Serveur<String> serveur = new Serveur<String>(new ServerSocket(PORT));
				serveur.setMyObject(s);
				serveur.start();
 
				/* on attend un premier echange */
				while(serveur.getClientObject() == null)
				{
					try {
						Thread.sleep(1000);
						System.out.println("en atente du premier echange");
					} catch (InterruptedException e) {
						System.out.println(e.getMessage());
					}
				}
 
				/* echange de donnees, condition de fin */
				BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));
				while(!s.contentEquals("quit") && !serveur.getClientObject().contentEquals("quit"))
				{
					System.out.println("s_client = " + serveur.getClientObject() + ", s_server = " + s + "\n"
							 + "entrez la nouvelle chaine : ");
					serveur.setMyObject(s = entree.readLine());
				}
 
				/* terminer le thread serveur */
				serveur.setFin(true);
			} 
			catch (IOException e) 
			{
				System.out.println(e.getMessage());
			}			
		}
		else
		{
			/* try/catch pour Socket */
			try 
			{				
				String s = new String("");
				Client<String> client = new Client<String>(new Socket(IP_SERVEUR, PORT));
				client.setMyObject(s);
				client.start();
 
				/* on attend un premier echange avant de contiuer */
				while(client.getServerObject() == null)
				{
					try {
						Thread.sleep(1000);
						System.out.println("en atente du premier echange");
					} catch (InterruptedException e) {
						System.out.println(e.getMessage());
					}
				}
 
				/* echange de donnees, condition de fin */
				BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));
				while(!s.contentEquals("quit") && !client.getServerObject().contentEquals("quit"))
				{
					System.out.println("s_client = " + client.getServerObject() + ", s_server = " + s + "\n"
							 + "entrez la nouvelle chaine : ");
					client.setMyObject(s = entree.readLine());
				}
 
				/* terminer le thread */
				client.setFin(true);
			} 
			catch (IOException e) 
			{
				System.out.println(e.getMessage());
			}				
		}
	}
}

- Sortie du serveur :

Voulez-vous :
0. Creer une partie
1. Rejoindre une partie
0 <enter>
en atente du premier echange
en atente du premier echange
en atente du premier echange
en atente du premier echange
en atente du premier echange
en atente du premier echange
...

-Sortie du client :

Voulez-vous :
0. Creer une partie
1. Rejoindre une partie
1 <enter>
Connection reset
en atente du premier echange
Broken pipe
en atente du premier echange
Broken pipe
en atente du premier echange
Broken pipe
...

A noter que à la ligne marquée par "//TODO : catch à chaque fois" dans la méthode run() du serveur, le try rate à chaque fois.

Merci pour les conseils que vous pourrez m'apporter.

**odsen.s** · 16/05/2010, 18h32

Personne ne voit d'où pourrait venir le problème ?

Mes premiers sockets : problème échange client serveur

Entrée/Sortie Java

Discussions similaires

Partager

Partager