Discussion :

[zapho]

Bonjour à tous,

Mon problème concerne l'envoi de fichier (sérialisation d'un objet) via un socket à un client qui en fait la demande. De son côté le client récupère le fichier et le sérialise.

Voici le 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
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
 
public class CatalogServer {
 
	private Catalog _instance;
	private int port = 44444;
	File tosend;
 
	public CatalogServer() throws Exception {
		_instance = Catalog.getInstance();
 
		// attends la connexion 
		ServerSocket ss = new ServerSocket(port);
		System.out.println("Started: " + ss);
		try {
			Socket socket = ss.accept();
			try {
				System.out.println("Connection accepted: " + socket);
				BufferedReader in =
					new BufferedReader(
						new InputStreamReader(socket.getInputStream()));
 
				PrintWriter out =
					new PrintWriter(
						new BufferedWriter(
							new OutputStreamWriter(socket.getOutputStream())),
						true);
 
				ObjectOutputStream out1 =
					new ObjectOutputStream(socket.getOutputStream());
 
				String str;
				while (!(str = in.readLine()).equals("END")) {
 
 
					if (str.equals("getLabel")) {
 
	System.out.println("Echoing: " + str);
						out.println(_instance.getLabel());
					}
 
					if (str.startsWith("getResource")) {
						System.out.println("Echoing: " + str);
						// On récupère le numéro de la ressource à envoyer
						String[] splitRequest = str.split(":");
						int idResource = Integer.parseInt(splitRequest[1]);
						//Sérialisation de la ressource & envoi sur la sortie du socket
						Resource res = _instance.getResource(idResource);
						// Création du fichier de sérialisation
						tosend =
							new File("resource.serial");
						try {
							// Sérialisation
							ObjectOutputStream serial_res =
								new ObjectOutputStream(
									new FileOutputStream(tosend));
							serial_res.writeObject(res);
							serial_res.close();
 
							// Envoi socket
							System.out.println("Sending object");
							out1.flush();
							out1.writeObject(tosend);
							out1.flush();
							System.out.println("Sending object : done");
 
							//System.out.println("Fichier serial détruit : " + tosend.delete());
 
						} catch (Exception e) {
							System.out.println(e.toString());
							// throw e;
						}
 
					}
				}
				out.close();
				out1.close();
				in.close();
 
			} catch (Exception e) {
				System.out.println("1 " + e.toString());
				//throw e;
			} finally { 			System.out.println("closing...");
				socket.close();
			}
		} catch (Exception e) {
			throw e;
		} finally {
			ss.close();
		}
	}
}

Voici le 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
 
public class CatalogManager {
 
	private Resource resource;
	private String _address = "127.0.0.1";
	private int _port = 44444;
	private File f;
 
	public CatalogManager() throws Exception {
		Socket socket = new Socket(_address, _port);
		try {
			System.out.println("socket = " + socket);
			BufferedReader in =
				new BufferedReader(
					new InputStreamReader(socket.getInputStream()));
 
			PrintWriter out =
				new PrintWriter(
					new BufferedWriter(
						new OutputStreamWriter(socket.getOutputStream())),
					true);
 
			ObjectInputStream in1 =
				new ObjectInputStream(socket.getInputStream());
			out.println("getLabel");
			String str0 = in.readLine();
			System.out.println(str0);
 
			System.out.println("getResource:3");
			out.println("getResource:3");
 
			try {
				System.out.println("Read file");
				f = (File)in1.readObject();
				System.out.println(f.toString());
			} catch (ClassNotFoundException e) {
				throw e;
			}
 
			if (f.exists()) {
				try {
					ObjectInputStream in2 =
						new ObjectInputStream(new FileInputStream(f));
					resource = (Resource) in2.readObject();
					in1.close();
					System.out.println(resource.getLabel());
				} catch (Exception e1) {
					throw e1;
				}
			} else {
				System.out.println("LE fichier n'existe pas");
			}
 
			// out.println("END");
 
		} finally {
			System.out.println("closing...");
			socket.close();
		}
 
	}
 
}

Avec ce code j'obtiens bien que le client et le serveur s'échange un objet Resource. Par contre il y a une levée d'exception côté serveur (au niveau de System.out.println("1 " + e.toString()) qui spécifie java.lang.NullPointerException.
Il me semblait que cela pouvait provenir du fait que, côté serveur je ne détruisais pas le fichier de sérialisation à la fin. J'ai donc ajouté un tosend.delete() qui est en commentaire dans le code.
A ce moment là je n'obtiens plus d'exception mais, côté client, le File f récupéré par socket n'existe plus quand la sérialisation est lancée.
Ma question est donc la suivante (enfin ! ) : comment se fait-il, qu'une fois le fichier récupéré côté client via la connexion socket, il existe un lien entre celui-ci et le fichier d'origine ??

J'espère avoir été à peu près clair. Merci à ceux qui prendront la peine de lire ce (long) message !
Z.

[Erok]

Comment ca un lien?

[zapho]

Je dis un "lien" car si je supprime le fichier côté serveur (tosend.delete()), le f.exists() côté client me retourne un "false"...
Je fais peut-être une confusion entre plusieurs choses, mais je ne vois pas où...

[Erok]

