JSch - 走看看

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支持三种文件传输模式：

OVERWRITE

完全覆盖模式，这是JSch的默认文件传输模式，即如果目标文件已经存在，传输的文件将完全覆盖目标文件，产生新的文件。

RESUME

恢复模式，如果文件已经传输一部分，这时由于网络或其他任何原因导致文件传输中断，如果下一次传输相同的文件，

则会从上一次中断的地方续传。

APPEND

追加模式，如果目标文件已存在，传输的文件将在目标文件后追加。

创建ChannelSftp对象

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

SFTPChannel.java

按 Ctrl+C 复制代码

SFTPChannel.java

package com.longyg.sftp;

import java.util.Map;
import java.util.Properties;

import org.apache.log4j.Logger;

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;

public class SFTPChannel {
    Session session = null;
    Channel channel = null;

private static final Logger LOG = Logger.getLogger(SFTPChannel.class.getName());

public ChannelSftp getChannel(Map<String, String> sftpDetails, int timeout) throws JSchException {

String ftpHost = sftpDetails.get(SFTPConstants.SFTP_REQ_HOST);
        String port = sftpDetails.get(SFTPConstants.SFTP_REQ_PORT);
        String ftpUserName = sftpDetails.get(SFTPConstants.SFTP_REQ_USERNAME);
        String ftpPassword = sftpDetails.get(SFTPConstants.SFTP_REQ_PASSWORD);

int ftpPort = SFTPConstants.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对象
        LOG.debug("Session created.");
        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(); // 通过Session建立链接
        LOG.debug("Session connected.");

LOG.debug("Opening Channel.");
        channel = session.openChannel("sftp"); // 打开SFTP通道
        channel.connect(); // 建立SFTP通道的连接
        LOG.debug("Connected successfully to ftpHost = " + ftpHost + ",as ftpUserName = " + ftpUserName
                + ", returning: " + channel);
        return (ChannelSftp) channel;
    }

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

按 Ctrl+C 复制代码

SFTPConstants是一个静态成员变量类：

SFTPConstans.java

按 Ctrl+C 复制代码

文件上传

实现文件上传可以调用ChannelSftp对象的put方法。ChannelSftp中有12个put方法的重载方法：

public void put(String src, String dst)	将本地文件名为src的文件上传到目标服务器，目标文件名为dst，若dst为目录，则目标文件名将与src文件名相同。采用默认的传输模式：OVERWRITE
public void put(String src, String dst, int mode)	将本地文件名为src的文件上传到目标服务器，目标文件名为dst，若dst为目录，则目标文件名将与src文件名相同。指定文件传输模式为mode（mode可选值为：ChannelSftp.OVERWRITE，ChannelSftp.RESUME， ChannelSftp.APPEND）
public void put(String src, String dst, SftpProgressMonitor monitor)	将本地文件名为src的文件上传到目标服务器，目标文件名为dst，若dst为目录，则目标文件名将与src文件名相同。采用默认的传输模式：OVERWRITE 并使用实现了SftpProgressMonitor接口的monitor对象来监控文件传输的进度。
public void put(String src, String dst, SftpProgressMonitor monitor, int mode)	将本地文件名为src的文件上传到目标服务器，目标文件名为dst，若dst为目录，则目标文件名将与src文件名相同。指定传输模式为mode 并使用实现了SftpProgressMonitor接口的monitor对象来监控文件传输的进度。
public void put(InputStream src, String dst)	将本地的input stream对象src上传到目标服务器，目标文件名为dst，dst不能为目录。采用默认的传输模式：OVERWRITE
public void put(InputStream src, String dst, int mode)	将本地的input stream对象src上传到目标服务器，目标文件名为dst，dst不能为目录。指定文件传输模式为mode
public void put(InputStream src, String dst, SftpProgressMonitor monitor)	将本地的input stream对象src上传到目标服务器，目标文件名为dst，dst不能为目录。采用默认的传输模式：OVERWRITE 并使用实现了SftpProgressMonitor接口的monitor对象来监控传输的进度。
public void put(InputStream src, String dst, SftpProgressMonitor monitor, int mode)	将本地的input stream对象src上传到目标服务器，目标文件名为dst，dst不能为目录。指定文件传输模式为mode 并使用实现了SftpProgressMonitor接口的monitor对象来监控传输的进度。
public OutputStream put(String dst)	该方法返回一个输出流，可以向该输出流中写入数据，最终将数据传输到目标服务器，目标文件名为dst，dst不能为目录。采用默认的传输模式：OVERWRITE
public OutputStream put(String dst, final int mode)	该方法返回一个输出流，可以向该输出流中写入数据，最终将数据传输到目标服务器，目标文件名为dst，dst不能为目录。指定文件传输模式为mode
public OutputStream put(String dst, final SftpProgressMonitor monitor, final int mode)	该方法返回一个输出流，可以向该输出流中写入数据，最终将数据传输到目标服务器，目标文件名为dst，dst不能为目录。指定文件传输模式为mode 并使用实现了SftpProgressMonitor接口的monitor对象来监控传输的进度。
public OutputStream put(String dst, final SftpProgressMonitor monitor, final int mode, long offset)	该方法返回一个输出流，可以向该输出流中写入数据，最终将数据传输到目标服务器，目标文件名为dst，dst不能为目录。指定文件传输模式为mode 并使用实现了SftpProgressMonitor接口的monitor对象来监控传输的进度。 offset指定了一个偏移量，从输出流偏移offset开始写入数据。

应用实例：

SFTPTest.java

按 Ctrl+C 复制代码

SFTPTest.java

package com.longyg.sftp;

import java.util.HashMap;
import java.util.Map;

import com.jcraft.jsch.ChannelSftp;

public class SFTPTest {

public SFTPChannel getSFTPChannel() {
        return new SFTPChannel();
    }

/**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        SFTPTest test = new SFTPTest();

Map<String, String> sftpDetails = new HashMap<String, String>();
        // 设置主机ip，端口，用户名，密码
        sftpDetails.put(SFTPConstants.SFTP_REQ_HOST, "10.9.167.55");
        sftpDetails.put(SFTPConstants.SFTP_REQ_USERNAME, "root");
        sftpDetails.put(SFTPConstants.SFTP_REQ_PASSWORD, "arthur");
        sftpDetails.put(SFTPConstants.SFTP_REQ_PORT, "22");
        
        String src = "D:\DevSoft\HB-SnagIt1001.rar"; // 本地文件名
        String dst = "/home/omc/ylong/sftp/HB-SnagIt1001.rar"; // 目标文件名
              
        SFTPChannel channel = test.getSFTPChannel();
        ChannelSftp chSftp = channel.getChannel(sftpDetails, 60000);
        
        /**
         * 代码段1
        OutputStream out = chSftp.put(dst, ChannelSftp.OVERWRITE); // 使用OVERWRITE模式
        byte[] buff = new byte[1024 * 256]; // 设定每次传输的数据块大小为256KB
        int read;
        if (out != null) {
            System.out.println("Start to read input stream");
            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);
            System.out.println("input stream read done.");
        }
        **/
        
