Hochladen von Dateien auf den FTP-Server mit Java

Um Java-Code zu schreiben, der Dateien von der lokalen Festplatte auf den Online-FTP-Server hochlädt, ist die Apache Commons Net API eine sehr gute Wahl für Java-Entwickler. Es ist einfach und macht die Programmierung mit FTP einfach.

1- Laden Sie die Apache Commons Net

API herunter Apache Commons Net API herunterladen  das eine Reihe von Netzwerktools enthält und mehrere Protokolle unterstützt, wie z. B.: FTP, Telnet, SMTP... Nach dem Hochladen sollte die .jar-Datei in den Klassenpfad Ihres Projekts eingebettet werden.

2- Die Apache Commons Net API für die Dateiübertragung über das FTPDie Klasse  FTPClient  bietet Methoden zum Übertragen einer lokalen Datei auf den Online-Server über FTP:
  • boolean storeFile(String remote, InputStream local)
  • OutputStream storeFileStream(String remote)
  • boolean storeUniqueFile(InputStream local)
  • boolean storeUniqueFile(String remote, InputStream local)
  • OutputStream storeUniqueFileStream()
  • OutputStream storeUniqueFileStream(String remote)
Was ist der Unterschied zwischen diesen Methoden? Brunnen! Sie können wie folgt kategorisiert werden:
  • Speichern von Dateien durch Angabe von a  InputStream  der lokalen Datei (dies sind die Methoden, die a  InputStream  als Parameter). Diese Art von Methoden wird angewendet, wenn Sie nicht wissen müssen, wie. die  Bytes  werden von der lokalen Datei auf den Server übertragen. Wir lassen das System das tun. processing.
  • Speichern von Dateien durch Schreiben in die  OutputStream  der Verbindung (dies sind die Methoden, die einen OutputStream als Ausgabe haben). Diese Arten von Methoden sind erforderlich, wenn Sie steuern möchten, wie die Bytes verwendet werden. sind  weitergeleitet, indem wir unseren eigenen Code schreiben, um die bytes  über die lokale Datei, die im Remote-Dateipfad über das Objekt gespeichert wird  OutputStream. Dies kann nützlich sein, wenn Sie die Fortschritt  des Uploads und berechnet, wie viele Bytes über die Dateigröße .
Die beiden oben genannten Methoden können in Kombination verwendet werden mit:
  • Benennen Sie die entfernte Datei eindeutig (Die Methoden, die einen String-Parameter mit dem Namen remote akzeptieren).
  • Belassen Sie die Servernamen und die entfernte Datei mit einem eindeutigen Namen (Diese Methoden, die keinen String-Parameter haben).
Trotz der Komplexität dieser Methoden In der Praxis werden hauptsächlich nur zwei Methoden verwendet:
  • boolean storeFile(String remote,InputStream local)
  • OutputStream storeFileStream(String remote)
