FTP连接池

我们项目使用的是 Apache的（commons-net-3.2.jar） FTPClient，但是系统偶尔会有异常，趁着刚解决完，总结一下。

日志中提示是类似

java.lang.Exception: FTP response 421 received.  Server closed connection.

上网上一查，说是FTP服务端连接数已满了，出现这种问题一般是，部分连接占用的时间太久，导致新连接获取不到，从而抛出的异常，找到问题就方便下手了（^_^）；

我的思路是，既然连接会出问题，那就从这里入手，

使用FTP连接池，管理连接
初始化连接池，设置超时时间，
连接数满时，等待连接释放

我的连接池这一块采用的也是Apache的（commons-pool2-2.2.jar）GenericObjectPool，大概有一下几个类

配置类

package com.i1stcs.mvs.utils.ftp;

//FTPClient配置类
class FTPConfig {

    private String host;
    private int port;
    private String username;
    private String password;
    private String encoding;
    private String workPath;

    private int maxTotal;
    private int maxWaitMillis;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEncoding() {
        return encoding;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    public String getWorkPath() {
        return workPath;
    }

    public void setWorkPath(String workPath) {
        this.workPath = workPath;
    }

    public int getMaxTotal() {
        return maxTotal;
    }

    public void setMaxTotal(int maxTotal) {
        this.maxTotal = maxTotal;
    }

    public int getMaxWaitMillis() {
        return maxWaitMillis;
    }

    public void setMaxWaitMillis(int maxWaitMillis) {
        this.maxWaitMillis = maxWaitMillis;
    }

}

连接池实现类

package com.i1stcs.mvs.utils.ftp;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.i1stcs.mvs.utils.PropertiesUtil;

public class FTPPool {

    private static final GenericObjectPool<FTPClient> internalPool;
    private static Logger logger = LoggerFactory.getLogger(FTPPool.class);

    static {
        String ip = PropertiesUtil.getValue("ftp.server.ip", "");
        String userName = PropertiesUtil.getValue("ftp.server.username", "");
        String password = PropertiesUtil.getValue("ftp.server.password", "");
        String encoding = PropertiesUtil.getValue("ftp.server.encoding", "UTF-8");
        int port = PropertiesUtil.getValue("ftp.server.port", 21);

        int maxTotal = PropertiesUtil.getValue("ftp.server.maxTotal", 8);
        int maxWaitMillis = PropertiesUtil.getValue("ftp.server.maxWaitMillis", 30_000);

        FTPConfig config = new FTPConfig();
        config.setEncoding(encoding);
        config.setHost(ip);
        config.setUsername(userName);
        config.setPassword(password);
        config.setPort(port);
        config.setMaxTotal(maxTotal);
        config.setMaxWaitMillis(maxWaitMillis);

        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(config.getMaxTotal());// 不设置的话默认是8
        poolConfig.setMaxWaitMillis(config.getMaxWaitMillis());// 不设置默认无限等待

        internalPool = new GenericObjectPool<FTPClient>(new FTPPoolFactory(config), poolConfig);
    }

    /**
     * 获取资源
     *
     * @return
     */
    public static FTPClient getFTPClient() {
        try {
            return internalPool.borrowObject();
        } catch (Exception e) {
            logger.error("获取FTP连接异常：", e);
            return null;
        }
    }

    /**
     * 归还资源
     *
     * @param ftpClient
     */
    public static void returnFTPClient(FTPClient ftpClient) {
        try {
            internalPool.returnObject(ftpClient);
        } catch (Exception e) {
            logger.error("释放FTP连接异常：", e);
        }
    }

    /**
     * 销毁池子
     */
    public static void destroy() {
        try {
            internalPool.close();
        } catch (Exception e) {
            logger.error("销毁FTP数据源异常：", e);
        }
    }

}

连接池工厂类

package com.i1stcs.mvs.utils.ftp;

import java.io.IOException;
import java.net.SocketException;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPClientConfig;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;

class FTPPoolFactory implements PooledObjectFactory<FTPClient> {

