Comment transférer un fichier d'un répertoire à un autre en utilisant Java SFTP Library JSch?

J'ai besoin d'un programme de transfert de fichiers à l'aide de JSch de la bibliothèque. J'ai un répertoire simple avec deux dossiers -

Dans le SFTP_1 dossier, j'ai une image bitmap. Et le SFTP_2 dossier est juste un dossier vide. Mon objectif est de transférer l'image à l'aide de SFTP de SFTP_1 à SFTP_2 .

Voici mon code donc loin :

import com.jcraft.jsch.*;

import java.awt.Desktop;

import java.nio.channels.Channel;


public class FileTransfer {

    public FileTransfer() {  
        super();                               
    }

       public static void main (String[] args) {
        FileTransfer fileTransfer = new FileTransfer();              

    JSch jsch = new JSch();

          try {

              String host = "127.0.0.1";
              int port = 22;

              String user = "user";
              Session session = jsch.getSession(user, host, port);      
              session = jsch.getSession("username", "127.0.0.1", 22);
              session.connect();

             //Channel channel  = session.openChannel("sftp");
              ChannelSftp sftp = null;
              sftp = (ChannelSftp)session.openChannel("sftp") ; //channel;
              //channel.connect();
              //Channel channel = session.openChannel("shell");  



             sftp.rename("C:\\Users\\ADMIN\\Desktop\\Work\\ConnectOne_Bancorp\\Java_Work\\SFTP_1\\house.bmp", "C:\\Users\\ADMIN\\Desktop\\Work\\ConnectOne_Bancorp\\Java_Work\\SFTP_2\\house.bmp");  // /SFTP_1/file.txt 
              //sftpChannel.get("remotefile.txt", "localfile.txt");
              //sftpChannel.exit();
              session.disconnect();

          } catch (JSchException e) {
              e.printStackTrace();  
          } catch (SftpException e) {
              e.printStackTrace();
          }
       }
}

Ce que je voudrais faire c'est simplement de transférer un fichier d'un répertoire dans ma machine à un autre répertoire. des conseils apprécié, merci !

source d'informationauteur Coffee

8

Noter que pour la copie entre deux dossiers, on n'a pas besoin d'utiliser le protocole SFTP. On peut copier à partir d'un dossier à l'autre sans impliquer le protocole SFTP qui est essentiellement utilisé pour copier des fichiers à distance, soit à partir de l'ordinateur local vers un ordinateur distant, ou à partir d'une machine distante (le même ou un différent) à distance de la machine ou de la machine à distance sur la machine locale.

C'est parce que le FTP est un réseau basé sur le protocole. Afin de l'utiliser (ou l'un de ses protocoles) va utiliser le réseau (ou d'un réseau simulé).

La sécurité que JSch fournit la sécurité est conçu pour protéger contre certains types d'attaques qui se produisent sur les réseaux. Il ne fournira aucune sécurité supplémentaire à l'intérieur de la machine.

Pour copier des fichiers entre les dossiers sur une seule machine, la façon la plus simple de le faire est de ne pas utiliser JSch, comme
```
private static void copyFileUsingJava7Files(File source, File dest)
        throws IOException {
    Files.copy(source.toPath(), dest.toPath());
}
```
Il existe d'autres techniques, et si vous voulez vraiment utiliser JSch, vous devez réaliser que JSch doit être fourni beaucoup d'informations "supplémentaires pour se connecter à l'ordinateur que vous utilisez, car il va essayer de se connecter à cette machine, comme si c'était de la connexion via le réseau
```
Session sessionRead = jsch.getSession("username", "127.0.0.1", 22);
sessionRead.connect();

Session sessionWrite = jsch.getSession("username", "127.0.0.1", 22);
sessionWrite.connect();

ChannelSftp channelRead = (ChannelSftp)sessionRead.openChannel("sftp");
channelRead.connect();

ChannelSftp channelWrite = (ChannelSftp)sessionWrite.openChannel("sftp");
channelWrite.connect();

PipedInputStream pin = new PipedInputStream(2048);
PipedOutputStream pout = new PipedOutputStream(pin);

channelRead.get("/path/to/your/file/including/filename.txt", pout);
channelWrite.put(pin, "/path/to/your/file/destination/including/filename.txt");

channelRead.disconnect();
channelWrite.disconnect();

sessionRead.disconnect();
sessionWrite.disconnect();
```
Le code ci-dessus manque de contrôle d'erreur, gestion des exceptions, et de revenir routines pour si des fichiers sont manquants, les réseaux ne sont pas en place, etc. Mais vous devriez obtenir l'idée principale.

Il devrait être aussi évident que l'utilisation d'un protocole de réseau où aucun protocole réseau doit exister ouvre la porte à beaucoup plus de scénarios de défaillance. Seulement utiliser le SFTP méthode si votre programme est bientôt destinée à copier les fichiers qui ne sont pas situés sur votre machine.
2

Fait JSch est conçu pour le travail à distance et le système de fichiers modification est l'un des type de travail. @Edwin Buck réponse utilise le réseau pour faire face entre les dossiers locaux sur l'hôte distant. Il y a une meilleure approche:
```
session.connect();
ChannelExec exec = (ChannelExec) session.openChannel("exec");
exec.setCommand("cp a.out b.out");
exec.connect();
```
Je n'ai pas de windows sur la main, comme le résultat de mon exemple est pour unix. Mais l'idée est simple: exécuter la commande de copie sur l'hôte distant.

Si l'affiche originale est actuellement à la recherche d'un exemple de travail de JSch dans l'action entre les deux distincts des sites FTP, va ici:

import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
...
JSch jsch = new JSch();
JSch session = null;
try {
  session = jsch.getSession(userid, sourceservername, sourceserverport);
  session.setPassword(sourceserverpassword);
  Properties props = new Properties();
  props.put("StrictHostKeyChecking", "no");
  session.setConfig(props);
  session.connect();
  Channel channel = session.openChannel("sftp");
  channel.connect();
  ChanelSftp channelsftp = (ChannelSftp) channel;
  channelsftp.cd(sourcefilepath);
  channelsftp.lcd(localfilepath);
  FileOutputStream fos = new FileOutputStream(new File(localfilepath + "/" + localfilename));
  channelsftp.get(sourcefilename, fos);
  fos.flush();
  fos.close();
  channelsftp.disconnect()
  session.disconnect();
} catch (Exception e) {
  e.printStackTrace();
}

Dans la pratique, vous pourriez casser ces actions distinctes try{}catch(){} bloqué états afin d'introduire plus granulaire erreur de déclaration, ainsi que d'ajouter toute information lignes de sortie pour informer l'utilisateur de l'état, etc. Mais cette vous y arriver. Certes, tout le JSch exemples sont mieux que la plupart des exemples de ce type d'freeware bibliothèques, même les bonnes comme celle-ci, il peut y avoir quelques omissions d'entre eux autour des détails qui peuvent faire ou défaire votre tentative d'obtenir les choses à travailler. Espérons que cela aide si pas le posteur d'origine, puis quelqu'un d'autre la recherche d'un travail JSch exemple. Une fois que vous avez de travail, il ne va comme un charme, alors ça vaut la peine.

Vous devez vous connecter pour publier un commentaire.