java操作ftp server

stono發表於2024-04-24

參考：https://www.jianshu.com/p/2efc2669b736

POM依賴

        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.6</version>
        </dependency>

配置資訊：

ftp:
  hostName: 192.168.0.2
  port: 21
  userName:root
  passWord: root
  defaultLocalPath: D:/ftp  //下載到本地儲存的路徑
  defaultRemotePath: /ftp/ //ftp server上的檔案路徑

FTP建立：

@Component
public class FtpClientFactory {

    private static final String ENCODING = "utf-8";

    private static final int TIMEOUT = 10 * 1000;

    private final FtpConfig ftpConfig;

    public FtpClientFactory(FtpConfig ftpConfig) {
        this.ftpConfig = ftpConfig;
    }

    public FTPClient makeClient() {
        FTPClient ftpClient = new FTPClient();
        ftpClient.setConnectTimeout(TIMEOUT);
        ftpClient.setControlEncoding(ENCODING);
        try {
            // connect ftp server
            ftpClient.connect(ftpConfig.getHostName(), ftpConfig.getPort());
            // login ftp server
            ftpClient.login(ftpConfig.getUserName(), ftpConfig.getPassWord());
            // check whether login in to the server
            int replyCode = ftpClient.getReplyCode();
            if (FTPReply.isPositiveCompletion(replyCode)) {
                log.info("The login to the FTP server is successful.");
            } else {
                log.error("The login to the FTP server failed.");
                return null;
            }
            // File Type
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            // Passive Mode
            ftpClient.enterLocalActiveMode();
        } catch (Exception e) {
            log.error("factory make client exception", e);
            destroyClient(ftpClient);
        }
        return ftpClient;
    }

    public void destroyClient(FTPClient ftpClient) {
        try {
            if (ftpClient != null && ftpClient.isConnected()) {
                ftpClient.logout();
            }
        } catch (Exception e) {
            log.error("ftpClient logout exception", e);
        } finally {
            try {
                if (ftpClient != null) {
                    ftpClient.disconnect();
                }
            } catch (Exception e2) {
                log.error("ftpClient disconnect exception", e2);
            }
        }
    }

    public boolean validateClient(FTPClient ftpClient) {
        try {
            return ftpClient.sendNoOp();
        } catch (Exception e) {
            log.error("ftpClient validate exception", e);
        }
        return false;
    }

FTP工具類：

public class FtpUtils {

    private static final String SLASH_STR = "/";

    private static final String NOT_FIND_DIRECTORY = "Can not find the directory in ftp server.";

    private static final String NOT_FIND_FILE = "Can not find the file in the path.";

    private static final String NOT_FIND_LOCAL_PATH = "Can not find the local path.";

    private static final String LOCAL_PATH_NOT_DIRECTORY = "The local path is not a directory.";

    /**
     * traverse all files under the directory recursively
     *
     * @param ftpClient ftp client
     * @param fileList  file list
     * @param pathName  directory to be traversed, must start and end with a slash(/)
     */
    public static List<String> listFile(FTPClient ftpClient, List<String> fileList, String pathName) {
        if (pathName.startsWith(SLASH_STR) && pathName.endsWith(SLASH_STR)) {
            //change working directory
            changeWorkingDirectory(ftpClient, pathName);
            FTPFile[] files = new FTPFile[0];
            try {
                files = ftpClient.listFiles();
            } catch (IOException e) {
                log.error("Get ftp server file list error.");
            }
            for (FTPFile file : files) {
                if (file.isFile()) {
                    fileList.add(pathName + file.getName());
                } else if (file.isDirectory()) {
                    /*
                     * This judgment needs to be added.
                     * FTP will include the directory under the project file directory(./)
                     * and the directory under the directory one level up from the project
                     * file directory(../) in the recursion.
                     * It will cause a cycle, so need to filter it out.
                     */
                    if (!".".equals(file.getName()) && !"..".equals(file.getName())) {
                        listFile(ftpClient, fileList, pathName + file.getName() + SLASH_STR);
                    }
                }
            }
        }
        return fileList;
    }