    private static Logger logger = LoggerFactory.getLogger(FTPPoolFactory.class);

    private FTPConfig ftpConfig;
    private static int BUFF_SIZE = 256000;

    public FTPPoolFactory(FTPConfig ftpConfig) {
        this.ftpConfig = ftpConfig;
    }

    @Override
    public PooledObject<FTPClient> makeObject() throws Exception {
        FTPClient ftpClient = new FTPClient();
        ftpClient.setDefaultPort(ftpConfig.getPort());
        ftpClient.setConnectTimeout(30000);
        ftpClient.setDataTimeout(180000);
        ftpClient.setControlKeepAliveTimeout(60);
        ftpClient.setControlKeepAliveReplyTimeout(60);
        ftpClient.setControlEncoding(ftpConfig.getEncoding());

        FTPClientConfig clientConfig = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
        clientConfig.setServerLanguageCode(ftpConfig.getEncoding());
        ftpClient.configure(clientConfig);

        try {
            ftpClient.connect(ftpConfig.getHost());
        } catch (SocketException exp) {
            logger.warn("connect timeout with FTP server:" + ftpConfig.getHost());
            throw new Exception(exp.getMessage());
        } catch (IOException exp) {
            logger.warn("connect FTP server:" + ftpConfig.getHost() + " meet error:" + exp.getMessage());
            throw new Exception(exp.getMessage());
        }

        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect();
            logger.error("FTPServer refused connection");
            return null;
        }
        boolean result = ftpClient.login(ftpConfig.getUsername(), ftpConfig.getPassword());
        if (!result) {
            logger.warn("FTP server refused refused connection.");
            throw new Exception(
                    "login failed with FTP server:" + ftpConfig.getHost() + " may user name and password is wrong");
        }
        ftpClient.setBufferSize(BUFF_SIZE);
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.setFileTransferMode(FTP.COMPRESSED_TRANSFER_MODE);

        ftpClient.changeWorkingDirectory(ftpConfig.getWorkPath());

        return new DefaultPooledObject<FTPClient>(ftpClient);
    }

    @Override
    public void destroyObject(PooledObject<FTPClient> pooledObject) throws Exception {
        FTPClient ftpClient = pooledObject.getObject();
        try {
            ftpClient.logout();
            if (ftpClient.isConnected()) {
                ftpClient.disconnect();
            }
        } catch (IOException e) {
            throw new RuntimeException("Could not disconnect from server.", e);
        }
    }

    @Override
    public boolean validateObject(PooledObject<FTPClient> pooledObject) {
        FTPClient ftpClient = pooledObject.getObject();
        try {
            return ftpClient.sendNoOp();//
        } catch (IOException e) {
            logger.error("Failed to validate client:", e);
            return false;
        }
    }

    @Override
    public void activateObject(PooledObject<FTPClient> p) throws Exception {
        // TODO Auto-generated method stub

    }

    @Override
    public void passivateObject(PooledObject<FTPClient> p) throws Exception {
        // TODO Auto-generated method stub

    }

}

FTP工具类

package com.songyz.ftp;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.i1stcs.mvs.utils.PropertiesUtil;

public class FTPHelper {
    private static final Logger log = LoggerFactory.getLogger(FTPHelper.class);

    public static FTPCommand createDelDirCmd(String remotePath) {
        return new DeleteDirCommand(remotePath);
    }

    public static FTPCommand createDelFileCmd(String remoteFile) {
        return new DeleteFileCommand(remoteFile);
    }