        chSftp.put(src, dst, ChannelSftp.OVERWRITE); // 代码段2
        
        // chSftp.put(new FileInputStream(src), dst, ChannelSftp.OVERWRITE); // 代码段3
        
        chSftp.quit();
        channel.closeChannel();
    }
}

按 Ctrl+C 复制代码

注：请分别将代码段1，代码段2，代码段3取消注释，运行程序来进行测试。这三段代码分别演示了如何使用JSch的不同的put方法来进行文件上传。

代码段1：采用向put方法返回的输出流中写入数据的方式来传输文件。需要由程序来决定写入什么样的数据，这里是将本地文件的输入流写入输出流。采用这种方式的好处是，可以自行设定每次写入输出流的数据块大小，如本示例中的语句：

byte[] buff = new byte[1024 * 256]; // 设定每次传输的数据块大小为256KB

代码段2：直接将本地文件名为src的文件上传到目标服务器，目标文件名为dst。（注：使用这个方法时，dst可以是目录，当dst是目录时，上传后的目标文件名将与src文件名相同）

代码段3：将本地文件名为src的文件输入流上传到目标服务器，目标文件名为dst。

这三段代码实现的功能是一样的，都是将本地的文件src上传到了服务器的dst文件。使用时可根据具体情况选择使用哪种实现方式。

监控传输进度

