码迷，mamicode.com
首页 > 编程语言 > 详细

文件系统之-JAVA Sftp远程操作:

时间：2017-09-14 13:30:23      阅读：263      评论：0      收藏：0      [点我收藏+]

标签：use   sdn   keyword   成员   tail   执行   string   http   inux   

转载：http://blog.csdn.net/lee272616/article/details/52789018

java远程操作文件服务器(linux)，使用sftp协议
版本会持续更新，
当前版本：0.31
版本更新时间：2016-10-13
版本修正说明：
1.修正连接关闭，将关闭的方法改成私有，不允许使用者自行关闭（否则会导致连接池获取错误）

2.优化删除文件及文件夹，先判断文件或文件夹是否存在，然后再删除

前言：

sftp是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供一种安全的加密方法。sftp 与 ftp 有着几乎一样的语法和功能。SFTP 为 SSH的一部分，是一种传输档案至 Blogger 伺服器的安全方式。其实在SSH软件包中，已经包含了一个叫作SFTP(Secure File Transfer Protocol)的安全文件传输子系统，SFTP本身没有单独的守护进程，它必须使用sshd守护进程（端口号默认是22）来完成相应的连接操作，所以从某种意义上来说，SFTP并不像一个服务器程序，而更像是一个客户端程序。SFTP同样是使用加密传输认证信息和传输的数据，所以，使用SFTP是非常安全的。但是，由于这种传输方式使用了加密/解密技术，所以传输效率比普通的FTP要低得多，如果您对网络安全性要求更高时，可以使用SFTP代替FTP。

本工具基于对JSch - Java Secure Channel进行的封装，linux服务器不用安装任何插件和软件

 

使用指南：

首先是jar包

 

[html] view plain copy
 
  1. <dependency>  
  2.   <groupId>com.jcraft</groupId>  
  3.   <artifactId>jsch</artifactId>  
  4.   <version>0.1.42</version>  
  5. </dependency>  

 

Sftp协议工具类-v0.1

 

