ftp连接池实现文件上传下载

已于 2022-02-22 14:46:11 修改
阅读量1k 收藏 5
点赞数
文章标签： ftp java
于 2020-08-10 14:49:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45697944/article/details/107912587
版权

1、pom中引入依赖

<!-- FTp上传依赖-->
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.6</version>
        </dependency>
        <!-- 使用commons-pool 实现FTP连接池 -->
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>

2、设置ftp连接信息

在yml文件中设置

## ftp 服务器配置
FTP:
    ## 配置 ftp 服务器的 ip
    HOSTNAME: 10.10.1.xxx
    ##　ftp 服务的端口号
    PORT: 21
    ## 用于登录 ftp 服务器的用户
    USERNAME: ftpweb
    ## 用户的密码
    PASSWORD: aaaa
    ## ftp连接池的连接对象个数
    DEFAULTPOOLSIZE: 15
    ## 用户上传的文件的保存地址
    ## ftp 服务器配置时、指定了 ftp上传的 起始目录
    ## 完整地址: ftp起始目录/resource/ghtz/
    FILEPATH: /resource/ghtz/

编写实体类获取ftp连接信息，其中获取yml文件的信息使用@Value("${path}")的形式

package com.hwhy.hainandatacheck.common.util.ftp;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 文件上传常量
 * @className FtpConstant
 * @description TODO
 * @date 2020/6/24-17:21
 */
@Component
public class FtpConstant {

    /**
     * 规定文件名编码
     */
    private static String serverCharset = "ISO-8859-1";

    /**
     * 本地字符编码
     */
    private static String localCharset = "UTF-8";

    /**
     * 服务器地址
     */
    private static String hostName;

    /**
     * 服务器端口号默认为
     */
    private static Integer port;

    /**
     * 登录账号
     */
    private static String username;

    /**
     * 登录密码
     */
    private static String password;

    /**
     * 文件保存路径
     */
    private static String filePath;

    /**
     *
     */
    private static Integer defultPoolSize;

    public void setServerCharset(String serverCharset) {
        FtpConstant.serverCharset = serverCharset;
    }

    public void setLocalCharset(String localCharset) {
        FtpConstant.localCharset = localCharset;
    }

    @Value("${FTP.HOSTNAME}")
    public void setHostName(String hostName) {
        FtpConstant.hostName = hostName;
    }

    @Value("${FTP.PORT}")
    public void setPort(Integer port) {
        FtpConstant.port = port;
    }

    @Value("${FTP.USERNAME}")
    public void setUsername(String username) {
        FtpConstant.username = username;
    }

    @Value("${FTP.PASSWORD}")
    public void setPassword(String password) {
        FtpConstant.password = password;
    }

    @Value("${FTP.FILEPATH}")
    public void setFilePath(String filePath) {
        FtpConstant.filePath = filePath;
    }

    @Value("${FTP.DEFAULTPOOLSIZE}")
    public void setDefultPoolSize(Integer defultPoolSize) {
        FtpConstant.defultPoolSize = defultPoolSize;
    }

    public String getServerCharset() {
        return serverCharset;
    }

    public String getLocalCharset() {
        return localCharset;
    }

    public String getHostName() {
        return hostName;
    }

    public Integer getPort() {
        return port;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public String getFilePath() {
        return filePath;
    }

    public Integer getDefultPoolSize() {
        return defultPoolSize;
    }
}

3、编写ftp工厂

主要作用是生产ftp连接对象，实现 PoolableObjectFactory 接口后重写接口的几个方法，这个写法比较固定

package com.hwhy.hainandatacheck.common.util.ftp;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.commons.pool.PoolableObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
@Slf4j
@SuppressWarnings("all")
public class FtpFactory implements PoolableObjectFactory<FTPClient> {