从前面的介绍中知道，JSch支持在文件传输时对传输进度的监控。可以实现JSch提供的SftpProgressMonitor接口来完成这个功能。

SftpProgressMonitor接口类的定义为：

 1 SftpProgressMonitor.java 
 2 
 3 package com.jcraft.jsch;
 4 
 5 public interface SftpProgressMonitor{
 6   public static final int PUT=0;
 7   public static final int GET=1;
 8   void init(int op, String src, String dest, long max);
 9   boolean count(long count);
10   void end();
11 }

SftpProgressMonitor

init(): 当文件开始传输时，调用init方法。

count(): 当每次传输了一个数据块后，调用count方法，count方法的参数为这一次传输的数据块大小。

end(): 当传输结束时，调用end方法。

下面是一个简单的实现：

 1 MyProgressMonitor.java 
 2 
 3 package com.longyg.sftp;
 4 
 5 import com.jcraft.jsch.SftpProgressMonitor;
 6 
 7 public class MyProgressMonitor implements SftpProgressMonitor {
 8     private long transfered;
 9 
10     @Override
11     public boolean count(long count) {
12         transfered = transfered + count;
13         System.out.println("Currently transferred total size: " + transfered + " bytes");
14         return true;
15     }
16 
17     @Override
18     public void end() {
19         System.out.println("Transferring done.");
20     }
21 
22     @Override
23     public void init(int op, String src, String dest, long max) {
24         System.out.println("Transferring begin.");
25     }
26 }

MyProgressMonitor.java

此时如果改变SFTPTest main方法里调用的put方法，即可实现监控传输进度：

 1 SFTPTest.java 
 2 
 3 package com.longyg.sftp;
 4 
 5 import java.util.HashMap;
 6 import java.util.Map;
 7 
 8 import com.jcraft.jsch.ChannelSftp;
 9 
10 public class SFTPTest {
11 
12     public SFTPChannel getSFTPChannel() {
13         return new SFTPChannel();
14     }
15 
16     /**
17      * @param args
18      * @throws Exception
19      */
20     public static void main(String[] args) throws Exception {
21         SFTPTest test = new SFTPTest();
22 
23         Map<String, String> sftpDetails = new HashMap<String, String>();
24         // 设置主机ip，端口，用户名，密码
25         sftpDetails.put(SFTPConstants.SFTP_REQ_HOST, "10.9.167.55");
26         sftpDetails.put(SFTPConstants.SFTP_REQ_USERNAME, "root");
27         sftpDetails.put(SFTPConstants.SFTP_REQ_PASSWORD, "arthur");
28         sftpDetails.put(SFTPConstants.SFTP_REQ_PORT, "22");
29         
30         String src = "D:\DevSoft\HB-SnagIt1001.rar"; // 本地文件名
31         String dst = "/home/omc/ylong/sftp/HB-SnagIt1001.rar"; // 目标文件名
32               
33         SFTPChannel channel = test.getSFTPChannel();
34         ChannelSftp chSftp = channel.getChannel(sftpDetails, 60000);
35         
36         /**
37          * 代码段1
38         OutputStream out = chSftp.put(dst, new MyProgressMonitor(), ChannelSftp.OVERWRITE); // 使用OVERWRITE模式
39         byte[] buff = new byte[1024 * 256]; // 设定每次传输的数据块大小为256KB
40         int read;
41         if (out != null) {
42             System.out.println("Start to read input stream");
43             InputStream is = new FileInputStream(src);
44             do {
45                 read = is.read(buff, 0, buff.length);
46                 if (read > 0) {
47                     out.write(buff, 0, read);
48                 }
49                 out.flush();
50             } while (read >= 0);
51             System.out.println("input stream read done.");
52         }
53         **/
54         
55         chSftp.put(src, dst, new MyProgressMonitor(), ChannelSftp.OVERWRITE); // 代码段2
56         
57         // chSftp.put(new FileInputStream(src), dst, new MyProgressMonitor(), ChannelSftp.OVERWRITE); // 代码段3
58         
59         chSftp.quit();
60         channel.closeChannel();
61     }
62 }

SFTPTest.java

 1 logs 
 2 
 3 Start to read input stream
 4 Currently transferred total size: 262144 bytes
 5 Currently transferred total size: 524288 bytes
 6 Currently transferred total size: 786432 bytes
 7 Currently transferred total size: 1048576 bytes
 8 Currently transferred total size: 1310720 bytes
 9 Currently transferred total size: 1572864 bytes
