Probleme d'exception java.io.StreamCorruptedException
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:
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:
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:
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:
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
