wake-up-neo.com

Wie kopiere ich eine Datei auf dem FTP-Server in ein Verzeichnis auf demselben Server in Java?

Ich verwende Apache Commons FTP, um eine Datei hochzuladen. Vor dem Hochladen möchte ich überprüfen, ob die Datei bereits auf dem Server vorhanden ist, und eine Sicherungskopie davon in einem Sicherungsverzeichnis auf demselben Server erstellen.

Weiß jemand, wie man eine Datei von einem FTP-Server in ein Sicherungsverzeichnis auf demselben Server kopiert?

public static void uploadWithCommonsFTP(File fileToBeUpload){
    FTPClient f = new FTPClient();
    FTPFile backupDirectory;
    try {
        f.connect(server.getServer());
        f.login(server.getUsername(), server.getPassword());
        FTPFile[] directories = f.listDirectories();
        FTPFile[] files = f.listFiles();
        for(FTPFile file:directories){
            if (!file.getName().equalsIgnoreCase("backup")) {
                backupDirectory=file;
            } else {
               f.makeDirectory("backup");
            }
        }
        for(FTPFile file: files){
            if(file.getName().equals(fileToBeUpload.getName())){
                //copy file to backupDirectory
            }
        }

    } catch (IOException e) {
        e.printStackTrace();
    }

}

Bearbeiteter Code: Es gibt immer noch ein Problem, wenn ich eine Zip-Datei sichere, ist die gesicherte Datei beschädigt.

Kennt jemand den Grund dafür?

 public static void backupUploadWithCommonsFTP(File fileToBeUpload) {
    FTPClient f = new FTPClient();
    boolean backupDirectoryExist = false;
    boolean fileToBeUploadExist = false;
    FTPFile backupDirectory = null;
    try {
        f.connect(server.getServer());
        f.login(server.getUsername(), server.getPassword());
        FTPFile[] directories = f.listDirectories();
        // Check for existence of backup directory
        for (FTPFile file : directories) {
            String filename = file.getName();
            if (file.isDirectory() && filename.equalsIgnoreCase("backup")) {
                backupDirectory = file;
                backupDirectoryExist = true;
                break;
            }
        }
        if (!backupDirectoryExist) {
            f.makeDirectory("backup");
        }
        // Check if file already exist on the server
        f.changeWorkingDirectory("files");
        FTPFile[] files = f.listFiles();
        f.changeWorkingDirectory("backup");
        String filePathToBeBackup="/home/user/backup/";
        String prefix;
        String suffix;
        String fileNameToBeBackup;
        FTPFile fileReadyForBackup = null;
        f.setFileType(FTP.BINARY_FILE_TYPE);
        f.setFileTransferMode(FTP.BINARY_FILE_TYPE);
        for (FTPFile file : files) {
            if (file.isFile() && file.getName().equals(fileToBeUpload.getName())) {
                prefix = FilenameUtils.getBaseName(file.getName());
                suffix = ".".concat(FilenameUtils.getExtension(file.getName()));
                fileNameToBeBackup = prefix.concat(Calendar.getInstance().getTime().toString().concat(suffix));
                filePathToBeBackup = filePathToBeBackup.concat(fileNameToBeBackup);
                fileReadyForBackup = file;
                fileToBeUploadExist = true;
                break;
            }
        }
        // If file already exist on the server create a backup from it otherwise just upload the file.
        if(fileToBeUploadExist){
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            f.retrieveFile(fileReadyForBackup.getName(), outputStream);
            InputStream is = new ByteArrayInputStream(outputStream.toByteArray());
            if(f.storeUniqueFile(filePathToBeBackup, is)){
                JOptionPane.showMessageDialog(null, "Backup succeeded.");
                f.changeWorkingDirectory("files");
                boolean reply = f.storeFile(fileToBeUpload.getName(), new FileInputStream(fileToBeUpload));
                if(reply){
                    JOptionPane.showMessageDialog(null,"Upload succeeded.");
                }else{
                    JOptionPane.showMessageDialog(null,"Upload failed after backup.");
                }
            }else{
                JOptionPane.showMessageDialog(null,"Backup failed.");
            }
        }else{
            f.changeWorkingDirectory("files");
            f.setFileType(FTP.BINARY_FILE_TYPE);
            f.enterLocalPassiveMode();
            InputStream inputStream = new FileInputStream(fileToBeUpload);
            ByteArrayInputStream in = new ByteArrayInputStream(FileUtils.readFileToByteArray(fileToBeUpload));
            boolean reply = f.storeFile(fileToBeUpload.getName(), in);
            System.out.println("Reply code for storing file to server: " + reply);
            if(!f.completePendingCommand()) {
                f.logout();
                f.disconnect();
                System.err.println("File transfer failed.");
                System.exit(1);
            }
            if(reply){

                JOptionPane.showMessageDialog(null,"File uploaded successfully without making backup." +
                        "\nReason: There wasn't any previous version of this file.");
            }else{
                JOptionPane.showMessageDialog(null,"Upload failed.");
            }
        }
        //Logout and disconnect from server
        in.close();
        f.logout();
        f.disconnect();
    } catch (IOException e) {
        e.printStackTrace();
    }

}
13
itro

