springboot读取sftp文件
日常打BUG 人气:7springboot读取sftp的文件
1.添加pom依赖（基于springboot项目）
<dependency>
<groupId>com.jcraft</groupId>
<artifactId>jsch</artifactId>
<version>0.1.54</version>
</dependency>
2.application.yaml配置文件
sftp: ip: 192.168.1.102 port: 22 username: admin password: admin root: /img #文件根目录
3.工具类
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.SftpException;
import lombok.extern.slf4j.Slf4j;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
/**
*
*/
@Slf4j
public class SFTPUtil {
/**
* 下载重试次数
*/
private static final int DOWNLOAD_RETRY = 3;
/**
* 下载重试间隔时间 单位毫秒
*/
private static final long DOWNLOAD_SLEEP = 3 * 1000;
private static final SFTPUtil SFTP = new SFTPUtil();
private static ChannelSftp client;
private static Session session;
/**
* @return
*/
public static SFTPUtil getInstance() {
return SFTP;
}
/**
* 获取SFTP连接
*
* @param username
* @param password
* @param ip
* @param port
* @return
*/
synchronized public ChannelSftp makeConnection(String username, String password, String ip, int port) {
if (client == null || session == null || !client.isConnected() || !session.isConnected()) {
try {
JSch jsch = new JSch();
session = jsch.getSession(username, ip, port);
if (password != null) {
session.setPassword(password);
}
Properties config = new Properties();
// 设置第一次登陆的时候主机公钥确认提示，可选值：(ask | yes | no)
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
//sftp协议
Channel channel = session.openChannel("sftp");
channel.connect();
client = (ChannelSftp) channel;
log.info("sftp connected success，connect to [{}:{}], username [{}]", ip, port, username);
} catch (JSchException e) {
log.error("sftp connected fail，connect to [{}:{}], username [{}], password [{}], error message : [{}]", ip, port, username, password, e.getMessage());
}
}
return client;
}
/**
*
* 关闭连接 server
*/
public static void close() {
if (client != null && client.isConnected()) {
client.disconnect();
}
if (session != null && session.isConnected()) {
session.disconnect();
}
}
/**
* 单次下载文件
*
* @param downloadFile 下载文件地址
* @param saveFile 保存文件地址
* @param ip 主机地址
* @param port 主机端口
* @param username 用户名
* @param password 密码
* @param rootPath 根目录
* @return
*/
public synchronized static File download(String downloadFile, String saveFile, String ip, Integer port, String username, String password, String rootPath) {
boolean result = false;
File file = null;
Integer i = 0;
while (!result) {
//获取连接
ChannelSftp sftp = getInstance().makeConnection(username, password, ip, port);
FileOutputStream fileOutputStream = null;
log.info("sftp file download start, target filepath is {}, save filepath is {}", downloadFile, saveFile);
try {
sftp.cd(rootPath);
file = new File(saveFile);
if (file.exists()) {
file.delete();
} else {
file.createNewFile();
}
fileOutputStream = new FileOutputStream(file);
sftp.get(downloadFile, fileOutputStream);
result = true;
} catch (FileNotFoundException e) {
log.error("sftp file download fail, FileNotFound: [{}]", e.getMessage());
} catch (IOException e) {
log.error("sftp file download fail, IOException: [{}]", e.getMessage());
} catch (SftpException e) {
i++;
log.error("sftp file download fail, sftpException: [{}]", e.getMessage());
if (i > DOWNLOAD_RETRY) {
log.error("sftp file download fail, retry three times, SftpException: [{}]", e.getMessage());
return file;
}
try {
TimeUnit.MILLISECONDS.sleep(DOWNLOAD_SLEEP);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
SFTPUtil.close();
}
return file;
}
/**
* 下载文件
*
* @param downloadFile 下载文件的路径
* @param saveFile 保存的路径
* @param rootPath 根目录
* @return
*/
public synchronized static File download(String downloadFile, String saveFile, String rootPath) {
boolean result = false;
File file = null;
Integer i = 0;
while (!result) {
FileOutputStream fileOutputStream = null;
log.info("sftp file download start, target filepath is {}, save filepath is {}", downloadFile, saveFile);
try {
//获取连接、读取文件(ChannelSftp) session.openChannel("sftp")
client.cd(rootPath);
file = new File(saveFile);
if (file.exists()) {
file.delete();
} else {
file.createNewFile();
}
fileOutputStream = new FileOutputStream(file);
client.get(downloadFile, fileOutputStream);
result = true;
} catch (FileNotFoundException e) {
log.error("sftp file download fail, FileNotFound: [{}]", e.getMessage());
} catch (IOException e) {
log.error("sftp file download fail, IOException: [{}]", e.getMessage());
} catch (SftpException e) {
i++;
log.error("sftp file download fail, sftpException: [{}]", e.getMessage());
if (i > DOWNLOAD_RETRY) {
log.error("sftp file download fail, retry three times, SftpException: [{}]", e.getMessage());
return file;
}
try {
TimeUnit.MILLISECONDS.sleep(DOWNLOAD_SLEEP);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
} finally {
try {
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
return file;
}
}
4.实际调用
public class SFTP {
@Value("${sftp.ip}")
String ip;
@Value("${sftp.port}")
Integer port;
@Value("${sftp.username}")
String username;
@Value("${sftp.password}")
String password;
@Value("${sftp.root}")
String rootPath;
@GetMapping("/test")
public void test() throws IOException {
SFTPUtil.getInstance().makeConnection(username, password, ip, port);
File file= SFTPUtil.download(downloadFilePath, "1.txt", rootPath);
SFTPUtil.close();
InputStreamReader read = null;
BufferedReader bufferedReader = null;
String encoding = "utf-8";
try {
read = new InputStreamReader(new FileInputStream(file), encoding);
bufferedReader = new BufferedReader(read);
String lineTxt = null;
while ((lineTxt = bufferedReader.readLine()) != null) {
log.info("[{}] downfile is [{}] ", username, lineTxt);
}
read.close();
bufferedReader.close();
file.delete();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (read != null) {
read.close();
}
if (bufferedReader != null) {
bufferedReader.close();
}
if (file != null && file.exists()) {
file.delete();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
springboot使用SFTP文件上传
最近在工作功能使用了sftp做文件上传下载的功能，在这里简单的记录一下
pom文件中引入相关的jar包
<!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
<dependency>
<groupId>com.jcraft</groupId>
<artifactId>jsch</artifactId>
<version>0.1.54</version>
</dependency>
建立springboot项目，在application.properties添加如下配置
sftp.ip=127.0.0.1 sftp.port=22 sftp.username=xuyy sftp.password=paswpord #ftp根目录 sftp.rootpath="D:SFTP/
上面一sftp开头的都是自定义配置，需要写个配置类读取一下，自动注入到springboot中
package com.uinnova.ftpsynweb.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 特点： 读取配置文件。可以对静态变量直接赋值
*
* @author xuyangyang
*/
@Component
@ConfigurationProperties(prefix = "sftp")
@Data
public class SftpConfig {
public static String ip;
public static Integer port;
public static String username;
public static String password;
public static String rootpath;
//注意这里是 static 修饰，便于sftputil直接取值
public static String getIp() {
return ip;
}
public void setIp(String ip) {
SftpConfig.ip = ip;
}
public static Integer getPort() {
return port;
}
public void setPort(Integer port) {
SftpConfig.port = port;
}
public static String getUsername() {
return username;
}
public void setUsername(String username) {
SftpConfig.username = username;
}
public static String getPassword() {
return password;
}
public void setPassword(String password) {
SftpConfig.password = password;
}
public static String getRootpath() {
return rootpath;
}
public void setRootpath(String rootpath) {
SftpConfig.rootpath = rootpath;
}
}
下面是具体的工具类，代码写的比较简单，可以自己下载优化一下，等我有时间在优化
package com.uinnova.ftpsynweb.util;
import com.jcraft.jsch.*;
import com.uinnova.ftpsynweb.config.SftpConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.thymeleaf.util.StringUtils;
import javax.transaction.SystemException;
import java.io.*;
import java.util.*;
/**
* SFTP工具类
*/
@Slf4j
@Component
public class SftpUtil {
@Autowired
SftpConfig sftpConfig;
private static String sftp_ip = SftpConfig.getIp();
private static Integer sftp_port = SftpConfig.getPort();
private static String sftp_username = SftpConfig.getUsername();
private static String sftp_password = SftpConfig.getPassword();
/**
* sftp存储根目录
*/
public static String windows_path = "D:SFTP/";
public static String linux_path = "/home/xuyy/";
private Session session;
private ChannelSftp channel;
/**
* 规避多线程并发不断开问题
*/
private volatile static ThreadLocal<SftpUtil> sftpLocal = new ThreadLocal<>();
private SftpUtil() {
}
private SftpUtil(String host, Integer port, String username, String password) {
super();
init(host, port, username, password);
}
/**
* 获取本地线程存储的sftp客户端，使用玩必须调用 release()释放连接
*
* @return
* @throws Exception
*/
public static SftpUtil getSftpUtil() {
SftpUtil sftpUtil = sftpLocal.get();
if (null == sftpUtil || !sftpUtil.isConnected()) {
sftpLocal.set(new SftpUtil(sftp_ip, sftp_port, sftp_username, sftp_password));
}
return sftpLocal.get();
}
/**
* 获取本地线程存储的sftp客户端，使用玩必须调用 release()释放连接
*
* @param host
* @param port
* @param username
* @param password
* @return
*/
public static SftpUtil getSftpUtil(String host, Integer port, String username, String password) {
SftpUtil sftpUtil = sftpLocal.get();
if (null == sftpUtil || !sftpUtil.isConnected()) {
log.info("建立连接");
sftpLocal.set(new SftpUtil(host, port, username, password));
} else {
log.info("连接已经存在");
}
return sftpLocal.get();
}
/**
* 初始化 创建一个新的 SFTP 通道
*
* @param host
* @param port
* @param username
* @param password
*/
private void init(String host, Integer port, String username, String password) {
try {
//场景JSch对象
JSch jSch = new JSch();
// jsch.addIdentity(); 私钥
session = jSch.getSession(username, host, port);
// 第一次登陆时候提示, (ask|yes|no)
Properties config = new Properties();
config.put("StrictHostKeyChecking", "no");
config.put("compression.s2c", "zlib,none");
config.put("compression.c2s", "zlib,none");
session.setConfig(config);
//设置超时
// session.setTimeout(10*1000);
//设置密码
session.setPassword(password);
session.connect();
//打开SFTP通道
channel = (ChannelSftp) session.openChannel("sftp");
//建立SFTP通道的连接
channel.connect();
// 失败重试2次 失败不管了，只发送一次 失败回复 并行调用所有节点
} catch (JSchException e) {
log.error("init话sftp异常，可能是获得连接错误，请检查用户名密码或者重启sftp服务" + e);
}
}
/**
* 是否已连接
*
* @return
*/
private boolean isConnected() {
return null != channel && channel.isConnected();
}
/**
* 关闭通道
*/
public void closeChannel() {
if (null != channel) {
try {
channel.disconnect();
} catch (Exception e) {
log.error("关闭SFTP通道发生异常:", e);
}
}
if (null != session) {
try {
session.disconnect();
} catch (Exception e) {
log.error("SFTP关闭 session异常:", e);
}
}
}
/**
* 每次连接必须释放资源，类似OSS服务
* 释放本地线程存储的sftp客户端
*/
public static void release() {
if (null != sftpLocal.get()) {
sftpLocal.get().closeChannel();
sftpLocal.set(null);
}
}
/**
* 列出目录下文件，只列出文件名字，没有类型
*
* @param dir 目录
* @return
*/
public List list(String dir) {
if (channel == null) {
log.error("获取sftp连接失败，请检查" + sftp_ip + +sftp_port + "@" + sftp_username + " " + sftp_password + "是否可以访问");
return null;
}
Vector<ChannelSftp.LsEntry> files = null;
try {
files = channel.ls(dir);
} catch (SftpException e) {
log.error(e.getMessage());
}
if (null != files) {
List fileNames = new ArrayList<String>();
Iterator<ChannelSftp.LsEntry> iter = files.iterator();
while (iter.hasNext()) {
String fileName = iter.next().getFilename();
if (StringUtils.equals(".", fileName) || StringUtils.equals("..", fileName)) {
continue;
}
fileNames.add(fileName);
}
return fileNames;
}
return null;
}
/**
* 列出文件详情
*
* @param dir
* @return
*/
public List listDetail(String dir) {
if (channel == null) {
log.error("获取sftp连接失败，请检查" + sftp_ip + +sftp_port + "@" + sftp_username + " " + sftp_password + "是否可以访问");
return null;
}
Vector<ChannelSftp.LsEntry> files = null;
try {
files = channel.ls(dir);
} catch (SftpException e) {
log.error("listDetail 获取目录列表 channel.ls " + dir + "失败 " + e);
}
if (null != files) {
List<Map<String, String>> fileList = new ArrayList<>();
Iterator<ChannelSftp.LsEntry> iter = files.iterator();
while (iter.hasNext()) {
ChannelSftp.LsEntry next = iter.next();
Map<String, String> map = new HashMap<>();
String fileName = next.getFilename();
if (StringUtils.equals(".", fileName) || StringUtils.equals("..", fileName)) {
continue;
}
String size = String.valueOf(next.getAttrs().getSize());
long mtime = next.getAttrs().getMTime();
String type = "";
String longname = String.valueOf(next.getLongname());
if (longname.startsWith("-")) {
type = "file";
} else if (longname.startsWith("d")) {
type = "dir";
}
map.put("name", fileName);
map.put("size", size);
map.put("type", type);
map.put("mtime", DateTimeUtil.timestampToDate(mtime));
fileList.add(map);
}
return fileList;
}
return null;
}
/**
* 递归获得文件path下所有文件列表
*
* @param path
* @param list
* @return
* @throws SftpException
*/
public List<String> listOfRecursion(String path, List<String> list) throws SftpException {
if (channel == null) {
log.error("获取sftp连接失败，请检查" + sftp_ip + +sftp_port + "@" + sftp_username + "" + sftp_password + "是否可以访问");
return null;
}
Vector<ChannelSftp.LsEntry> files = null;
files = channel.ls(path);
for (ChannelSftp.LsEntry entry : files) {
if (!entry.getAttrs().isDir()) {
String str = path + "/" + entry.getFilename();
str = str.replace("//", "/");
list.add(str);
} else {
if (!entry.getFilename().equals(".") && !entry.getFilename().equals("..")) {
listOfRecursion(path + "/" + entry.getFilename(), list);
}
}
}
log.debug(list.toString());
return list;
}
/**
* @param file 上传文件
* @param remotePath 服务器存放路径，支持多级目录
* @throws SystemException
*/
public void upload(File file, String remotePath) throws SystemException {
if (channel == null) {
log.error("获取sftp连接失败，请检查" + sftp_ip + +sftp_port + "@" + sftp_username + "" + sftp_password + "是否可以访问");
}
FileInputStream fileInputStream = null;
try {
if (file.isFile()) {
String rpath = remotePath;//服务器要创建的目录
try {
createDir(rpath);
} catch (Exception e) {
throw new SystemException("创建路径失败：" + rpath);
}
channel.cd(remotePath);
System.out.println(remotePath);
fileInputStream = new FileInputStream(file);
channel.put(fileInputStream, file.getName());
}
} catch (FileNotFoundException e) {
throw new SystemException("上传文件没有找到");
} catch (SftpException e) {
throw new SystemException("上传ftp服务器错误");
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* @param file 上传文件
* @param remoteName 上传文件名字
* @param remotePath 服务器存放路径，支持多级目录
* @throws SystemException
*/
public boolean upload(File file, String remoteName, String remotePath) {
if (channel == null) {
System.out.println("get sftp connect fail，please reboot sftp client");
log.error("获取sftp连接失败，请检查" + sftp_ip + +sftp_port + "@" + sftp_username + "" + sftp_password + "是否可以访问");
} else {
FileInputStream fileInputStream = null;
try {
if (file.isFile()) {
//服务器要创建的目录
String rpath = remotePath;
createDir(rpath);
channel.cd(remotePath);
log.error(remotePath + " " + remoteName);
fileInputStream = new FileInputStream(file);
channel.put(fileInputStream, remoteName);
return true;
}
} catch (FileNotFoundException e) {
log.error("上传文件没有找到", e.getMessage());
return false;
} catch (SftpException e) {
log.error("upload" + remotePath + e);
return false;
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();//这里要关闭文件流
} else {
log.error("流不存在" + remotePath + " " + remoteName);
}
} catch (IOException e) {
e.printStackTrace();
}
// try to delete the file immediately
// boolean deleted = false;
// try {
// deleted = file.delete();
// } catch (SecurityException e) {
// log.error(e.getMessage());
// }
// // else delete the file when the program ends
// if (deleted) {
// System.out.println("Temp file deleted.");
// log.info("Temp file deleted.");
// } else {
// file.deleteOnExit();
// System.out.println("Temp file scheduled for deletion.");
// log.info("Temp file scheduled for deletion.");
// }
}
}
return false;
}
public boolean upload(InputStream inputStream, String remoteName, String remotePath) {
if (channel == null) {
log.error("获取sftp连接失败，请检查" + sftp_ip + +sftp_port + "@" + sftp_username + "" + sftp_password + "是否可以访问");
} else {
try {
//服务器要创建的目录
String rpath = remotePath;
createDir(rpath);
channel.cd(remotePath);
log.debug(remotePath + " " + remoteName);
channel.put(inputStream, remoteName);
return true;
} catch (SftpException e) {
log.error("upload路径不存在" + remotePath + e);
return false;
} finally {
try {
if (inputStream != null) {
inputStream.close();//这里要关闭文件流
} else {
log.error("流不存在" + remotePath + " " + remoteName);
}
} catch (IOException e) {
log.error(e.getMessage());
}
// try to delete the file immediately
// boolean deleted = false;
// try {
// deleted = file.delete();
// } catch (SecurityException e) {
// log.error(e.getMessage());
// }
// // else delete the file when the program ends
// if (deleted) {
// System.out.println("Temp file deleted.");
// log.info("Temp file deleted.");
// } else {
// file.deleteOnExit();
// System.out.println("Temp file scheduled for deletion.");
// log.info("Temp file scheduled for deletion.");
// }
}
}
return false;
}
/**
* 下载文件
*
* @param rootDir
* @param filePath
* @return
*/
public File downFile(String rootDir, String filePath) {
if (channel == null) {
log.error("获取sftp连接失败，请检查" + sftp_ip + +sftp_port + "@" + sftp_username + " " + sftp_password + "是否可以访问");
return null;
}
OutputStream outputStream = null;
File file = null;
try {
channel.cd(rootDir);
String folder = System.getProperty("java.io.tmpdir");
file = new File(folder + File.separator + filePath.substring(filePath.lastIndexOf("/") + 1));
// file = new File(filePath.substring(filePath.lastIndexOf("/") + 1));
outputStream = new FileOutputStream(file);
channel.get(filePath, outputStream);
} catch (SftpException e) {
log.error("downFile" + filePath + e);
file = null;
} catch (FileNotFoundException e) {
log.error("FileNotFoundException", e);
file = null;
} finally {
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return file;
}
/**
* 创建一个文件目录
*/
public void createDir(String createpath) {
try {
if (isDirExist(createpath)) {
this.channel.cd(createpath);
return;
}
String pathArry[] = createpath.split("/");
StringBuffer filePath = new StringBuffer("/");
for (String path : pathArry) {
if (path.equals("")) {
continue;
}
filePath.append(path + "/");
if (isDirExist(filePath.toString())) {
channel.cd(filePath.toString());
} else {
// 建立目录
channel.mkdir(filePath.toString());
// 进入并设置为当前目录
channel.cd(filePath.toString());
}
}
this.channel.cd(createpath);
} catch (SftpException e) {
log.error("createDir" + createpath + e);
}
}
/**
* 判断目录是否存在
*/
public boolean isDirExist(String directory) {
boolean isDirExistFlag = false;
try {
SftpATTRS sftpATTRS = channel.lstat(directory);
isDirExistFlag = true;
return sftpATTRS.isDir();
} catch (Exception e) {
if (e.getMessage().toLowerCase().equals("no such file")) {
isDirExistFlag = false;
}
}
return isDirExistFlag;
}
static String PS = "/";
/**
* This method is called recursively to download the folder content from SFTP server
*
* @param sourcePath
* @param destinationPath
* @throws SftpException
*/
public void recursiveFolderDownload(String sourcePath, String destinationPath) throws SftpException {
Vector<ChannelSftp.LsEntry> fileAndFolderList = channel.ls(sourcePath); // Let list of folder content
//Iterate through list of folder content
for (ChannelSftp.LsEntry item : fileAndFolderList) {
if (!item.getAttrs().isDir()) { // Check if it is a file (not a directory).
if (!(new File(destinationPath + PS + item.getFilename())).exists()
|| (item.getAttrs().getMTime() > Long
.valueOf(new File(destinationPath + PS + item.getFilename()).lastModified()
/ (long) 1000)
.intValue())) { // Download only if changed later.
new File(destinationPath + PS + item.getFilename());
channel.get(sourcePath + PS + item.getFilename(),
destinationPath + PS + item.getFilename()); // Download file from source (source filename, destination filename).
}
} else if (!(".".equals(item.getFilename()) || "..".equals(item.getFilename()))) {
new File(destinationPath + PS + item.getFilename()).mkdirs(); // Empty folder copy.
recursiveFolderDownload(sourcePath + PS + item.getFilename(),
destinationPath + PS + item.getFilename()); // Enter found folder on server to read its contents and create locally.
}
}
}
/**
* 文件夹不存在，创建
*
* @param folder 待创建的文件节夹
*/
public void createFolder(String folder) {
SftpATTRS stat = null;
try {
stat = channel.stat(folder);
} catch (SftpException e) {
log.error("复制目的地文件夹" + folder + "不存在，创建");
}
if (stat == null) {
try {
channel.mkdir(folder);
} catch (SftpException e) {
log.error("创建失败", e.getCause());
}
}
}
public InputStream get(String filePath) {
InputStream inputStream = null;
try {
inputStream = channel.get(filePath);
} catch (SftpException e) {
log.error("get" + e);
}
return inputStream;
}
public void put(InputStream inputStream, String filePath) {
try {
channel.put(inputStream, filePath);
} catch (SftpException e) {
log.error("put" + e);
}
}
public Vector<ChannelSftp.LsEntry> ls(String filePath) {
Vector ls = null;
try {
ls = channel.ls(filePath);
} catch (SftpException e) {
log.error("ls" + e);
}
return ls;
}
/**
* 复制文件夹
*
* @param src 源文件夹
* @param desc 目的文件夹
*/
public void copy(String src, String desc) {
// 检查目的文件存在与否，不存在则创建
this.createDir(desc);
// 查看源文件列表
Vector<ChannelSftp.LsEntry> fileAndFolderList = this.ls(src);
for (ChannelSftp.LsEntry item : fileAndFolderList) {
if (!item.getAttrs().isDir()) {//是一个文件
try (InputStream tInputStream = this.get(src + PS + item.getFilename());
ByteArrayOutputStream baos = new ByteArrayOutputStream()
) {
byte[] buffer = new byte[1024];
int len;
while ((len = tInputStream.read(buffer)) > -1) {
baos.write(buffer, 0, len);
}
baos.flush();
InputStream nInputStream = new ByteArrayInputStream(baos.toByteArray());
this.put(nInputStream, desc + PS + item.getFilename());
} catch (IOException e) {
log.error(e.getMessage());
}
// 排除. 和 ..
} else if (!(".".equals(item.getFilename()) || "..".equals(item.getFilename()))) {
// 创建文件，可能不需要
this.createFolder(desc + PS + item.getFilename());
//递归复制文件
copy(src + PS + item.getFilename(), desc + PS + item.getFilename());
}
}
}
/**
* 删除指定目录文件
*
* @param filePath 删除文件路径
* @return
*/
public Boolean del(String filePath) {
boolean flag = false;
try {
channel.rm(filePath);
flag = true;
} catch (SftpException e) {
flag = false;
log.error("删除文件错误报告： " + e);
}
return flag;
}
}
下面是具体的几个接口，这里也贴出来了，方便大家使用
@Slf4j
@RestController
public class FileController {
/**
* @param file 上传文件
* @param targetPath 保存文件路径
* @param fileName 上传文件名字
* @return
* @throws IOException
*/
@RequestMapping(value = "/file/upload")
@ResponseBody
public Return upload(@RequestParam("file") MultipartFile file, String targetPath, String fileName) throws IOException {
log.debug("上传文件原始名字：" + file.getOriginalFilename() + "上传路径：" + targetPath + "上传文件名： " + fileName);
InputStream uploadFile = file.getInputStream();
SftpUtil sftpUtil = SftpUtil.getSftpUtil();
boolean upload = false;
if (SftpConfig.WIN.equals(SftpConfig.getEnv())) {
upload = sftpUtil.upload(uploadFile, fileName, targetPath);
} else {
upload = sftpUtil.upload(uploadFile, fileName, SftpConfig.getRootpath() + targetPath);
}
SftpUtil.release();
return Return.Ok(upload);
}
/**
* 需要下载的文件具体路径
*
* @param targetPath
* @param response
* @return
* @throws UnsupportedEncodingException
*/
@RequestMapping(value = "/file/download")
@ResponseBody
public void download(String targetPath, HttpServletResponse response) throws UnsupportedEncodingException {
log.debug("下载文件名字" + targetPath);
// targetPath = new String(targetPath.getBytes("ISO8859-1"), "UTF-8");
if (StringUtils.isEmpty(targetPath) || !targetPath.contains("/")) {
log.error("下载路径不正确" + targetPath);
// return Return.Fail("下载路径不正确");
}
String fileName = targetPath.substring(targetPath.lastIndexOf("/") + 1);
log.debug(fileName);
File file = null;
SftpUtil sftpUtil = SftpUtil.getSftpUtil();
if (SftpConfig.WIN.equals(SftpConfig.getEnv())) {
file = sftpUtil.downFile("/", targetPath);
} else {
file = sftpUtil.downFile("/", SftpConfig.getRootpath() + targetPath);
}
SftpUtil.release();
if (!Objects.isNull(file)) {
// 配置文件下载
response.setHeader("content-type", "application/octet-stream");
response.setContentType("application/octet-stream");
// 下载文件能正常显示中文
// response.setHeader("Content-Disposition", "attachment;filename=" + new String(fileName.getBytes("gb2312"), "ISO8859-1"));
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
byte[] buffer = new byte[1024];
FileInputStream fis = null;
BufferedInputStream bis = null;
try {
fis = new FileInputStream(file);
bis = new BufferedInputStream(fis);
OutputStream os = response.getOutputStream();
int i = bis.read(buffer);
while (i != -1) {
os.write(buffer, 0, i);
i = bis.read(buffer);
}
// return Return.Ok("下载成功");
} catch (Exception e) {
log.error("down fail" + e);
// return Return.Fail("下載失敗");
} finally {
if (bis != null) {
try {
bis.close();
} catch (IOException e) {
log.error("down fail" + e);
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
log.error("down fail" + e);
}
}
}
}
// return Return.Fail("下載失敗");
}
/**
* 获取sftp下文件消息列表
*
* @param filePath 文件路径
* @return
*/
@RequestMapping(value = "/file/list")
@ResponseBody
public Return list(@RequestParam("filePath") String filePath) {
log.debug("获取路径下列表 ：{}", filePath);
SftpUtil sftpUtil = SftpUtil.getSftpUtil();
List<String> list = new ArrayList();
if (SftpConfig.WIN.equals(SftpConfig.getEnv())) {
list = sftpUtil.listDetail(filePath);
} else {
list = sftpUtil.listDetail(SftpConfig.getRootpath() + filePath);
}
SftpUtil.release();
return Return.Ok(list);
}
/**
* 递归获得文件path下所有文件列表
*
* @param filePath 文件路径
* @return
*/
@RequestMapping(value = "/file/listOfRecursion")
@ResponseBody
public Return listOfRecursion(@RequestParam("filePath") String filePath) {
log.debug("获取路径下列表 ：{}", filePath);
SftpUtil sftpUtil = SftpUtil.getSftpUtil();
ArrayList<String> strings = new ArrayList<>();
Return ret = null;
List<String> list;
List<String> list1 = new ArrayList<>();
try {
if (SftpConfig.WIN.equals(SftpConfig.getEnv())) {
list = sftpUtil.listOfRecursion(filePath, strings);
ret = Return.Ok(list);
} else {
list = sftpUtil.listOfRecursion(SftpConfig.getRootpath() + filePath, strings);
for (String str : list) {
str = StringUtils.substring(str, SftpConfig.getRootpath().length() - 1);
list1.add(str);
}
ret = Return.Ok(list1);
}
} catch (SftpException e) {
log.error("listOfRecursion 获取目录列表 channel.ls " + filePath + "失败 " + e);
SftpUtil.release();
ret = Return.Fail(e.getMessage());
}finally {
SftpUtil.release();
}
return ret;
}
/**
* sftp内复制文件夹
*
* @param src 源文件夹
* @param desc 目的文件夹
* @return
*/
@RequestMapping(value = "file/copy")
@ResponseBody
public Return copy(String src, String desc) {
SftpUtil sftpUtil = SftpUtil.getSftpUtil();
if (SftpConfig.WIN.equals(SftpConfig.getEnv())) {
sftpUtil.copy(src, desc);
} else {
sftpUtil.copy(SftpConfig.getRootpath() + src, SftpConfig.getRootpath() + desc);
}
SftpUtil.release();
return Return.Ok("复制成功");
}
/**
* 删除文件 文件存在返回true ，文件不存在或删除失败返回 false
*
* @param filePath
* @return
*/
@RequestMapping(value = "file/del")
@ResponseBody
public Return del(String filePath) {
log.debug("删除此文件 ：{}", filePath);
Boolean flag = false;
SftpUtil sftpUtil = SftpUtil.getSftpUtil();
if (SftpConfig.WIN.equals(SftpConfig.getEnv())) {
flag = sftpUtil.del(filePath);
} else {
flag = sftpUtil.del(SftpConfig.getRootpath() + filePath);
}
SftpUtil.release();
return new Return(flag, flag ? "删除成功" : "文件不存在或删除失败");
}
}
以上为个人经验，希望能给大家一个参考，也希望大家多多支持。
加载全部内容