Problème ObjectInputStream client-serveur
Bonjour à tous,
Me voilà confronté à un problème épineux où je n'ai toujours pas trouvé de réponse. Je suis en train de développer le jeu des Inventeurs en client-serveur avec 2 IA jouant automatiquement entre elles, lors du lancement du client-serveur je me retrouve confronté à l'erreur suivante lorsque j'instancie les flux ObjectInputStream et ObjectoutputStream dans le traitementServeur et le traitementClient:
Joueur : 1 se connecte à l'adresse/127.0.0.1
Joueur : 2 se connecte à l'adresse/127.0.0.1
java.net.SocketException: Relais brisé (pipe)
at java.net.SocketOutputStream.socketWrite0(Native Method)
at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:109)
at java.net.SocketOutputStream.write(SocketOutputStream.java:153)
at java.io.ObjectOutputStream$BlockDataOutputStream.drain(ObjectOutputStream.java:1877)
at java.io.ObjectOutputStream$BlockDataOutputStream.setBlockDataMode(ObjectOutputStream.java:1786)
at java.io.ObjectOutputStream.<init>(ObjectOutputStream.java:247)
at Serveur.traitementServeur.run(traitementServeur.java:47)
at java.lang.Thread.run(Thread.java:745)
java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2353)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2822)
at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:804)
at java.io.ObjectInputStream.<init>(ObjectInputStream.java:301)
at Client.traitementClient.run(traitementClient.java:39)
at java.lang.Thread.run(Thread.java:745)
java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2353)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2822)
at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:804)
at java.io.ObjectInputStream.<init>(ObjectInputStream.java:301)
at Client.traitementClient.run(traitementClient.java:39)
at java.lang.Thread.run(Thread.java:745)
Petites explications sur mon code je lance donc un serveur, après quoi je fais appel à la méthode openService pour ouvrir le service une fois cela fait j'instancie de nouveaux clients. Dans la méthode traitement connexion le thread serveur s'occupant des connexion va accepter les connexion clientes puis lancer le thread serveur s'occupant du lancement et du déroulement de la partie puis le constructeur du traitement serveur va instancier les thread clients et les lancer avec en paramètre la socket client associées récupérée par la méthode .accept(). Une fois les deux threads clients lancée le run du traitementServeur se lance et la partie commence.
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
| public class Serveur{
private final int port = 1028;
private final String host = "127.0.0.01";
private Thread serverConnexionThread;
private ServerSocket serverSock;
private Socket [] clientSocket;
public Serveur(){
try{
this.serverSock = new ServerSocket(this.port, 10, InetAddress.getByName(this.host));
} catch(UnknownHostException e) {
e.printStackTrace();
} catch(IOException e){
e.printStackTrace();
}
}
public void openService() throws IOException, Exception{
this.serverConnexionThread = new Thread(new TraitementConnexionServeur(serverSock), "ThreadServerConnexion");
this.serverConnexionThread.start();
}
public ServerSocket getSocket(){
return this.serverSock;
}
public boolean getStateThread(){
return this.serverConnexionThread.isAlive();
}
} |
classe TraitementConnexion qui gère le thread s'occupant des connexion clientes:
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
| public class TraitementConnexionServeur implements Runnable{
private ServerSocket socketServer;
private Socket [] clientSocket;
private Thread serverJeuThread;
public TraitementConnexionServeur(ServerSocket socketServ){
this.socketServer = socketServ;
this.clientSocket = new Socket [2];
}
@Override
public void run() {
try {
int i = 0;
int nbConnexion = 0;
while(nbConnexion < this.clientSocket.length){
this.clientSocket[i++] = socketServer.accept();
nbConnexion++;
System.out.println("Joueur : " + i + " se connecte à l'adresse" + this.clientSocket[i -1].getInetAddress());
}
this.serverJeuThread = new Thread(new traitementServeur(this.clientSocket, this.socketServer), "threadServerJeu");
this.serverJeuThread.start();
} catch (Exception ex) {
Logger.getLogger(TraitementConnexionServeur.class.getName()).log(Level.SEVERE, null, ex);
}
}
} |
classe TraitementServeur s'occupant de la mise en place de la partie une fois les connexion clientes effectuées:
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
| public class traitementServeur implements Runnable {
// Variable du constructeur
private ServerSocket socketServer;
private Socket [] socketJoueurs;
private Thread [] threadJoueurs;
private MoteurJeu moteur;
private ObjectOutputStream [] out;
private ObjectInputStream [] in;
public traitementServeur(Socket [] clients, ServerSocket currentSocket) throws IOException, Exception{
this.socketServer = currentSocket;
this.moteur = new MoteurJeu();
this.threadJoueurs = new Thread [clients.length];
this.socketJoueurs = new Socket [clients.length];
this.out = new ObjectOutputStream [clients.length];
this.in = new ObjectInputStream [clients.length];
for(int i = 0; i < clients.length; i++){
this.socketJoueurs[i] = clients[i];
this.threadJoueurs[i] = new Thread(new traitementClient(this.socketServer,this.socketJoueurs[i], this.moteur), "Joueur "+(i + 1));
this.threadJoueurs[i].start();
}
}
@Override
public synchronized void run() {
boolean tourJ1 = true;
try{
for(int i = 0; i < this.socketJoueurs.length; i++){
this.out[i] = new ObjectOutputStream(socketJoueurs[i].getOutputStream());
out[i].flush();
}
for(int i = 0; i < this.socketJoueurs.length; i++){
this.in [i] = new ObjectInputStream (socketJoueurs[i].getInputStream());
}
while(!moteur.finPartie()){
while(!moteur.ageTermine()){
if(tourJ1 == true){
this.out[0].writeObject(this.moteur.getJeuCourant());
this.out[0].flush();
Object finTour = in[0].readObject();
this.moteur.majJeu((ArrayList<Invention>) finTour, 1);
tourJ1 = false;
} else{
this.out[1].writeObject(this.moteur.getJeuCourant());
this.out[1].flush();
Object finTour = in[1].readObject();
this.moteur.majJeu((ArrayList<Invention>) finTour, 2);
tourJ1 = true;
}
}
System.out.println("l'age "+this.moteur.getAgeInvention()+" est terminé");
this.moteur.changementAge();
}
// On envoie flux de caractère avec le nom du vainqueur au client
OutputStream os;
OutputStreamWriter ow;
BufferedWriter wr;
for (int i = 0; i < socketJoueurs.length; i++){
try {
os = socketJoueurs[i].getOutputStream();
ow = new OutputStreamWriter(os);
wr = new BufferedWriter(ow);
wr.write(this.moteur.Vainqueur()+"\n");
wr.flush();
wr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
this.in[0].close();
this.in[1].close();
this.out[0].close();
this.out[1].close();
} catch (Exception e){
e.printStackTrace();
}
}
} |
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
| public class Client {
private Socket socket;
private String host = "localhost";
private int port = 1028;
public Client(String host, int port){
try {
this.socket = new Socket(host, port);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public Client(){
try {
this.socket = new Socket(this.host, this.port);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
} |
classe traitementClient qui gère le thread client lors de la partie:
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
| public class traitementClient implements Runnable{
private ServerSocket socketServer;
private Socket currentSocket;
private IA IAJoueur;
private static int nbClient = 0;
public traitementClient(ServerSocket sockServ, Socket socket, MoteurJeu moteur){
this.socketServer = sockServ;
this.currentSocket = socket;
if(traitementClient.nbClient == 0)
this.IAJoueur = moteur.chargementJoueur("Maxime");
else
this.IAJoueur = moteur.chargementJoueur("Guillaume");
traitementClient.nbClient++;
}
@Override
public synchronized void run() {
try {
ObjectOutputStream out = new ObjectOutputStream(this.currentSocket.getOutputStream());
out.flush();
ObjectInputStream in = new ObjectInputStream (this.currentSocket.getInputStream());
InputStream os = this.currentSocket.getInputStream();
InputStreamReader ow = new InputStreamReader(os);
BufferedReader wr = new BufferedReader(ow);
while(wr.readLine() == null && wr.readLine() != "EXIT"){
if(in.readObject() != null){
ArrayList<Invention> jeu = ((ArrayList<Invention>) in.readObject());
ArrayList jeuUpdate = this.IAJoueur.IaJoue(jeu);
out.writeObject(jeuUpdate);
out.flush();
}
}
in.close();
out.close();
wr.close();
this.currentSocket.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
} |
Merci d'avance pour vos retours, en espérant que vous pourrez m'aider.