sftp实现OS之间的远程传输文件与文件夹

问题场景

package com.business.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.Vector;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelSftp.LsEntry;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpATTRS;
import com.jcraft.jsch.SftpException;

/**
* @author  youxingyang
* @Date    2017-6-26 上午9:27:32
*/
public final class FtpUtils {

private static String separator = "/";
/**
* 连接sftp服务器
* @param host     主机
* @param port     端口
* @param username 用户名
* @param password 密码
* @return
*/
public static ChannelSftp connect(String host, int port, String username, String password) {

ChannelSftp sftp = null;
try {
JSch jsch = new JSch();
jsch.getSession(username, host, port);
Session sshSession = jsch.getSession(username, host, port);
System.out.println("Session created.");
sshSession.setPassword(password);
Properties sshConfig = new Properties();
sshConfig.put("StrictHostKeyChecking", "no");
sshSession.setConfig(sshConfig);
sshSession.connect();
System.out.println("Session connected.");
System.out.println("Opening Channel.");
Channel channel = sshSession.openChannel("sftp");
channel.connect();
sftp = (ChannelSftp) channel;
System.out.println("Connected to " + host + ".");
} catch (Exception e) {
e.printStackTrace();
}
return sftp;
}

/**
* 列出目录下的文件
*
* @param directory 要列出的目录
* @param sftp
* @return
* @throws SftpException
*/
public Vector<?> listFiles(String directory, ChannelSftp sftp) throws SftpException {
return sftp.ls(directory);
}

/**
* 删除-单个文件
* @param directory  要删除文件所在目录
* @param deleteFile 要删除的文件
* @param sftp
*/

public void delete(String directory, String deleteFile, ChannelSftp sftp) {
try {
sftp.cd(directory);
sftp.rm(deleteFile);
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 删除文件夹或者文件
* @param path 文件夹或者文件路径
* @param sftp sftp
* @param resursion 是否递归删除文件夹
* @throws Exception 异常
*/
public static void deleteFile(String path, ChannelSftp sftp, boolean recursion) throws Exception {
try {
if (isDirExist(sftp, path)) {
if (recursion)
doDeleteFile(path, sftp);
else
sftp.rmdir(path);
} else {
sftp.rm(path);
}
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 递归删除执行
* @param pathString 文件路径
* @param sftp sftp连接
* @throws SftpException
*/
private static void doDeleteFile(final String pathString, final ChannelSftp sftp) throws SftpException {
@SuppressWarnings("unchecked")
Vector<LsEntry> vector = sftp.ls(pathString);
if (vector.size() == 1) { // 文件，直接删除
sftp.rm(pathString);
} else if (vector.size() == 2) { // 空文件夹，直接删除
sftp.rmdir(pathString);
} else {
String fileName = "";
// 删除文件夹下所有文件
for (LsEntry en : vector) {
fileName = en.getFilename();
if (".".equals(fileName) || "..".equals(fileName)) {
continue;
} else {
doDeleteFile(pathString + separator + fileName, sftp);
}
}
// 删除文件夹
sftp.rmdir(pathString);//rmdir只能删除空的文件夹
}
}

public static void mkdir(String directory, ChannelSftp sftp) {
try {
sftp.ls(directory);
} catch (SftpException e) {
try {
sftp.mkdir(directory);
} catch (SftpException ex) {
ex.printStackTrace();
}
}
}

public static void mkdirs(String directory, ChannelSftp sftp) {
List<String> fileNames = getFileNames(directory);
StringBuffer buf = new StringBuffer();
if (fileNames != null && fileNames.size() > 0) {
for (String fileName : fileNames) {
buf.append(separator);
buf.append(fileName);
mkdi
f2ce
r(buf.toString(), sftp);
}
}
}

/**
* 列出目录下的所有文件及文件夹
* @param dir
* @return
*/
public static List<String> getFileNames(String dir) {
File file = new File(dir);
List<String> list = new ArrayList<String>();
if (file.getParentFile() != null) {
List<String> fileNames = getFileNames(file.getParentFile().getPath());
for (String fileName : fileNames) {
if (fileName != null && !fileName.equals(""))
list.add(fileName);
}
}
if (!file.getName().equals(""))
list.add(file.getName());
return list;
}

/**
* 下载文件-单个文件
* @param directory    下载目录
* @param downloadFile 下载的文件
* @param saveFile     存在本地的路径
* @param sftp
*/

public void download(String directory, String downloadFile, String saveFile, ChannelSftp sftp) {
try {
sftp.cd(directory);
File file = new File(saveFile);
sftp.get(downloadFile, new FileOutputStream(file));
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 下载文件-支持文件夹
* @param sftp          sftp
* @param ftpPath       ftp上的路径-文件夹或者文件路径
* @param localPath     本地路径
*/
public static void downloadFile(ChannelSftp sftp, String ftpPath, String localPath) {
try {
//要下载的是一个目录
if (isDirExist(sftp, ftpPath)) {
Vector<?> v = sftp.ls(ftpPath);
for (Object object : v) {
ChannelSftp.LsEntry entry = (ChannelSftp.LsEntry) object;
doDownloadFile(sftp, entry, ftpPath, localPath);
}
} else {
File file = new File(ftpPath);
sftp.get(localPath, new FileOutputStream(file));
}
} catch (SftpException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

/**
* 从远端递归下载数据到本地-支持文件夹
* @param sftp
* @param entry         文件实体
* @param ftpPath       ftp上的文件路径
* @param localPath     存储下载文件的路径
*/
public static void doDownloadFile(ChannelSftp sftp, ChannelSftp.LsEntry entry, String ftpPath, String localPath) {
try {
SftpATTRS attrs = entry.getAttrs();
String filename = entry.getFilename();
if (filename.equals(".") || filename.equals("..")) {
return;
}
String nextFtpPath = getRealName(ftpPath, filename);
String nextLocalPath = getRealName(localPath, filename);
if (attrs.isDir()) {
sftp.cd(nextFtpPath);

Vector<?> v = sftp.ls(sftp.pwd());
for (Object object : v) {
ChannelSftp.LsEntry entry1 = (ChannelSftp.LsEntry) object;
doDownloadFile(sftp, entry1, nextFtpPath, nextLocalPath);
}
} else {
File file = new File(nextLocalPath);
// 如果路径不存在,则创建
File parentFile = file.getParentFile();
if (!parentFile.exists()) {
parentFile.mkdirs();
}
sftp.get(nextFtpPath, new FileOutputStream(nextLocalPath));
}
} catch (SftpException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

private static String getRealName(String pwd, String filename) {
return pwd.endsWith(separator) ? pwd + filename : pwd + separator + filename;
}

/**
* 上传文件-单个文件
*
* @param directory  上传的目录
* @param uploadFile 要上传的文件
* @param sftp
*/
public void upload(InputStream is, String directory, String uploadFile, ChannelSftp sftp) {
try {
sftp.cd(directory);
File file = new File(uploadFile);
sftp.put(is, file.getName());
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 上传文件-支持文件夹
* @param sftp          sftp
* @param localPath     要传的文件夹或者文件路径
* @param ftpPath       目标位置
*/
public static void uploadFile(ChannelSftp sftp, String localPath, String ftpPath) {

try {
//如果目标目录不存在则捕获异常创建
try {
sftp.cd(ftpPath);
} catch (SftpException e) {
mkdirs(ftpPath, sftp);
sftp.cd(ftpPath);
}
File file = new File(localPath);
doUploadFile(sftp, file, sftp.pwd());
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 从本地递归上传数据到远端-支持文件夹
* @param sftp  sftp
* @param file  文件或者文件夹
* @param pwd   当前目录
*/
public static void doUploadFile(ChannelSftp sftp, File file, String pwd) {
try {
if (file.isDirectory()) {
File[] list = file.listFiles();
String fileName = file.getName();
sftp.cd(pwd);
pwd = pwd + separator + file.getName();
if (!isDirExist(sftp, pwd)) {
sftp.mkdir(fileName);
}
//切换到下一级文件夹
sftp.cd(file.getName());
for (File aList : list) {
doUploadFile(sftp, aList, pwd);
}
} else {
sftp.cd(pwd);
sftp.put(new FileInputStream(file), file.getName());
}
} catch (SftpException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

/**
* 判断目录是否存在
* @param directory
* @return
*/
public static boolean isDirExist(ChannelSftp sftp, String directory) {
boolean isDirExistFlag = false;
try {
SftpATTRS sftpATTRS = sftp.lstat(directory);
isDirExistFlag = sftpATTRS.isDir();
} catch (Exception e) {
if (e.getMessage().toLowerCase().equals("no such file")) {
isDirExistFlag = false;
}
}
return isDirExistFlag;
}

public static void main(String[] args) {
String host = "192.168.XXX.XXX";
int port = 22;
String username = "root";
String password = "master";
ChannelSftp sftp = connect(host, port, username, password);

// upload paths
String ftpPathUpload = "/samples/a/b/";//不是root权限注意能否使用根目录
//file
//String localPathFileUpload = "/Users/yyx/IdeaProjects/study/lib/com.jcraft.jsch_0.1.31.jar";
//directory
String localPathDirUpload = "E:\\1报告数据\\XXX\\全自动化\\全自动化-x\\XXX\\TB_0001";

//download paths
String localPathDownload = "E:\\TB_0001";
String ftpPathDownload = "/samples/a/b/TB_0001/";
try {

uploadFile(sftp, localPathDirUpload, ftpPathUpload);
System.out.println("upload finished");

downloadFile(sftp, ftpPathDownload, localPathDownload);
System.out.println("download finished");

deleteFile("/samples/a/b/", sftp, true);
System.out.println("delete finished");

} catch (Exception e) {
System.out.println(e.getMessage());
} finally {
sftp.quit();
sftp.getSession().disconnect();
}
}
}