    /**
     * 生成ftp连接对象
     *
     * @return
     * @throws Exception
     */
    @Override
    public FTPClient makeObject() throws Exception {
        FTPClient ftpClient = new FTPClient();
        ftpClient.setControlEncoding("utf-8");
        try {
            FtpConstant ftpConstant = new FtpConstant();
            log.info("连接ftp服务器:" + ftpConstant.getHostName() + ":" + ftpConstant.getPort());
            //连接ftp服务器
            if (!ftpClient.isConnected()) {
                ftpClient.connect(ftpConstant.getHostName(), ftpConstant.getPort());
            }
            //登录ftp服务器
            ftpClient.login(ftpConstant.getUsername(), ftpConstant.getPassword());
            //是否成功登录服务器
            int replyCode = ftpClient.getReplyCode();
            if (!FTPReply.isPositiveCompletion(replyCode)) {
                log.info("连接失败ftp服务器:" + ftpConstant.getHostName() + ":" + ftpConstant.getPort());
            }
            //连接超时为60秒
            ftpClient.setConnectTimeout(60000);
            log.info("FTP服务器 >>>>>>> 连接成功");
            FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"));
            ftpClient.setControlEncoding(ftpConstant.getLocalCharset());
            return ftpClient;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ftpClient;
    }

    /**
     * 释放ftp连接资源
     *
     * @param ftpClient
     * @throws Exception
     */
    @Override
    public void destroyObject(FTPClient ftpClient) throws Exception {
        try {
            if(ftpClient != null && ftpClient.isConnected()) {
                ftpClient.logout();
            }
        } catch (Exception e) {
            log.error("ftp Exception , 错误信息：", e);
            throw e;
        } finally {
            if(ftpClient != null) {
                ftpClient.disconnect();
            }
        }
    }

    /**
     * 验证 ftp连接对象 的有效性
     *
     * @param ftpClient
     * @return
     */
    @Override
    public boolean validateObject(FTPClient ftpClient) {
        try {
            return ftpClient.sendNoOp();
        } catch (Exception e) {
            log.error("Failed to validate client: {}");
        }
        return false;
    }

    @Override
    public void activateObject(FTPClient ftpClient) throws Exception {

    }

    @Override
    public void passivateObject(FTPClient ftpClient) throws Exception {

    }
}

4、编写ftp连接池

使用ftp工厂生产ftp连接对象并存入ftp连接池中，实现implements ObjectPool 接口后也是重写接口的几个方法，写法也比较固定

package com.hwhy.hainandatacheck.common.util.ftp;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolableObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

@Slf4j
public class FtpPool implements ObjectPool<FTPClient> {

    public static FtpFactory ftpFactory = new FtpFactory();

    public static BlockingQueue<FTPClient> blockingQueue;

    public static FtpConstant ftpConstant = new FtpConstant();


    /**
     * 初始化ftp连接池
     *
     * @param maxPoolSize
     * @throws Exception
     */
    static  {
        blockingQueue = new ArrayBlockingQueue<FTPClient>(ftpConstant.getDefultPoolSize());
        FtpFactory factory = new FtpFactory();

        int count = 0;
        while (count < ftpConstant.getDefultPoolSize()) {
            try {
                blockingQueue.offer(factory.makeObject());
                //blockingQueue.offer(factory.makeObject(), 20000, TimeUnit.MINUTES);
            }catch (Exception e){
                log.error("初始化ftpPool 时 FtpFactory的makeObject()错误：" , e);
            }
            count++;
        }
        log.info("ftpPool中连接对象个数为："+blockingQueue.size());
    }


    /**
     * 从 ftpPool 中获取连接对象
     *
     * @return
     * @throws Exception
     * @throws NoSuchElementException
     * @throws IllegalStateException
     */
    @Override
    public FTPClient borrowObject() throws Exception, NoSuchElementException, IllegalStateException {
        log.info("ftpPool 取出连接前的个数为:"+getNumIdle());

        FTPClient client = blockingQueue.poll(1, TimeUnit.MINUTES);
        log.info("ftpPool 取出连接后的个数为:"+getNumIdle());
        if (client == null) {
            this.addObject();
            log.info("client==null ");
            client=borrowObject();
        } else if (!ftpFactory.validateObject(client)) {
            log.info("获取的连接对象无效");
            //invalidateObject(client);
            try {
                ftpFactory.destroyObject(client);
            } catch (Exception e) {
                //e.printStackTrace();
                log.info("invalidateObject error:{}",e);
            }
            //制造并添加新对象到池中
            log.info("添加新的连接对象到 ftpPool 中");
            this.addObject();

            client=borrowObject();
        }
        return client;

    }