10 Currently transferred total size: 1835008 bytes
11 Currently transferred total size: 2097152 bytes
12 Currently transferred total size: 2359296 bytes
13 Currently transferred total size: 2621440 bytes
14 Currently transferred total size: 2883584 bytes
15 Currently transferred total size: 3145728 bytes
16 Currently transferred total size: 3407872 bytes
17 Currently transferred total size: 3670016 bytes
18 Currently transferred total size: 3848374 bytes
19 input stream read done.

logs

当然这个SftpProgressMonitor的实现实在太简单。JSch每次传输一个数据块，就会调用count方法来实现主动进度通知。

现在我们希望每间隔一定的时间才获取一下文件传输的进度。。。看看下面的SftpProgressMonitor实现：

  1 FileProgressMonitor.java 
  2 
  3 package com.longyg.sftp;
  4 
  5 import java.text.DecimalFormat;
  6 import java.util.Timer;
  7 import java.util.TimerTask;
  8 
  9 import com.jcraft.jsch.SftpProgressMonitor;
 10 
 11 public class FileProgressMonitor extends TimerTask implements SftpProgressMonitor {
 12     
 13     private long progressInterval = 5 * 1000; // 默认间隔时间为5秒
 14     
 15     private boolean isEnd = false; // 记录传输是否结束
 16     
 17     private long transfered; // 记录已传输的数据总大小
 18     
 19     private long fileSize; // 记录文件总大小
 20     
 21     private Timer timer; // 定时器对象
 22     
 23     private boolean isScheduled = false; // 记录是否已启动timer记时器
 24     
 25     public FileProgressMonitor(long fileSize) {
 26         this.fileSize = fileSize;
 27     }
 28     
 29     @Override
 30     public void run() {
 31         if (!isEnd()) { // 判断传输是否已结束
 32             System.out.println("Transfering is in progress.");
 33             long transfered = getTransfered();
 34             if (transfered != fileSize) { // 判断当前已传输数据大小是否等于文件总大小
 35                 System.out.println("Current transfered: " + transfered + " bytes");
 36                 sendProgressMessage(transfered);
 37             } else {
 38                 System.out.println("File transfering is done.");
 39                 setEnd(true); // 如果当前已传输数据大小等于文件总大小，说明已完成，设置end
 40             }
 41         } else {
 42             System.out.println("Transfering done. Cancel timer.");
 43             stop(); // 如果传输结束，停止timer记时器
 44             return;
 45         }
 46     }
 47     
 48     public void stop() {
 49         System.out.println("Try to stop progress monitor.");
 50         if (timer != null) {
 51             timer.cancel();
 52             timer.purge();
 53             timer = null;
 54             isScheduled = false;
 55         }
 56         System.out.println("Progress monitor stoped.");
 57     }
 58     
 59     public void start() {
 60         System.out.println("Try to start progress monitor.");
 61         if (timer == null) {
 62             timer = new Timer();
 63         }
 64         timer.schedule(this, 1000, progressInterval);
 65         isScheduled = true;
 66         System.out.println("Progress monitor started.");
 67     }
 68     
 69     /**
 70      * 打印progress信息
 71      * @param transfered
 72      */
 73     private void sendProgressMessage(long transfered) {
 74         if (fileSize != 0) {
 75             double d = ((double)transfered * 100)/(double)fileSize;
 76             DecimalFormat df = new DecimalFormat( "#.##"); 
 77             System.out.println("Sending progress message: " + df.format(d) + "%");
 78         } else {
 79             System.out.println("Sending progress message: " + transfered);
 80         }
 81     }
 82 
 83     /**
 84      * 实现了SftpProgressMonitor接口的count方法
 85      */
 86     public boolean count(long count) {
 87         if (isEnd()) return false;
 88         if (!isScheduled) {
 89             start();
 90         }
 91         add(count);
 92         return true;
 93     }
 94 
 95     /**
 96      * 实现了SftpProgressMonitor接口的end方法
 97      */
 98     public void end() {
 99         setEnd(true);
100         System.out.println("transfering end.");
101     }
102     
103     private synchronized void add(long count) {
104         transfered = transfered + count;
105     }
106     
107     private synchronized long getTransfered() {
108         return transfered;
109     }
110     
111     public synchronized void setTransfered(long transfered) {
112         this.transfered = transfered;
113     }
114     
115     private synchronized void setEnd(boolean isEnd) {
116         this.isEnd = isEnd;
117     }
118     
119     private synchronized boolean isEnd() {
120         return isEnd;
121     }
122 
123     public void init(int op, String src, String dest, long max) {
124         // Not used for putting InputStream
125     }
126 }

