ssslinppp

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
【SFTP】使用Jsch实现Sftp文件上传-支持断点续传和进程监控
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都有多个重载方法，具体请看源代码，这里不一一列出。）

步骤：
  1. 根据Jsch创建Session;
  2. 设置Session密码、超时时间和属性等；
  3. 连接session；
  4. 使用Session创建ChannelSftp通道；
  5. 接下来就可以使用ChannelSftp进行各种操作了：如文件上传、文件下载；
  6. 最后，关系各种资源：如Session、ChannelSftp等；
其他：还可以设置监听器，监控文件上传和下载的进度；

创建ChannelSftp对象

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


监控传输进度

文件上传



测试断点续传






完整程序

  1. package com.sssppp.Communication;
  3. /**
  4.  * This program will demonstrate the sftp protocol support.
  5.  *   $ CLASSPATH=.:../build javac Sftp.java
  6.  *   $ CLASSPATH=.:../build java Sftp
  7.  * You will be asked username, host and passwd. 
  8.  * If everything works fine, you will get a prompt 'sftp>'. 
  9.  * 'help' command will show available command.
  10.  * In current implementation, the destination path for 'get' and 'put'
  11.  * commands must be a file, not a directory.
  12.  *
  13.  */
  14. import java.text.DecimalFormat;
  15. import java.util.HashMap;
  16. import java.util.Map;
  17. import java.util.Properties;
  18. import java.util.Timer;
  19. import java.util.TimerTask;
  21. import javax.swing.ProgressMonitor;
  23. import com.jcraft.jsch.Channel;
  24. import com.jcraft.jsch.ChannelSftp;
  25. import com.jcraft.jsch.JSch;
  26. import com.jcraft.jsch.JSchException;
  27. import com.jcraft.jsch.Session;
  28. import com.jcraft.jsch.SftpProgressMonitor;
  30. /**
  31.  * <pre>
  32.  *  ----------命令集合---------------------
  33.  *  可参考链接(官方示例程序)：http://www.jcraft.com/jsch/examples/Sftp.java
  34.  *  ChannelSftp c = (ChannelSftp) channel;
  35.  *  c.quit();
  36.  *  c.exit();
  37.  *  c.cd("/home/example");
  38.  *  c.lcd("/home/example");
  39.  *  c.rm("/home/example.gz");
  40.  *  c.rmdir("/home/example");
  41.  *  c.mkdir("/home/example");
  42.  *  c.chgrp(777, "/home/example");
  43.  *  c.chown(777, "/home/example");
  44.  *  c.chmod(777, "/home/example");
  45.  *  c.pwd();
  46.  *  c.lpwd();
  47.  *  c.ls("/home/example");
  48.  *  
  49.  *  SftpProgressMonitor monitor = new MyProgressMonitor(); //显示进度
  50.  *  //文件下载
  51.  *  c.get("srcPath", "dstPath", monitor, ChannelSftp.OVERWRITE);
  52.  *  c.get("srcPath", "dstPath", monitor, ChannelSftp.RESUME); //断点续传
  53.  *  c.get("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
  54.  *  //文件上传
  55.  *  c.put("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
  56.  *  c.put("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
  57.  *  c.put("srcPath", "dstPath", monitor, ChannelSftp.APPEND);
  58.  * 
  59.  *  c.hardlink("oldPath", "newPath");
  60.  *  c.rename("oldPath", "newPath");
  61.  *  c.symlink("oldPath", "newPath");
  62.  *  c.readlink("Path");
  63.  *  c.realpath("Path");
  64.  *  c.version();
  65.  *  
  66.  *  SftpStatVFS stat = c.statVFS("path");  //df 命令
  67.  *  long size = stat.getSize();
  68.  *  long used = stat.getUsed();
  69.  *  long avail = stat.getAvailForNonRoot();
  70.  *  long root_avail = stat.getAvail();
  71.  *  long capacity = stat.getCapacity();
  72.  *  
  73.  *  c.stat("path");
  74.  *  c.lstat("path");
  75.  * ----------------------------------------------------------------------
  76.  * </pre>
  77.  * 
  78.  */
  79. public class SftpUtil {
  81.   Session session = null;
  82.   Channel channel = null;
  83.   public static final String SFTP_REQ_HOST = "host";
  84.   public static final String SFTP_REQ_PORT = "port";
  85.   public static final String SFTP_REQ_USERNAME = "username";
  86.   public static final String SFTP_REQ_PASSWORD = "password";
  87.   public static final int SFTP_DEFAULT_PORT = 22;
  88.   public static final String SFTP_REQ_LOC = "location";
  90.   
  91.   /**
  92.    * 测试程序
  93.    * @param arg
  94.    * @throws Exception 
  95.    */
  96.   public static void main(String[] arg) throws Exception {
  97.     // 设置主机ip，端口，用户名，密码
  98.     Map<String, String> sftpDetails = new HashMap<String, String>();
  99.     sftpDetails.put(SFTP_REQ_HOST, "10.180.137.221");
  100.     sftpDetails.put(SFTP_REQ_USERNAME, "root");
  101.     sftpDetails.put(SFTP_REQ_PASSWORD, "xxx");
  102.     sftpDetails.put(SFTP_REQ_PORT, "22");
  103.     
  104.     //测试文件上传
  105.     String src = "C:\\xxx\\TMP\\site-1.10.4.zip"; // 本地文件名
  106.         String dst = "/tmp/sftp/"; // 目标文件名
  107.         uploadFile(src, dst, sftpDetails);
  108.               
  109.   }
  110.   
  111.   public static void uploadFile(String src, String dst,
  112.       Map<String, String> sftpDetails) throws Exception {
  113.     SftpUtil sftpUtil = new SftpUtil();
  114.     ChannelSftp chSftp = sftpUtil.getChannel(sftpDetails, 60000);
  116.     /**
  117.      * 代码段1/代码段2/代码段3分别演示了如何使用JSch的不同的put方法来进行文件上传。这三段代码实现的功能是一样的，
  118.      * 都是将本地的文件src上传到了服务器的dst文件
  119.      */
  121.     /**代码段1 
  122.         OutputStream out = chSftp.put(dst,new MyProgressMonitor2(), ChannelSftp.OVERWRITE); // 使用OVERWRITE模式
  123.         byte[] buff = new byte[1024 * 256]; // 设定每次传输的数据块大小为256KB
  124.         int read;
  125.         if (out != null) {
  126.             InputStream is = new FileInputStream(src);
  127.             do {
  128.                 read = is.read(buff, 0, buff.length);
  129.                 if (read > 0) {
  130.                     out.write(buff, 0, read);
  131.                 }
  132.                 out.flush();
  133.             } while (read >= 0);
  134.         }
  135.         **/
  136.         
  137.     // 使用这个方法时，dst可以是目录，当dst是目录时，上传后的目标文件名将与src文件名相同
  138.     // ChannelSftp.RESUME：断点续传
  139.     chSftp.put(src, dst, new MyProgressMonitor(), ChannelSftp.RESUME); // 代码段2
  141.     // 将本地文件名为src的文件输入流上传到目标服务器，目标文件名为dst。
  142.     // chSftp.put(new FileInputStream(src), dst,new MyProgressMonitor2(), ChannelSftp.OVERWRITE); // 代码段3
  143.         
  144.         chSftp.quit();
  145.         sftpUtil.closeChannel();
  146.   }
  148.   /**
  149.    * 根据ip，用户名及密码得到一个SFTP
  150.    * channel对象，即ChannelSftp的实例对象，在应用程序中就可以使用该对象来调用SFTP的各种操作方法
  151.    * 
  152.    * @param sftpDetails
  153.    * @param timeout
  154.    * @return
  155.    * @throws JSchException
  156.    */
  157.   public ChannelSftp getChannel(Map<String, String> sftpDetails, int timeout)
  158.       throws JSchException {
  159.     String ftpHost = sftpDetails.get(SFTP_REQ_HOST);
  160.     String port = sftpDetails.get(SFTP_REQ_PORT);
  161.     String ftpUserName = sftpDetails.get(SFTP_REQ_USERNAME);
  162.     String ftpPassword = sftpDetails.get(SFTP_REQ_PASSWORD);
  164.     int ftpPort = SFTP_DEFAULT_PORT;
  165.     if (port != null && !port.equals("")) {
  166.       ftpPort = Integer.valueOf(port);
  167.     }
  169.     JSch jsch = new JSch(); // 创建JSch对象
  170.     session = jsch.getSession(ftpUserName, ftpHost, ftpPort); // 根据用户名，主机ip，端口获取一个Session对象
  171.     if (ftpPassword != null) {
  172.       session.setPassword(ftpPassword); // 设置密码
  173.     }
  174.     Properties config = new Properties();
  175.     config.put("StrictHostKeyChecking", "no");
  176.     session.setConfig(config); // 为Session对象设置properties
  177.     session.setTimeout(timeout); // 设置timeout时间
  178.     session.connect(5000); // 通过Session建立链接
  179.     channel = session.openChannel("sftp"); // 打开SFTP通道
  180.     channel.connect(); // 建立SFTP通道的连接
  181.     return (ChannelSftp) channel;
  182.   }
  184.   public void closeChannel() throws Exception {
  185.     if (channel != null) {
  186.       channel.disconnect();
  187.     }
  188.     if (session != null) {
  189.       session.disconnect();
  190.     }
  191.   }
  194.   /**
  195.    * 进度监控器-JSch每次传输一个数据块，就会调用count方法来实现主动进度通知
  196.    * 
  197.    */
  198.   public static class MyProgressMonitor implements SftpProgressMonitor {
  199.       private long count = 0;     //当前接收的总字节数
  200.       private long max = 0;       //最终文件大小
  201.       private long percent = -1;  //进度
  203.       /**
  204.        * 当每次传输了一个数据块后，调用count方法，count方法的参数为这一次传输的数据块大小
  205.        */
  206.       @Override
  207.     public boolean count(long count) {
  208.       this.count += count;
  209.       if (percent >= this.count * 100 / max) {
  210.         return true;
  211.       }
  212.       percent = this.count * 100 / max;
  214.       System.out.println("Completed " + this.count + "(" + percent
  215.           + "%) out of " + max + ".");
  216.       return true;
  217.     }
  219.       /**
  220.        * 当传输结束时，调用end方法
  221.        */
  222.       @Override
  223.       public void end() {
  224.           System.out.println("Transferring done.");
  225.       }
  227.       /**
  228.        * 当文件开始传输时，调用init方法
  229.        */
  230.       @Override
  231.       public void init(int op, String src, String dest, long max) {
  232.           System.out.println("Transferring begin.");
  233.           this.max = max;  
  234.           this.count = 0;
  235.           this.percent = -1;
  236.       }
  237.   }
  238.   
  239.   /**
  240.    * 官方提供的进度监控器
  241.    *
  242.    */
  243.   public static class DemoProgressMonitor implements SftpProgressMonitor {
  244.     ProgressMonitor monitor;
  245.     long count = 0;
  246.     long max = 0;
  248.     /**
  249.      * 当文件开始传输时，调用init方法。
  250.      */
  251.     public void init(int op, String src, String dest, long max) {
  252.       this.max = max;
  253.       monitor = new ProgressMonitor(null,
  254.           ((op == SftpProgressMonitor.PUT) ? "put" : "get") + ": "
  255.               + src, "", 0, (int) max);
  256.       count = 0;
  257.       percent = -1;
  258.       monitor.setProgress((int) this.count);
  259.       monitor.setMillisToDecideToPopup(1000);
  260.     }
  262.     private long percent = -1;
  264.     /**
  265.      * 当每次传输了一个数据块后，调用count方法，count方法的参数为这一次传输的数据块大小。
  266.      */
  267.     public boolean count(long count) {
  268.       this.count += count;
  270.       if (percent >= this.count * 100 / max) {
  271.         return true;
  272.       }
  273.       percent = this.count * 100 / max;
  275.       monitor.setNote("Completed " + this.count + "(" + percent
  276.           + "%) out of " + max + ".");
  277.       monitor.setProgress((int) this.count);
  279.       return !(monitor.isCanceled());
  280.     }
  282.     /**
  283.      * 当传输结束时，调用end方法。
  284.      */
  285.     public void end() {
  286.       monitor.close();
  287.     }
  288.   }
  289. }










posted on 2017-01-04 15:09  ssslinppp  阅读(8424)  评论(2)    收藏  举报