    /**
     * 将 连接对象 返回给 ftpPool 中
     *
     * @param ftpClient
     * @throws Exception
     */
    @Override
    public void returnObject(FTPClient ftpClient) throws Exception {
        log.info("回收连接对象 前 的ftpPool连接数为：" + getNumIdle());
        if ((ftpClient != null)) {
            if (!blockingQueue.offer(ftpClient)) {
                try {
                    ftpFactory.destroyObject(ftpClient);
                    log.info("销毁无效连接对象");
                } catch (Exception e) {
                    throw e;
                }
            }else {
                log.info("回收连接对象 后 的ftpPool连接数为：" + getNumIdle());
            }

        }
    }


    /**
     * 删除失效的 ftp连接对象
     *
     * @param ftpClient
     * @throws Exception
     */
    @Override
    public void invalidateObject(FTPClient ftpClient) throws Exception {
        blockingQueue.remove(ftpClient);
    }


    /**
     * 给 ftpPool 中添加一个新的连接对象，且在超时后会从 ftpPool 中删去
     *
     * @throws Exception
     * @throws IllegalStateException
     * @throws UnsupportedOperationException
     */
    @Override
    public void addObject() throws Exception, IllegalStateException, UnsupportedOperationException {
        //超时时间20秒
        blockingQueue.offer(ftpFactory.makeObject(), 20000, TimeUnit.MINUTES);
    }


    /**
     *获取空闲的 ftp连接数
     *
     * @return
     * @throws UnsupportedOperationException
     */
    @Override
    public int getNumIdle() throws UnsupportedOperationException {
        return blockingQueue.size();
    }


    /**
     * 获取正在被使用的 ftp连接数
     *
     * @return
     * @throws UnsupportedOperationException
     */
    @Override
    public int getNumActive() throws UnsupportedOperationException {
        return ftpConstant.getDefultPoolSize() - getNumIdle();
    }

    @Override
    public void clear() throws Exception, UnsupportedOperationException {

    }


    /**
     * 关闭连接池
     *
     * @throws Exception
     */
    @Override
    public void close() throws Exception {
        try {
            while (blockingQueue.iterator().hasNext()) {
                FTPClient client = blockingQueue.take();
                ftpFactory.destroyObject(client);
            }
        } catch (Exception e) {
            log.error("关闭连接池错误：", e);
        }
    }

    @Override
    public void setFactory(PoolableObjectFactory<FTPClient> poolableObjectFactory) throws IllegalStateException, UnsupportedOperationException {

    }
}

5、编写文件上传下载的方法

package com.hwhy.hainandatacheck.common.util.ftp;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.nio.charset.StandardCharsets;

/**
 * ftp文件上传、下载、删除工具类
 */
@Slf4j
@Component
public class FtpUtils {

    public static FtpPool ftpPool;

    static {
        ftpPool = new FtpPool();
    }

