ObjetInputStream Socket retourne rien ou EOF

Version imprimable

Bonjour a tous,

J'ai configure un petit serveur(Java) pour communiquer avec mon téléphone (Android) via des sockets. J'utilise la sérialisation afin de pouvoir transférer mes objets.

J'arrive a envoyer et a récupérer sur le serveur un objet avec ObjetInputStream. Mais des que j'essaie de renvoyer un autre objet, je n'ai aucun retour ou une erreur EOF. Voici l'exemple que j'utilise actuellement, le 1er objet passe sans problème mais si je veux réutiliser l'objectInputStream encore ca ne marche pas ...
Code:

1 2 3 4 5 6 7 8 9 10 11 Object object = null; try { object = myUser.getObjectInput().readObject(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } myPositions = (ListPositionObjectServer) object; System.out.println("size position:" + myPositions.getListPositions().size());
J'ai cherche différent moyen de faire en sorte de pouvoir communiquer N fois mais rien ne marche ...

03/08/2016, 18h31
tchize_

Tu peux montrer comment tu réutilise? Je ne vois que la lecture d'un objet là.

Aussi, objectInputStream / outputStream ne devrait pas être utilisé pour communiquer entre un client et un serveur. La moindre mise à jour du serveur peut rendre tes clients inopérants.

Salut Tchize_,

Ouais c'est vrai que cette histoire de sérialisation et de partage d'objet n'est pas la meilleur méthode.. Je n'ai que 3 voir 4 max objet a sérialiser qui sont assez simple structurellement.

En ce qui concerne le code cote 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
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
 
public class Match extends Thread {
	Player player_1;
	Player player_2;
	private boolean initialized;
	private ListPositionObjectServer positionsStations;
	private ListPositionObjectServer positionsRiver;
 
	public Match(Player player_1, Player player_2) {
		this.player_1 = player_1;
		this.player_2 = player_2;
		this.initialized = false;
	}
 
	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		if (initialized == false) {
			System.out.println("Match generated ... ");
			try {
				player_1.dataOutputStream = new DataOutputStream(player_1.getSocket().getOutputStream());
				player_1.dataOutputStream.writeInt(2);
				player_2.dataOutputStream = new DataOutputStream(player_2.getSocket().getOutputStream());
				player_2.dataOutputStream.writeInt(3);
 
				player_1.dataOutputStream.flush();
				player_2.dataOutputStream.flush();
 
				Object object = null;
				try {
					object = player_1.getObjectInput().readObject();
				} catch (ClassNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
 
				positionsStations = (ListPositionObjectServer) object;
				System.out.println("size position station" + positionsStations.getPositions().size());
 
				Object object1 = player_1.getObjectInput().readObject();
 
				positionsRiver = (ListPositionObjectServer) object1;
				System.out.println("size position river" + positionsStations.getPositions().size());
				initialized = true;
			} catch (IOException e) {
				// catch (IOException | ClassNotFoundException e)
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

J'ai fais pas mal de changement dessus pour essayer de résoudre mon problème. Tester différentes méthodes qui n'ont rien donner, donc le code est brute ..

Pour la partie client, j'ai 2 AsyncTask: la 1ere envoie le 1er objet après exécution, je lance la 2eme avec le 2eme objet.

03/08/2016, 21h03
tchize_

Ce serait bien qu'on voie comment tu écris les objets et ce qui se cache derrière cette méthode getInput()

Classe player

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
 
public class Player implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    Socket socket;
    ObjectInputStream objectInput;
    DataOutputStream dataOutputStream;
 
 
    public DataOutputStream getDataOutputStream() {
		return dataOutputStream;
	}
 
	public void setDataOutputStream(DataOutputStream dataOutputStream) {
		this.dataOutputStream = dataOutputStream;
	}
 
	public Player(String name) {
        this.name = name;
    }
 
    public ObjectInputStream getObjectInput() {
		return objectInput;
	}
 
	public void setObjectInput(ObjectInputStream objectInput) {
		this.objectInput = objectInput;
	}
 
	public String getName() {
        return name;
    }
    public void setSocket(Socket socket ){
    	this.socket = socket;
    }
 
    public Socket getSocket(){
    	return socket;
    }
}

Et l’activité principale

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
 
 
import java.io.DataInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
 
public class MainActivity {
	final static int port = 34567;
	private static ServerSocket servesock;
	private static Matchmaking matchMaking = new Matchmaking();
	public static ArrayList<Player> playersMainActivity = new ArrayList<>();
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("Server running...");
		matchMaking.start();
		try {
			servesock = new ServerSocket(port);
			while (true) {
				try {
					Socket socket = servesock.accept();
 
						ObjectInputStream objectInput = new ObjectInputStream(socket.getInputStream());
						Object object;
						object = objectInput.readObject();
						Player player = (Player) object;
						player.setSocket(socket);
						player.setObjectInput(objectInput);
						System.out.println(
								"Player: " + player.getName() + " is connected " + " infos : " + socket.getInetAddress());
						Matchmaking.runMatchmaking = true;
						matchMaking.addPlayer(player);
						playersMainActivity.add(player);
 
 
 
				} catch (ClassNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
 
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

03/08/2016, 22h09
tchize_

ok, ca corrsepond pas à ce que tu as décris jusqu'à présent du tout. Là ce que je vois, c'est que les deux cotés: android et serveur, lisent des objets, que l'android agit comme un server (socket.accept), que le serveur écrit dans des DataOutputStream que le client /serveur android prend pour des ObjectInputStream. Dans tout ça je n'ai pas vu un seul ObjectOutputStream.

Met juste les bout de code intéressant: écriture / lecture des object, en précisant de quel coté est chaque code. Parce que là c'est un peu la soupe.
04/08/2016, 00h00
lulz17
Je n'utilise pas d'ObjectOutputStream pour le moment cote serveur .. (Uniquement cote android pour le moment. Toutes classes que j'ai fournis dans ce post proviennent du serveur)

L'idee est que:
1. Player 1 envoie ses objets
2. Le serveur les récupère
3. Le serveur les envoie a player 2
Seulement pour l'instant je suis a la 2eme étape. Et je n'utilise que les ObjectInputStream pour essayer de récupérer mes objets. Car, je récupère bien un objet sur deux. Effectivement, j'ai besoin d'avoir un aspect serveur cote android afin de pouvoir écouter d'éventuelle retour ou requête du serveur.
04/08/2016, 19h41
tchize_

Sauf que ce que je demande à voir depuis le début et que je n'ai toujours pas vu, c'est le code qui écrit ces objet, il n'est nulle part.