Discussion :

[amath1]

Bonjour
je suis confronté a un petit problème ,j'effectue un transfert de fichier entre un client et un serveur via les socket ,le problème c'est que la taille des données n'est pas identique :
voici mon code coté 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
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
 
 
public class Client  {
	public static void main(String[] args) throws IOException{
	    BufferedOutputStream bos;
	    Socket sock;
	    Socket socket;
	    BufferedReader in;
 
	    try{
	    	socket = new Socket(InetAddress.getLocalHost(),25005);
	    	System.out.println("Connection 1 etabile !");
	    	in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
	    	String nom_fichier = in.readLine();
	    	System.out.println("" + nom_fichier);
	    	socket.close();
 
	    	File f = new File("" + nom_fichier);
	    	bos = new BufferedOutputStream(new FileOutputStream(f));
	    	sock = new Socket(InetAddress.getLocalHost(),25006);
	    	System.out.println("Connection 2 etabile !");
	    	byte buf[] = new byte[1024];
	        int n;
	    	l
	        while((n=sock.getInputStream().read(buf))!=-1){
	            bos.write(buf,0,n);
	        }
	        System.out.println("size :" + f.length());
 
 
	            bos.close();
	    	    sock.close();
	    }
 
	    catch (UnknownHostException e) {
 
            e.printStackTrace();
        }
	    catch (FileNotFoundException e) {
	        e.printStackTrace();
	    } catch (IOException e) {
	        e.printStackTrace();
	      }   
	}
}

et coté 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
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
 
 
public class Serveur {
	public static void main(String[] args) throws IOException{
		BufferedInputStream fis;
	    Socket sock;
	    Socket socket;
	    PrintWriter out;
 
	    try{
	    	socket = new  ServerSocket(25005).accept();
	    	out = new PrintWriter(socket.getOutputStream());
 
	    	 File f= new File("merco.jpg");
	    	 String nom_fichier=f.getName();
	    	 System.out.println("" + nom_fichier);
	    	 out.println("" + nom_fichier);
	    	 out.flush();
	    	 out.close();
	    	 socket.close();
 
	    	 fis = new BufferedInputStream(new FileInputStream(f));
 
	    	// String ext = nom_fichier.substring(nom_fichier.lastIndexOf("." ));
 
	         sock = new ServerSocket(25006).accept();
	    	byte buf[] = new byte[1024];
	        int n;
	        while(fis.read(buf)!=-1){
	            sock.getOutputStream().write(buf);
	        }
	        System.out.println("size : " + f.length());
	            fis.close();
	    	    sock.close();
	    }
	    catch (UnknownHostException e) {
 
            e.printStackTrace();
        }
	    catch (FileNotFoundException e) {
	        e.printStackTrace();
	    } catch (IOException e) {
	        e.printStackTrace();
	      }   
	}
}

ce programme transfère bien des données photos et vidéos légère avec une petite différence de taille,mais lors d'un transfert d'une grosse vidéo ,il y a des pertes d'informations conséquentes

merci de vos conseils et/ou suggestion.

[Jidefix]

Bonjour,
essaye de rajouter la ligne suivante avant le close dans le client:

Code :

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

1
2
3
4
5
6
7
 
...
System.out.println("size :" + f.length());
 
 bos.flush(); // <= Un BufferedOutputStream n'est pas flushé automatiquement à la fermeture, il risque donc de manquer la fin du fichier
	            bos.close();
...

[wax78]

Quand tu call le close, il flush automatiquement en théorie (cf : Javadoc)

[adiGuba]

Salut,

Ton problème vient de ce bout de code sur ton serveur :

Code :

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

1
2
3
while(fis.read(buf)!=-1){
    sock.getOutputStream().write(buf);
}

Tu ne récupère pas le retour de read(), donc tu ne sait pas combien de byte ont été écrit dans le buffer.
Mais malgré cela tu écrits tout le buffer dans la socket (et donc avec potentiellement des octets en trop).

Le pire c'est que tu fait bien cela coté client...



Sinon :
- C'est très "C" de déclarer les variables au début de la méthode
- Utilises des try/finally pour libérer les ressources proprement, ou le try-with-ressources de Java 7 si tu peux


a++

[Jidefix]

Ah damned je venais de trouver

Marrant c'était le problème inverse de mon histoire de flush: au lieu de ne pas avoir la fin il l'avait en double!

[amath1]

Bonjour
j'ai modifié mon code comme vous me l'avez demandé
c'est a dire j'ai mis coté serveur :

Code :

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

1
2
3
  while((n=fis.read(buf))!=-1){
	            sock.getOutputStream().write(buf,0,n);
	        }

et j'ai flushé le outputstream

je ne comprend pas bien ta remarque adiGuba
quand tu dis que je ne récupère pas le retour du read.
la quantité de donné n'est toujours pas égale
merci de votre aide

[adiGuba]

je ne comprend pas bien ta remarque adiGuba
quand tu dis que je ne récupère pas le retour du read.
la quantité de donné n'est toujours pas égale

Non et c'est indiqué dans la doc.

read() va lire au minimum un byte, et au maximum de quoi remplir ton tableau. La quantité réel de bytes qui sera lu dépend de l'état du flux.

C'est en particulier vrai dans un flux réseau, où les données ne vont pas arriver forcément en même temps.

Donc il est impératif de lire le retour de read() pour savoir combien de données on été lues, quitte à boucler pour recevoir le reste...


a++