 /**
     * 上传文件
     *
     * @param filePath    文件路径
     * @param fileName    文件名
     * @param inputStream 输入文件流
     * @return
     */
    public static boolean uploadFile(String filePath, String fileName, InputStream inputStream) throws Exception {
        //连接服务器
        //FTPClient ftpClient = initFtpClient();
        FTPClient ftpClient = ftpPool.borrowObject();
        try {
            log.info("开始上传文件");
            //设置传输类型
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            //创建子目录
            ftpClient.makeDirectory(filePath);
            //更改当前目录
            ftpClient.changeWorkingDirectory(filePath);
            //写入文件
            boolean b = ftpClient.storeFile(fileName, inputStream);
            if (b) {
                log.info("上传文件成功");
            } else {
                log.info("上传文件失败");
            }
            return b;
        } catch (Exception e) {
            log.info("上传文件失败");
            e.printStackTrace();
            return false;
        } finally {
            //closeFtp(ftpClient);
            ftpPool.returnObject(ftpClient);
        }
    }

/**
     * 下载文件
     *
     * @param remotePath FTP服务器上的相对路径
     * @param fileName   要下载的文件名
     * @return
     */
    public static InputStream downFile(String remotePath, String fileName) throws Exception {
        //连接服务器
        //FTPClient ftpClient = initFtpClient();
        FTPClient ftpClient = ftpPool.borrowObject();

        try {
            // 转移到FTP服务器目录
            ftpClient.changeWorkingDirectory(remotePath);
            FTPFile[] ftpFiles = ftpClient.listFiles();
            for (FTPFile ftpFile : ftpFiles) {
                if (ftpFile.getName().equals(fileName)) {
                    InputStream inputStream = ftpClient.retrieveFileStream(ftpFile.getName());
                    if (inputStream != null) {
                        return inputStream;
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //closeFtp(ftpClient);
            ftpPool.returnObject(ftpClient);
        }
        return null;
    }

}
yuqizzp
关注
ftp连接池实现
wd501771382的博客
03-08 4614
项目中需要用到ftp，经常性的开关会造成极大的开销，效率比较低。就想封装一个ftp连接池，不过遗憾的是没有找到现成的，只得根据别人提供的思路来实现了。 中心思想 创建若干个ftp连接，然后将这些连接放入阻塞队列BlockingQueue中，每次使用时从队列中获取一个连接，使用完成后将连接重新插入队列中。 实现ObjectPool接口就可以实现一个简单的自定义连接池。 pub
ftp连接池的实现
哦绝影
06-14 1167
类似数据库连接，ftp连接也是一个比较浪费时间的连接，为了高效快速获取连接，对连接数量和资源进行有效管理，引入了连接池比较合理。 实现一个ftp连接池，工程已经压缩成jar，需要使用直接下载即可，相关ftp的jar包已经封装在jar中，提供了常用ftp操作方法在FTPUtils，和文件留痕处理的FileUtils。 jar下载地址： 引入上述的jar包后，手动配置下面几步就可以使用了。 使用步骤 1.application.properties配置ftp连接信息 ftp.host=xxxxxx
java ftp连接池
03-08
在网上找了好久没有现成的ftp连接池jar包，自己花了一些时间实现了一个简单的连接池，用了一段时间稳定性还可以。
FTP连接池
chubo8387的博客
07-09 290
import java.io.IOException; import java.util.NoSuchElementException; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.B...
ftp pool 功能分析及 golang 实现
最新发布
我的梦
07-13 1147
业务中一般使用较多的是各种开源组件，设计有点重，因此本文探究一种轻量级的 pool 池的思想实现。
java ftpclient 池_JAVA ftp连接池功能实现
weixin_35763055的博客
02-13 263
packagecom.echo.services;importorg.apache.commons.net.ftp.FTPClient;importorg.apache.commons.net.ftp.FTPFile;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importjava.io.File;importjava.io.FileO...
FTPClient连接池
07-22
基于SpringBoot搭建 使用apache的commons-pool2 构建 FTPClient连接池 有FtpClientFactory、FtpClientPool、FtpConfig、FtpOperate 四个类组成 还有ftp连接池的一些配置参数信息在ftp.properties文件中 注释完整欢迎大家下载使用
java 多ftp连接池,实现一个ftp连接池
weixin_32787251的博客
03-12 991
背景在此之前，本人曾经写过两篇总结文章，《封装一个FTP工具类》和《使用commons-pool管理FTP连接》，相应地造了两个小项目轮子。两个项目之间有相同点，也有不同的侧重点：都是使用commons-net和commons-pool库构建的，前者最大的特点是使用了模板方法设计模式，借鉴了JdbcTemplate的实现，造了上传下载工具类方法；后者最大的特点是使用AutoCloseable的方式...
springboot集成ftp连接池工具
04-18
本文将深入探讨如何在Spring Boot项目中集成FTP连接池，以解决并发用户上传附件时的性能问题。 首先，我们需要引入相关的依赖。在Spring Boot项目中，可以使用Apache Commons Net库来实现FTP功能，并使用Apache ...
使用FTP连接池在Ubuntu服务器上实现文件上传与播放
qq_44752836的博客
05-09 999
在开发应用程序时，我们经常需要与服务器进行文件交互，比如上传文件或从服务器获取文件进行播放。这篇博客将介绍如何在Ubuntu服务器使用FTP连接池来高效地处理文件上传和播放。在Ubuntu系统搭建FTP服务器可以参考这篇博客。
ftp连接池实例
11-03
经过几天的琢磨，去看了csdn上一位大牛的数据库的连接池实现方案，从中感悟很多，感谢这位大神。 让我才能有信心去坚持下去。也不知道写的好不好··不好的话，大家指出。但是我是努力去做了，这一个过程，很享受，大家互相学习吧~ 其实ftp连接池跟数据库连接池的原理是差不多的，不同的是ftp连接池有个连接时间的限制，如果你没设置的话，它的默认连接服务器的时间是0，所以我们要合理的设置它的服务器的时间，ftp.setConnectTimeout(5000);在这里设置了它的时间是5s。 写ftp连接池的目的就是合理的利用资源，本文的目的是在初始的时候，创建10个Ftp连接，放到一个队列中去，当多个用户同时去下载ftp上的文件的时候，就会从队列中取，若当前的队列中存在着空闲的连接，就获取该ftp的连接，并设置此连接为忙的状态，否则就在创建新的连接到连接池中去（有最大的连接池数的限制，不能超过这个连接数，超过的话，就会进入等待状态，直到其它连接释放连接），在执行下载操作的前对登录ftp时间进行判断。看是否超时，超时的话，就重新连接到ftp服务器，在这里我所做的操作就是，在开始创建ftp连接池的时候，记录下系统的当前时间，例如为：long beginTime=System.currentTimeMillis(),在取文件之前获得 当前系统的时间 long endTime=System.currentTimeMillis(),此时我们就可以获得系统登录ftp的时间time=endTime-beginTime,在此我们可以用time与ftp最大登录服务器时间（ftpPool.getConnection();）进行比较。 当然了，在操作完之后我们需要将所操作的连接池中的ftp设置为空闲状态。代码在文件中，为了测试，我本地自己创建了一个ftp服务器，创建ftp的方法，大家可以到网上查资料，我用的是Serv-U工具。傻瓜式的。所用到的jar包是commons-net2.0.
java ftpClient 连接池设计
08-11
1 博文链接：https://bai2mumu.iteye.com/blog/2231916
Java通过FTP服务器上传下载文件的方法
09-03
同时，考虑使用连接池管理FTP连接，以提高性能和资源利用效率。此外，使用异步或多线程处理文件传输可以提高上传和下载的速度。 总之，Java通过Apache Commons Net库与FTP服务器交互，可以方便地实现文件的上传、...
java ftp 心跳_java实现ftp连接池
weixin_32672471的博客
02-13 1158
前言由于工作需要使用到ftp服务，一开始是每次建立ftp连接，上传文件成功后，再释放连接，后来发现这个方法太浪费资源和时间了，就想到了使用ftp连接池的方式实现，这样，预先创建好ftp连接池，需要上传的时候从池子取一个连接，上传成功后再放回池子即可，省下了创建和释放ftp连接的时间。实现ftp服务的配置文件在config.properties配置好ftp服务ftp.ip=127.0.0.1ftp....
Java连接FTP服务器，并使用ftp连接池进行文件操作
qq_41481924的博客
04-25 2470
使用Java连接FTP服务器进行文件操作，包含文件和文件夹上传、下载、获取文件夹内文件名、文件数量、将文件夹打包成zip在浏览器下载等接口，并且使用FTP连接池降低资源消耗，提高响应速率。
【池化-ftp客户端连接池（支持多ftp源以及连接保活）】
whatjeans的博客
04-07 755
支持多ftp配置的客户端连接池实现
springboot ftp连接池
04-30
Spring Boot是一款优秀的Java框架，在处理文件上传、下载等操作时，需要用到FTP连接池来提高效率和稳定性。FTP连接池是一种用于缓存和管理FTP连接的技术，通过减少连接的创建和销毁，可以大大提高FTP客户端的性能和可靠性。 使用Spring Boot来实现FTP连接池非常简单，只需要在配置文件中增加相应的配置项即可。首先需要添加commons-net和commons-pool2的依赖： ``` <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</artifactId> <version>3.6</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.7.0</version> </dependency> ``` 然后在application.properties中添加相关配置项： ``` # FTP config ftp.pool.maxTotal=8 ftp.pool.maxIdle=2 ftp.server.host=ftp.example.com ftp.server.port=21 ftp.server.username=user ftp.server.password=pass ftp.server.remote.dir=/path/to/remote/dir ``` 其中，ftp.server.*是远程FTP服务器的配置，ftp.pool.*是连接池的相关配置。通过配置如上的参数，应用程序即可建立FTP连接池，然后在需要使用FTP连接的地方，直接从连接池中获取连接即可，无需手动创建和关闭。 使用FTP连接池可以避免频繁地创建和销毁连接，也能够管理连接的生命周期，提高程序的性能和稳定性。此外，Spring Boot还提供了各种其他类型的连接池，如JDBC连接池、Redis连接池等，方便开发人员进行快速开发和可靠的运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值