    /**
     * traverse the specified type file under the directory recursively
     *
     * @param ftpClient ftp client
     * @param fileList  file list
     * @param pathName  directory to be traversed, must start and end with a slash(/)
     * @param ext       the extension of the file
     */
    public static List<String> listFileByExt(FTPClient ftpClient, List<String> fileList, String pathName, String ext) {
        if (pathName.startsWith(SLASH_STR) && pathName.endsWith(SLASH_STR)) {
            FTPFile[] files = new FTPFile[0];
            try {
                //change working directory
                changeWorkingDirectory(ftpClient, pathName);
                files = ftpClient.listFiles();
            } catch (IOException e) {
                log.error("Get ftp server file list error.");
            }
            for (FTPFile file : files) {
                if (file.isFile()) {
                    if (file.getName().endsWith(ext)) {
                        fileList.add(pathName + file.getName());
                    }
                } else if (file.isDirectory()) {
                    if (!".".equals(file.getName()) && !"..".equals(file.getName())) {
                        listFileByExt(ftpClient, fileList, pathName + file.getName() + SLASH_STR, ext);
                    }
                }
            }
        }
        return fileList;
    }

    /**
     * upload file
     *
     * @param ftpClient   ftp client
     * @param pathname    ftp server path
     * @param fileName    upload file name
     * @param inputStream inputStream
     * @return operation result
     */
    public static boolean uploadFile(FTPClient ftpClient, String pathname, String fileName, InputStream inputStream) {
        boolean flag = false;
        try {
            log.info("start upload file");
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            ftpClient.enterLocalPassiveMode();
            createDirectory(ftpClient, pathname);
            ftpClient.makeDirectory(pathname);
            ftpClient.setControlEncoding("utf-8");
            ftpClient.storeFile(fileName, inputStream);

            inputStream.close();
            flag = true;
            log.info("upload file successful");

        } catch (Exception e) {
            log.error("failed to upload file");
            e.printStackTrace();
        } finally {
            if (null != inputStream) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return flag;
    }


    /**
     * change working directory
     *
     * @param ftpClient ftp client
     * @param directory ftp directory
     * @return operation result
     */
    public static boolean changeWorkingDirectory(FTPClient ftpClient, String directory) {
        boolean flag;
        try {
            flag = ftpClient.changeWorkingDirectory(directory);
            if (flag) {
                log.info("enter" + directory + " successfully！");
            } else {
                log.info("enter" + directory + " failed！Start to create this directory.");
                throw new CommonException(HttpStatusCode.BAD_REQUEST, NOT_FIND_DIRECTORY);
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        return true;
    }

    /**
     * Create multilayer directory. If the directory already exists on the FTP server, do not create it. If no, create it.
     *
     * @param ftpClient ftp client
     * @param remote    remote path
     * @throws IOException io exception
     */
    public static void createDirectory(FTPClient ftpClient, String remote) throws IOException {
        String directory = remote + SLASH_STR;
        // If the remote directory does not exist, the remote server directory will be created recursively
        if (!SLASH_STR.equalsIgnoreCase(directory) && !changeWorkingDirectory(ftpClient, directory)) {
            int start = 0;
            int end;
            if (directory.startsWith(SLASH_STR)) {
                start = 1;
            }
            end = directory.indexOf(SLASH_STR, start);
            String path = "";
            do {
                String subDirectory = new String(remote.substring(start, end).getBytes(StandardCharsets.UTF_8), StandardCharsets.ISO_8859_1);
                path = path + SLASH_STR + subDirectory;
                if (!existFile(ftpClient, path)) {
                    if (!makeDirectory(ftpClient, subDirectory)) {
                        log.error("create directory[" + subDirectory + "]failed");
                    }
                }
                changeWorkingDirectory(ftpClient, subDirectory);

                start = end + 1;
                end = directory.indexOf(SLASH_STR, start);
                // Check whether all directories are created
            } while (end > start);
        }
    }

    /**
     * Check whether files on the FTP server exist
     *
     * @param ftpClient ftp client
     * @param path      path name
     * @return operation result
     * @throws IOException io exception
     */
    public static boolean existFile(FTPClient ftpClient, String path) throws IOException {
        boolean flag = false;
        FTPFile[] ftpFileArr = ftpClient.listFiles(path);
        if (ftpFileArr.length > 0) {
            flag = true;
        }
        return flag;
    }

    /**
     * Check whether local path exist
     *
     * @param path local path name
     */
    public static void existLocalPath(String path) {
        File directory = new File(path);
        if (!directory.exists()) {
            throw new CommonException(HttpStatusCode.BAD_REQUEST, NOT_FIND_LOCAL_PATH);
        }
        if (!directory.isDirectory()) {
            throw new CommonException(HttpStatusCode.BAD_REQUEST, LOCAL_PATH_NOT_DIRECTORY);
        }
    }

    /**
     * create directory
     *
     * @param ftpClient ftp client
     * @param dir       dir name
     * @return operation result
     */
    public static boolean makeDirectory(FTPClient ftpClient, String dir) {
        boolean flag = true;
        try {
            flag = ftpClient.makeDirectory(dir);
            if (flag) {
                log.info("create directory " + dir + " successful！");
            } else {
                log.error("create directory " + dir + " failed！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * download all files, not include package by given path
     *
     * @param ftpClient ftp client
     * @param pathName  FTP server path name
     * @param localPath local file path
     * @return operation result
     */
    public static boolean downloadFileByPath(FTPClient ftpClient, String pathName, String localPath) {
        boolean flag = false;
        OutputStream os = null;
        //switch ftp directory
        changeWorkingDirectory(ftpClient, pathName);
        //check local path
        existLocalPath(localPath);
        try {
            log.info("start to download file");
            FTPFile[] ftpFiles = ftpClient.listFiles();
            for (FTPFile file : ftpFiles) {
                if (file.isFile()) {
                    File localFile = new File(localPath + SLASH_STR + file.getName());
                    os = new FileOutputStream(localFile);
                    ftpClient.retrieveFile(file.getName(), os);
                    os.close();
                }
            }
            flag = true;
            log.info("download file successful");
        } catch (Exception e) {
            log.error("download file failed");
            e.printStackTrace();
        } finally {
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return flag;
    }

    /**
     * download file
     *
     * @param ftpClient ftp client
     * @param pathName  FTP server path name
     * @param fileName  file name
     * @param localPath local file path
     * @return operation result
     */
    public static boolean downloadFile(FTPClient ftpClient, String pathName, String fileName, String localPath) {
        boolean flag = false;
        OutputStream os = null;
        //switch ftp directory
        changeWorkingDirectory(ftpClient, pathName);
        //check local path
        existLocalPath(localPath);
        try {
            log.info("start to download file");
            FTPFile[] ftpFiles = ftpClient.listFiles();
            for (FTPFile file : ftpFiles) {
                if (fileName.equalsIgnoreCase(file.getName())) {
                    File localFile = new File(localPath + SLASH_STR + file.getName());
                    os = new FileOutputStream(localFile);
                    ftpClient.retrieveFile(file.getName(), os);
                    os.close();
                    flag = true;
                }
            }
        } catch (Exception e) {
            log.error("download file failed");
            e.printStackTrace();
        } finally {
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        if (!flag) {
            throw new CommonException(HttpStatusCode.BAD_REQUEST, NOT_FIND_FILE);
        }

        return true;
    }

    /**
     * delete file
     *
     * @param ftpClient ftp client
     * @param pathname  FTP server path name
     * @param filename  file name
     * @return operation result
     */
    public static boolean deleteFile(FTPClient ftpClient, String pathname, String filename) {
        boolean flag = false;
        try {
            log.info("start to delete file");
            // switch ftp directory
            ftpClient.changeWorkingDirectory(pathname);
            ftpClient.dele(filename);
            flag = true;
            log.info("delete file successful");
        } catch (Exception e) {
            log.info("delete file failed");
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * write inputStream to HtpServletResponse
     *
     * @param input    inputStream
     * @param response HttpServletResponse
     * @return operation result
     */
    public static boolean inputToResponse(InputStream input, HttpServletResponse response) {
        boolean flag = false;
        byte[] buffer = new byte[2048];
        BufferedInputStream bis = null;
        try {
            bis = new BufferedInputStream(input);
            OutputStream os = response.getOutputStream();
            int i = bis.read(buffer);
            while (i != -1) {
                os.write(buffer, 0, i);
                i = bis.read(buffer);
            }
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bis != null) {
                    bis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return flag;
    }
}

構建一個clientPool,原理是透過ftpClientFactory來建立ftpClient,然後將ftpClient放入一個阻塞佇列中(BlockingQueue<FTPClient> pool)

@Data
public class FtpClientPool {

    private static final int DEFAULT_POOL_SIZE = 16;

    private static final int TIMEOUT = 10;

    private BlockingQueue<FTPClient> pool;

    private FtpClientFactory factory;

    public FtpClientPool(FtpClientFactory factory) {
        this(factory, DEFAULT_POOL_SIZE);
    }

    public FtpClientPool(FtpClientFactory factory, int size) {
        this.factory = factory;
        this.pool = new ArrayBlockingQueue<>(size);
        initPool(size);
    }

    /**
     * Initialize the pool
     *
     * @param maxPoolSize max pool size
     * @throws Exception
     */
    private void initPool(int maxPoolSize) {
        try {
            int count = 0;
            while (count < maxPoolSize) {
                pool.offer(factory.makeClient(), TIMEOUT, TimeUnit.SECONDS);
                count++;
            }
        } catch (Exception e) {
            log.error("init ftp connection pool failed", e);
        }
    }

    public FTPClient borrowClient() {
        FTPClient client = null;
        try {
            client = pool.take();
        } catch (InterruptedException e) {
            log.error("Get connection from ftp connection pool error.");
        }

        if (client == null) {
            client = factory.makeClient();
            returnClient(client);
        } else if (!factory.validateClient(client)) {
            invalidateClient(client);
            client = factory.makeClient();
            returnClient(client);
        }
        return client;
    }

    /**
     * Return the client, or destroy it if it cannot be returned within 10 seconds
     *
     * @param ftpClient ftp client
     */
    public void returnClient(FTPClient ftpClient) {
        try {
            if (ftpClient != null && !pool.offer(ftpClient, TIMEOUT, TimeUnit.SECONDS)) {
                factory.destroyClient(ftpClient);
            }
        } catch (Exception e) {
            log.error("Failed to return client.", e);
        }
    }

    /**
     * Invalidate the client
     *
     * @param ftpClient ftp client
     */
    public void invalidateClient(FTPClient ftpClient) {
        pool.remove(ftpClient);
        factory.destroyClient(ftpClient);
    }

    @PreDestroy
    public void close() throws Exception {
        while (pool.iterator().hasNext()) {
            FTPClient client = pool.take();
            factory.destroyClient(client);
        }
    }

}

定期檢查連線狀態：

@Component
public class FtpClientKeepAlive {

    private static final int CYCLE_TIME = 30 * 1000;

    private KeepAliveThread keepAliveThread;

    private final FtpClientPool ftpClientPool;

    public FtpClientKeepAlive(FtpClientPool ftpClientPool) {
        this.ftpClientPool = ftpClientPool;
    }

    @PostConstruct
    public void init() {
        // Start the heartbeat detection thread
        if (keepAliveThread == null) {
            keepAliveThread = new KeepAliveThread();
            Thread thread = new Thread(keepAliveThread);
            thread.start();
        }
    }

    class KeepAliveThread implements Runnable {
        @Override
        public void run() {
            FTPClient ftpClient = null;
            while (true) {
                try {
                    BlockingQueue<FTPClient> pool = ftpClientPool.getPool();
                    if (pool != null && pool.size() > 0) {
                        Iterator<FTPClient> it = pool.iterator();
                        while (it.hasNext()) {
                            ftpClient = it.next();
                            boolean result = ftpClient.sendNoOp();
                            log.debug("heart beat result: {}", result);
                            if (!result) {
                                ftpClientPool.invalidateClient(ftpClient);
                            }
                        }

                    }
                } catch (Exception e) {
                    log.error("ftp heart beat exception", e);
                    ftpClientPool.invalidateClient(ftpClient);
                }

                try {
                    Thread.sleep(CYCLE_TIME);
                } catch (InterruptedException e) {
                    log.error("ftp sleep exception", e);
                }
            }

        }
    }
}

ftp server
2011-11-09
FTPServer
推薦一個java操作ftp的工具類
2019-01-19
JavaFTP
C#FTP操作
2010-05-31
C#FTP
Java實現FTP跨伺服器檔案操作
2020-11-14
JavaFTP伺服器
wing ftp server(ftp伺服器軟體)
2020-05-04
FTPServer伺服器
wing ftp server 註冊碼
2020-11-23
FTPServer
ftp工具,ftp工具怎麼使用,如何操作？使用教程圖解。
2020-05-30
FTP圖解
linux使用命令列操作ftp
2017-06-05
Linux命令列FTP
FTP命令詳解（含操作例項）
2015-06-06
FTP
java ftp工具類，帶你領略5款不同的java ftp工具類
2020-07-02
JavaFTP
wing ftp server網頁無法訪問
2015-01-27
FTPServer網頁
Python實現ftp常用操作[ftplib]
2015-11-25
PythonFTP
摘錄_c# ftp操作程式碼集
2011-11-07
C#FTP
使用FileZilla Server輕鬆搭建個人FTP伺服器
2015-05-25
ServerFTP伺服器
用java實現ftp的功能
2005-07-01
JavaFTP
JAVA FTP客戶端問題
2006-08-02
JavaFTP客戶端
FTP方式實現BS下的WORD操作 (轉)
2007-11-13
FTP
Sql_server基本操作
2018-08-28
SQLServer
Nodejs 操作 Sql Server
2018-11-24
NodeJSSQLServer
java 使用 common-net.jar來操作ftp伺服器上傳下載，刪除，移動，重新命名等操作
2018-09-11
JavaJARFTP伺服器
SQL Server 審計操作概念
2018-01-10
SQLServer
windows server 域間的操作
2024-03-25
WindowsServer
免費的FTP伺服器，FileZilla Server 0.9.42 版本釋出
2013-12-17
FTP伺服器Server
SQL Server 2008稽核操作組和操作
2008-11-25
SQLServer
雲端計算學習路線教程大綱課件：FTP Server
2019-10-15
FTPServer
zabbix server & proxy部署操作過程
2021-06-30
Server
Sql Server系列：資料庫操作
2014-11-07
SQLServer資料庫
Sql Server系列：資料表操作
2014-11-10
SQLServer
Sql Server系列：分割槽表操作
2014-11-10
SQLServer
SQL server 日期與時間操作
2009-02-16
SQLServer
操作 WebSphere Process Server 環境概述
2010-04-15
WebServer
C#操作SQL Server通用類
2016-01-24
C#SQLServer
Java上傳檔案到ftp伺服器
2018-04-11
JavaFTP伺服器
Java操作Word
2019-07-20
Java
java操作excel
2019-07-20
JavaExcel
JAVA操作XML
2017-11-06
JavaXML
Java操作MongoDB
2015-03-26
JavaMongoDB
Java 操作PDF
2014-07-15
Java

java操作ftp server

相關文章