Discussion :

[BibiDev11]

Bonjour,

Je suis nouveau sur le forum.
Je suis étudiant et je dois créer un système de transfert de fichiers en java avec différents protocoles.
J'ai commencé par le TCP.

Petit problème : le transfert marche bien mais seulement si la taille du fichier est supérieur à 4172.

Voici mon code :

Classe ClientTCP

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
public class ClientTCP {
 
	public void envoi ( String fileName, String filePath ) throws Exception {
        Socket socket;
 
        try {
            socket = new Socket ( "localhost", 7778 );
        } catch ( Exception e ) {
            throw new Exception ( "Impossible de créer la connexion !" );
        }
 
        File file = new File ( filePath );
        if ( file.exists () ) {
            OutputStream out = (OutputStream) socket.getOutputStream ();
 
            long fileSize = file.length ();
            long numberOfPath = fileSize / 4096;
 
            System.out.println ( "Passages supposés : " + numberOfPath );
 
            InputStream in = new BufferedInputStream ( new FileInputStream ( file ) );
            ByteArrayOutputStream output = new ByteArrayOutputStream ();
            BufferedOutputStream tampon = new BufferedOutputStream ( output );
 
            int read = in.read ();
            int[] toWrite = new int[4096];
            int compteur = 0;
            long pathNumerber = 0;
 
            output.write ( fileName.getBytes (), 0, fileName.getBytes ().length );
            output.flush ();
 
            while ( read > -1 ) {
                toWrite[compteur] = read;
                read = in.read ();
                compteur++;
 
                if ( compteur == 4096 ) {
                    compteur = 0;
                    pathNumerber++;
                    for ( int x = 0; x < 4096; x++ )
                        tampon.write ( toWrite[x] );
 
                    out.write ( output.toByteArray () );
 
                    output.reset ();
                    System.out.println ( "Avancement : " + ( float ) pathNumerber / numberOfPath * 100 + "%" );
                }
            }
            for ( int x = 0; x < compteur; x++ )
                tampon.write ( toWrite[x] );
 
            tampon.flush ();
            out.write ( output.toByteArray () );
            out.flush ();
            in.close ();
            tampon.close ();
            socket.close ();
 
        }
        else
            throw new Exception ( "Fichier non trouvé" );
 
    }
}

Classe 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
public class Server {
 
    private static ServerSocket socket;
    private static Thread thread;
 
    public static void main ( String[] args ) {
        try {
        	String PORT = JOptionPane.showInputDialog("Entrez le port :");  
            socket = new ServerSocket ( Integer.parseInt(PORT) );
            thread = new Thread ( new ServeurTCP ( socket ) );
            thread.start ();
        } catch ( IOException e ) {
            e.printStackTrace ();
        }
    }
}

Classe ServeurTCP

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
public class ServeurTCP implements Runnable {
 
	private ServerSocket socketServer;
 
	public ServeurTCP ( ServerSocket socketServer ) {
	    this.socketServer = socketServer;
	}
 
	public void run () {
	    while ( true ) {
	        try {
	            Socket serviceSocket = socketServer.accept ();
	            int read;
	            InputStream input = serviceSocket.getInputStream ();
	            BufferedInputStream inBuffer = new BufferedInputStream ( input );
 
	            byte buf[] = new byte[50000];
	            read = inBuffer.read ( buf );
                OutputStream out = new FileOutputStream ( new String ( buf, 0, read ) );
                BufferedOutputStream outBuffer = new BufferedOutputStream ( out );
                read = inBuffer.read ();
 
	            int compteur = 0;
 
	            while ( read > -1 ) {
	                outBuffer.write ( read );
	                read = inBuffer.read ();
	                compteur++;
	            }
 
	            outBuffer.write ( read );
 
	            outBuffer.flush ();
	            outBuffer.close ();
	            inBuffer.close ();
 
	            out.flush ();
	            out.close ();
	            input.close ();
	            serviceSocket.close ();
 
	        } catch ( Exception e ) {
	            System.out.println ( "Erreur avec la connexion ou la réception !" );
	        }
	    }
	}
}

Merci de votre aide !

[thelvin]

Hum. Il n'y a pourtant pas de raison que ça marche, à part avec de gros coups de bol.

Ce code contient beaucoup de problèmes, mais nous allons nous concentrer sur les deux plus gros :

- Le côté client est drôlement compliqué. Le tampon devrait juste être le byte[] toWrite. Un ByteArrayOutputStream est inutile.

- Tu n'as mis aucun mécanisme pour séparer le nom de fichier envoyé au début, et le début du contenu du fichier. Le serveur ne peut donc pas savoir qui se termine et commence où.

Le plus simple serait de commencer par envoyer un premier byte qui indique la taille du nom de fichier. Côté serveur il faudra d'abord lire ce byte qui indique la taille du nom, puis autant de bytes pour récupérer le nom, et à partir de là on sait que la suite est le contenu du fichier.