【SFTP】使用Jsch实现Sftp文件上传-支持断点续传和进程监控

2023-08-05 18:00:22

JSch是Java Secure Channel的缩写。JSch是一个SSH2的纯Java实现。它允许你连接到一个SSH服务器，并且可以使用端口转发，X11转发，文件传输等，当然你也可以集成它的功能到你自己的应用程序。

本文只介绍如何使用JSch实现的SFTP功能。

SFTP是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供一种安全的加密方法。SFTP 为 SSH的一部份，是一种传输文件到服务器的安全方式。SFTP是使用加密传输认证信息和传输的数据，所以，使用SFTP是非常安全的。但是，由于这种传输方式使用了加密/解密技术，所以传输效率比普通的FTP要低得多，如果您对网络安全性要求更高时，可以使用SFTP代替FTP。（来自百度的解释）

要使用JSch，需要下载它的jar包，请从官网下载它：http://www.jcraft.com/jsch/

ChannelSftp类是JSch实现SFTP核心类，它包含了所有SFTP的方法，如：

put()：文件上传

get()：文件下载

cd()：进入指定目录

ls()：得到指定目录下的文件列表

rename()：重命名指定文件或目录

rm()：删除指定文件

mkdir()：创建目录

rmdir()：删除目录

等等（这里省略了方法的参数，put和get都有多个重载方法，具体请看源代码，这里不一一列出。）

步骤：

根据Jsch创建Session;
设置Session密码、超时时间和属性等；
连接session；
使用Session创建ChannelSftp通道；
接下来就可以使用ChannelSftp进行各种操作了：如文件上传、文件下载；
最后，关系各种资源：如Session、ChannelSftp等；

其他：还可以设置监听器，监控文件上传和下载的进度；

创建ChannelSftp对象

编写一个工具类，根据ip，用户名及密码得到一个SFTP channel对象，即ChannelSftp的实例对象，在应用程序中就可以使用该对象来调用SFTP的各种操作方法。

监控传输进度

文件上传

测试断点续传

完整程序


package com.sssppp.Communication;

/**
 * This program will demonstrate the sftp protocol support.
 *   $ CLASSPATH=.:../build javac Sftp.java
 *   $ CLASSPATH=.:../build java Sftp
 * You will be asked username, host and passwd. 
 * If everything works fine, you will get a prompt 'sftp>'. 
 * 'help' command will show available command.
 * In current implementation, the destination path for 'get' and 'put'
 * commands must be a file, not a directory.
 *
 */
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.ProgressMonitor;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpProgressMonitor;

/**
 * <pre>
 *  ----------命令集合---------------------
 *  可参考链接(官方示例程序)：http://www.jcraft.com/jsch/examples/Sftp.java
 *  ChannelSftp c = (ChannelSftp) channel;
 *  c.quit();
 *  c.exit();
 *  c.cd("/home/example");
 *  c.lcd("/home/example");
 *  c.rm("/home/example.gz");
 *  c.rmdir("/home/example");
 *  c.mkdir("/home/example");
 *  c.chgrp(777, "/home/example");
 *  c.chown(777, "/home/example");
 *  c.chmod(777, "/home/example");
 *  c.pwd();
 *  c.lpwd();
 *  c.ls("/home/example");
 *  
 *  SftpProgressMonitor monitor = new MyProgressMonitor(); //显示进度
 *  //文件下载
 *  c.get("srcPath", "dstPath", monitor, ChannelSftp.OVERWRITE);
 *  c.get("srcPath", "dstPath", monitor, ChannelSftp.RESUME); //断点续传
 *  c.get("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
 *  //文件上传
 *  c.put("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
 *  c.put("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
 *  c.put("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
 * 
 *  c.hardlink("oldPath", "newPath");
 *  c.rename("oldPath", "newPath");
 *  c.symlink("oldPath", "newPath");
 *  c.readlink("Path");
 *  c.realpath("Path");
 *  c.version();
 *  
 *  SftpStatVFS stat = c.statVFS("path");  //df 命令
 *  long size = stat.getSize();
 *  long used = stat.getUsed();
 *  long avail = stat.getAvailForNonRoot();
 *  long root_avail = stat.getAvail();
 *  long capacity = stat.getCapacity();
 *  
 *  c.stat("path");
 *  c.lstat("path");
 * ----------------------------------------------------------------------
 * </pre>
 * 
 */
