<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>springboot-learning-parents</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>springboot-demo</groupId>
    <artifactId>springboot-ftp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>springboot-ftp</name>
    <url>https://gitee.com/leo825/springboot-learning-parents.git</url>
    <description>springboot 集成 ftp、ftps、sftp</description>
    <properties>
        <start-class>com.demo.SpringbootFtpApplication</start-class>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <mybatisplus.version>3.5.1</mybatisplus.version>
        <freemaker.version>2.3.31</freemaker.version>
        <mysql.version>8.0.28</mysql.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- ftp 連接工具包 -->
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.8.0</version>
        </dependency>
        <!-- 連接池化技術(shù) -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!-- apache 常用 common工具包-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>
        <!-- zip、gz、tar.gz 解壓-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-compress</artifactId>
            <version>1.21</version>
        </dependency>
        <!-- sftp 連接依賴-->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.55</version>
        </dependency>
        <!-- 常用工具包 hutool -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.9</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

package com.demo.ftp.config;
import lombok.Data;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@EnableConfigurationProperties
@PropertySource(value = {"ftp.properties"})
@ConfigurationProperties(prefix = "ftp.client")
@Configuration
@Data
public class FTPPoolConfig extends GenericObjectPoolConfig {
    // 默認進入的路徑
    String workingDirectory;
    // 主機地址
    String host;
    // 主機端口
    int port;
    // 主機用戶名
    String username;
    // 主機密碼
    String password;
    // 傳輸編碼
    String encoding;
    // 被動模式：在這種模式下，數(shù)據(jù)連接是由客戶程序發(fā)起的
    boolean passiveMode;
    // 連接超時時間
    int clientTimeout;
    // 線程數(shù)
    int threaNum;
    // 0=ASCII_FILE_TYPE(ASCII格式)，1=EBCDIC_FILE_TYPE，2=LOCAL_FILE_TYPE(二進制文件)
    int transferFileType;
    // 是否重命名
    boolean renameUploaded;
    // 重新連接時間
    int retryTimes;
    // 緩存大小
    int bufferSize;
    // 最大數(shù)
    int maxTotal;
    // 最小空閑
    int minldle;
    // 最大空閑
    int maxldle;
    // 最大等待時間
    int maxWait;
    // 池對象耗盡之后是否阻塞，maxWait < 0 時一直等待
    boolean blockWhenExhausted;
    // 取對象時驗證
    boolean testOnBorrow;
    // 回收驗證
    boolean testOnReturn;
    // 創(chuàng)建時驗證
    boolean testOnCreate;
    // 空閑驗證
    boolean testWhileldle;
    // 后進先出
    boolean lifo;
}

package com.demo.ftp.factory;
import com.demo.ftp.config.FTPPoolConfig;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
 * FtpClient 工廠聲場連接對象
 */