Tu utilise d String pour envoyer ton fichier?
peut etre que tu devrai aussi essayer des Bytes

sinon qu'est ce que tu veux faire avec ton fichier?

[Erok]

En fai je suis sceptique par rapport a ton code, tu a verifié le fichier d'arrivée? sjil y avai dedan?

[zapho]

Ce que je veux faire avec ce fichier, c'est le désérialiser afin de pouvoir faire des opérations sur l'objet correspondant.
Cela fonctionne si je mets côté serveur en commentaire la ligne

Code :

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

//System.out.println("Fichier serial détruit : " + tosend.delete());

Je récupère le fichier côté client je le désérialise et la ligne

Code :

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

System.out.println(resource.getLabel());

m'affiche bien les infos correspondantes.

[Erok]

Ok, mais c'est la methode d'envoie qui m'intrigue...
J'ai fai des envoi de fichiers par socket et j'utilisai simplement BufferedInputStream et BufferedOutputStream
j'envoyai un fichier avec des donnée serialisée qui etai sur mon serveur
le client le recevai et deserialisai le tou
c'est ce que tu veu faire donc?

[zapho]

Oui, tout à fait.

[Erok]

alors j'ai 2 solution a te proposer
la premiere c que je met mon code ici et tu en fai ce que tu veu
ou alor tu peu regarder RMI

[zapho]

Merci pour ta proposition et ton temps.
Je veux bien que tu mettes ton code, çela me permettra de mettre tout cela un peu au clair.
Quand à RMI, j'y ai pensé mais pour l'instant cela va me demander un peu trop de temps. Je le mets de côté pour un prochain projet.

[Erok]

En comparaison... mon serveur et client pour envoyer mon fichier ma pris 1 semaine, RMI 2jours ^^ le tem de comprendr

Voila mon code :

partie d'envoi :

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
public void envoyerBase() {
	try {
	    File monFichier = new File("./BasePDB.dat");
	    byte FichierBinaire[]= new byte[(new Long(monFichier.length())).intValue()];
	    DataInputStream FluxFichier = new DataInputStream(new FileInputStream(monFichier));
	    FluxFichier.read(FichierBinaire);
 
	   long size = monFichier.length();// la taille du fichier
	   String taille = "#" + size + "#";
	   out.write(taille.getBytes());
 
	    int i=0;
	    while (i<(new Long(monFichier.length())).intValue()) {
		byte[] tmp = new byte[1];
		tmp[0]=FichierBinaire[i];
		out.write(tmp);
		i++;
		out.flush();
	    }
	    out.close();
	    FluxFichier.close();
	} catch(java.io.IOException e) {};
    }

Mon thread de reception :

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
 
public void run(){
	try {monFichier = new FileOutputStream("./BasePDB2.dat");}catch(java.lang.Exception e) {};
	int i=1;
 
	//lecture taille
	      // state = 0 : rien de lu
      // state = 1 : lu un premier #
      // state = 2 : lu le deuxieme #
        int state = 0;
        char c = 0;
        StringBuffer buf = new StringBuffer();
        while (state != 2) {
            try{ c = (char) entree.read(); }catch (IOException e){};
            switch (state) {
                case 0 :
                if (c == '#') {
                    state = 1;
                }
                else {
                    System.out.println("Erreur de protocol: ca dot commencer par #");
                }
                break;
                case 1 :
                if (c == '#')  {
                    state = 2;
                }
                else {
                    buf.append(c);
                }
                break;
            }
       }
       long taille = 0;
       try {
           taille = Long.parseLong(buf.toString());
       } catch (NumberFormatException e) {
            System.out.println("Erreur conversion"); };
 
	Barre = new JProgressBar(0,new Long((taille)).intValue());
	Barre.setString(null);
	int nbParcouru=0;
	JFrame FenProgress = new JFrame();
	FenProgress.getContentPane().add(Barre);
	Barre.setVisible(true);
	Barre.setStringPainted(true);
	FenProgress.setVisible(true);
	FenProgress.pack();
	FenProgress.validate();
	FenProgress.update(FenProgress.getGraphics());
 
 
	try {
	    byte[] tmp = new byte[1];
	    i=entree.read(tmp);
	    while (i!=-1) {
	        monFichier.write(tmp);
		i=entree.read(tmp);
		nbParcouru++;
		if(nbParcouru%50==0){ Barre.setValue(nbParcouru);
			FenProgress.update(FenProgress.getGraphics());}
	    }
	    FenProgress.setVisible(false);
	    monPere.deblocage();
	}catch(java.io.IOException e) { System.out.println("IO Error");}
 
    }

voila avec ca tu as un fichier identique a celui du serveur , sur ton client,il ne te reste qu'a l'ouvrir et faire un read Object, lire un fichier serialisé en fait ^^
si tu as des question n'hesite pas

[Erok]

ah oui tien j'avai une barde progressoin...un peu gadget mais javai envi de la mettre ^^ ell indique ou en est le transfert

[zapho]

Merci bien. Je regarde ça.

[zapho]

Tu avais bien raison, RMI est beaucoup plus pratique pour ce besoin là. C'est la solution que j'ai adopté malgré mes réticences quant au temps d'apprentissage.
En tout cas merci pour ton aide !
A+
Z.