public class SftpUtil {

  Session session = null;
  Channel channel = null;
  public static final String SFTP_REQ_HOST = "host";
  public static final String SFTP_REQ_PORT = "port";
  public static final String SFTP_REQ_USERNAME = "username";
  public static final String SFTP_REQ_PASSWORD = "password";
  public static final int SFTP_DEFAULT_PORT = 22;
  public static final String SFTP_REQ_LOC = "location";

  
  /**
   * 测试程序
   * @param arg
   * @throws Exception 
   */
  public static void main(String[] arg) throws Exception {
    // 设置主机ip，端口，用户名，密码
    Map<String, String> sftpDetails = new HashMap<String, String>();
    sftpDetails.put(SFTP_REQ_HOST, "10.180.137.221");
    sftpDetails.put(SFTP_REQ_USERNAME, "root");
    sftpDetails.put(SFTP_REQ_PASSWORD, "xxx");
    sftpDetails.put(SFTP_REQ_PORT, "22");
    
    //测试文件上传
    String src = "C:\\xxx\\TMP\\site-1.10.4.zip"; // 本地文件名
        String dst = "/tmp/sftp/"; // 目标文件名
        uploadFile(src, dst, sftpDetails);
              
  }
  
  public static void uploadFile(String src, String dst,
      Map<String, String> sftpDetails) throws Exception {
    SftpUtil sftpUtil = new SftpUtil();
    ChannelSftp chSftp = sftpUtil.getChannel(sftpDetails, 60000);

    /**
     * 代码段1/代码段2/代码段3分别演示了如何使用JSch的不同的put方法来进行文件上传。这三段代码实现的功能是一样的，
     * 都是将本地的文件src上传到了服务器的dst文件
     */

    /**代码段1 
        OutputStream out = chSftp.put(dst,new MyProgressMonitor2(), ChannelSftp.OVERWRITE); // 使用OVERWRITE模式
        byte[] buff = new byte[1024 * 256]; // 设定每次传输的数据块大小为256KB
        int read;
        if (out != null) {
            InputStream is = new FileInputStream(src);
            do {
                read = is.read(buff, 0, buff.length);
                if (read > 0) {
                    out.write(buff, 0, read);
                }
                out.flush();
            } while (read >= 0);
        }
        **/
        
    // 使用这个方法时，dst可以是目录，当dst是目录时，上传后的目标文件名将与src文件名相同
    // ChannelSftp.RESUME：断点续传
    chSftp.put(src, dst, new MyProgressMonitor(), ChannelSftp.RESUME); // 代码段2

    // 将本地文件名为src的文件输入流上传到目标服务器，目标文件名为dst。
    // chSftp.put(new FileInputStream(src), dst,new MyProgressMonitor2(), ChannelSftp.OVERWRITE); // 代码段3
        
        chSftp.quit();
        sftpUtil.closeChannel();
  }