    public static void execute(FTPCommand... cmds) throws Exception {
        FTPClient client = null;
        try {
            client = FTPPool.getFTPClient();
            String mode = PropertiesUtil.getValue("ftp.server.mode", "localactive");
            String workpath = PropertiesUtil.getValue("ftp.server.workpath", "./");
            for (FTPCommand cmd : cmds) {
                client.changeWorkingDirectory(workpath);
                if (mode.equals("localactive"))
                    client.enterLocalActiveMode();
                else if (mode.equals("localpassive"))
                    client.enterLocalPassiveMode();
                else
                    client.enterRemotePassiveMode();

                cmd.isOK = cmd.doAction(client);
                if (cmd.isOK == false) {
                    if (cmd.error == null || cmd.error.isEmpty()) {
                        String clsName = cmd.getClass().getName();
                        cmd.error = "execute command:" + clsName.substring(clsName.lastIndexOf("$") + 1) + " failed -- "
                                + client.getReplyString();
                    }
                    throw new Exception(cmd.error);
                }
            }
        } finally {
            FTPPool.returnFTPClient(client);
        }
    }

    public static abstract class FTPCommand {
        protected boolean isOK = false;
        protected String error = "";

        public abstract boolean doAction(FTPClient client);

        public boolean isSuccessed() {
            return isOK;
        }

        public String getError() {
            return error;
        }
    }

    static class DeleteDirCommand extends FTPCommand {
        private String remotePath;

        public DeleteDirCommand(String remotePath) {
            this.remotePath = remotePath;
        }

        @Override
        public boolean doAction(FTPClient client) {
            try {
                FTPFile[] files = client.listFiles(remotePath);
                if (files == null || files.length == 0)
                    return client.removeDirectory(remotePath);

                for (FTPFile file : files) {
                    if (file.isDirectory())
                        deleteChildren(client, remotePath + "/" + file.getName());
                    else
                        client.dele(remotePath + "/" + file.getName());
                }
                return client.removeDirectory(remotePath);
            } catch (Exception exp) {
                error = "failed to delete dirctory " + remotePath + " in FTP server because " + exp.getMessage();
                log.warn(error, exp);
                return false;
            }
        }

        private boolean deleteChildren(FTPClient client, String pathName) {
            try {
                FTPFile[] files = client.listFiles(pathName);
                if (files == null || files.length == 0)
                    return client.removeDirectory(pathName);

                for (FTPFile file : files) {
                    if (file.isDirectory())
                        deleteChildren(client, pathName + "/" + file.getName());
                    else
                        client.dele(pathName + "/" + file.getName());
                }
                return client.removeDirectory(pathName);
            } catch (Exception exp) {
                error = "failed to delete dirctory " + remotePath + "in FTP server because " + exp.getMessage();
                log.warn(error, exp);
                return false;
            }
        }
    }

    static class DeleteFileCommand extends FTPCommand {
        private String remoteFilePath;

        public DeleteFileCommand(String remoteFilePath) {
            this.remoteFilePath = remoteFilePath;
        }

        @Override
        public boolean doAction(FTPClient client) {
            try {
                FTPFile[] files = client.listFiles(remoteFilePath);
                if (files == null || files.length == 0)
                    return true;
                else
                    return client.deleteFile(remoteFilePath);
            } catch (Exception exp) {
                error = "failed to delete file " + remoteFilePath + " in FTP server because " + exp.getMessage();
                log.warn(error, exp);
                return false;
            }
        }
    }

}

特别提示：PropertiesUtil这个类是我自己读取配置文件的类，就不贴代码了，

至此，大功告成！！！

FTP连接池的更多相关文章