@Component
@Slf4j
public class FTPClientFactory implements PooledObjectFactory<FTPClient> {
    /**
     * 注入 ftp 連接配置
     */
    @Autowired
    FTPPoolConfig config;
    /**
     * 創(chuàng)建連接到池中
     *
     * @return
     * @throws Exception
     */
    @Override
    public PooledObject<FTPClient> makeObject() throws Exception {
        FTPClient ftpClient = new FTPClient();
        ftpClient.setConnectTimeout(config.getClientTimeout());
        ftpClient.connect(config.getHost(), config.getPort());
        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect();
            return null;
        }
        boolean success;
        if (StringUtils.isBlank(config.getUsername())) {
            success = ftpClient.login("anonymous", "anonymous");
        } else {
            success = ftpClient.login(config.getUsername(), config.getPassword());
        }
        if (!success) {
            return null;
        }
        ftpClient.setFileType(config.getTransferFileType());
        ftpClient.setBufferSize(1024);
        ftpClient.setControlEncoding(config.getEncoding());
        if (config.isPassiveMode()) {
            ftpClient.enterLocalPassiveMode();
        }
        log.debug("創(chuàng)建ftp連接");
        return new DefaultPooledObject<>(ftpClient);
    }
    /**
     * 鏈接狀態(tài)檢查
     *
     * @param pool
     * @return
     */
    @Override
    public boolean validateObject(PooledObject<FTPClient> pool) {
        FTPClient ftpClient = pool.getObject();
        try {
            return ftpClient != null && ftpClient.sendNoOp();
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * 銷毀連接，當連接池空閑數(shù)量達到上限時，調(diào)用此方法銷毀連接
     *
     * @param pool
     * @throws Exception
     */
    @Override
    public void destroyObject(PooledObject<FTPClient> pool) throws Exception {
        FTPClient ftpClient = pool.getObject();
        if (ftpClient != null) {
            try {
                ftpClient.disconnect();
                log.debug("銷毀ftp連接");
            } catch (Exception e) {
                log.error("銷毀ftpClient異常，error：", e.getMessage());
            }
        }
    }
    /**
     * 鈍化連接，是連接變?yōu)榭捎脿顟B(tài)
     *
     * @param p
     * @throws Exception
     */
    @Override
    public void passivateObject(PooledObject<FTPClient> p) throws Exception{
        FTPClient ftpClient = p.getObject();
        try {
            ftpClient.changeWorkingDirectory(config.getWorkingDirectory());
            ftpClient.logout();
            if (ftpClient.isConnected()) {
                ftpClient.disconnect();
            }
        } catch (Exception e) {
            throw new RuntimeException("Could not disconnect from server.", e);
        }
    }
    /**
     * 初始化連接
     *
     * @param pool
     * @throws Exception
     */
    @Override
    public void activateObject(PooledObject<FTPClient> pool) throws Exception {
        FTPClient ftpClient = pool.getObject();
        ftpClient.connect(config.getHost(),config.getPort());
        ftpClient.login(config.getUsername(), config.getPassword());
        ftpClient.setControlEncoding(config.getEncoding());
        ftpClient.changeWorkingDirectory(config.getWorkingDirectory());
        //設(shè)置上傳文件類型為二進制，否則將無法打開文件
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    }
    /**
     * 獲取 FTP 連接配置
     * @return
     */
    public FTPPoolConfig getConfig(){
        return config;
    }
}

package com.demo.ftp.service;
import com.demo.ftp.config.FTPPoolConfig;
import org.apache.commons.net.ftp.FTPClient;
/**
 * 獲取 ftp 客戶端對象的接口
 */
public interface FTPPoolService {
    /**
     * 獲取ftpClient
     */
    FTPClient borrowObject();
    /**
     * 歸還ftpClient
     */
    void returnObject(FTPClient ftpClient);
    /**
     * 獲取 ftp 配置信息
     * @return
     */
    FTPPoolConfig getFtpPoolConfig();
}

package com.demo.ftp.service.imp;
import com.demo.ftp.config.FTPPoolConfig;
import com.demo.ftp.factory.FTPClientFactory;
import com.demo.ftp.service.FTPPoolService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
@Slf4j
public class FTPPoolServiceImpl implements FTPPoolService {
    /**
     * ftp 連接池生成
     */
    private GenericObjectPool<FTPClient> pool;
    /**
     * ftp 客戶端配置文件
     */
    @Autowired
    private FTPPoolConfig config;
    /**
     * ftp 客戶端工廠
     */
    @Autowired
    private FTPClientFactory factory;
    /**
     * 初始化pool
     */
    @PostConstruct
    private void initPool() {
        this.pool = new GenericObjectPool<FTPClient>(this.factory, this.config);
    }
    /**
     * 獲取ftpClient
     */
    @Override
    public FTPClient borrowObject() {
        if (this.pool != null) {
            try {
                return this.pool.borrowObject();
            } catch (Exception e) {
                log.error("獲取 FTPClient 失敗 ", e);
            }
        }
        return null;
    }
    /**
     * 歸還 ftpClient
     */
    @Override
    public void returnObject(FTPClient ftpClient) {
        if (this.pool != null && ftpClient != null) {
            this.pool.returnObject(ftpClient);
        }
    }
    @Override
    public FTPPoolConfig getFtpPoolConfig() {
        return config;
    }
}

package com.demo.util;
import cn.hutool.core.util.CharsetUtil;
import com.demo.ftp.service.FTPPoolService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
 * FTP工具類
 *
 * @Scope設(shè)置Bean的作用域 作用域類型            使用范圍	            作用域描述
 * singleton	    所有Spring應(yīng)用	    默認值,IoC容器只存在單例
 * prototype	    所有Spring應(yīng)用	    每次從IoC容器中取出都是一個bean，都創(chuàng)建一個新的bean
 * session	        Spring web應(yīng)用	    Http會話
 * application	    Spring web應(yīng)用	    web工程生命周期
 * request	        Spring web應(yīng)用	    web工程單次請求
 * globalSession	Spring web應(yīng)用	    在一個全局的 httpSession中，一個bean對應(yīng)一個實例。實踐中基本不使用
 */
@Component
@Slf4j
public class FTPUtil {
    /**
     * ftp 連接池
     */
    @Autowired
    FTPPoolService ftpPoolService;
    /**
     * 從FTP服務(wù)器上下載文件,支持斷點續(xù)傳，下載百分比匯報
     *
     * @param remote 遠程文件路徑及名稱
     * @param local  本地文件完整絕對路徑
     * @return 下載的狀態(tài)
     * @throws IOException
     */
    public DownloadStatus download(String remote, String local) throws IOException {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        // 設(shè)置被動模式,由于Linux安全性考慮，端口沒有全部放開，所有被動模式不能用
        ftpClient.enterLocalPassiveMode();
        // 設(shè)置以二進制方式傳輸
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        DownloadStatus result;
        try {
            // 檢查遠程文件是否存在
            FTPFile[] files = ftpClient.listFiles(new String(remote.getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1));
            if (files.length != 1) {
                log.info("遠程文件不存在");
                return DownloadStatus.RemoteFileNotExist;
            }
            long lRemoteSize = files[0].getSize();
            File f = new File(local);
            // 本地存在文件，進行斷點下載
            if (f.exists()) {
                long localSize = f.length();
                // 判斷本地文件大小是否大于遠程文件大小
                if (localSize >= lRemoteSize) {
                    log.info("本地文件大于遠程文件，下載中止");
                    return DownloadStatus.LocalFileBiggerThanRemoteFile;
                }
                // 進行斷點續(xù)傳，并記錄狀態(tài)
                FileOutputStream out = new FileOutputStream(f, true);
                ftpClient.setRestartOffset(localSize);
                InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1));
                byte[] bytes = new byte[1024];
                long step = lRemoteSize / 100;
                step = step == 0 ? 1 : step;// 文件過小，step可能為0
                long process = localSize / step;
                int c;
                while ((c = in.read(bytes)) != -1) {
                    out.write(bytes, 0, c);
                    localSize += c;
                    long nowProcess = localSize / step;
                    if (nowProcess > process) {
                        process = nowProcess;
                        if (process % 10 == 0) {
                            log.info("下載進度：" + process);
                        }
                    }
                }
                in.close();
                out.close();
                boolean isDo = ftpClient.completePendingCommand();
                if (isDo) {
                    result = DownloadStatus.DownloadFromBreakSuccess;
                } else {
                    result = DownloadStatus.DownloadFromBreakFailed;
                }
            } else {
                OutputStream out = new FileOutputStream(f);
                InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1));
                byte[] bytes = new byte[1024];
                long step = lRemoteSize / 100;
                step = step == 0 ? 1 : step;// 文件過小，step可能為0
                long process = 0;
                long localSize = 0L;
                int c;
                while ((c = in.read(bytes)) != -1) {
                    out.write(bytes, 0, c);
                    localSize += c;
                    long nowProcess = localSize / step;
                    if (nowProcess > process) {
                        process = nowProcess;
                        if (process % 10 == 0) {
                            log.info("下載進度：" + process);
                        }
                    }
                }
                in.close();
                out.close();
                boolean upNewStatus = ftpClient.completePendingCommand();
                if (upNewStatus) {
                    result = DownloadStatus.DownloadNewSuccess;
                } else {
                    result = DownloadStatus.DownloadNewFailed;
                }
            }
        } catch (Exception e) {
            log.error("download error", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return DownloadStatus.DownloadNewFailed;
    }
    /**
     * 切換遠程目錄
     *
     * @param path
     * @return
     * @throws IOException
     */
    public boolean changeDirectory(String path) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        boolean result = false;
        try {
            result = ftpClient.changeWorkingDirectory(path);
        } catch (Exception e) {
            log.error("changeDirectory error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return result;
    }
    /**
     * 創(chuàng)建遠程目錄
     *
     * @param pathName
     * @return
     * @throws IOException
     */
    public boolean createDirectory(String pathName) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        boolean result = false;
        try {
            result = ftpClient.makeDirectory(pathName);
        } catch (Exception e) {
            log.error("createDirectory error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return result;
    }
    /**
     * 刪除遠程目錄
     *
     * @param path
     * @return
     * @throws IOException
     */
    public boolean removeDirectory(String path) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        boolean result = false;
        try {
            result = ftpClient.removeDirectory(path);
        } catch (Exception e) {
            log.error("removeDirectory error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return result;
    }
    /**
     * 刪除遠程目錄，可遞歸刪除所有
     *
     * @param path
     * @param isAll
     * @return
     * @throws IOException
     */
    public boolean removeDirectory(String path, boolean isAll) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        boolean result = false;
        try {
            if (!isAll) {
                return removeDirectory(path);
            }
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);
            if (ftpFileArr == null || ftpFileArr.length == 0) {
                return removeDirectory(path);
            }
            //
            for (FTPFile ftpFile : ftpFileArr) {
                String name = ftpFile.getName();
                if (ftpFile.isDirectory()) {
                    log.info("* [sD]Delete subPath [" + path + "/" + name + "]");
                    if (!ftpFile.getName().equals(".") && (!ftpFile.getName().equals(".."))) {
                        removeDirectory(path + "/" + name, true);
                    }
                } else if (ftpFile.isFile()) {
                    log.info("* [sF]Delete file [" + path + "/" + name + "]");
                    deleteFile(path + "/" + name);
                } else if (ftpFile.isSymbolicLink()) {
                } else if (ftpFile.isUnknown()) {
                }
            }
            result = ftpClient.removeDirectory(path);
        } catch (Exception e) {
            log.error("removeDirectory error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return result;
    }
    /**
     * 查看目錄是否存在
     *
     * @param path
     * @return
     * @throws IOException
     */
    public boolean isDirectoryExists(String path) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        boolean flag = false;
        try {
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);
            for (FTPFile ftpFile : ftpFileArr) {
                if (ftpFile.isDirectory() && ftpFile.getName().equalsIgnoreCase(path)) {
                    flag = true;
                    break;
                }
            }
        } catch (Exception e) {
            log.error("isDirectoryExists error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return flag;
    }
    /**
     * 得到某個目錄下的文件名列表
     *
     * @param path
     * @return
     * @throws IOException
     */
    public List<String> getFileList(String path) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        List<String> retList = new ArrayList<String>();
        try {
            FTPFile[] ftpFiles = ftpClient.listFiles(path);
            if (ftpFiles == null || ftpFiles.length == 0) {
                return retList;
            }
            for (FTPFile ftpFile : ftpFiles) {
                if (ftpFile.isFile()) {
                    retList.add(ftpFile.getName());
                }
            }
        } catch (Exception e) {
            log.error("getFileList error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return retList;
    }
    /**
     * 刪除文件
     *
     * @param pathName
     * @return
     * @throws IOException
     */
    public boolean deleteFile(String pathName) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        boolean result = false;
        try {
            result = ftpClient.deleteFile(pathName);
        } catch (Exception e) {
            log.error("deleteFile error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return result;
    }
    /**
     * 上傳文件到FTP服務(wù)器，支持斷點續(xù)傳
     *
     * @param local  本地文件名稱，絕對路徑
     * @param remote 遠程文件路徑，按照Linux上的路徑指定方式，支持多級目錄嵌套，支持遞歸創(chuàng)建不存在的目錄結(jié)構(gòu)
     * @return 上傳結(jié)果
     * @throws IOException
     */
    public UploadStatus upload(String local, String remote) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        UploadStatus result = UploadStatus.UploadNewFileFailed;
        try {
            ftpClient.changeWorkingDirectory(ftpPoolService.getFtpPoolConfig().getWorkingDirectory());
            // 設(shè)置PassiveMode傳輸
            ftpClient.enterLocalPassiveMode();
            // 設(shè)置以二進制流的方式傳輸
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            ftpClient.setControlEncoding(CharsetUtil.UTF_8);
            // 對遠程目錄的處理
            String remoteFileName = remote;
            if (remote.contains("/")) {
                remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
                // 創(chuàng)建服務(wù)器遠程目錄結(jié)構(gòu)，創(chuàng)建失敗直接返回
                if (createDirecroty(remote, ftpClient) == UploadStatus.CreateDirectoryFail) {
                    return UploadStatus.CreateDirectoryFail;
                }
            }
            // 檢查遠程是否存在文件
            FTPFile[] files = ftpClient.listFiles(new String(remoteFileName.getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1));
            if (files.length == 1) {
                long remoteSize = files[0].getSize();
                File f = new File(local);
                long localSize = f.length();
                if (remoteSize == localSize) { // 文件存在
                    return UploadStatus.FileExits;
                } else if (remoteSize > localSize) {
                    return UploadStatus.RemoteFileBiggerThanLocalFile;
                }
                // 嘗試移動文件內(nèi)讀取指針,實現(xiàn)斷點續(xù)傳
                result = uploadFile(remoteFileName, f, ftpClient, remoteSize);
                // 如果斷點續(xù)傳沒有成功，則刪除服務(wù)器上文件，重新上傳
                if (result == UploadStatus.UploadFromBreakFailed) {
                    if (!ftpClient.deleteFile(remoteFileName)) {
                        return UploadStatus.DeleteRemoteFaild;
                    }
                    result = uploadFile(remoteFileName, f, ftpClient, 0);
                }
            } else {
                result = uploadFile(remoteFileName, new File(local), ftpClient, 0);
            }
        } catch (Exception e) {
            log.error("upload error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return result;
    }
    /**
     * 遞歸創(chuàng)建遠程服務(wù)器目錄
     *
     * @param remote    遠程服務(wù)器文件絕對路徑
     * @param ftpClient FTPClient對象
     * @return 目錄創(chuàng)建是否成功
     * @throws IOException
     */
    public UploadStatus createDirecroty(String remote, FTPClient ftpClient) throws IOException {
        UploadStatus status = UploadStatus.CreateDirectorySuccess;
        String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
        if (!directory.equalsIgnoreCase("/") && !ftpClient.changeWorkingDirectory(new String(directory.getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1))) {
            // 如果遠程目錄不存在，則遞歸創(chuàng)建遠程服務(wù)器目錄
            int start = 0;
            int end = 0;
            if (directory.startsWith("/")) {
                start = 1;
            } else {
                start = 0;
            }
            end = directory.indexOf("/", start);
            while (true) {
                String subDirectory = new String(remote.substring(start, end).getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1);
                if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                    if (ftpClient.makeDirectory(subDirectory)) {
                        ftpClient.changeWorkingDirectory(subDirectory);
                    } else {
                        log.info("創(chuàng)建目錄失敗");
                        return UploadStatus.CreateDirectoryFail;
                    }
                }
                start = end + 1;
                end = directory.indexOf("/", start);
                // 檢查所有目錄是否創(chuàng)建完畢
                if (end <= start) {
                    break;
                }
            }
        }
        return status;
    }
    /**
     * 上傳文件到服務(wù)器,新上傳和斷點續(xù)傳
     *
     * @param remoteFile 遠程文件名，在上傳之前已經(jīng)將服務(wù)器工作目錄做了改變，一定要注意這里的 remoteFile 已經(jīng)別被編碼 ISO-8859-1
     * @param localFile  本地文件File句柄，絕對路徑
     * @param ftpClient  FTPClient引用
     * @return
     * @throws IOException
     */
    public UploadStatus uploadFile(String remoteFile, File localFile, FTPClient ftpClient, long remoteSize) {
        if (null == ftpClient) {
            ftpClient = ftpPoolService.borrowObject();
            ;
        }
        if (null == ftpClient) {
            return null;
        }
        UploadStatus status = UploadStatus.UploadNewFileFailed;
        try (RandomAccessFile raf = new RandomAccessFile(localFile, "r");
             // 一定要注意這里的 remoteFile 已經(jīng)別被編碼 ISO-8859-1
             OutputStream out = ftpClient.appendFileStream(remoteFile);) {
            // 顯示進度的上傳
            log.info("localFile.length():" + localFile.length());
            long step = localFile.length() / 100;
            step = step == 0 ? 1 : step;// 文件過小，step可能為0
            long process = 0;
            long localreadbytes = 0L;
            // 斷點續(xù)傳
            if (remoteSize > 0) {
                ftpClient.setRestartOffset(remoteSize);
                process = remoteSize / step;
                raf.seek(remoteSize);
                localreadbytes = remoteSize;
            }
            byte[] bytes = new byte[1024];
            int c;
            while ((c = raf.read(bytes)) != -1) {
                out.write(bytes, 0, c);
                localreadbytes += c;
                if (localreadbytes / step != process) {
                    process = localreadbytes / step;
                    if (process % 10 == 0) {
                        log.info("上傳進度：" + process);
                    }
                }
            }
            out.flush();
            raf.close();
            out.close();
            // FTPUtil的upload方法在執(zhí)行ftpClient.completePendingCommand()之前應(yīng)該先關(guān)閉OutputStream，否則主線程會在這里卡死執(zhí)行不下去。
            // 原因是completePendingCommand()會一直在等FTP Server返回226 Transfer complete，但是FTP Server只有在接受到OutputStream執(zhí)行close方法時，才會返回。
            boolean result = ftpClient.completePendingCommand();
            if (remoteSize > 0) {
                status = result ? UploadStatus.UploadFromBreakSuccess : UploadStatus.UploadFromBreakFailed;
            } else {
                status = result ? UploadStatus.UploadNewFileSuccess : UploadStatus.UploadNewFileFailed;
            }
        } catch (Exception e) {
            log.error("uploadFile error ", e);
        }
        return status;
    }
    /**
     * 下載資源文件
     *
     * @param sourceFileName
     * @return
     * @throws IOException
     */
    public InputStream downFile(String sourceFileName) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        InputStream result = null;
        try {
            result = ftpClient.retrieveFileStream(sourceFileName);
        } catch (Exception e) {
            log.error("deleteFile error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
        return result;
    }
    /**
     * 查看用戶目錄
     *
     * @param path
     * @throws IOException
     */
    public void listFilesDir(String path) {
        FTPClient ftpClient = ftpPoolService.borrowObject();
        try {
            String ftpPath = path;
            ftpClient.changeWorkingDirectory(ftpPath);
            FTPFile[] files = ftpClient.listFiles();
            for (FTPFile ff : files) {
                if (!ff.isDirectory()) {
                } else {
                    if (!ff.getName().startsWith(".")) {
                        ftpPath = ff.getName() + "/";
                        ftpClient.changeWorkingDirectory(ftpPath);
                        listFilesDir(ftpPath);
                        ftpClient.changeWorkingDirectory(path);
                    }
                }
            }
        } catch (Exception e) {
            log.error("deleteFile error ", e);
        } finally {
            ftpPoolService.returnObject(ftpClient);
        }
    }
    /**
     * 上傳狀態(tài)枚舉
     */
    public enum UploadStatus {
        CreateDirectoryFail, // 遠程服務(wù)器相應(yīng)目錄創(chuàng)建失敗
        CreateDirectorySuccess, // 遠程服務(wù)器闖將目錄成功
        UploadNewFileSuccess, // 上傳新文件成功
        UploadNewFileFailed, // 上傳新文件失敗
        FileExits, // 文件已經(jīng)存在
        RemoteFileBiggerThanLocalFile, // 遠程文件大于本地文件
        UploadFromBreakSuccess, // 斷點續(xù)傳成功
        UploadFromBreakFailed, // 斷點續(xù)傳失敗
        DeleteRemoteFaild; // 刪除遠程文件失敗
    }
    /**
     * 下載狀態(tài)枚舉
     */
    public enum DownloadStatus {
        RemoteFileNotExist, // 遠程文件不存在
        DownloadNewSuccess, // 下載文件成功
        DownloadNewFailed, // 下載文件失敗
        LocalFileBiggerThanRemoteFile, // 本地文件大于遠程文件
        DownloadFromBreakSuccess, // 斷點續(xù)傳成功
        DownloadFromBreakFailed; // 斷點續(xù)傳失敗
    }
}

package com.demo.sftp.config;
import lombok.Data;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@EnableConfigurationProperties
@PropertySource(value = {"sftp.properties"})
@ConfigurationProperties(prefix = "sftp.client")
@Configuration
@Data
public class SFTPPoolConfig extends GenericObjectPoolConfig {
    // 默認進入的路徑
    String workingDirectory;
    // 主機地址
    String host;
    // 主機端口
    int port;
    // 主機用戶名
    String username;
    // 主機密碼
    String password;
    // 主機密碼
    String privateKey;
    // 傳輸編碼
    String encoding;
    // 連接超時時間
    int clientTimeout;
    // 重新連接時間
    int retryTimes;
    // 緩存大小
    int bufferSize;
    // 最大數(shù)
    int maxTotal;
    // 最小空閑
    int minldle;
    // 最大空閑
    int maxldle;
    // 最大等待時間
    int maxWait;
    // 池對象耗盡之后是否阻塞，maxWait < 0 時一直等待
    boolean blockWhenExhausted;
    // 取對象時驗證
    boolean testOnBorrow;
    // 回收驗證
    boolean testOnReturn;
    // 創(chuàng)建時驗證
    boolean testOnCreate;
    // 空閑驗證
    boolean testWhileldle;
    // 后進先出
    boolean lifo;
}

package com.demo.sftp.factory;
import com.demo.sftp.config.SFTPPoolConfig;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import lombok.EqualsAndHashCode;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Properties;
/**
 * SFTP 工廠聲場連接對象
 */
@EqualsAndHashCode(callSuper = true)
@Component
@Slf4j
public class ChannelSftpFactory extends BasePooledObjectFactory<ChannelSftp>{
    /**
     * 注入 sftp 連接配置
     */
    @Autowired
    SFTPPoolConfig config;
    /**
     * 新建對象
     */
    @Override
    public ChannelSftp create() {
        ChannelSftp channel = null;
        try {
            // 用戶名密碼不能為空
            if (StringUtils.isBlank(config.getUsername()) || StringUtils.isBlank(config.getPassword())) {
                log.error("username or password is needed !!!");
                return null;
            }
            JSch jsch = new JSch();
            // 設(shè)置私鑰
            if (StringUtils.isNotBlank(config.getPrivateKey())) {
                jsch.addIdentity(config.getPrivateKey());
            }
            // jsch的session需要補充設(shè)置sshConfig.put("PreferredAuthentications", "publickey,keyboard-interactive,password")來跳過Kerberos認證，同樣的HutoolSFTPUtil工具類里面也有這個問題
            Session sshSession = jsch.getSession(config.getUsername(), config.getHost(), config.getPort());
            sshSession.setPassword(config.getPassword());
            Properties sshConfig = new Properties();
            // “StrictHostKeyChecking”如果設(shè)置成“yes”，ssh就不會自動把計算機的密匙加入“$HOME/.ssh/known_hosts”文件，并且一旦計算機的密匙發(fā)生了變化，就拒絕連接。
            sshConfig.put("StrictHostKeyChecking", "no");
            sshSession.setConfig(sshConfig);
            sshSession.connect();
            channel = (ChannelSftp) sshSession.openChannel("sftp");
            channel.connect();
        } catch (Exception e) {
            log.error("連接 sftp 失敗，請檢查配置", e);
        }
        return channel;
    }
    /**
     * 創(chuàng)建一個連接
     *
     * @param channelSftp
     * @return
     */
    @Override
    public PooledObject<ChannelSftp> wrap(ChannelSftp channelSftp) {
        return new DefaultPooledObject<>(channelSftp);
    }
    /**
     * 銷毀一個連接
     *
     * @param p
     */
    @Override
    public void destroyObject(PooledObject<ChannelSftp> p) {
        ChannelSftp channelSftp = p.getObject();
        channelSftp.disconnect();
    }
    @Override
    public boolean validateObject(final PooledObject<ChannelSftp> p) {
        final ChannelSftp channelSftp = p.getObject();
        try {
            if (channelSftp.isClosed()) {
                return false;
            }
            channelSftp.cd("/");
        } catch (Exception e) {
            log.error("channelSftp 不可用 ", e);
            return false;
        }
        return true;
    }
    /**
     * 獲取 FTP 連接配置
     * @return
     */
    public SFTPPoolConfig getConfig(){
        return config;
    }
}

package com.demo.sftp.service;
import com.demo.sftp.config.SFTPPoolConfig;
import com.jcraft.jsch.ChannelSftp;
/**
 * 獲取 sftp 客戶端對象的接口
 */
public interface SFTPPoolService {
    /**
     * 獲取 sftp
     */
    ChannelSftp borrowObject() ;

    /**
     * 歸還 sftp
     */
    void returnObject(ChannelSftp channelSftp);
    /**
     * 獲取 ftp 配置信息
     * @return
     */
    SFTPPoolConfig getFtpPoolConfig();
}

package com.demo.sftp.service.imp;
import com.demo.sftp.config.SFTPPoolConfig;
import com.demo.sftp.factory.ChannelSftpFactory;
import com.demo.sftp.service.SFTPPoolService;
import com.jcraft.jsch.ChannelSftp;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
@Slf4j
public class SFTPPoolServiceImpl implements SFTPPoolService {
    /**
     * ftp 連接池生成
     */
    private GenericObjectPool<ChannelSftp> pool;
    /**
     * ftp 客戶端配置文件
     */
    @Autowired
    private SFTPPoolConfig config;
    /**
     * ftp 客戶端工廠
     */
    @Autowired
    private ChannelSftpFactory factory;
    /**
     * 初始化pool
     */
    @PostConstruct
    private void initPool() {
        this.pool = new GenericObjectPool<ChannelSftp>(this.factory, this.config);
    }
    /**
     * 獲取sftp
     */
    @Override
    public ChannelSftp borrowObject() {
        if (this.pool != null) {
            try {
                return this.pool.borrowObject();
            } catch (Exception e) {
                log.error("獲取 ChannelSftp 失敗", e);
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 歸還 sftp
     */
    @Override
    public void returnObject(ChannelSftp channelSftp) {
        if (this.pool != null && channelSftp != null) {
            this.pool.returnObject(channelSftp);
        }
    }
    @Override
    public SFTPPoolConfig getFtpPoolConfig() {
        return config;
    }
}

package com.demo.util;
import cn.hutool.core.io.file.FileNameUtil;
import cn.hutool.core.util.ArrayUtil;
import com.demo.sftp.service.SFTPPoolService;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.SftpException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.stream.Collectors;
/**
 * Sftp工具類
 */
@Component
@Slf4j
public class SFTPUtil {
    /**
     * sftp連接池服務(wù)
     */
    @Autowired
    SFTPPoolService sFtpPoolService;
    /**
     * 文件分隔符，linux下就是 /
     */
    private String NODE_SEPARATOR = "/";
    /**
     * 權(quán)限數(shù)字
     */
    private String permission = "755";
    /**
     * 每個目錄下最大子文件(夾)數(shù)量
     */
    private int MAX_CHILD_FILE_NUMBER = 1000;
    /**
     * 本地文件上傳到遠程 目錄
     *
     * @param relativePath 遠程文件最后一級目錄
     * @param fileName 遠程文件名
     * @param localFileFullPath 本地文件全路徑
     * @return
     */
    public String uploadLocalToRemote(String relativePath, String fileName, String localFileFullPath) {
        String remoteFullPath = "";
        File localFile = new File(localFileFullPath);
        if (localFile.exists() && localFile.isFile()) {
            try (InputStream inputStream = new FileInputStream(localFile)) {
                if (!relativePath.endsWith(NODE_SEPARATOR)) {
                    relativePath = relativePath.concat(NODE_SEPARATOR);
                }
                remoteFullPath = upload(relativePath, fileName, inputStream);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return remoteFullPath;
    }
    /**
     * 附件上傳
     *
     * @param fileName    文件名
     * @param inputStream 文件流
     * @return 上傳后的文件完整路徑
     */
    public String upload(String fileName, InputStream inputStream) {
        return upload(null, fileName, inputStream);
    }
    /**
     * 文件上傳
     *
     * @param relativePath 文件保存的相對路徑(最后一級目錄)
     * @param fileName     文件名
     * @param inputStream  文件流
     * @return 上傳后的文件完整路徑
     */
    public String upload(String relativePath, String fileName, InputStream inputStream) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        String filePath = sFtpPoolService.getFtpPoolConfig().getWorkingDirectory();
        try {
            if (relativePath != null && !relativePath.trim().isEmpty()) {
                filePath = filePath + relativePath;
            }
            if (!dirIsExist(filePath)) {
                filePath = generateValidPath(filePath, sftp);
            }
            filePath = filePath.concat(fileName);
            sftp.put(inputStream, filePath);
            sftp.chmod(Integer.parseInt(permission, 8), filePath);
            return filePath;
        } catch (SftpException e) {
            log.error("SFTP上傳文件出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
        return filePath;
    }
    /**
     * 文件下載
     *
     * @param fileUrl 文件路徑
     * @return 文件字節(jié)數(shù)組
     */
    public byte[] download(String fileUrl) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            InputStream inputStream = sftp.get(fileUrl);
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            int n;
            byte[] data = new byte[sFtpPoolService.getFtpPoolConfig().getBufferSize()];
            while ((n = inputStream.read(data, 0, data.length)) != -1) {
                buffer.write(data, 0, n);
            }
            buffer.flush();
            return buffer.toByteArray();
        } catch (IOException | SftpException e) {
            log.error("SFTP下載文件出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
        return new byte[0];
    }
    /**
     * 創(chuàng)建目錄(只能創(chuàng)建一級目錄,如果需要創(chuàng)建多級目錄,需要調(diào)用mkdirs方法)
     *
     * @param path 目錄路徑
     */
    public void createFolder(String path) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            sftp.mkdir(path);
        } catch (SftpException e) {
            log.error("SFTP創(chuàng)建文件夾出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
    }
    /**
     * 如果目錄不存在，則創(chuàng)建多級目錄
     *
     * @param path
     * @return
     */
    public boolean createFolders(String path){
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        boolean result = false;
        try {
            if (validatePathValid(path, sftp)) {
                result = true;
            } else {
                String newPath = path + String.valueOf(System.currentTimeMillis()).substring(9);
                mkdirs(sftp, newPath.split("/"), "", newPath.split("/").length, 0);
                result = true;
            }
        } catch (Exception e) {
            log.error("SFTP創(chuàng)建文件夾出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
        return result;
    }
    /**
     * 文件讀取
     *
     * @param fileUrl 文件路徑
     * @return 文件字節(jié)數(shù)組
     */
    public String read(String fileUrl) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            InputStream inputStream = sftp.get(fileUrl);
            BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
            String str, resultStr = "";
            while ((str = in.readLine()) != null) {
                resultStr = resultStr.concat(str);
            }
            return resultStr;
        } catch (SftpException | IOException e) {
            log.error("SFTP讀取文件出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
        return "";
    }
    /**
     * 判斷目錄是否存在
     *
     * @param url 文件夾目錄
     * @return ture:存在；false:不存在
     */
    public boolean dirIsExist(String url) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            if (isDirectory(url)) {
                sftp.cd(url);
                String pwd = sftp.pwd();
                return pwd.equals(url) || pwd.concat("/").equals(url);
            }
            return false;
        } catch (SftpException e) {
            log.error("SFTP讀取文件夾出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
        return false;
    }
    /**
     * 刪除文件 或 刪除文件夾
     * 注: 如果是文件夾， 不論該文件夾中有無內(nèi)容，都能刪除， 因此:此方法慎用
     *
     * @param remoteDirOrRemoteFile 要刪除的文件  或 文件夾
     */
    public void delete(String remoteDirOrRemoteFile) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            List<String> targetFileOrDirContainer = new ArrayList<>(8);
            targetFileOrDirContainer.add(remoteDirOrRemoteFile);
            List<String> toBeDeletedEmptyDirContainer = new ArrayList<>(8);
            if (isDirectory(remoteDirOrRemoteFile)) {
                toBeDeletedEmptyDirContainer.add(remoteDirOrRemoteFile);
            }
            collectToBeDeletedEmptyDir(toBeDeletedEmptyDirContainer, targetFileOrDirContainer);
            if (!toBeDeletedEmptyDirContainer.isEmpty()) {
                String targetDir;
                for (int i = toBeDeletedEmptyDirContainer.size() - 1; i >= 0; i--) {
                    targetDir = toBeDeletedEmptyDirContainer.get(i);
                    sftp.rmdir(targetDir);
                }
            }
        } catch (SftpException e) {
            log.error("SFTP刪除文件或者文件夾出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
    }
    /**
     * 刪除相關(guān)文件 并 采集所有 需要被刪除的 文件夾
     * <p>
     * 注: 如果是文件夾， 不論該文件夾中有無內(nèi)容，都能刪除， 因此:此方法慎用
     *
     * @param toBeDeletedEmptyDirContainer 所有待刪除的空文件夾集合
     * @param targetFileOrDirContainer     本次, 要刪除的文件的集合   或   本次, 要刪除的文件所在文件夾的集合
     */
    public void collectToBeDeletedEmptyDir(List<String> toBeDeletedEmptyDirContainer, List<String> targetFileOrDirContainer) {
        List<String> todoCallDirContainer = new ArrayList<>(8);
        List<String> subfolderList;
        for (String remoteDirOrRemoteFile : targetFileOrDirContainer) {
            subfolderList = fileDeleteExecutor(remoteDirOrRemoteFile);
            toBeDeletedEmptyDirContainer.addAll(subfolderList);
            todoCallDirContainer.addAll(subfolderList);
        }
        if (!todoCallDirContainer.isEmpty()) {
            collectToBeDeletedEmptyDir(toBeDeletedEmptyDirContainer, todoCallDirContainer);
        }
    }
    /**
     * 刪除remoteDirOrRemoteFile指向的文件 或 刪除remoteDirOrRemoteFile指向的文件夾下的所有子級文件
     * 注: 如果是文件夾， 只會刪除該文件夾下的子級文件；不會刪除該文件夾下的孫子級文件(如果有孫子級文件的話)
     *
     * @param remoteDirOrRemoteFile 要刪除的文件 或 要 文件夾   【絕對路徑】
     * @return remoteDirOrRemoteFile指向的文件夾 下的 文件夾集合
     * 注: 如果remoteDirOrRemoteFile指向的是文件的話，返回空的集合
     * 注: 只會包含子級文件夾，不包含孫子級文件夾(如果有孫子級文件夾的話)
     */
    public List<String> fileDeleteExecutor(String remoteDirOrRemoteFile) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            List<String> subfolderList = new ArrayList<>(8);
            // 如果是文件，直接刪除
            if (!isDirectory(remoteDirOrRemoteFile)) {
                sftp.rm(remoteDirOrRemoteFile);
                return subfolderList;
            }
            // 保證 remoteDirOrRemoteFile 以 “/” 開頭,以 “/” 結(jié)尾
            remoteDirOrRemoteFile = handlePath(remoteDirOrRemoteFile, true, true);
            Vector<?> vector = sftp.ls(remoteDirOrRemoteFile);
            String fileName;
            String sftpAbsoluteFilename;
            // 列出文件名
            for (Object item : vector) {
                ChannelSftp.LsEntry entry = (ChannelSftp.LsEntry) item;
                fileName = entry.getFilename();
                if (invalidFileName(fileName)) {
                    continue;
                }
                sftpAbsoluteFilename = remoteDirOrRemoteFile + fileName;
                // 如果是文件，直接刪除
                if (!isDirectory(sftpAbsoluteFilename)) {
                    sftp.rm(sftpAbsoluteFilename);
                    continue;
                }
                subfolderList.add(sftpAbsoluteFilename);
            }
            return subfolderList;
        } catch (SftpException e) {
            log.error("SFTP刪除文件或者文件夾出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
        return new ArrayList<>(0);
    }
    /**
     * 從給定路徑中截取文件名
     *
     * @param path 路徑，  如: /files/abc/info.yml
     * @return 文件名， 如: info.yml
     */
    private String getFilenameFromPath(String path) {
        return path.substring(path.lastIndexOf(NODE_SEPARATOR) + 1);
    }
    /**
     * 路徑處理器
     * <p>
     * 根據(jù)參數(shù)控制處理類型，如:
     * 當: originPath 為【var/apps】時，
     * 當: handleHead 為 true, 處理結(jié)果為【/var/apps】
     * 當: handleTail 為 true, 處理結(jié)果為【var/apps/】
     * 當: handleHead 和 handleTail 均為 true, 處理結(jié)果為【/var/apps/】
     *
     * @param originPath 要處理的路徑
     * @param handleHead 處理 起始處
     * @param handleTail 處理 結(jié)尾處
     * @return 處理后的路徑
     */
    private String handlePath(String originPath, boolean handleHead, boolean handleTail) {
        if (originPath == null || "".equals(originPath.trim())) {
            return NODE_SEPARATOR;
        }
        if (handleHead && !originPath.startsWith(NODE_SEPARATOR)) {
            originPath = NODE_SEPARATOR.concat(originPath);
        }
        if (handleTail && !originPath.endsWith(NODE_SEPARATOR)) {
            originPath = originPath.concat(NODE_SEPARATOR);
        }
        return originPath;
    }
    /**
     * 判斷是否為無效的文件名
     * 注:文件名(夾)名為【.】或【..】時，是無效的
     *
     * @param fileName 文件名
     * @return 是有無效
     */
    public boolean invalidFileName(String fileName) {
        return ".".equals(fileName) || "..".equals(fileName);
    }
    /**
     * 判斷SFTP上的path是否為文件夾
     * 注:如果該路徑不存在，那么會返回false
     *
     * @param path SFTP上的路徑
     * @return 判斷結(jié)果
     */
    public boolean isDirectory(String path) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        // 合法的錯誤id
        // int legalErrorId = 4;
        try {
            sftp.cd(path);
            return true;
        } catch (SftpException e) {
            // 如果 path不存在，那么報錯信息為【No such file】，錯誤id為【2】
            // 如果 path存在，但是不能cd進去，那么報錯信息形如【Can't change directory: /files/sqljdbc4-3.0.jar】，錯誤id為【4】
            return false;
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
    }
    /**
     * 獲取某個文件夾下的所有文件名稱
     *
     * @param path      文件夾路徑
     * @param fileTypes 文件類型,如果為null或者長度為0,則獲取所有文件名稱,如果已指定,則獲取指定類型的文件類型
     * @return 文件名稱
     */
    public List<String> queryFileName(String path, String... fileTypes) {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            Vector<ChannelSftp.LsEntry> ls = sftp.ls(path);
            return ls.stream().map(ChannelSftp.LsEntry::getFilename).filter(
                    name -> {
                        if (ArrayUtil.isNotEmpty(fileTypes)) {
                            return FileNameUtil.isType(name, fileTypes);
                        }
                        return true;
                    }).collect(Collectors.toList());
        } catch (SftpException e) {
            log.error("SFTP獲取某個文件夾下的所有文件名稱出錯", e);
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
        return new ArrayList<>(0);
    }
    /**
     * 創(chuàng)建多級文件目錄
     *
     * @param dirs     每個目錄的名稱數(shù)組
     * @param tempPath 臨時路徑，傳入""空字符串，主要為了遞歸調(diào)用方便
     * @param length   數(shù)組長度
     * @param index    當前索引，為了遞歸調(diào)用
     */
    private void mkdirs(ChannelSftp sftp, String[] dirs, String tempPath, int length, int index) {
        // 以"/a/b/c/d"為例按"/"分隔后,第0位是"";顧下標從1開始
        index++;
        if (index < length) {
            // 目錄不存在，則創(chuàng)建文件夾
            tempPath += "/" + dirs[index];
        }
        try {
            sftp.cd(tempPath);
            if (index < length) {
                mkdirs(sftp, dirs, tempPath, length, index);
            }
        } catch (SftpException ex) {
            try {
                sftp.mkdir(tempPath);
                sftp.chmod(Integer.parseInt(permission, 8), tempPath);
                sftp.cd(tempPath);
            } catch (SftpException e) {
                return;
            }
            mkdirs(sftp, dirs, tempPath, length, index);
        }
    }
    /**
     * 統(tǒng)計目錄下文件(夾)數(shù)量
     *
     * @param path 目錄路徑
     * @return 文件數(shù)量
     */
    private int countFiles(String path) throws SftpException {
        ChannelSftp sftp = sFtpPoolService.borrowObject();
        try {
            sftp.cd(path);
            return sftp.ls(path).size();
        } finally {
            sFtpPoolService.returnObject(sftp);
        }
    }
    /**
     * 校驗路徑是否可用
     *
     * @param path 路徑
     * @return 是否可用
     */
    private boolean validatePathValid(String path, ChannelSftp sftp) {
        int countFiles = 0;
        try {
            countFiles = countFiles(path);
        } catch (SftpException e) {
            mkdirs(sftp, path.split("/"), "", path.split("/").length, 0);
        }
        return countFiles <= MAX_CHILD_FILE_NUMBER;
    }
    /**
     * 生成有效路徑
     *
     * @param path 參數(shù)路徑
     * @return 解析后的有效路徑
     */
    private String generateValidPath(String path, ChannelSftp sftp) {
        if (validatePathValid(path, sftp)) {
            return path;
        } else {
            String newPath = path + String.valueOf(System.currentTimeMillis()).substring(9);
            mkdirs(sftp, newPath.split("/"), "", newPath.split("/").length, 0);
            return newPath;
        }
    }
}

package com.demo.util;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.extra.ssh.JschUtil;
import cn.hutool.extra.ssh.Sftp;
import com.demo.sftp.config.SFTPPoolConfig;
import com.jcraft.jsch.Session;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.File;
@Component
@Slf4j
public class HutoolSFTPUtil {
    @Autowired
    SFTPPoolConfig sftpPoolConfig;
    /**
     * 創(chuàng)建目錄
     *
     * @param newDir
     */
    public boolean mkdir(String newDir) {
        // jsch的session需要補充設(shè)置sshConfig.put("PreferredAuthentications", "publickey,keyboard-interactive,password")來跳過Kerberos認證，同樣的HutoolSFTPUtil工具類里面也有這個問題
        Session session = JschUtil.createSession(sftpPoolConfig.getHost(), sftpPoolConfig.getPort(), sftpPoolConfig.getUsername(), sftpPoolConfig.getPassword());
        Sftp sftp = JschUtil.createSftp(session);
        boolean result = false;
        try {
            result = sftp.mkdir(newDir);
        } catch (Exception e) {
            log.error("mkdir error ", e);
        } finally {
            JschUtil.close(session);
        }
        return result;
    }
    /**
     * 刪除目錄
     *
     * @param delDir
     */
    public boolean delDir(String delDir) {
        Session session = JschUtil.createSession(sftpPoolConfig.getHost(), sftpPoolConfig.getPort(), sftpPoolConfig.getUsername(), sftpPoolConfig.getPassword());
        Sftp sftp = JschUtil.createSftp(session);
        boolean result = false;
        try {
            result = sftp.delDir(delDir);
        } catch (Exception e) {
            log.error("mkdir error ", e);
        } finally {
            JschUtil.close(session);
        }
        return result;
    }
    /**
     * 遞歸創(chuàng)建目錄
     *
     * @param newDir
     * @return
     */
    public boolean mkdirs(String newDir) {
        Session session = JschUtil.createSession(sftpPoolConfig.getHost(), sftpPoolConfig.getPort(), sftpPoolConfig.getUsername(), sftpPoolConfig.getPassword());
        Sftp sftp = JschUtil.createSftp(session);
        boolean result = false;
        try {
            sftp.mkDirs(newDir);
            result = true;
        } catch (Exception e) {
            log.error("mkdir error ", e);
        } finally {
            JschUtil.close(session);
        }
        return result;
    }
    /**
     * 上傳文件
     *
     * @param destPath
     * @param srcFileFullPath
     * @return
     */
    public boolean upload(String destPath, String srcFileFullPath) {
        Session session = JschUtil.createSession(sftpPoolConfig.getHost(), sftpPoolConfig.getPort(), sftpPoolConfig.getUsername(), sftpPoolConfig.getPassword());
        Sftp sftp = JschUtil.createSftp(session);
        boolean result = false;
        try {
            File file = new File(srcFileFullPath);
            result = sftp.upload(destPath, file);
        } catch (Exception e) {
            log.error("mkdir error ", e);
        } finally {
            JschUtil.close(session);
        }
        return result;
    }
    /**
     * 下載文件
     *
     * @param src
     * @param destFileFullPath
     * @return
     */
    public boolean download(String src, String destFileFullPath) {
        Session session = JschUtil.createSession(sftpPoolConfig.getHost(), sftpPoolConfig.getPort(), sftpPoolConfig.getUsername(), sftpPoolConfig.getPassword());
        Sftp sftp = JschUtil.createSftp(session);
        boolean result = false;
        try {
            File destFile = new File(destFileFullPath);
            if (!destFile.exists()) {
                destFile.createNewFile();
            }
            sftp.download(src, destFile);
            result = true;
        } catch (Exception e) {
            log.error("mkdir error ", e);
        } finally {
            JschUtil.close(session);
        }
        return result;
    }
    /**
     * 遠程執(zhí)行 shell 命令
     *
     * @param command
     * @return
     * @throws Exception
     */
    public String exec(String command) {
        Session session = JschUtil.createSession(sftpPoolConfig.getHost(), sftpPoolConfig.getPort(), sftpPoolConfig.getUsername(), sftpPoolConfig.getPassword());
        String result = "";
        try {
            log.info("執(zhí)行命令：{}", command);
            result = JschUtil.exec(session, command, CharsetUtil.CHARSET_UTF_8);
            log.info("執(zhí)行結(jié)果：{}", result);
        } catch (Exception e) {
            log.error("exec error ", e);
        } finally {
            JschUtil.close(session);
        }
        return result;
    }
}

package com.demo.controller;
import com.demo.util.FTPUtil;
import com.demo.util.HutoolSFTPUtil;
import com.demo.util.SFTPUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * controller 測試
 *
 */
@RestController
@RequestMapping("/test")
@Slf4j
public class TestController {
    /**
     * 構(gòu)造方法注入
     */
    @Autowired
    FTPUtil ftpUtil;
    @Autowired
    SFTPUtil sftpUtil;
    @Autowired
    HutoolSFTPUtil hutoolSFTPUtil;
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/ftpCreate")
    public String ftpCreate() {
        boolean result =  false;
        try {
            result = ftpUtil.createDirectory("test03");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/upload")
    public String upload() {
        try {
            String remotePath = "/test01/test-20220718 -測試.txt";
            ftpUtil.createDirectory(remotePath);
            String localPath = "D:\\logs\\log\\test-20220718 -測試.txt";
            FTPUtil.UploadStatus uploadStatus = ftpUtil.upload(localPath,remotePath);
            log.info(String.valueOf(uploadStatus));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "success";
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/sftpCreate")
    public String sftpCreate() {
        boolean result =  false;
        try {
            result = sftpUtil.createFolders("/home/hadoop/sftpdata/test01");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/sftpUpload")
    public String sftpUpload() {
        String result =  "";
        try {
            String remotePath = "/test01";
            String remoteFileName = "test-20220718 -測試.txt";
            String localFileFullPath = "D:\\logs\\log\\test-20220718 -測試.txt";
            result = sftpUtil.uploadLocalToRemote(remotePath,remoteFileName,localFileFullPath);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/hutoolMakeDir")
    public String hutoolMakeDir() {
        boolean result = false;
        try {
            result = hutoolSFTPUtil.mkdir("/home/hadoop/sftpdata/hutool");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/hutoolMakeDirs")
    public String hutoolMakeDirs() {
        boolean result = false;
        try {
            result = hutoolSFTPUtil.mkdirs("/home/hadoop/sftpdata/hutool/test01/test02");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/hutoolUpload")
    public String hutoolUpload() {
        boolean result = false;
        try {
            String remoteFile = "/home/hadoop/sftpdata/hutool/test01/test02/test01.txt";
            String localFile = "D:\\logs\\log\\test-20220718 -測試.txt";
            String remotePath = remoteFile.substring(0,remoteFile.lastIndexOf("/"));
            if(hutoolSFTPUtil.mkdirs(remotePath)){
                result = hutoolSFTPUtil.upload(remoteFile,localFile);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/hutoolDownload")
    public String hutoolDownload() {
        boolean result = false;
        try {
            String remoteFile = "/home/hadoop/sftpdata/hutool/01.txt";
            String localFile = "D:\\logs\\log\\test-20220718-02.txt";
            result = hutoolSFTPUtil.download(remoteFile,localFile);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/hutoolDelDir")
    public String hutoolDelDir() {
        boolean result = false;
        try {
            result = hutoolSFTPUtil.delDir("/home/hadoop/sftpdata/hutool");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
    /**
     * 保存數(shù)據(jù)
     *
     * @return
     */
    @GetMapping("/exec")
    public String exec() {
        String result = "";
        try {
            result = hutoolSFTPUtil.exec("ls /home/hadoop");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return String.valueOf(result);
    }
}