Wenn Sie Apache commons net FTPClient verwenden, gibt es eine direkte Methode zum Verschieben einer Datei an einen anderen Speicherort (sofern user über die richtigen Berechtigungen verfügt).

ftpClient.rename(from, to);

oder, Wenn Sie mit ftp commands vertraut sind, können Sie so etwas wie verwenden

ftpClient.sendCommand(FTPCommand.yourCommand, args);
if(FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
     //command successful;
} else {
     //check for reply code, and take appropriate action.
}

Wenn Sie einen anderen Client verwenden, lesen Sie die Dokumentation durch. Zwischen den Clientimplementierungen ändert sich nichts.

UPDATE:

Der obige Ansatz verschiebt die Datei in das Verzeichnis to, d. H. Die Datei befindet sich nicht mehr im Verzeichnis from. Grundsätzlich sollte das FTP-Protokoll die Dateien von local <-> remote oder remote <-> other remote übertragen, jedoch nicht mit dem Server übertragen.

Die Arbeit hier wäre einfacher, holen Sie die komplette Datei in eine lokale InputStream und schreiben Sie sie als neue Datei im Sicherungsverzeichnis auf den Server zurück.

um die komplette Datei zu erhalten, 

ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ftpClient.retrieveFile(fileName, outputStream);
InputStream is = new ByteArrayInputStream(outputStream.toByteArray());

speichern Sie diesen Stream jetzt im Sicherungsverzeichnis. Zuerst müssen wir das Arbeitsverzeichnis in das Sicherungsverzeichnis ändern.

// assuming backup directory is with in current working directory
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);//binary files
ftpClient.changeWorkingDirectory("backup");
//this overwrites the existing file
ftpClient.storeFile(fileName, is);
//if you don't want to overwrite it use storeUniqueFile

Hoffe das hilft dir ..

19
RP-

Versuchen Sie es so,

Ich verwende die Bibliothek von Apache.

ftpClient.rename (von, bis) wird es einfacher machen, ich habe im folgenden Code erwähnt, wo ftpClient.rename (von, bis) hinzugefügt wird.

public void goforIt(){


        FTPClient con = null;

        try
        {
            con = new FTPClient();
            con.connect("www.ujudgeit.net");

            if (con.login("ujud3", "Stevejobs27!!!!"))
            {
                con.enterLocalPassiveMode(); // important!
                con.setFileType(FTP.BINARY_FILE_TYPE);
                String data = "/sdcard/prerakm4a.m4a";
                ByteArrayInputStream(data.getBytes());
                FileInputStream in = new FileInputStream(new File(data));
                boolean result = con.storeFile("/Ads/prerakm4a.m4a", in);
                in.close();
                if (result) 
                       {
                            Log.v("upload result", "succeeded");

// $$$$$$$$$$$$$$$$$$$$$$$$$ Rückbestätigung Here $$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$ //

                   // Now here you can store the file into a backup location

                  // Use ftpClient.rename(from, to) to place it in backup

// $$$$$$$$$$$$$$$$$$$$$$$$$ Rückbestätigung Here $$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$ //

                       }
                con.logout();
                con.disconnect();
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }   

    }
1

Es gibt keine Standardmethode zum Kopieren einer Remote-Datei über das FTP-Protokoll. Einige FTP-Server unterstützen jedoch proprietäre oder nicht standardmäßige Erweiterungen. 


Wenn Sie also Glück haben, dass Ihr Server ProFTPD mit dem Modul mod_copy ist, können Sie diese Befehle mit FTP.sendCommand ausführen:

f.sendCommand("CPFR sourcepath");
f.sendCommand("CPTO targetpath");

Die zweite Möglichkeit ist, dass Sie mit Ihrem Server beliebige Shell-Befehle ausführen können. Dies ist noch seltener. Wenn Ihr Server dies unterstützt, können Sie den Befehl SITE EXEC verwenden:

SITE EXEC cp -p sourcepath targetpath

Eine andere Problemumgehung besteht darin, eine zweite Verbindung zum FTP-Server zu öffnen und den Server dazu zu veranlassen, die Datei auf sich selbst hochzuladen, indem eine Passivmodus-Datenverbindung an eine Aktivmodus-Datenverbindung geleitet wird. Die Implementierung dieser Lösung (in PHP) wird jedoch in FTP angezeigt. Kopieren Sie eine Datei an einen anderen Ort im selben FTP .


Wenn dies nicht funktioniert, können Sie die Datei nur an einem lokalen temporären Speicherort herunterladen und erneut an den Zielspeicherort hochladen. Dies ist, dass die Antwort von @ RP- zeigt .


Siehe auch FTP kopiert eine Datei an einen anderen Ort im selben FTP .

0
Martin Prikryl