Neben diesen sechs Methoden gibt es noch zwei weitere, die vor und nach dem Herunterladen der Datei aufgerufen werden müssen:
  • boolean setFileType(int fileType): Bestimmt den Dateityp, d.h. FTP. ASCII_FILE_TYPE oder FTP. BINARY_FILE_TYPE, wird verwendet, um die Datei zu übertragen. Der Standardtyp ist ASCII (Nur-Text), aber er muss binär gemacht werden, damit er für alle Dateien funktioniert. Diese Methode muss aufgerufen werden, bevor die Dateiübertragung beginnt.
  •   boolean completePendingCommand(): Diese Methode muss aufgerufen werden, nachdem der Download abgeschlossen ist, um die Transaktion abzuschließen. Sie kehrt zurück wahr  Wenn die Übertragung erfolgreich abgeschlossen wurde, wenn nicht; falsch. Der Rückgabewert dieser Methode muss überprüft werden, um sicherzustellen, dass der Upload stattgefunden hat.
    Standardmäßig stellt FTP die Verbindung her, indem es einen Port für den Client öffnet und dem Server erlaubt, sich mit diesem Port zu verbinden. Dies ist der aktive Modus, der jedoch manchmal von der Firewall blockiert wird und die Dateiübertragung nicht funktioniert. Glücklicherweise verfügt das FTP-Protokoll über einen anderen Modus, nämlich den passiven Modus, in dem die Verbindung hergestellt wird, indem ein Port im Server geöffnet wird, damit der Client eine Verbindung herstellen kann. Dieser Modus wird von der Firewall nicht blockiert.

    Es wird daher empfohlen, vor dem Start der Datenübertragung mit dem Aufruf der FTPClient-Klassenmethode enterLocalPassiveMode().

    3- Die Schritte zum Übertragen einer Datei in Java

    Um den Code zum Übertragen einer Datei auf den FTP-Server mithilfe der Apache Commons Net-API ordnungsgemäß zu schreiben, müssen die folgenden Schritte ausgeführt werden:
    • Verbinden Sie sich und melden Sie sich beim Server an.
    • Verwenden Sie den passiven Modus für die Verbindung.
    • Ändern Sie den Dateityp, der in binary übertragen werden soll.
    • Erstellen Sie eine InputStream für die lokale Datei.
    • Rufen Sie eine der Methoden Laden... () um mit der Übertragung der Datei zu beginnen. Es gibt zwei Szenarien:
      • Verwenden eines InputStream: Dies ist der einfachste Weg, da Sie das Senden und Empfangen dem System überlassen. Es gibt keinen zusätzlichen Code, geben Sie einfach den Artikel weiter InputStream  in der entsprechenden Methode, z. B. der Methode storeFile(String remote, InputStream local).
      • Using  OutputStream: Dies ist komplexer, aber Sie erhalten mehr Kontrolle über die übertragenen Daten. Im Allgemeinen muss man ein paar Codezeilen schreiben, um Bytes zu lesen  InputStream  der lokalen Datei und schreiben Sie diese Bytes in ein OutputStream der von der Methode speichern... (), z. B. storeFileStream(String remote).
    • Datenströme schließen  InputStream  et  OutputStream.
    • Rufen Sie die Methode completePendingCommand() um die Transaktion abzuschließen.
    • Disconnect from server.
    Der Wert der Rückgabe der Methoden Laden... () und completePendingCommand() um sicherzustellen, dass der Upload abgeschlossen wurde.

    4- Java

    Dieser Code zeigt, wie Dateien mit diesen beiden Methoden vom Computer an den FTP-Server gesendet werden:
    • boolean storeFile(String remote, InputStream local)
    • OutputStream storeFileStream(String remote)
    Nach dem Aufruf des storeFile() ist es nicht zwingend erforderlich, die completePendingCommand(). Hier ist der vollständige Code:

    import java.io.File; 
    import java.io.FileInputStream; 
    import java.io.IOException; 
    import java.io.InputStream; 
    import java.io.OutputStream; 
    import org.apache.commons.net.ftp.FTP; 
    import org.apache.commons.net.ftp.FTPClient; 

    public class FTPUploadFile {

     public static void main(String[] args) {
     Server String = "ServerAddress"; 
     int port = 21; 
     Zeichenkette user = "Benutzername"; 
     Zeichenfolgenkennwort = "IhrKennwort"; 

     FTPClient ftpClient = new FTPClient(); 
     try {

     ftpClient.connect(server, port); 
     ftpClient.login(Benutzer, Passwort); 
     ftpClient.enterLocalPassiveMode(); 

     ftpClient.setFileType(FTP. BINARY_FILE_TYPE); 

     // Ansatz 1: Laden Sie eine Datei mit InputStream hoch
     Datei file = new File("C:/plugins and styles.txt"); 

     String-Pfad = "Plugins und styles.txt"; 
     InputStream inputStream = new FileInputStream(Datei); 

     System.out.println("Upload starten"); 
     //Ausgabe von upload
     boolean res = ftpClient.storeFile(path, inputStream); 
     //schließt den Lesestrom
     inputStream.close(); 
     
     if (res==true) {
     System.out.println("Die Datei "+path+" wurde erfolgreich heruntergeladen"); 
     }

     // Ansatz 2: Hochladen einer Datei mit OutputStream
     file = new File("C:/track 1.wma"); 
     path = "Audio/Spur 1.wma"; 
     inputStream = new FileInputStream(file); 

     System.out.println("Upload starten"); 
     OutputStream outputStream = ftpClient.storeFileStream(Pfad); 
     byte[] bytesIn = neues Byte[4096]; 
     int buffer = 0; 

     //solange wir das Ende der Datei noch nicht erreicht haben
     System.out.println("Downloading..."); 
     int übertragen = 0; 
     int Prozent = 0; 
     //solange wir das Ende der Datei noch nicht erreicht haben
     while ((buffer = inputStream.read(bytesIn)) != -1) {
     //Lesen der Daten mit einem Puffer von 4096 Bytes
     outputStream.write(bytesIn, 0, buffer); 
     übergeben += Puffer; 
     Prozent = (int) (übertragen*100/file.length()); 
     System.out.println(percentage+"%"); 
     }
     //close write read streams
     inputStream.close(); 
     outputStream.close(); 

     //upload result
     res = ftpClient.completePendingCommand(); 
     if (res) {
     System.out.println("Die Datei "+path+" wurde erfolgreich heruntergeladen"); 
     }

     } catch (IOException e) {
     System.out.println(e.getMessage()); 
     e.printStackTrace(); 
     } finally {
     try {
     if (ftpClient.isConnected()) {
     //close FTP
     ftpClient.logout(); 
     ftpClient.disconnect(); 
     }
     } catch (IOException ex) {
     ex.printStackTrace(); 
     }
     }
     }
    }
    Die Ausführung dieses Codes gibt zurück, dass die Übertragung erfolgreich war: 

    Start des Uploads
    Die Plugins und styles.txt Datei wurden erfolgreich heruntergeladen
    Start des Uploads
    1%
    2%
    3%
    .
    .
    97%
    98%
    98%
    99%
    99%
    100%
    Die 1.wma-Track-Datei wurde erfolgreich heruntergeladen