springboot中使用SFTP文件上传

springboot中使用SFTP文件上传最近在工作功能使用了sftp做文件上传下载的功能,在这里简单的记录一下,pom文件中引入相关的jar包<!–https://mvnrepository.com/artifact/com.jcraft/jsch–><dependency><groupId>com.jcraft</g…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

  1. 最近在工作功能使用了sftp做文件上传下载的功能,在这里简单的记录一下,
  2. pom文件中引入相关的jar包

        <!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.54</version>
        </dependency>
  1. 建立springboot项目,在application.properties添加如下配置
sftp.ip=127.0.0.1
sftp.port=22
sftp.username=xuyy
sftp.password=paswpord
#ftp根目录
sftp.rootpath="D:SFTP/
  1. 上面一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;
    }

}

  1. 下面是具体的工具类,代码写的比较简单,可以自己下载优化一下,等我有时间在优化,
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;
    }

}

  1. 下面是具体的几个接口,这里也贴出来了,方便大家使用
@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 ? "删除成功" : "文件不存在或删除失败");
    }

   

}

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/180089.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • python递归函数讲解_Python递归函数实例讲解

    python递归函数讲解_Python递归函数实例讲解Python递归函数实例讲解Python递归函数实例1、打开Python开发工具IDLE,新建‘递归.py’文件,并写代码如下:defdigui(n):ifn==0:print(”)returnprint(‘*’*n)digui(n-1)if__name__==’__main__’:digui(5)这里递归打印*号,先打印后递归2、F5运行程序,打印内容如下;********…

    2022年10月25日
  • JavaScript 算法 — 贪心算法

    JavaScript 算法 — 贪心算法文章目录贪心算法例题一:分饼干例题二:买卖股票的最佳时机II贪心算法贪心算法是算法设计的一种方法。期盼通过每个阶段的局部最优选择,从而达到全局的最优,但最后的结果不一定最优。例题一:分饼干 /** *@param{number[]}g胃口 *@param{number[]}s饼干尺寸 *@return{number} */ varfindContentChildren=function(g,s){ constmysort=(a,

  • android离线打包[通俗易懂]

    android离线打包[通俗易懂]本文章参考官网和其他博客,如有侵权,立即删除官网地址:https://nativesupport.dcloud.net.cn/AppDocs/usesdk/android需要的工具HBuilderX链接:https://www.dcloud.io/hbuilderx.htmlAndroidStudio链接:https://developer.android.google.cn/studio/index.htmlApp离线SDK链接:https://nativesupp…

    2022年10月31日
  • NHibernate 缓存

    NHibernate 缓存NHibernate支持两种级别的缓存,即一级缓存以及二级缓存。一级缓存一级缓存就是ISession缓存,在ISession的生命周期内可用,多个ISession之间不能共享缓存的对象,通过ISessionFactory创建的ISession默认支持一级缓存,不需要特殊的配置。在NHibernate的参考文档中,对ISession的描述如下:

  • windows虚拟显示器SDK开发和提供

    windows虚拟显示器SDK开发和提供背景这周末闲来无事,整理了下虚拟显示器的源码,发现有几个项目都用到了,但是使用的功能不尽相同:(1)最简单的运用仅仅是需要显示器的拔插;(2)稍微复杂一点的是需要设置显示器的分辨率,包括标准的分辨率,如19201080,还包括非标准的分辨率,如1120900;(3)再复杂一点的需要设置显示器名称、刷新频率、获取虚拟显示器屏幕图像信息。再观察我的那几个项目,都重复的导入了源码,每次发现一个…

  • autoconf 简介

    autoconf 简介Autoconf的内容Autoconf能生成用于自动配置源代码的shell脚本。安装下列程序:autoconf,autoheader,autom4te,autoreconf,autoscan,autoupdate和ifnames简短说明autoconf是一个产生可以自动配置源代码包,生成shell脚本的工具,以适应各种类UNIX系统的需

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号