FTP连接池

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

日志中提示是类似

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

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

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

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

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

1. 配置类

   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;
       }
   
   }

    

2. 连接池实现类

   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);
           }
       }
   
   }

    

3. 连接池工厂类

   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
   
       }
   
   }

    

4. 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这个类是我自己读取配置文件的类，就不贴代码了，

   至此，大功告成！！！

转载于:https://www.cnblogs.com/songyz/p/9077755.html