[TCP]Transfert 1 fichier,OK - Plusieurs fichiers, PROBLEME

**sqwam71** · 06/06/2006, 09h57

Bonjour à tous. Je suis en train de faire un prog qui permet le transfert de plusieurs fichiers à la suite (du serveur au client).

-ça fonctionne NIKEL pour un seul fichier-

J'ai tout tenté,

mais je ne vois pas comment faire pour envoyer (par exemple) les 5 fichiers d'un dossier précis. (et surtout comment les recevoirs)

J'ai tenté pas mal de trucs, mais à chaque fois j'ai une erreur de type : "java.lang.NullPointerException" du coté client, et "Erreur : java.net.SocketException: Socket is closed".

Voici mon code du 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
 
public class Serveur {
 
protected static final int PORT=8086;
static ServerSocket ecoute;
static Socket ss;
private static int e=0;
static String type;
 
    public Serveur() {
             }
 
 
public void connect_serv(String fichier)
{
 
      while (true) // attente en boucle de connexion (bloquant sur ss.accept)
      {  try {
              ecoute=new ServerSocket(PORT);
              ss = ecoute.accept();         // un client se connecte, un nouveau thread client est lancé
             System.out.println("Connexion acceptée\n");
 
 
 
                BufferedOutputStream out = new BufferedOutputStream(ss.getOutputStream());
                File mon_fichier = new File(fichier);
                BufferedInputStream flux = new BufferedInputStream(new FileInputStream(mon_fichier));
                int tt = flux.available();
                byte[] buffer = new byte[10];
                int nbr = 0;
 
                while ((nbr = flux.read(buffer)) != -1) {
                    out.write(buffer, 0, nbr);
                }
                System.out.println("Fin du transfert de fichier");
                flux.close();
 
               out.close();
 
       } catch (Exception e){ 
            System.out.println("Erreur : " + e);
            System.exit(0);}
 
      }
 
 
 
   }

Que rajouter pour pouvoir tranférer plusieurs fichiers à la suite ???

Merci beaucoup bcp bcp.

**afrikha** · 06/06/2006, 10h00

Normalement tu dois avoir une collection contenant les fichiers à envoyer, ensuite tu les envoient un à un.
Je ne suis pas sùr d'avoir bien compris ton problème.

**sqwam71** · 06/06/2006, 10h06

Oui, les noms des fichiers à envoyer sont stockés dans un tableau.

Le problème, est que si j'appel xFois connect_serv(String fichier); ça ne marche pas puisque un socket est recrée (ss = ecoute.accept()).

Même en plaçant cette dernière instruction ailleur, je ne vois pas comment faire.

Comment faire (en chageant un peu mon code), pour pouvoir envoyer plusieurs fichiers à la suite, et les recevoirs correctement évidemment !

**le y@m's** · 06/06/2006, 10h28

Il faut que tu maintienne la connection tant que tu n'as pas transféré tous tes fichiers.
_ connection du client
_ envoie fichier 1
_ envoie fichier 2
_ envoie fichier 3
_ ...................
_ envoie fichier N
_ fermeture connection

Tu peus faire une méthode spécifique au transfert de fichier puis l'appeler pour chaque fichier.

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
public class Serveur {
 
    protected static final int PORT=8086;
    static ServerSocket ecoute;
    static Socket ss;
    private static int e=0;
    static String type;
 
    public Serveur() {
    }
 
    public void transfertFichier(String fichier) throws IOException {
        BufferedOutputStream out = new BufferedOutputStream(ss.getOutputStream());
        BufferedInputStream flux = new BufferedInputStream(new FileInputStream(fichier));
        byte[] buffer = new byte[2048];
        int nbr = 0;
        try {
           while ((nbr = flux.read(buffer)) != -1) {
                 out.write(buffer, 0, nbr);
           }
           System.out.println("Fin du transfert de fichier");
        } finally {
           flux.close();
           out.close();
       }
    }
 
    public void connect_serv(String ...fichiers) {
      while (true) // attente en boucle de connexion (bloquant sur ss.accept) {
          try {
             ecoute=new ServerSocket(PORT);
             ss = ecoute.accept();
             System.out.println("Connexion acceptée\n");
             for(String fichier : fichiers) {
                 transfertFichier(ficher);
             }                   
          } catch (Exception e) { 
             System.out.println("Erreur : " + e);
             System.exit(0);
          }
    }
}

Autre remarque, pourquoi tous tes attributs sont-ils static ?
Je pense que tu devrais réviser les concepts de la POO.

**sqwam71** · 06/06/2006, 12h34

Merci. J'avais déjà essayé de faire un truc du même style, mais tjs ce problème dans le serveur "socket is closed". Et puis je ne vois pas comment faire du coté client ??

voila ce que j'ai essayé :

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
public class Connexion extends Thread
{
 
  private Socket _s; // recevra le socket liant au client
  String nom_chemin=""; 
  Serveur serveur;
  String [] tab;
 
    public BufferedInputStream in;
    public BufferedOutputStream out;
 
    /** Creates a new instance of Connexion */
 
    public Connexion(Socket s) {
  tab=new String[2];
  tab[0]="lolo.jpg";
  tab[1]="caca.jpg";
           try{
               _s= s;
 
        }catch(Exception e){System.out.println(e);}
 
 }
 
 
    public void run(){
        for(int i=0; i<tab.length;i++){
            nom_chemin=tab[i];
 
        try {
 
            //BufferedInputStream in = new BufferedInputStream(soc.getInputStream());
            in = new BufferedInputStream(_s.getInputStream());
            //BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("D:\\INCOMING\\BOOTEX2.LOG"));
            out = new BufferedOutputStream(new FileOutputStream(nom_chemin));
 
            byte[] buffer = new byte[(int)in.available()];
 
            int nbr = 0;
 
            while ((nbr = in.read(buffer, 0, buffer.length)) !=-1){
                out.write(buffer, 0, nbr);
            }
                        System.out.println("Fichier reçu !");
 
 
        } catch(Exception e){
            System.out.println("Erreur :" + e);
        }
 
 
        }
        try{
             in.close();
            out.close();
        _s.close();
        }catch(Exception e){}
    }       
}

**White Rabbit** · 15/06/2006, 15h32

Envoyé par sqwam71

Oui, les noms des fichiers à envoyer sont stockés dans un tableau.

Le problème, est que si j'appel xFois connect_serv(String fichier); ça ne marche pas puisque un socket est recrée (ss = ecoute.accept()).

Même en plaçant cette dernière instruction ailleur, je ne vois pas comment faire.

Comment faire (en chageant un peu mon code), pour pouvoir envoyer plusieurs fichiers à la suite, et les recevoirs correctement évidemment !

Ce n'est pas temps qu'un socket est créé mais le fait que le port pour ce socket est déjà assigné...

Une solution si tu veux appelé connect_serv() plusieurs fois(dans une boucle?) modifie ton connect_serv() avec un paramètre "port" qui est incrémenté par rapport au premier connect_serv() appelé.

Exemple :

Code :

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

1
2
3
4
5
6
int portDepart = 2048;
int nombreFichiers = tableau_nom_fichiers.length;
int maxPorts = (portDepart + nombreFichiers);
 
for ( i = 0; i <nombreFichiers; i++)
   connec_serv(tableau_nom_fichiers[i], i + portDepart);

Qu'en pense-tu?