[java] view plain copy
 
  1. package com.noryar.filesystem.utils;  
  2.   
  3. import java.io.ByteArrayOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileOutputStream;  
  6. import java.util.ArrayList;  
  7. import java.util.List;  
  8. import java.util.Properties;  
  9. import java.util.Vector;  
  10.   
  11. import org.apache.commons.lang.StringUtils;  
  12.   
  13. import com.jcraft.jsch.Channel;  
  14. import com.jcraft.jsch.ChannelSftp;  
  15. import com.jcraft.jsch.JSch;  
  16. import com.jcraft.jsch.JSchException;  
  17. import com.jcraft.jsch.Session;  
  18. import com.jcraft.jsch.SftpException;  
  19.   
  20. /** 
  21.  * 文件工具类. 
  22.  * @author Leon Lee 
  23.  */  
  24. public class SftpUtil {  
  25.   
  26.     /** 
  27.      * 文件路径前缀. /ddit-remote 
  28.      */  
  29.     private static final String PRE_FIX = "/test-noryar";  
  30.   
  31.     /** 
  32.      * 获取sftp协议连接. 
  33.      * @param host 主机名 
  34.      * @param port 端口 
  35.      * @param username 用户名 
  36.      * @param password 密码 
  37.      * @return 连接对象 
  38.      * @throws JSchException 异常 
  39.      */  
  40.     public static ChannelSftp getSftpConnect(final String host, final int port, final String username,  
  41.             final String password) throws JSchException {  
  42.         ChannelSftp sftp = null;  
  43.         JSch jsch = new JSch();  
  44.         jsch.getSession(username, host, port);  
  45.         Session sshSession = jsch.getSession(username, host, port);  
  46.         sshSession.setPassword(password);  
  47.         Properties sshConfig = new Properties();  
  48.         sshConfig.put("StrictHostKeyChecking", "no");  
  49.         sshSession.setConfig(sshConfig);  
  50.         sshSession.connect();  
  51.         Channel channel = sshSession.openChannel("sftp");  
  52.         channel.connect();  
  53.         sftp = (ChannelSftp) channel;  
  54.         return sftp;  
  55.     }  
  56.   
  57.     /** 
  58.      * 下载文件-sftp协议. 
  59.      * @param downloadFile 下载的文件 
  60.      * @param saveFile 存在本地的路径 
  61.      * @param sftp sftp连接 
  62.      * @return 文件 
  63.      * @throws Exception 异常 
  64.      */  
  65.     public static File download(final String downloadFile, final String saveFile, final ChannelSftp sftp)  
  66.             throws Exception {  
  67.         FileOutputStream os = null;  
  68.         File file = new File(saveFile);  
  69.         try {  
  70.             if (!file.exists()) {  
  71.                 File parentFile = file.getParentFile();  
  72.                 if (!parentFile.exists()) {  
  73.                     parentFile.mkdirs();  
  74.                 }  
  75.                 file.createNewFile();  
  76.             }  
  77.             os = new FileOutputStream(file);  
  78.             List<String> list = formatPath(downloadFile);  
  79.             sftp.get(list.get(0) + list.get(1), os);  
  80.         } catch (Exception e) {  
  81.             exit(sftp);  
  82.             throw e;  
  83.         } finally {  
  84.             os.close();  
  85.         }  
  86.         return file;  
  87.     }  
  88.   
  89.     /** 
  90.      * 下载文件-sftp协议. 
  91.      * @param downloadFile 下载的文件 
  92.      * @param saveFile 存在本地的路径 
  93.      * @param sftp sftp连接 
  94.      * @return 文件 byte[] 
  95.      * @throws Exception 异常 
  96.      */  
  97.     public static byte[] downloadAsByte(final String downloadFile, final ChannelSftp sftp) throws Exception {  
  98.         ByteArrayOutputStream os = new ByteArrayOutputStream();  
  99.         try {  
  100.             List<String> list = formatPath(downloadFile);  
  101.             sftp.get(list.get(0) + list.get(1), os);  
  102.         } catch (Exception e) {  
  103.             exit(sftp);  
  104.             throw e;  
  105.         } finally {  
  106.             os.close();  
  107.         }  
  108.         return os.toByteArray();  
  109.     }  
  110.   
  111.     /** 
  112.      * 删除文件-sftp协议. 
  113.      * @param deleteFile 要删除的文件 
  114.      * @param sftp sftp连接 
  115.      * @throws Exception 异常 
  116.      */  
  117.     public static void rmFile(final String deleteFile, final ChannelSftp sftp) throws Exception {  
  118.         try {  
  119.             sftp.rm(deleteFile);  
  120.         } catch (Exception e) {  
  121.             exit(sftp);  
  122.             throw e;  
  123.         }  
  124.     }  
  125.   
  126.     /** 
  127.      * 删除文件夹-sftp协议. 
  128.      * @param deleteFile 文件夹路径 
  129.      * @param sftp sftp连接 
  130.      * @throws Exception 异常 
  131.      */  
  132.     public static void rmDir(final String pathString, final ChannelSftp sftp) throws Exception {  
  133.         try {  
  134.             sftp.rmdir(pathString);  
  135.         } catch (Exception e) {  
  136.             exit(sftp);  
  137.             throw e;  
  138.         }  
  139.     }  
  140.   
  141.     /** 
  142.      * 上传文件-sftp协议. 
  143.      * @param srcFile 源文件 
  144.      * @param dir 保存路径 
  145.      * @param fileName 保存文件名 
  146.      * @param sftp sftp连接 
  147.      * @throws Exception 异常 
  148.      */  
  149.     private static void uploadFile(final String srcFile, final String dir, final String fileName, final ChannelSftp sftp)  
  150.             throws Exception {  
  151.         mkdir(dir, sftp);  
  152.         sftp.cd(dir);  
  153.         sftp.put(srcFile, fileName);  
  154.     }  
  155.   
  156.     /** 
  157.      * 上传文件-sftp协议. 
  158.      * @param srcFile 源文件路径，/xxx/xxx.zip 或 x:/xxx/xxx.zip; 
  159.      * @param sftp sftp连接 
  160.      * @throws Exception 异常 
  161.      */  
  162.     public static void uploadFile(final String srcFile, final ChannelSftp sftp) throws Exception {  
  163.         try {  
  164.             File file = new File(srcFile);  
  165.             if (file.exists()) {  
  166.                 List<String> list = formatPath(srcFile);  
  167.                 uploadFile(srcFile, list.get(0), list.get(1), sftp);  
  168.             }  
  169.         } catch (Exception e) {  
  170.             exit(sftp);  
  171.             throw e;  
  172.         }  
  173.     }  
  174.   
  175.     /** 
  176.      * 根据路径创建文件夹. 
  177.      * @param dir 路径 必须是 /xxx/xxx/xxx/ 不能就单独一个/ 
  178.      * @param sftp sftp连接 
  179.      * @throws Exception 异常 
  180.      */  
  181.     public static boolean mkdir(final String dir, final ChannelSftp sftp) throws Exception {  
  182.         try {  
  183.             if (StringUtils.isBlank(dir))  
  184.                 return false;  
  185.             String md = dir.replaceAll("\\\\", "/");  
  186.             if (md.indexOf("/") != 0 || md.length() == 1)  
  187.                 return false;  
  188.             return mkdirs(md, sftp);  
  189.         } catch (Exception e) {  
  190.             exit(sftp);  
  191.             throw e;  
  192.         }  
  193.     }  
  194.   
  195.     /** 
  196.      * 递归创建文件夹. 
  197.      * @param dir 路径 
  198.      * @param sftp sftp连接 
  199.      * @return 是否创建成功 
  200.      * @throws SftpException 异常 
  201.      */  
  202.     private static boolean mkdirs(final String dir, final ChannelSftp sftp) throws SftpException {  
  203.         String dirs = dir.substring(1, dir.length() - 1);  
  204.         String[] dirArr = dirs.split("/");  
  205.         String base = "";  
  206.         for (String d : dirArr) {  
  207.             base += "/" + d;  
  208.             if (dirExist(base + "/", sftp)) {  
  209.                 continue;  
  210.             } else {  
  211.                 sftp.mkdir(base + "/");  
  212.             }  
  213.         }  
  214.         return true;  
  215.     }  
  216.   
  217.     /** 
  218.      * 判断文件夹是否存在. 
  219.      * @param dir 文件夹路径， /xxx/xxx/ 
  220.      * @param sftp sftp协议 
  221.      * @return 是否存在 
  222.      */  
  223.     public static boolean dirExist(final String dir, final ChannelSftp sftp) {  
  224.         try {  
  225.             Vector<?> vector = sftp.ls(dir);  
  226.             if (null == vector)  
  227.                 return false;  
  228.             else  
  229.                 return true;  
  230.         } catch (SftpException e) {  
  231.             return false;  
  232.         }  
  233.     }  
  234.   
  235.     /** 
  236.      * 格式化路径. 
  237.      * @param srcPath 原路径. /xxx/xxx/xxx.yyy 或 X:/xxx/xxx/xxx.yy 
  238.      * @return list, 第一个是路径（/xxx/xxx/）,第二个是文件名（xxx.yy） 
  239.      */  
  240.     public static List<String> formatPath(final String srcPath) {  
  241.         List<String> list = new ArrayList<String>(2);  
  242.         String dir = "";  
  243.         String fileName = "";  
  244.         String repSrc = srcPath.replaceAll("\\\\", "/");  
  245.         int firstP = repSrc.indexOf("/");  
  246.         int lastP = repSrc.lastIndexOf("/");  
  247.         fileName = repSrc.substring(lastP + 1);  
  248.         dir = repSrc.substring(firstP, lastP);  
  249.         dir = PRE_FIX + (dir.length() == 1 ? dir : (dir + "/"));  
  250.         list.add(dir);  
  251.         list.add(fileName);  
  252.         return list;  
  253.     }  
  254.   
  255.     /** 
  256.      * 关闭协议-sftp协议. 
  257.      * @param sftp sftp连接 
  258.      */  
  259.     public static void exit(final ChannelSftp sftp) {  
  260.         sftp.exit();  
  261.     }  
  262.   
  263.     public static void main(String[] args) throws Exception {  
  264.         ChannelSftp sftp = getSftpConnect("192.168.0.35", 22, "root", "root");  
  265.         String pathString = "C:\\test\\aaa\\Foxmail7.zip";  
  266.         File file = new File(pathString);  
  267.         System.out.println("上传文件开始...");  
  268.         uploadFile(pathString, sftp);  
  269.         System.out.println("上传成功，开始删除本地文件...");  
  270.         file.delete();  
  271.         System.out.println("删除完成，开始校验本地文件...");  
  272.         if (!file.exists()) {  
  273.             System.out.println("文件不存在，开始从远程服务器获取...");  
  274.             download(pathString, pathString, sftp);  
  275.             System.out.println("下载完成");  
  276.         } else {  
  277.             System.out.println("在本地找到文件");  
  278.         }  
  279.         exit(sftp);  
  280.         System.exit(0);  
  281.     }  
  282. }  

