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.