Discussion :

[Fladnag]

Bonjour,

j'ai une application répartie qui transfert un fichier d'un repertoire a un autre. Un programme de l'application est sur une machine linux, l'autre partie est sur windows XP. La partition linux est montée sous le systeme XP a travers le reseau.

Le programme sous XP lit un fichier sur la partition linux, puis l'ecrit dans un repertoire d'echange sur la partion linux, ou il est lu par le programme sur la machine linux qui l'ecrit alors dans le repertoire de destination.

en gros on a :

1) XP lit un fichier unix et le convertit en string
2) XP ecrit sur une partition unix la string dans un autre fichier
3) linux lit la string dans le fichier qu'on vient d'ecrire
2) linux réécrit cette chaine dans le fichier destination toujours sur la partition linux

Mon probleme vient du fait que certains caracteres binaires (mes fichiers sont des images jpeg) sont transformés en caractere 3F (?).

J'ai fini par trouver que le probleme vient de l'encodage des caracteres, les seuls changés en 3F étant 81, 8D, 8F, 90, 9D.
(voir cette page : http://lists.w3.org/Archives/Public/...tDec/0049.html)

Mais meme en sachant pourquoi ca ne marche pas, je ne sais pas comment resoudre le probleme...
J'aimerais utiliser les systemes de lecture et d'ecriture des bons formats de caracteres en java (avec getBytes(..., "encodage") ou String(...., "encodage")), mais j'y arrive pas...
Si ca marche pas, je ferais une fonction pour encoder les caracteres qui ne marchent pas, mais ca serait pas tres propre.

Voici mes 2 fonctions de lecture/ecriture de fichier... merci de votre aide ;o)

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
/**
 * Lit le fichier et renvoi une chaine de caractere
 * @param filename Le nom du fichier a lire
 * @return Le contenu du fichier
 */	
public static String read(String filename) {
	String content="";
	int bufferSize=1024;
	byte[] buffer=new byte[bufferSize];
	int lus=0;
 
	File f=new File(filename);
	FileInputStream fis=null;
 
	content="";
	try {
		fis=new FileInputStream(f);
 
		while ((lus=fis.read(buffer))!=-1) {
			content+=new String(buffer, 0, lus);
		}
		fis.close();
		fis=null;
	} catch (Exception ex) {
		error("Erreur d'E/S flux entrant sur "+filename);
		ex.printStackTrace();
	}
 
	buffer=null;
	f=null;		
 
	return content;
}
 
/**
 * Ecrit une chaine dans un fichier
 * @param filename Le nom du fichier a ecrire
 * @param content La chaine a ecrire dans le fichier
 */
public static void put(String filename, String content) {
	File f=new File(filename);
 
	try {
		FileOutputStream fos=new FileOutputStream(f);
 
		fos.write(content.getBytes());
 
		fos.flush();
		fos.close();
 
		fos=null;
 
	} catch (Exception ex) {
		error("Erreur d'E/S flux sortant pour ecriture de "+content.length()+" octets dans "+filename);
		ex.printStackTrace();
	}
	f=null;
}

A noter que dans le programme, je fait aussi des convertions de la chaine en tableau de byte[] avec String.getBytes() puis je reconvertit en chaine avec new String(byte[])...

[mathieu]

je sais pas si ca va regler ton problème mais au moins ca va accélérer ton code : utilise un StringBuffer pour lire ton fichier, comme expliqué ici :
http://faqjava.developpez.com/?page=...G_stringBuffer

[Fladnag]

Bon, j'ai résolu mon probleme avec ce systeme :

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
 
public class Constants {
	public static final String ENCODING_TYPE="ISO8859_1";
}
 
....
 
	public static byte[] getEncodingBytes(String str) {
		byte[] tab;
		try {
			tab=str.getBytes(Constants.ENCODING_TYPE);
		} catch (UnsupportedEncodingException ex) {
			ex.printStackTrace();
			throw new RuntimeException("ERROR : "+Constants.ENCODING_TYPE+" not supported !");
		}
		return tab;
	}
 
	public static String getEncodingString(byte[] tab) {
		String str;
		try {
			str=new String(tab, Constants.ENCODING_TYPE);
		} catch (UnsupportedEncodingException ex) {
			ex.printStackTrace();
			throw new RuntimeException("ERROR : "+Constants.ENCODING_TYPE+" not supported !");			
		}
		return str;
	}
 
	public static String getEncodingString(byte[] tab, int offset, int length) {
		String str;
		try {
			str=new String(tab, offset, length, Constants.ENCODING_TYPE);
		} catch(UnsupportedEncodingException ex) {
			ex.printStackTrace();
			throw new RuntimeException("ERROR : "+Constants.ENCODING_TYPE+" not supported !");
		}
		return str;
	}

La perte d'information etait située au niveau de la conversion byte[] <-> String. Donc a chaque conversion, il faut utiliser les fonctions ci dessus.

par exemple, pour la fonction read(...) de mon post précédent, il faut mettre :

Code :

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

1
2
3
				while ((lus=fis.read(buffer))!=-1) {
					content+=getEncodingString(buffer, 0, lus);
				}

au lieu de

Code :

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

new String(buffer, 0, lus)