Communication par socket

Version imprimable

13/10/2011, 23h27
bloub

Communication par socket

bonsoir tout le monde,

je me suis mis à la programmation socket depuis quelques jours, autant dire que je débute ^^ et je bute déjà sur un problème...

tout ce qui est création de socket (serveur-client), connexion, je m'en sors mais c'est surtout au niveau du transfert de données entre le serveur et le(s) client(s)

pour ça, j'utilise les objets ObjectInputStream et ObjectOutputStream (car j'aurai besoin d'envoyer des objets) mais je rencontre toujours une erreur lors d'un 2e envoi (le 1er se fait nickel). l'erreur est EOFException

j'ai parcouru plusieurs forums et testé quelques possibles solutions (vider le tampon, fermer le flux etc) mais aucune n'a fonctionné à part une fois (chose que j'ai toujours pas compris)

quelqu'un aurait une astuce ou méthode qui me permette d'envoyer plusieurs objets entre 2 sockets ? merci beaucoup !
14/10/2011, 11h15
dinobogan

Donne un code simple et épuré qui reproduit ton problème.

très fort comme je suis, j'ai pas réussi à reproduire l'erreur (mon code est sur mon compte de l'iut...)

voilà les codes que je fais en règle générale pour les sockets

Serveur.java

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
 
package serveur ;
 
// communication réseau
import java.net.ServerSocket ;
import java.net.Socket ;
 
// flux E/S
import java.io.ObjectOutputStream ;
 
// exceptions
import java.io.IOException ;
 
import modele.Personne;
 
public class Serveur {
 
	// socket serveur
	private ServerSocket sockServ ;
	// unique client
	private Socket client ;
 
	/* constructeur par défaut */
	public Serveur() throws IOException, ClassNotFoundException {
 
		this.sockServ=new ServerSocket(1705) ;
 
		// attente d'une connexion
		this.client=this.sockServ.accept() ;
 
		// envoi de données
		this.envoyer(this.client, "tu es bien connecté au serveur !") ;
		this.envoyer(this.client, new Personne()) ;
	}
 
	/* flux de sortie */
	private void envoyer(Socket client, Object o) throws IOException, ClassNotFoundException {
 
		// ouverture du flux de sortie
		ObjectOutputStream out=new ObjectOutputStream(client.getOutputStream()) ;
 
		// écriture
		out.writeObject(o) ;
 
		// vidange du tampon
		out.flush() ;
 
		// fermeture du flux
		out.close() ;
	}
 
	/* lancement du serveur */
	public static void main(String[] args) {
 
		try {
 
			new Serveur() ;
 
		} catch (IOException ioe) {
			ioe.printStackTrace() ;
		} catch (ClassNotFoundException cnfe) {
			cnfe.printStackTrace() ;
		}
	}
}

Client.java

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
 
package client ;
 
// communication réseau
import java.net.Socket ;
 
// flux E/S
import java.io.ObjectInputStream ;
 
// exceptions
import java.io.IOException ;
 
public class Client {
 
	// client
	private Socket sock ;
 
	/* constructeur par défaut */
	public Client() throws IOException, ClassNotFoundException {
 
		this.sock=new Socket("localhost", 1705) ;
 
		// réception des données
		while (true) {
			System.out.println(this.recevoir()) ;
		}
	}
 
	/* flux d'entrée */
	private Object recevoir() throws IOException, ClassNotFoundException {
 
		Object o=null ;
 
		// ouverture du flux d'entrée
		ObjectInputStream in=new ObjectInputStream(this.sock.getInputStream()) ;
 
		// réception
		o=in.readObject() ;
 
		// femreture du flux
		in.close() ;
 
		return o ;
	}
 
	/* lancement du client */
	public static void main(String[] args) {
 
		try {
 
			new Client() ;
 
		} catch (IOException ioe) {
			ioe.printStackTrace() ;
		} catch (ClassNotFoundException cnfe) {
			cnfe.printStackTrace() ;
		}
	}
}

Personne.java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
package modele ;
 
// enregistrement de données
import java.io.Serializable ;
 
public class Personne implements Serializable {
 
	// prénom
	private String prenom ;
 
	/* constructeur par défaut */
	public Personne() {
 
		this.prenom="Romain" ;
	}
 
	/* getters */
	public String getPrenom() {
		return this.prenom ;
	}
}

quand je ferme le flux de sortie dans la méthode envoyer(Socket, Object), j'obtiens cette erreur :

Code:

1
2
3
4
5
6
 
java.net.SocketException: Socket is closed
	at java.net.Socket.getOutputStream(Socket.java:904)
	at serveur.Serveur.envoyer(Serveur.java:39)
	at serveur.Serveur.<init>(Serveur.java:32)
	at serveur.Serveur.main(Serveur.java:56)

et quand je décide de pas le fermer, j'ai alors celle-là :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
java.net.SocketException: Software caused connection abort: socket write error
	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:1857)
	at java.io.ObjectOutputStream$BlockDataOutputStream.setBlockDataMode(ObjectOutputStream.java:1766)
	at java.io.ObjectOutputStream.writeNonProxyDesc(ObjectOutputStream.java:1273)
	at java.io.ObjectOutputStream.writeClassDesc(ObjectOutputStream.java:1227)
	at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1411)
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1174)
	at java.io.ObjectOutputStream.writeFatalException(ObjectOutputStream.java:1557)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:349)
	at serveur.Serveur.envoyer(Serveur.java:42)
	at serveur.Serveur.<init>(Serveur.java:32)
	at serveur.Serveur.main(Serveur.java:56)