使用commons-pool2实现FTP连接池
GitHub : https://github.com/jayknoxqu/ftp-pool 一. 连接池概述频繁的建立和关闭连接,会极大的降低系统的性能,而连接池会在初始化的时候会创建一定 ...
Java 自定义FTP连接池
转自:https://blog.csdn.net/eakom/article/details/79038590 版权声明:本文为博主原创文章,未经博主允许不得转载. https://blog.csdn ...
JAVA ftp连接池功能实现
抽象类: package com.echo.store; import java.util.Enumeration; import java.util.Hashtable; abstract clas ...
SpringBoot整合自定义FTP文件连接池
说明:通过GenericObjectPool实现的FTP连接池,记录一下以供以后使用环境:JDK版本1.8框架 :springboot2.1文件服务器: Serv-U1.引入依赖 <!--ftp ...
连接SQLServer时，因启用连接池导致孤立事务的原因分析和解决办法
本文出处:http://www.cnblogs.com/wy123/p/6110349.html 之前遇到过这么一种情况: 连接数据库的部分Session会出现不定时的阻塞,这种阻塞时长时短,有时候持 ...
C3p0连接池配置
在Java开发中,使用JDBC操作数据库的四个步骤如下: ①加载数据库驱动程序(Class.forName("数据库驱动类");) ②连接数据库(Connection co ...
Java第三方数据库连接池库-DBCP-C3P0-Tomcat内置连接池
连接池原理数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”.预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后再放回去.我们可以通过设定连接池 ...
common-pool2 学习：thrift连接池的另一种实现
对象池是一种很实用的技术,经典的例子就是数据库连接池.去年曾经从零开始写过一个thrift客户端连接池.如果不想重造轮子,可以直接在apache开源项目commons-pool的基础上开发. 步骤: ...
druid连接池获取不到连接的一种情况
数据源一开始配置: jdbc.initialSize=1jdbc.minIdle=1jdbc.maxActive=5 程序运行一段时间后,执行查询抛如下异常: exception=org.mybati ...

随机推荐

Java 必看的 Spring 知识汇总！有比这更全的算我输！
往期精彩推荐 [1]Java Web技术经验总结 [2]15个顶级Java多线程面试题及答案,快来看看吧 [3]面试官最喜欢问的十道java面试题 [4]从零讲JAVA ,给你一条清晰 ...
mysql海量数据的优化
转载:https://www.cnblogs.com/trying/archive/2013/08/15/3259126.html 下面是一部分比较重要的建议:1.选择正确的存储引擎以 MySQL为例 ...
ORACLE之TO_DATE (转载)
转自 http://www.cnblogs.com/anran_guojianjun/archive/2009/09/11/1564535.html 一.在使用Oracle的to_date函数来做日期 ...
在 javascript 中，为什么 [1,2] + [3,4] 不等于 [1,2,3,4]？
在 stackoverflow 上有人提问:arrays - Why does [1,2] + [3,4] = "1,23,4" in JavaScript? 问题我想将一个数组 ...
Java Web开发中路径问题小结
Java Web开发中,路径问题是个挺麻烦的问题,本文小结了几个常见的路径问题,希望能对各位读者有所帮助. (1) Web开发中路径的几个基本概念假设在浏览器中访问了如下的页面,如图1所示: 图1 ...
使用Cli构建Go的命令行应用
转载出处:http://www.opscoder.info/cli.html 在Go里面应用中flag这一标准库,提供了很多我们在写命令行时需要的interface,然而如果你需要更强大更好的结构 ...
比较Fink, macports 跟 homebrew
http://www.myexception.cn/brew/412107.html 比较Fink, macports 和 homebrew 如果你有Linux/Unix背景,那么在Mac上你一定想安 ...
Java虚拟机-内存tips
java虚拟机内存可以分为独占区和共享区. 独占区:虚拟内存栈.本地方法栈.程序计数器. 共享区:方法区.Java堆(用来存放对象实例). 程序计数器比较小的内存空间,当前线程所执行的字节码的行号指 ...
寻找DevExpress破解经历之旅
众所周知DevExpress是收费的,但是破解版的也不少,近期公司需要做发票套打的功能让我找个打印工具,我寻思着DevExpress这个软件好像挺不错的,功能强大,看了下价格方面,好吧!2W多呢,市面 ...
mysql学习第二章数据库的基本操作
3.1 创建数据库 MySQL安装好之后,首先需要创建数据库,这是使用MySQL各种功能的前提.本章将详细介绍数据的基本操作,主要内容包括:创建数据库.删除数据库.不同类型的数据存储引擎和存储引擎 ...

FTP连接池

FTP连接池的更多相关文章

随机推荐

热门专题