Probleme d'exception java.io.StreamCorruptedException

**nzo70** · 12/01/2009, 17h48

Bonjour

je developpe une application qui permet d 'envoyer des fichiers.J'utilise pour cela des ObjectInputStream et ObjectOutputStream

Le premier objet que j'envoie (pour annoncer au serveur que l'on se connecte) n'engendre pas d'erreur.

Le probleme est lorsque le serveur renvoi un fichier au client j'ai une exception en boucle coté client. : java.io.StreamCorruptedException : invalid type code : AC

Cette exception est levée sur la ligne en gras de la classe ReceptioFichierThreadClient

Est ce que quelq'un pourrait m'aider ou au moins me donner la signification de l exception

voici mon code :

classe client

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
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
 
import java.net.*;
import java.io.*;
import java.awt.event.*;
import javax.swing.*;
import java.lang.Runnable;
import java.util.*;
 
public class client  {
 
	Socket soc, socFile;
	protected String pseudo;
	BufferedReader entree;
	PrintWriter sortie;
	OutputStream os;
	ObjectOutputStream sortieFile;
	InputStream is;
	ObjectInputStream entreeFile;
	String msg;
	FenetreContact fc;
	static List<String>lstconect = new ArrayList<String>();
 
	public client (String pseudo){
 
		this.pseudo=pseudo;
 
 
	}
 
	public void connexion() throws IOException{
 
 
		try{
 
			InetAddress ip = InetAddress.getByName("192.168.1.36");
			System.out.println("Adresse ip du serveur : " + ip);
			soc = new Socket (ip, Server.port);
 
			System.out.println("Socket : " + soc);
			entree = new BufferedReader(new InputStreamReader(soc.getInputStream()));
			sortie = new PrintWriter(new BufferedWriter(new OutputStreamWriter(soc.getOutputStream())),true);
			System.out.println("initialiser");
 
			sortie.println(this.pseudo);
 
            //conexion au serveur de fichier
			Socket socfic = this.connexionFichier();
			System.out.println("socfic recupere");
 
			new ReceptionThreadClient(this,entree, sortie, soc,fc).start();
 
			System.out.println("Thread OK");
			fc = new FenetreContact(this);
			System.out.println("FenetreContact OK");
 
 
 
		}catch (Exception e) {
 
			e.printStackTrace();
 
 
		}
	}
 
 
 
	public void envoyer(String msg){
 
		sortie.println(msg);
 
	}
 
	public Socket connexionFichier(){
 
		try{
 
			System.out.println("connexion ");
			InetAddress ip = InetAddress.getByName("192.168.1.36");
			socFile = new Socket(ip, 8081);
			System.out.println("connexion reussi");
			try{
 
				is = socFile.getInputStream();
				entreeFile = new ObjectInputStream(is);
				os = socFile.getOutputStream();
				sortieFile = new ObjectOutputStream(os);
				System.out.println("oksortieFile");
				sortieFile.writeObject(this.pseudo);
				System.out.println("writeObject(pseudo)OK");
 
				new ReceptionFichierThreadClient(is, os, entreeFile, sortieFile, socFile).start();
			}catch (Exception e){
 
				System.out.println("Erreur d'instantiation des flux fichiers client");
				System.out.println(e);
 
 
			}
 
		}catch(Exception e){
 
			System.out.println("Probleme de connexion au serveur de fichier");
			System.out.println(e);
 
		}
		return socFile;
 
	}
 
	public void envoyerFichier(Fichier fichier){
 
 
 
		File file = fichier.f;
		System.out.println(file.getName());
		if(file.exists()){
			System.out.println("file.exists==true");
 
		    try{
 
		    	sortieFile.writeObject(fichier);
 
 
		    }catch (Exception e){
 
		    	System.out.println("Probleme envoi fichier");
		    	System.out.println(e);
 
		    }
 
 
 
		}
 
 
	}
 
 
	public void deconnexion(){
 
		String msg = "deconect,"+this.pseudo;
		this.envoyer(msg);
 
		File f = new File("deconnexion");
		Fichier fic = new Fichier(f,"deconnexion");
		try{
 
			sortieFile.writeObject(fic);
 
		}catch (Exception e){
 
			System.out.println("Erreur lors de la deconnexion au serveur de fichier");
			System.out.println(e);
 
		}
 
		System.exit(0);
 
	}
 
 
 
}