v0.2-新增sftp连接池

由于创建sftp连接的花销比较大，因此考虑相同主机的连接存放在连接池中，下次获取sftp连接的时候直接去连接池获取
以下代码替换v0.1版的getSftpConnect()方法，并加上成员变量即可
[java] view plain copy
 
  1. /** 
  2.  * sftp连接池. 
  3.  */  
  4. private static final Map<String, Channel> SFTP_CHANNEL_POOL = new HashMap<String, Channel>();  
  5.   
  6. /** 
  7.  * 获取sftp协议连接. 
  8.  * @param host 主机名 
  9.  * @param port 端口 
  10.  * @param username 用户名 
  11.  * @param password 密码 
  12.  * @return 连接对象 
  13.  * @throws JSchException 异常 
  14.  */  
  15. public static ChannelSftp getSftpConnect(final String host, final int port, final String username,  
  16.         final String password) throws JSchException {  
  17.     Session sshSession = null;  
  18.     Channel channel = null;  
  19.     ChannelSftp sftp = null;  
  20.     String key = host + "," + port + "," + username + "," + password;  
  21.     if (null == SFTP_CHANNEL_POOL.get(key)) {  
  22.         JSch jsch = new JSch();  
  23.         jsch.getSession(username, host, port);  
  24.         sshSession = jsch.getSession(username, host, port);  
  25.         sshSession.setPassword(password);  
  26.         Properties sshConfig = new Properties();  
  27.         sshConfig.put("StrictHostKeyChecking", "no");  
  28.         sshSession.setConfig(sshConfig);  
  29.         sshSession.connect();  
  30.         channel = sshSession.openChannel("sftp");  
  31.         channel.connect();  
  32.         SFTP_CHANNEL_POOL.put(key, channel);  
  33.     } else {  
  34.         channel = SFTP_CHANNEL_POOL.get(key);  
  35.         sshSession = channel.getSession();  
  36.         if (!sshSession.isConnected())  
  37.             sshSession.connect();  
  38.         if (!channel.isConnected())  
  39.             channel.connect();  
  40.     }  
  41.     sftp = (ChannelSftp) channel;  
  42.     return sftp;  
  43. }  

v0.3-修改了一些bug，新增递归删除文件夹功能

