Mes premiers sockets : problème échange client serveur
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:
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:
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:
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:
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 :
Citation:
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 :
Citation:
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.
