Discussion :

[bloub]

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 !

[dinobogan]

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

[bloub]

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 :

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

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

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

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

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 :

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

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

[bloub]

je vois. pourtant, je rappelle en boucle la fonction recevoir(), qui crée une nouvelle instance du flux... ?

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