classe ReceptionFichierThreadClient

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
66

import java.io.*;
import java.net.*;

public class ReceptionFichierThreadClient extends Thread {
	
	
	private InputStream is;
	private OutputStream os;
	private ObjectInputStream entreFile;
	private ObjectOutputStream sortieFile;
	private Socket socFile;
	
	public ReceptionFichierThreadClient (InputStream is, OutputStream os, ObjectInputStream entreFile,ObjectOutputStream sortieFile, Socket socFile) {
		
		this.is=is;
		this.os=os;
		this.entreFile=entreFile;
		this.sortieFile=sortieFile;
		this.socFile=socFile;
		
	}
	
	public void run(){
		
		 while(true){
			 
			 try{
				 
				 Fichier fichier = (Fichier)entreFile.readObject();
				 String dest = fichier.getDest();
				 if(dest.equals("deconnexion")){
					 
					   System.out.println("deconnexion du serveur de fichier");
					    sortieFile.close();
				    	os.close();
				    	entreFile.close();
				    	is.close();
				    	socFile.close();
					    break;
					 
					 
				 }else{
					 
					 System.out.println("Fichier recu : "+fichier.getDest());
					 
				 }
				
				 
			 }catch (Exception e){
				 
				 System.out.println("Probleme reception fichier");
				 System.out.println(e);
				 
			 }
			 
			 
		 }
		
		
		
	}
	

}

la classe ServerFichier :

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
 
 
import java.net.*;
import java.util.HashMap;
import java.util.Map;
import java.io.*;
 
 
public class ServerFichier {
 
	    static Map<String,Socket> mapFichier = new HashMap<String, Socket>();
 
		public static void main(String [] args){
 
			int num = 0;
 
			try{
 
 
 
					ServerSocket srv = new ServerSocket(8081);
					System.out.println("Démarré " + srv);
 
					while(true){
 
						Socket conect = srv.accept();
						System.out.println("Connexion accepté : " + conect);
						new ServerThreadFichier(conect, num++).start();
 
 
					}
 
					/*InputStream is = conect.getInputStream();
					ObjectInputStream ois = new ObjectInputStream(is);
					Fichier f = (Fichier)ois.readObject();
					String dest = f.getDest();
					String s = f.getNom();
					System.out.println("Destinataire : " + dest + " fichier "+s);
					ois.close();
					is.close();
				    //conect.close();*/
 
 
 
			}catch (Exception e){
 
				System.out.println(e);
 
			}
 
 
		}
 
}

et enfin la classe ServerThreadFichier :

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
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
 
import java.net.*;
import java.lang.*;
import java.io.*;
import java.util.*;
 
public class ServerThreadFichier extends Thread {
 
	private Socket conect;
	private int num;
	private InputStream is;
	private ObjectInputStream entree;
	private OutputStream os;
	private ObjectOutputStream sortie;
	private String msgp;
 
 
	public ServerThreadFichier (Socket conect, int num){
 
		this.conect=conect;
		this.num=num;
 
 
	}
 
	public void run(){
 
 
		try{
 
 
			os = conect.getOutputStream();
			sortie = new ObjectOutputStream(os);
			is = conect.getInputStream();
			entree = new ObjectInputStream(is);
 
 
			msgp =(String)entree.readObject();
			System.out.println(msgp);
			ServerFichier.mapFichier.put(msgp, this.conect);
 
			this.communiquer();
 
		}catch (Exception e){
 
			System.out.println("Probleme d'instantiation des flux serveurs");
			System.out.println(e);
 
		}
 
 
	}
 