[java] view plain copy
 
  1. package com.noryar.filesystem.utils;  
  2.   
  3. import java.io.ByteArrayOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileOutputStream;  
  6. import java.util.ArrayList;  
  7. import java.util.HashMap;  
  8. import java.util.List;  
  9. import java.util.Map;  
  10. import java.util.Properties;  
  11. import java.util.Vector;  
  12.   
  13. import org.apache.commons.lang.StringUtils;  
  14.   
  15. import com.jcraft.jsch.Channel;  
  16. import com.jcraft.jsch.ChannelSftp;  
  17. import com.jcraft.jsch.ChannelSftp.LsEntry;  
  18. import com.jcraft.jsch.JSch;  
  19. import com.jcraft.jsch.JSchException;  
  20. import com.jcraft.jsch.Session;  
  21. import com.jcraft.jsch.SftpException;  
  22.   
  23. /** 
  24.  * 文件工具类.<br> 
  25.  * 1.所有的文件路径必须以‘/‘开头和结尾，否则路径最后一部分会被当做是文件名<br> 
  26.  * 2.方法出现异常的时候，会关闭sftp连接（但是不会关闭session和channel），异常会抛出 
  27.  * @author Leon Lee 
  28.  */  
  29. public class SftpUtil {  
  30.   
  31.     /** 
  32.      * 文件路径前缀. /ddit-remote 
  33.      */  
  34.     private static final String PRE_FIX = "/test-noryar";  
  35.   
  36.     /** 
  37.      * sftp连接池. 
  38.      */  
  39.     private static final Map<String, Channel> SFTP_CHANNEL_POOL = new HashMap<String, Channel>();  
  40.   
  41.     /** 
  42.      * 获取sftp协议连接. 
  43.      * @param host 主机名 
  44.      * @param port 端口 
  45.      * @param username 用户名 
  46.      * @param password 密码 
  47.      * @return 连接对象 
  48.      * @throws JSchException 异常 
  49.      */  
  50.     public static ChannelSftp getSftpConnect(final String host, final int port, final String username,  
  51.             final String password) throws JSchException {  
  52.         Session sshSession = null;  
  53.         Channel channel = null;  
  54.         ChannelSftp sftp = null;  
  55.         String key = host + "," + port + "," + username + "," + password;  
  56.         if (null == SFTP_CHANNEL_POOL.get(key)) {  
  57.             JSch jsch = new JSch();  
  58.             jsch.getSession(username, host, port);  
  59.             sshSession = jsch.getSession(username, host, port);  
  60.             sshSession.setPassword(password);  
  61.             Properties sshConfig = new Properties();  
  62.             sshConfig.put("StrictHostKeyChecking", "no");  
  63.             sshSession.setConfig(sshConfig);  
  64.             sshSession.connect();  
  65.             channel = sshSession.openChannel("sftp");  
  66.             channel.connect();  
  67.             SFTP_CHANNEL_POOL.put(key, channel);  
  68.         } else {  
  69.             channel = SFTP_CHANNEL_POOL.get(key);  
  70.             sshSession = channel.getSession();  
  71.             if (!sshSession.isConnected())  
  72.                 sshSession.connect();  
  73.             if (!channel.isConnected())  
  74.                 channel.connect();  
  75.         }  
  76.         sftp = (ChannelSftp) channel;  
  77.         return sftp;  
  78.     }  
  79.   
  80.     /** 
  81.      * 下载文件-sftp协议. 
  82.      * @param downloadFile 下载的文件 
  83.      * @param saveFile 存在本地的路径 
  84.      * @param sftp sftp连接 
  85.      * @return 文件 
  86.      * @throws Exception 异常 
  87.      */  
  88.     public static File download(final String downloadFile, final String saveFile, final ChannelSftp sftp)  
  89.             throws Exception {  
  90.         FileOutputStream os = null;  
  91.         File file = new File(saveFile);  
  92.         try {  
  93.             if (!file.exists()) {  
  94.                 File parentFile = file.getParentFile();  
  95.                 if (!parentFile.exists()) {  
  96.                     parentFile.mkdirs();  
  97.                 }  
  98.                 file.createNewFile();  
  99.             }  
  100.             os = new FileOutputStream(file);  
  101.             List<String> list = formatPath(downloadFile);  
  102.             sftp.get(list.get(0) + list.get(1), os);  
  103.         } catch (Exception e) {  
  104.             exit(sftp);  
  105.             e.getMessage();  
  106.             throw e;  
  107.         } finally {  
  108.             os.close();  
  109.         }  
  110.         return file;  
  111.     }  
  112.   
  113.     /** 
  114.      * 下载文件-sftp协议. 
  115.      * @param downloadFile 下载的文件 
  116.      * @param saveFile 存在本地的路径 
  117.      * @param sftp sftp连接 
  118.      * @return 文件 byte[] 
  119.      * @throws Exception 异常 
  120.      */  
  121.     public static byte[] downloadAsByte(final String downloadFile, final ChannelSftp sftp) throws Exception {  
  122.         ByteArrayOutputStream os = new ByteArrayOutputStream();  
  123.         try {  
  124.             List<String> list = formatPath(downloadFile);  
  125.             sftp.get(list.get(0) + list.get(1), os);  
  126.         } catch (Exception e) {  
  127.             exit(sftp);  
  128.             throw e;  
  129.         } finally {  
  130.             os.close();  
  131.         }  
  132.         return os.toByteArray();  
  133.     }  
  134.   
  135.     /** 
  136.      * 删除文件-sftp协议. 
  137.      * @param pathString 要删除的文件 
  138.      * @param sftp sftp连接 
  139.      * @throws Exception 异常 
  140.      */  
  141.     public static void rmFile(final String pathString, final ChannelSftp sftp) throws Exception {  
  142.         try {  
  143.             List<String> list = formatPath(pathString);  
  144.             sftp.rm(list.get(0) + list.get(1));  
  145.         } catch (Exception e) {  
  146.             exit(sftp);  
  147.             throw e;  
  148.         }  
  149.     }  
  150.   
  151.     /** 
  152.      * 删除文件夹-sftp协议.如果文件夹有内容，则会抛出异常. 
  153.      * @param pathString 文件夹路径 
  154.      * @param sftp sftp连接 
  155.      * @param resursion 递归删除 
  156.      * @throws Exception 异常 
  157.      */  
  158.     public static void rmDir(final String pathString, final ChannelSftp sftp, final boolean recursion) throws Exception {  
  159.         try {  
  160.             String fp = formatPath(pathString).get(0);  
  161.             if (recursion)  
  162.                 exeRmRec(fp, sftp);  
  163.             else  
  164.                 sftp.rmdir(fp);  
  165.         } catch (Exception e) {  
  166.             exit(sftp);  
  167.             throw e;  
  168.         }  
  169.     }  
  170.   
  171.     /** 
  172.      * 递归删除执行. 
  173.      * @param pathString 文件路径 
  174.      * @param sftp sftp连接 
  175.      * @throws SftpException 
  176.      */  
  177.     private static void exeRmRec(final String pathString, final ChannelSftp sftp) throws SftpException {  
  178.         @SuppressWarnings("unchecked")  
  179.         Vector<LsEntry> vector = sftp.ls(pathString);  
  180.         if (vector.size() == 1) { // 文件，直接删除  
  181.             sftp.rm(pathString);  
  182.         } else if (vector.size() == 2) { // 空文件夹，直接删除  
  183.             sftp.rmdir(pathString);  
  184.         } else {  
  185.             String fileName = "";  
  186.             // 删除文件夹下所有文件  
  187.             for (LsEntry en : vector) {  
  188.                 fileName = en.getFilename();  
  189.                 if (".".equals(fileName) || "..".equals(fileName)) {  
  190.                     continue;  
  191.                 } else {  
  192.                     exeRmRec(pathString + "/" + fileName, sftp);  
  193.                 }  
  194.             }  
  195.             // 删除文件夹  
  196.             sftp.rmdir(pathString);  
  197.         }  
  198.     }  
  199.   
  200.     /** 
  201.      * 上传文件-sftp协议. 
  202.      * @param srcFile 源文件 
  203.      * @param dir 保存路径 
  204.      * @param fileName 保存文件名 
  205.      * @param sftp sftp连接 
  206.      * @throws Exception 异常 
  207.      */  
  208.     private static void uploadFile(final String srcFile, final String dir, final String fileName, final ChannelSftp sftp)  
  209.             throws Exception {  
  210.         mkdir(dir, sftp);  
  211.         sftp.cd(dir);  
  212.         sftp.put(srcFile, fileName);  
  213.     }  
  214.   
  215.     /** 
  216.      * 上传文件-sftp协议. 
  217.      * @param srcFile 源文件路径，/xxx/xx.yy 或 x:/xxx/xxx.yy 
  218.      * @param sftp sftp连接 
  219.      * @return 上传成功与否 
  220.      * @throws Exception 异常 
  221.      */  
  222.     public static boolean uploadFile(final String srcFile, final ChannelSftp sftp) throws Exception {  
  223.         try {  
  224.             File file = new File(srcFile);  
  225.             if (file.exists()) {  
  226.                 List<String> list = formatPath(srcFile);  
  227.                 uploadFile(srcFile, list.get(0), list.get(1), sftp);  
  228.                 return true;  
  229.             }  
  230.             return false;  
  231.         } catch (Exception e) {  
  232.             exit(sftp);  
  233.             throw e;  
  234.         }  
  235.     }  
  236.   
  237.     /** 
  238.      * 根据路径创建文件夹. 
  239.      * @param dir 路径 必须是 /xxx/xxx/ 不能就单独一个/ 
  240.      * @param sftp sftp连接 
  241.      * @throws Exception 异常 
  242.      */  
  243.     public static boolean mkdir(final String dir, final ChannelSftp sftp) throws Exception {  
  244.         try {  
  245.             if (StringUtils.isBlank(dir))  
  246.                 return false;  
  247.             String md = dir.replaceAll("\\\\", "/");  
  248.             if (md.indexOf("/") != 0 || md.length() == 1)  
  249.                 return false;  
  250.             return mkdirs(md, sftp);  
  251.         } catch (Exception e) {  
  252.             exit(sftp);  
  253.             throw e;  
  254.         }  
  255.     }  
  256.   
  257.     /** 
  258.      * 递归创建文件夹. 
  259.      * @param dir 路径 
  260.      * @param sftp sftp连接 
  261.      * @return 是否创建成功 
  262.      * @throws SftpException 异常 
  263.      */  
  264.     private static boolean mkdirs(final String dir, final ChannelSftp sftp) throws SftpException {  
  265.         String dirs = dir.substring(1, dir.length() - 1);  
  266.         String[] dirArr = dirs.split("/");  
  267.         String base = "";  
  268.         for (String d : dirArr) {  
  269.             base += "/" + d;  
  270.             if (dirExist(base + "/", sftp)) {  
  271.                 continue;  
  272.             } else {  
  273.                 sftp.mkdir(base + "/");  
  274.             }  
  275.         }  
  276.         return true;  
  277.     }  
  278.   
  279.     /** 
  280.      * 判断文件夹是否存在. 
  281.      * @param dir 文件夹路径， /xxx/xxx/ 
  282.      * @param sftp sftp协议 
  283.      * @return 是否存在 
  284.      */  
  285.     private static boolean dirExist(final String dir, final ChannelSftp sftp) {  
  286.         try {  
  287.             Vector<?> vector = sftp.ls(dir);  
  288.             if (null == vector)  
  289.                 return false;  
  290.             else  
  291.                 return true;  
  292.         } catch (SftpException e) {  
  293.             return false;  
  294.         }  
  295.     }  
  296.   
  297.     /** 
  298.      * 格式化路径. 
  299.      * @param srcPath 原路径. /xxx/xxx/xxx.yyy 或 X:/xxx/xxx/xxx.yy 
  300.      * @return list, 第一个是路径（/xxx/xxx/）,第二个是文件名（xxx.yy） 
  301.      */  
  302.     public static List<String> formatPath(final String srcPath) {  
  303.         List<String> list = new ArrayList<String>(2);  
  304.         String repSrc = srcPath.replaceAll("\\\\", "/");  
  305.         int firstP = repSrc.indexOf("/");  
  306.         int lastP = repSrc.lastIndexOf("/");  
  307.         String fileName = lastP + 1 == repSrc.length() ? "" : repSrc.substring(lastP + 1);  
  308.         String dir = firstP == -1 ? "" : repSrc.substring(firstP, lastP);  
  309.         dir = PRE_FIX + (dir.length() == 1 ? dir : (dir + "/"));  
  310.         list.add(dir);  
  311.         list.add(fileName);  
  312.         return list;  
  313.     }  
  314.   
  315.     /** 
  316.      * 关闭协议-sftp协议. 
  317.      * @param sftp sftp连接 
  318.      */  
  319.     public static void exit(final ChannelSftp sftp) {  
  320.         sftp.exit();  
  321.     }  
  322.   
  323.     public static void main(String[] args) throws Exception {  
  324.         ChannelSftp sftp = getSftpConnect("192.168.0.35", 22, "root", "root");  
  325.         // String pathString = "C:\\test\\ccc\\Foxmail7.zip";  
  326.         // File file = new File(pathString);  
  327.         // System.out.println("上传文件开始...");  
  328.         // uploadFile(pathString, sftp);  
  329.         // System.out.println("上传成功，开始删除本地文件...");  
  330.         // file.delete();  
  331.         // System.out.println("删除完成，开始校验本地文件...");  
  332.         // if (!file.exists()) {  
  333.         // System.out.println("文件不存在，开始从远程服务器获取...");  
  334.         // download(pathString, pathString, sftp);  
  335.         // System.out.println("下载完成");  
  336.         // } else {  
  337.         // System.out.println("在本地找到文件");  
  338.         // }  
  339.         rmDir("", sftp, true);  
  340.         exit(sftp);  
  341.         System.exit(0);  
  342.     }  
  343. }  