  /**
   * 根据ip，用户名及密码得到一个SFTP
   * channel对象，即ChannelSftp的实例对象，在应用程序中就可以使用该对象来调用SFTP的各种操作方法
   * 
   * @param sftpDetails
   * @param timeout
   * @return
   * @throws JSchException
   */
  public ChannelSftp getChannel(Map<String, String> sftpDetails, int timeout)
      throws JSchException {
    String ftpHost = sftpDetails.get(SFTP_REQ_HOST);
    String port = sftpDetails.get(SFTP_REQ_PORT);
    String ftpUserName = sftpDetails.get(SFTP_REQ_USERNAME);
    String ftpPassword = sftpDetails.get(SFTP_REQ_PASSWORD);

    int ftpPort = SFTP_DEFAULT_PORT;
    if (port != null && !port.equals("")) {
      ftpPort = Integer.valueOf(port);
    }

    JSch jsch = new JSch(); // 创建JSch对象
    session = jsch.getSession(ftpUserName, ftpHost, ftpPort); // 根据用户名，主机ip，端口获取一个Session对象
    if (ftpPassword != null) {
      session.setPassword(ftpPassword); // 设置密码
    }
    Properties config = new Properties();
    config.put("StrictHostKeyChecking", "no");
    session.setConfig(config); // 为Session对象设置properties
    session.setTimeout(timeout); // 设置timeout时间
    session.connect(5000); // 通过Session建立链接
    channel = session.openChannel("sftp"); // 打开SFTP通道
    channel.connect(); // 建立SFTP通道的连接
    return (ChannelSftp) channel;
  }

  public void closeChannel() throws Exception {
    if (channel != null) {
      channel.disconnect();
    }
    if (session != null) {
      session.disconnect();
    }
  }


  /**
   * 进度监控器-JSch每次传输一个数据块，就会调用count方法来实现主动进度通知
   * 
   */
  public static class MyProgressMonitor implements SftpProgressMonitor {
      private long count = 0;     //当前接收的总字节数
      private long max = 0;       //最终文件大小
      private long percent = -1;  //进度

      /**
       * 当每次传输了一个数据块后，调用count方法，count方法的参数为这一次传输的数据块大小
       */
      @Override
    public boolean count(long count) {
      this.count += count;
      if (percent >= this.count * 100 / max) {
        return true;
      }
      percent = this.count * 100 / max;

      System.out.println("Completed " + this.count + "(" + percent
          + "%) out of " + max + ".");
      return true;
    }

      /**
       * 当传输结束时，调用end方法
       */
      @Override
      public void end() {
          System.out.println("Transferring done.");
      }

      /**
       * 当文件开始传输时，调用init方法
       */
      @Override
      public void init(int op, String src, String dest, long max) {
          System.out.println("Transferring begin.");
          this.max = max;  
          this.count = 0;
          this.percent = -1;
      }
  }
  
  /**
   * 官方提供的进度监控器
   *
   */
  public static class DemoProgressMonitor implements SftpProgressMonitor {
    ProgressMonitor monitor;
    long count = 0;
    long max = 0;

    /**
     * 当文件开始传输时，调用init方法。
     */
    public void init(int op, String src, String dest, long max) {
      this.max = max;
      monitor = new ProgressMonitor(null,
          ((op == SftpProgressMonitor.PUT) ? "put" : "get") + ": "
              + src, "", 0, (int) max);
      count = 0;
      percent = -1;
      monitor.setProgress((int) this.count);
      monitor.setMillisToDecideToPopup(1000);
    }

    private long percent = -1;

    /**
     * 当每次传输了一个数据块后，调用count方法，count方法的参数为这一次传输的数据块大小。
     */
    public boolean count(long count) {
      this.count += count;

      if (percent >= this.count * 100 / max) {
        return true;
      }
      percent = this.count * 100 / max;

      monitor.setNote("Completed " + this.count + "(" + percent
          + "%) out of " + max + ".");
      monitor.setProgress((int) this.count);

      return !(monitor.isCanceled());
    }

    /**
     * 当传输结束时，调用end方法。
     */
    public void end() {
      monitor.close();
    }
  }
}

参考链接

http://www.cnblogs.com/longyg/archive/2012/06/25/2556576.html

API: https://epaul.github.io/jsch-documentation/javadoc/

官方Demo：http://www.jcraft.com/jsch/examples/Sftp.java

http://www.jcraft.com/jsch/examples/Sftp.java.html

http://www.jcraft.com/jsch/examples/

来自为知笔记(Wiz)