	public void communiquer(){
 
 
		while(true){
 
			try{
 
				Fichier fichier = (Fichier)entree.readObject();
				String dest = fichier.getDest();
				if(dest.equals("deconnexion")){
 
 
					ServerFichier.mapFichier.remove(msgp);
					sortie.writeObject(fichier);
					System.out.println(fichier.getNom());
					this.fermerFlux();
					break;
 
				}
 
				if(ServerFichier.mapFichier.containsKey(dest)){
 
					Socket soc = (Socket)ServerFichier.mapFichier.get(dest);
					System.out.println(soc);
					OutputStream os = soc.getOutputStream();
					ObjectOutputStream sortieDest = new ObjectOutputStream(os);
					//sortieDest.writeObject(fichier);
 
 
				}
 
 
 
 
			}catch (Exception e){
 
				System.out.println("Probleme traitement fichier");
				System.out.println(e);
 
			}
 
 
 
 
		}
 
 
 
 
	}
 
	public void fermerFlux(){
 
		try{
 
			sortie.close();
			os.close();
			entree.close();
			is.close();
			conect.close();
 
		}catch (Exception e){
 
			System.out.println("Probleme de fermeture des flux du serveur de fichier");
			System.out.println(e);
 
		}
 
 
 
	}
 
}

Lorsque le destinataire du fichier est "deconnexion" tout se passe bien est le client se deconnecte du serveur de fichier. En revanche lorsque j'envoi un fichier a un autre client j'ai l'erreur mentionnée ci-dessus.

De plus l'envoi de fichier se fait via une interface graphique si vous voulez que je mette le code de cette classe faite le moi savoir

Quelqu'un aurait une idée?

Merci

**gifffftane** · 12/01/2009, 19h54

Je ne sais pas ce qu'est cette classe Fichier, mais, normalement, un fichier ne s'envoie pas par serialisation.

Sinon le StreamCorrupted pourrait venir d'une différence de JVM entre les deux postes ? Aussi d'un ObjectInputStream rouvert plusieurs fois ?

Sinon aussi j'ai un peu de mal à suivre ton code, parce qu'il y a plusieurs ObjectOutput je ne sais pas lequel est le bon... Ne pourrais-tu pas faire un code avec un seul flux, un coté envoyant les fichiers, l'autre les recevant ?

**nzo70** · 12/01/2009, 22h18

Enfet j'ai plusieurs flux car j'en utilise un pour envoyer des messages textes et un autre pour envoyer des fichiers.

De plus, le probleme ne vient pas de la JVM puisque pour l'instant je teste cela en localhost.

En ce qui concerne la classe Fichier voici le code :

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
 
 
import java.net.*;
import java.io.*;
 
 
public class Fichier implements Serializable{
 
	static final long serialVersionUID = 1;
 
	protected File f;
	private String dest;
 
	public Fichier(File f,String dest){
 
		super();
	    this.f=f;	
	    this.dest=dest;
 
	}
	public String getDest(){
 
		return this.dest;
 
	}
 
	public String getNom(){
 
		return this.f.getName();
 
	}
 
	public File getFile(){
 
		return this.f;
 
	}
 
}

En ce qui concerne la serialisation, etant debutant en java, je me suis peut etre tromper sur son utilité? car si je ne "serialize " pas la classe Fichier lors de l'envoi d'un Fichier j'ai une exception : java.io.NotSerializableException :Fichier

**gifffftane** · 15/01/2009, 08h18

Oui, il faut mettre implements Serializable, comme tu l'as fait, pour obtenir une classe serializable. Je m'inquiétais surtout de savoir ce que tu voulais serialiser d'un fichier, mais ce que tu as fait à l'air bon.

As-tu essayé un programme d'essai qui envoie et receptionne un seul flux composé uniquement de d'objets de classe Fichier ?

**nzo70** · 16/01/2009, 13h22

j'ai trouvé de quoi sa venait.

En fait dans la classe ServerThreadFichier lorsque j'instanciais l' ObjectOutputStream

Code :

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

1
2
3
 
 
(ObjectOutputStream sortieDest = new ObjectOutputStream(os))

cela provoqué l'exception. J'ai donc crée une Map qui associe un client a un ObjectOutputStream. Je recupere ensuite cet objet est ca marche.

en revanche je n'ai pas compris pourquoi cela posait probleme si je l'instancie

Probleme d'exception java.io.StreamCorruptedException

Entrée/Sortie Java

Discussions similaires

Partager

Partager