v0.31

修正连接关闭，将关闭的方法改成私有，不允许使用者自行关闭（否则会导致连接池获取错误）
优化删除文件及文件夹，先判断文件或文件夹是否存在，然后再删除
[java] view plain copy
 
  1. package com.noryar.filesystem.utils;  
  2.   
  3. import java.io.ByteArrayOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileOutputStream;  
  6. import java.util.ArrayList;  
  7. import java.util.HashMap;  
  8. import java.util.List;  
  9. import java.util.Map;  
  10. import java.util.Properties;  
  11. import java.util.Vector;  
  12.   
  13. import org.apache.commons.lang.StringUtils;  
  14.   
  15. import com.jcraft.jsch.Channel;  
  16. import com.jcraft.jsch.ChannelSftp;  
  17. import com.jcraft.jsch.ChannelSftp.LsEntry;  
  18. import com.jcraft.jsch.JSch;  
  19. import com.jcraft.jsch.JSchException;  
  20. import com.jcraft.jsch.Session;  
  21. import com.jcraft.jsch.SftpException;  
  22.   
  23. /** 
  24.  * 文件工具类.<br> 
  25.  * 1.所有的文件路径必须以‘/‘开头和结尾，否则路径最后一部分会被当做是文件名<br> 
  26.  * 2. @since version-0.3 方法出现异常的时候，<del>会关闭sftp连接(但是不会关闭session和channel)</del>(del @ version 0.31)，异常会抛出<br> 
  27.  * @author Leon Lee 
  28.  */  
  29. public class SftpUtil {  
  30.   
  31.     /** 
  32.      * 文件路径前缀. /ddit-remote 
  33.      */  
  34.     private static final String PRE_FIX = "/test-noryar";  
  35.   
  36.     /** 
  37.      * sftp连接池. 
  38.      */  
  39.     private static final Map<String, Channel> SFTP_CHANNEL_POOL = new HashMap<String, Channel>();  
  40.   
  41.     /** 
  42.      * 获取sftp协议连接. 
  43.      * @param host 主机名 
  44.      * @param port 端口 
  45.      * @param username 用户名 
  46.      * @param password 密码 
  47.      * @return 连接对象 
  48.      * @throws JSchException 异常 
  49.      */  
  50.     public static ChannelSftp getSftpConnect(final String host, final int port, final String username,  
  51.             final String password) throws JSchException {  
  52.         Session sshSession = null;  
  53.         Channel channel = null;  
  54.         ChannelSftp sftp = null;  
  55.         String key = host + "," + port + "," + username + "," + password;  
  56.         if (null == SFTP_CHANNEL_POOL.get(key)) {  
  57.             JSch jsch = new JSch();  
  58.             jsch.getSession(username, host, port);  
  59.             sshSession = jsch.getSession(username, host, port);  
  60.             sshSession.setPassword(password);  
  61.             Properties sshConfig = new Properties();  
  62.             sshConfig.put("StrictHostKeyChecking", "no");  
  63.             sshSession.setConfig(sshConfig);  
  64.             sshSession.connect();  
  65.             channel = sshSession.openChannel("sftp");  
  66.             channel.connect();  
  67.             SFTP_CHANNEL_POOL.put(key, channel);  
  68.         } else {  
  69.             channel = SFTP_CHANNEL_POOL.get(key);  
  70.             sshSession = channel.getSession();  
  71.             if (!sshSession.isConnected())  
  72.                 sshSession.connect();  
  73.             if (!channel.isConnected())  
  74.                 channel.connect();  
  75.         }  
  76.         sftp = (ChannelSftp) channel;  
  77.         return sftp;  
  78.     }  
  79.   
  80.     /** 
  81.      * 下载文件-sftp协议. 
  82.      * @param downloadFile 下载的文件 
  83.      * @param saveFile 存在本地的路径 
  84.      * @param sftp sftp连接 
  85.      * @return 文件 
  86.      * @throws Exception 异常 
  87.      */  
  88.     public static File download(final String downloadFile, final String saveFile, final ChannelSftp sftp)  
  89.             throws Exception {  
  90.         FileOutputStream os = null;  
  91.         File file = new File(saveFile);  
  92.         try {  
  93.             if (!file.exists()) {  
  94.                 File parentFile = file.getParentFile();  
  95.                 if (!parentFile.exists()) {  
  96.                     parentFile.mkdirs();  
  97.                 }  
  98.                 file.createNewFile();  
  99.             }  
  100.             os = new FileOutputStream(file);  
  101.             List<String> list = formatPath(downloadFile);  
  102.             sftp.get(list.get(0) + list.get(1), os);  
  103.         } catch (Exception e) {  
  104.             throw e;  
  105.         } finally {  
  106.             os.close();  
  107.         }  
  108.         return file;  
  109.     }  
  110.   
  111.     /** 
  112.      * 下载文件-sftp协议. 
  113.      * @param downloadFile 下载的文件 
  114.      * @param saveFile 存在本地的路径 
  115.      * @param sftp sftp连接 
  116.      * @return 文件 byte[] 
  117.      * @throws Exception 异常 
  118.      */  
  119.     public static byte[] downloadAsByte(final String downloadFile, final ChannelSftp sftp) throws Exception {  
  120.         ByteArrayOutputStream os = new ByteArrayOutputStream();  
  121.         try {  
  122.             List<String> list = formatPath(downloadFile);  
  123.             sftp.get(list.get(0) + list.get(1), os);  
  124.         } catch (Exception e) {  
  125.             throw e;  
  126.         } finally {  
  127.             os.close();  
  128.         }  
  129.         return os.toByteArray();  
  130.     }  
  131.   
  132.     /** 
  133.      * 删除文件-sftp协议. 
  134.      * @param pathString 要删除的文件 
  135.      * @param sftp sftp连接 
  136.      * @throws SftpException 异常 
  137.      */  
  138.     public static void rmFile(final String pathString, final ChannelSftp sftp) throws SftpException {  
  139.         List<String> list = formatPath(pathString);  
  140.         String dir = list.get(0);  
  141.         String file = list.get(1);  
  142.         if (dirExist(dir + file, sftp)) {  
  143.             sftp.rm(list.get(0) + list.get(1));  
  144.         }  
  145.     }  
  146.   
  147.     /** 
  148.      * 删除文件夹-sftp协议.如果文件夹有内容，则会抛出异常. 
  149.      * @param pathString 文件夹路径 
  150.      * @param sftp sftp连接 
  151.      * @param resursion 递归删除 
  152.      * @throws SftpException 异常 
  153.      */  
  154.     public static void rmDir(final String pathString, final ChannelSftp sftp, final boolean recursion)  
  155.             throws SftpException {  
  156.         String fp = formatPath(pathString).get(0);  
  157.         if (dirExist(fp, sftp)) {  
  158.             if (recursion)  
  159.                 exeRmRec(fp, sftp);  
  160.             else  
  161.                 sftp.rmdir(fp);  
  162.         }  
  163.     }  
  164.   
  165.     /** 
  166.      * 递归删除执行. 
  167.      * @param pathString 文件路径 
  168.      * @param sftp sftp连接 
  169.      * @throws SftpException 
  170.      */  
  171.     private static void exeRmRec(final String pathString, final ChannelSftp sftp) throws SftpException {  
  172.         @SuppressWarnings("unchecked")  
  173.         Vector<LsEntry> vector = sftp.ls(pathString);  
  174.         if (vector.size() == 1) { // 文件，直接删除  
  175.             sftp.rm(pathString);  
  176.         } else if (vector.size() == 2) { // 空文件夹，直接删除  
  177.             sftp.rmdir(pathString);  
  178.         } else {  
  179.             String fileName = "";  
  180.             // 删除文件夹下所有文件  
  181.             for (LsEntry en : vector) {  
  182.                 fileName = en.getFilename();  
  183.                 if (".".equals(fileName) || "..".equals(fileName)) {  
  184.                     continue;  
  185.                 } else {  
  186.                     exeRmRec(pathString + "/" + fileName, sftp);  
  187.                 }  
  188.             }  
  189.             // 删除文件夹  
  190.             sftp.rmdir(pathString);  
  191.         }  
  192.     }  
  193.   
  194.     /** 
  195.      * 上传文件-sftp协议. 
  196.      * @param srcFile 源文件 
  197.      * @param dir 保存路径 
  198.      * @param fileName 保存文件名 
  199.      * @param sftp sftp连接 
  200.      * @throws Exception 异常 
  201.      */  
  202.     private static void uploadFile(final String srcFile, final String dir, final String fileName, final ChannelSftp sftp)  
  203.             throws SftpException {  
  204.         mkdir(dir, sftp);  
  205.         sftp.cd(dir);  
  206.         sftp.put(srcFile, fileName);  
  207.     }  
  208.   
  209.     /** 
  210.      * 上传文件-sftp协议. 
  211.      * @param srcFile 源文件路径，/xxx/xx.yy 或 x:/xxx/xxx.yy 
  212.      * @param sftp sftp连接 
  213.      * @return 上传成功与否 
  214.      * @throws SftpException 异常 
  215.      */  
  216.     public static boolean uploadFile(final String srcFile, final ChannelSftp sftp) throws SftpException {  
  217.         File file = new File(srcFile);  
  218.         if (file.exists()) {  
  219.             List<String> list = formatPath(srcFile);  
  220.             uploadFile(srcFile, list.get(0), list.get(1), sftp);  
  221.             return true;  
  222.         }  
  223.         return false;  
  224.     }  
  225.   
  226.     /** 
  227.      * 根据路径创建文件夹. 
  228.      * @param dir 路径 必须是 /xxx/xxx/ 不能就单独一个/ 
  229.      * @param sftp sftp连接 
  230.      * @throws SftpException 异常 
  231.      */  
  232.     public static boolean mkdir(final String dir, final ChannelSftp sftp) throws SftpException {  
  233.         if (StringUtils.isBlank(dir))  
  234.             return false;  
  235.         String md = dir.replaceAll("\\\\", "/");  
  236.         if (md.indexOf("/") != 0 || md.length() == 1)  
  237.             return false;  
  238.         return mkdirs(md, sftp);  
  239.     }  
  240.   
  241.     /** 
  242.      * 递归创建文件夹. 
  243.      * @param dir 路径 
  244.      * @param sftp sftp连接 
  245.      * @return 是否创建成功 
  246.      * @throws SftpException 异常 
  247.      */  
  248.     private static boolean mkdirs(final String dir, final ChannelSftp sftp) throws SftpException {  
  249.         String dirs = dir.substring(1, dir.length() - 1);  
  250.         String[] dirArr = dirs.split("/");  
  251.         String base = "";  
  252.         for (String d : dirArr) {  
  253.             base += "/" + d;  
  254.             if (dirExist(base + "/", sftp)) {  
  255.                 continue;  
  256.             } else {  
  257.                 sftp.mkdir(base + "/");  
  258.             }  
  259.         }  
  260.         return true;  
  261.     }  
  262.   
  263.     /** 
  264.      * 判断文件夹是否存在. 
  265.      * @param dir 文件夹路径， /xxx/xxx/ 
  266.      * @param sftp sftp协议 
  267.      * @return 是否存在 
  268.      */  
  269.     private static boolean dirExist(final String dir, final ChannelSftp sftp) {  
  270.         try {  
  271.             Vector<?> vector = sftp.ls(dir);  
  272.             if (null == vector)  
  273.                 return false;  
  274.             else  
  275.                 return true;  
  276.         } catch (SftpException e) {  
  277.             return false;  
  278.         }  
  279.     }  
  280.   
  281.     /** 
  282.      * 格式化路径. 
  283.      * @param srcPath 原路径. /xxx/xxx/xxx.yyy 或 X:/xxx/xxx/xxx.yy 
  284.      * @return list, 第一个是路径（/xxx/xxx/）,第二个是文件名（xxx.yy） 
  285.      */  
  286.     public static List<String> formatPath(final String srcPath) {  
  287.         List<String> list = new ArrayList<String>(2);  
  288.         String repSrc = srcPath.replaceAll("\\\\", "/");  
  289.         int firstP = repSrc.indexOf("/");  
  290.         int lastP = repSrc.lastIndexOf("/");  
  291.         String fileName = lastP + 1 == repSrc.length() ? "" : repSrc.substring(lastP + 1);  
  292.         String dir = firstP == -1 ? "" : repSrc.substring(firstP, lastP);  
  293.         dir = PRE_FIX + (dir.length() == 1 ? dir : (dir + "/"));  
  294.         list.add(dir);  
  295.         list.add(fileName);  
  296.         return list;  
  297.     }  
  298.   
  299.     /** 
  300.      * 关闭协议-sftp协议.(关闭会导致连接池异常，因此不建议用户自定义关闭) 
  301.      * @param sftp sftp连接 
  302.      */  
  303.     private static void exit(final ChannelSftp sftp) {  
  304.         sftp.exit();  
  305.     }  
  306.   
  307.     public static void main(String[] args) throws Exception {  
  308.         ChannelSftp sftp = getSftpConnect("192.168.0.35", 22, "root", "root");  
  309.         // String pathString = "C:\\test\\ccc\\Foxmail7.zip";  
  310.         // File file = new File(pathString);  
  311.         // System.out.println("上传文件开始...");  
  312.         // uploadFile(pathString, sftp);  
  313.         // System.out.println("上传成功，开始删除本地文件...");  
  314.         // file.delete();  
  315.         // System.out.println("删除完成，开始校验本地文件...");  
  316.         // if (!file.exists()) {  
  317.         // System.out.println("文件不存在，开始从远程服务器获取...");  
  318.         // download(pathString, pathString, sftp);  
  319.         // System.out.println("下载完成");  
  320.         // } else {  
  321.         // System.out.println("在本地找到文件");  
  322.         // }  
  323.         // rmDir("", sftp, true);  
  324.         String path = "E:\\aaa.zip";  
  325.         File file = SftpUtil.download(path, path, sftp);  
  326.         // SftpUtil.exit(sftp);  
  327.         exit(sftp);  
  328.         System.exit(0);  
  329.     }  
  330. }  

文件系统之-JAVA Sftp远程操作:

标签：use   sdn   keyword   成员   tail   执行   string   http   inux   

原文地址：http://www.cnblogs.com/ceshi2016/p/7519788.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！