je posterai un autre bout de code correspondant à une instance de EOFException quand j'aurai réussi à reproduire l'erreur, sinon merci pour vos lumières !!

16/10/2011, 08h34
tchize_

Ton client fait un close de la socket. Dès ce moment là, le serveur ne peux plus rien envoyer vers la socket, c'est normal, le client s'est déconnecté.

Si le flux doit être maintenu, il ne faut pas faire de close dessus.
16/10/2011, 12h15
bloub

je vois. pourtant, je rappelle en boucle la fonction recevoir(), qui crée une nouvelle instance du flux... ?
16/10/2011, 20h40
tchize_

recevoir n'établit pas de connexion. Il ne fait que wrapper un ObjectInputStream sur le flux de la socket. Mais une fois le flux de la socket fermé, la connexion réseau sera rompue.
17/10/2011, 11h16
bloub

je confirme, je viens d'essayer avec une seule instance de flux (sortant/entrant) et ça a fonctionné !! (par ailleurs, j'avais réussi à recréer l'exception EOFException...) enfin bref, merci beaucoup pour ton aide !
23/10/2011, 23h53
bloub

je ré-ouvre ce topic car j'ai encore une fois un problème avec la communication entre 2 sockets.... et quelques incompréhension qui se sont amenées

la communication entre socket client et serveur ne se fait plus depuis aujourd'hui, et ce même lorsque j'ouvre les flux prévu pour (ObjectInputStream et ObjectOutputStream), j'ai débuggé et j'ai remarqué que ça bloquait à partir du moment où je crée une instance de ces objets coté client et coté serveur (et ça m'arrange pas vraiment)

j'ai donc tenté de récupérer tout simplement le flux coté coté serveur :

Code:

OutputStream out=socket.getOutputStream() ;

et de le caster en ObjectOutputStream (ce qui je pense est possible) mais cette fonction me renvoit un SocketOutputStream (???)

je ne comprends de moins en moins la logique avec les sockets =(

qui aurait un exemple de code (un truc super simple) qui montrerait une communication entre socket serveur et client en utilisant ObjectInputStream (respectivement Output) ? une communication dans les 2 sens aussi, pas seulement serveur vers client =)

je précise que j'ai déjà regardé sur internet des exemples de communication, mais pas trouvé

sinon, merci beacoup !
24/10/2011, 10h25
tchize_

Les ObjectOutput/InputStream ne sont pas vraiment destiné à de la communication client / serveur tel quelle.

Et il n'y a aucune raison pour que socket.getOutputStream retourne un ObjectOutputStream. ObjectOutputStream est une classe séparée qui fait la mise en forme et la sérialisation d'un objet vers un outputstream qui lui est passé en argmuent à sa construction.

Si tu veux faire de la communication avec ça, il va te falloir crée des objets destinés à la communication que tu va sérialiser d'un coté et recevoir de l'autre. C'est un peu se casser la tête.

Si tout ce que tu veux ce sont des objets partagés entre le client et le serveur, le mieux est de te pencher sur RMI.
24/10/2011, 11h33
+Guilhem

Qu'as-tu modifié pour que ça ne marche plus du jour au lendemain ?
Quelle erreur obtiens-tu quand tu dis que ça bloque au moment de la création des streams ?

justement, je n'obtiens aucune erreur lors de l'exécution du serveur, puis du client, d'où mon blocage.... je redonne les sources, peut-être que ce sera plus simple que mes mots

Serveur.java

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
// communication réseau
import java.net.ServerSocket ;
import java.net.Socket ;
 
// flux e/s
import java.io.ObjectInputStream ;
import java.io.ObjectOutputStream ;
 
// collections
import java.util.HashMap ;
 
// lecture au clavier
import java.util.Scanner ;
 
// exceptions
import java.io.IOException ;
 
public class Serveur extends ServerSocket {
 
	// liste des clients
	private HashMap<Socket, Flux> clients ;
 
	/* constructeur par défaut */
	public Serveur() throws IOException {
 
		super(1705) ;
 
		// debug - serveur démarré
		System.out.println("serveur démarré") ;
 
		this.startServeur() ;
	}
 
	/* lance le serveur */
	private void startServeur() throws IOException {
 
		// instance de la des clients
		this.clients=new HashMap<Socket, Flux>() ;
 
		// debug - liste des clients créée
		System.out.println("liste des clients créée" +"\n" +"attente de connexion d'un client") ;
 
		// écoute des connexion entrante
		Socket dernierClient=this.accepterConnexion() ;
 
		// debug - client connecté
		System.out.println("client connecté" +"\n" +"le serveur est prêt à envoyer des messages au client") ;
 
		// debug - envoi constant de messages au client
		Scanner sc=new Scanner(System.in) ;
		while (true) {
			System.out.print("Entre un message : ") ;
			String s=sc.nextLine() ;
 
			// envoi au client
			this.envoyer(dernierClient, s) ;
		}
	}
 
	/* écoute des connexions entrantes */
	private Socket accepterConnexion() throws IOException {
 
		Socket client=super.accept() ;
 
		// ouverture de ses flux
		Flux f=new Flux(client) ;
 
		// ajout du client dans la liste
		this.clients.put(client, f) ;
 
		return client ;
	}
 
	/* envoie des données à un client */
	private void envoyer(Socket client, Object o) throws IOException {
 
		// récupération du flux du client
		ObjectOutputStream out=this.clients.get(client).getOutputStream() ;
 
		// écriture
		out.writeObject(o) ;
 
		// vidange du flux
		out.flush() ;
 
		// fermeture de la variable
		out=null ;
	}
 
	/* lancement de l'application */
	public static void main(String[] args) {
 
		try {
 
			new Serveur() ;
 
		} catch (IOException ioe) {
			ioe.printStackTrace() ;
		}
	}
}

Client.java

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
// communication réseau
import java.net.Socket ;
 
// flux e/s
import java.io.ObjectInputStream ;
import java.io.ObjectOutputStream ;
 
// exceptions
import java.io.IOException ;
 
public class Client extends Socket {
 
	// flux
	private ObjectInputStream in ;
	private ObjectOutputStream out ;
 
	/* constructeur par défaut */
	public Client() throws IOException, ClassNotFoundException {
 
		super("localhost", 1705) ;
 
		// debug - connexion en cours
		System.out.println("connexion établie") ;
 
		this.startClient() ;
	}
 
	/* lance le client */
	private void startClient() throws IOException, ClassNotFoundException {
 
		// debug - ouverture des flux en cours
		System.out.println("ouverture des flux en cours") ;
 
		// ouverture des flux
		this.in=new ObjectInputStream(super.getInputStream()) ;
		this.out=new ObjectOutputStream(super.getOutputStream()) ;
 
		// debug - ouverture des flux effectuée
		System.out.println("ouverture des flux effectuée" +"\n" +"le client est prêt à recevoir les messages du serveur") ;
 
		// debug - réception en continu des messages du serveur
		while (true) {
			System.out.println("serveur dit : " +this.recevoir()) ;
		}
	}
 
	/* reçoit les données venant du serveur */
	private Object recevoir() throws IOException, ClassNotFoundException {
 
		// lecture
		return this.in.readObject() ;
	}
 
	/* lancement de l'application */
	public static void main(String[] args) {
 
		try {
 
			new Client() ;
 
		} catch (IOException ioe) {
			ioe.printStackTrace() ;
		} catch (ClassNotFoundException cnfe) {
			cnfe.printStackTrace() ;
		}
	}
}

Flux.java

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
// communication réseau
import java.net.Socket ;
 
// flux e/s
import java.io.ObjectInputStream ;
import java.io.ObjectOutputStream ;
 
// exceptions
import java.io.IOException ;
 
public class Flux {
 
	// client
	private Socket client ;
	// ses flux
	private ObjectInputStream in ;
	private ObjectOutputStream out ;
 
	/* constructeur par défaut */
	public Flux() {}
 
	/* constructeur de la classe */
	public Flux(Socket client) throws IOException {
 
		this.client=client ;
 
		// ouverture de ses flux
		this.in=new ObjectInputStream(this.client.getInputStream()) ;
		this.out=new ObjectOutputStream(this.client.getOutputStream()) ;
	}
 
	/* getters */
	public ObjectInputStream getInputStream() {
		return this.in ;
	}
	public ObjectOutputStream getOutputStream() {
		return this.out ;
	}
}

l'utilisation de la classe Flux est le seul moyen que j'ai trouvé pour pouvoir mapper, sans problèmes de type d'objets, le client à ses flux e/s. pourtant, après exécution, grâce aux sorties écran que j'ai placé un peu partout, j'ai vu que le serveur/client s'arrêtaient tous les 2 sur les instances de flux correspondant à un client.

je n'utilise aussi que les flux Object[Input|Output]Stream car je n'envoie pratiquement que des objets.

voila voila... merci pour vos aides ! =)

EDIT : le serveur/client fonctionnait car j'instanciais un ObjectOutputStream coté serveur et un ObjectInputStream coté client, du coup il n'y avait pas de conflit.

24/10/2011, 15h46
tchize_

Construit tes ObjectOutputStream avant tes ObjectInputStream, et pas l'inverse. Sinon les deux parties attendent mutuellement que l'autre partie envoie ses headers.
24/10/2011, 15h54
bloub

je bloquais sur un problème aussi simple que ça -_-* merci beaucoup pour ton aide =) ça fonctionne nickel maintenant, jusqu'à ce que je crée une nouvelle erreur ^^