Discussion :

[lulz17]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ...

[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.

[lulz17]

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 :

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
 
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.

[tchize_]

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

[lulz17]

Classe player

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
 
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 :

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
 
 
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();
		}
	}
}

[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.