Discussion :

[julien20vt]

Bonjour à tous,

J'ai un bout de code qui lit un fichier distant et qui crée une copie de ce fichier sur le serveur.
Mon problème est que ce programme doit traiter des dizaines de fichiers par heure et que son temps d'execution (pour un fichier) varie dans des proportions inquiétantes de quelques centièmes de secondes à plusieurs minutes !!
Voilà mon morceau de code, j'espère que vous pourrez me dire si selon vous il y a des choses à revoir pour fiabiliser son execution.
(Pour info, j'ai fait un test en faisant le même traitement mais en php, cela est carrément plus rapide et surtout beaucoup plus stable)

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
URL url = new URL("URL_FICHIER_DISTANT");
 
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.connect();
 
BufferedInputStream inputstream = new BufferedInputStream(url.openStream());			
 
 
byte abyte0[] = new byte[8];
 
int i;
File dest = new File("CHEMIN_FICHIER_SUR_SERVEUR");
 
 
BufferedOutputStream destinationFile = new BufferedOutputStream(new FileOutputStream(dest));
 
while((i = inputstream.read(abyte0)) != -1) 
{	                
	destinationFile.write(abyte0, 0, i);
}			
 
destinationFile.close();
inputstream.close();

Merci à tous,

Julien

[adiGuba]

Salut,



Déjà il manque les try/finally pour la fermeture des flux

Ensuite c'est bien d'utiliser les BufferedStream, mais ca sert à rien si derrière c'est pour lire par bloc de 8 octets

A la rigueur tu peux te passer des "Buffered" et utiliser uniquement ton propre buffer, mais un peu plus grand (en général on utilise 8192).

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
		URL url = new URL("URL_FICHIER_DISTANT");
 
		InputStream input = url.openStream();
		try {
			OutputStream output = new FileOutputStream("CHEMIN_FICHIER_SUR_SERVEUR");
			try {
				byte buffer[] = new byte[8192];
				int len;
 
				while ((len = input.read(buffer)) != -1) {
					output.write(buffer, 0, len);
				}
 
			} finally {
				output.close();
			}
		} finally {
			input.close();
		}

a++

[julien20vt]

Bonjour et merci.

En fait il y avait bien les blocs try/finally dans mon code mais je les ai enlevés pour raccourcir au le message dans le forum.
Ok pour ta proposition, je testerai.
Cela dit, depuis mon précédent message j'ai modifié mon code pour utiliser les nio.
Malheureusement les problèmes persistent, mon code étant maintenant (en laissant les try/finally :

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
 
URL url = new URL(URL_FICHIER_DISTANT);
InputStream inputstream = url.openConnection().getInputStream();
 
ReadableByteChannel readChannel = Channels.newChannel(inputstream);
ByteBuffer buffer = ByteBuffer.allocate(2048);
 
File dest = new File(CHEMIN_FICHIER_LOCAL);
BufferedOutputStream destinationFile = new BufferedOutputStream(new FileOutputStream(dest));
 
WritableByteChannel writeChannel = Channels.newChannel(destinationFile);
try{
	int iNbRead = 0;
	buffer.clear();
	while ((iNbRead = readChannel.read(buffer)) > 0 && writeChannel.isOpen())
	{
		buffer.rewind();
		ByteBuffer bufferW = buffer.wrap(buffer.array(),0,iNbRead);
 
		writeChannel.write(bufferW);
		buffer.clear();
	} 
}
finally
{
	destinationFile.close();
	inputstream.close();
}

Il n'est sans doute pas optimisé, mais ce qui est étonnant c'est que le temps de traitement d'un fichier varie toujours de quelques dizièmes de secondes à plusieurs minutes, les fichiers faisant généralement quelques centaines de kO