FileProgressMonitor

再次修改SFTPTest main方法里的put方法，改为使用新的SftpProgressMonitor的实现类对象monitor作为参数，注意新的monitor对象的构造函数需要传入文件大小作为参数：

 1 SFTPTest.java 
 2 
 3 package com.longyg.sftp;
 4 
 5 import java.io.File;
 6 import java.util.HashMap;
 7 import java.util.Map;
 8 
 9 import com.jcraft.jsch.ChannelSftp;
10 
11 public class SFTPTest {
12 
13     public SFTPChannel getSFTPChannel() {
14         return new SFTPChannel();
15     }
16 
17     /**
18      * @param args
19      * @throws Exception
20      */
21     public static void main(String[] args) throws Exception {
22         SFTPTest test = new SFTPTest();
23 
24         Map<String, String> sftpDetails = new HashMap<String, String>();
25         // 设置主机ip，端口，用户名，密码
26         sftpDetails.put(SFTPConstants.SFTP_REQ_HOST, "10.9.167.55");
27         sftpDetails.put(SFTPConstants.SFTP_REQ_USERNAME, "root");
28         sftpDetails.put(SFTPConstants.SFTP_REQ_PASSWORD, "arthur");
29         sftpDetails.put(SFTPConstants.SFTP_REQ_PORT, "22");
30         
31         String src = "D:\DevSoft\HB-SnagIt1001.rar"; // 本地文件名
32         String dst = "/home/omc/ylong/sftp/HB-SnagIt1001.rar"; // 目标文件名
33               
34         SFTPChannel channel = test.getSFTPChannel();
35         ChannelSftp chSftp = channel.getChannel(sftpDetails, 60000);
36         
37         File file = new File(src);
38         long fileSize = file.length();
39         
40         /**
41          * 代码段1
42         OutputStream out = chSftp.put(dst, new FileProgressMonitor(fileSize), ChannelSftp.OVERWRITE); // 使用OVERWRITE模式
43         byte[] buff = new byte[1024 * 256]; // 设定每次传输的数据块大小为256KB
44         int read;
45         if (out != null) {
46             System.out.println("Start to read input stream");
47             InputStream is = new FileInputStream(src);
48             do {
49                 read = is.read(buff, 0, buff.length);
50                 if (read > 0) {
51                     out.write(buff, 0, read);
52                 }
53                 out.flush();
54             } while (read >= 0);
55             System.out.println("input stream read done.");
56         }
57         **/
58         
59         chSftp.put(src, dst, new FileProgressMonitor(fileSize), ChannelSftp.OVERWRITE); // 代码段2
60         
61         // chSftp.put(new FileInputStream(src), dst, new FileProgressMonitor(fileSize), ChannelSftp.OVERWRITE); // 代码段3
62         
63         chSftp.quit();
64         channel.closeChannel();
65     }
66 }

SFTPTest

再次运行，结果输出为：

 1 logs 
 2 
 3 Try to start progress monitor.
 4 Progress monitor started.
 5 Transfering is in progress.
 6 Current transfered: 98019 bytes
 7 Sending progress message: 2.55%
 8 Transfering is in progress.
 9 Current transfered: 751479 bytes
10 Sending progress message: 19.53%
11 Transfering is in progress.
12 Current transfered: 1078209 bytes
13 Sending progress message: 28.02%
14 ......
15 Transfering is in progress.
16 Current transfered: 3430665 bytes
17 Sending progress message: 89.15%
18 transfering end.
19 Transfering done. Cancel timer.
20 Try to stop progress monitor.
21 Progress monitor stoped.

logs

现在，程序每隔5秒钟才会打印一下进度信息。可以修改FileProgressMonitor类里的progressInterval变量的值，来修改默认的间隔时间。