[DEV] ftp upload and down load file

atms-api/src/main/java/pwc/taxtech/atms/common/ftp/FTPClientPool.java

@@ -4,21 +4,19 @@ import org.apache.commons.lang3.StringUtils;
 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 org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 import pwc.taxtech.atms.exception.ServiceException;
 
-
 import javax.annotation.PostConstruct;
-import java.io.BufferedOutputStream;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
+import java.io.*;
+
 
 @Component
 public class FTPClientPool {
+    private static final Logger LOGGER = LoggerFactory.getLogger(FTPClientPool.class);
     private GenericObjectPoolConfig config;
     private GenericObjectPool<FTPClient> pool;
     private String ftpRootPath;
@@ -48,12 +46,15 @@ public class FTPClientPool {
         Runtime.getRuntime().addShutdownHook(new Thread(() -> {
             pool.close();
         }));
-        ftpRootPath = pool.borrowObject().printWorkingDirectory();
+        FTPClient client = pool.borrowObject();
+        ftpRootPath = client.printWorkingDirectory();
+        pool.returnObject(client);
+
     }
 
     // this method should only be used in test
     public FTPClient getClient() throws Exception {
-       return pool.borrowObject();
+        return pool.borrowObject();
     }
 
     /**
@@ -66,8 +67,7 @@ public class FTPClientPool {
      */
     public void upload(String filePath, String fileName, InputStream inputStream) throws Exception {
         String upPath;
-        FTPClient client = pool.borrowObject();
-        try {
+        try (WrapFtpClient wrapFtpClient = new WrapFtpClient(pool)) {
             if (StringUtils.isBlank(filePath)) {
                 upPath = ftpRootPath;
             } else {
@@ -76,12 +76,10 @@ public class FTPClientPool {
             if (!StringUtils.endsWith(upPath, SYMBOL)) {
                 upPath = upPath + SYMBOL;
             }
-            if (!isExist(upPath, client)) {
-                mkDir(upPath, client);
+            if (!isExist(upPath, wrapFtpClient.ftpClient)) {
+                mkDir(upPath, wrapFtpClient.ftpClient);
             }
-            client.storeFile(upPath + fileName, inputStream);
-        } finally {
-            pool.returnObject(client);
+            wrapFtpClient.ftpClient.storeFile(upPath + fileName, inputStream);
         }
     }
 
@@ -93,19 +91,18 @@ public class FTPClientPool {
      * @throws Exception Exception
      */
     public InputStream download(String filePath) throws Exception {
-        FTPClient client = pool.borrowObject();
-        if (StringUtils.isBlank(filePath)) throw new ServiceException("file path should not empty");
-        client.changeWorkingDirectory(ftpRootPath);
-        try (InputStream in = client.retrieveFileStream(filePath); OutputStream out = new ByteArrayOutputStream();){
+        try (WrapFtpClient wrapFtpClient = new WrapFtpClient(pool); OutputStream out = new ByteArrayOutputStream();) {
+            if (StringUtils.isBlank(filePath)) throw new ServiceException("file path should not empty");
+            wrapFtpClient.ftpClient.changeWorkingDirectory(ftpRootPath);
+            InputStream in = wrapFtpClient.ftpClient.retrieveFileStream(filePath);
             int len = 0;
             byte[] bytes = new byte[1024];
             while ((len = in.read(bytes)) != -1) {
                 out.write(bytes, 0, len);
             }
             return new ByteArrayInputStream(((ByteArrayOutputStream) out).toByteArray());
-        } finally {
-            pool.returnObject(client);
         }
+
     }
 
     private void mkDir(String path, FTPClient ftpClient) throws IOException {
@@ -144,18 +141,15 @@ public class FTPClientPool {
      * @param filePath
      */
     public void delete(String filePath) throws Exception {
-        if (StringUtils.isBlank(filePath)) {
-            return;
-        }
-        FTPClient client = pool.borrowObject();
-        try {
-            if (!isExist(filePath, client)) {
+        try (WrapFtpClient wrapFtpClient = new WrapFtpClient(pool);) {
+            if (StringUtils.isBlank(filePath)) {
+                return;
+            }
+            if (!isExist(filePath, wrapFtpClient.ftpClient)) {
                 return;
             } else {
-                client.deleteFile(filePath);
+                wrapFtpClient.ftpClient.deleteFile(filePath);
             }
-        } finally {
-            pool.returnObject(client);
         }
     }
 

atms-api/src/main/java/pwc/taxtech/atms/common/ftp/FtpClientFactory.java

@@ -21,6 +21,10 @@ public class FtpClientFactory implements PooledObjectFactory<FTPClient> {
         this.config = config;
     }
 
+    public FTPClientConfig getConfig() {
+        return config;
+    }
+
     @Override
     public PooledObject<FTPClient> makeObject() throws Exception {
         FTPClient ftpClient = new FTPClient();
@@ -77,6 +81,11 @@ public class FtpClientFactory implements PooledObjectFactory<FTPClient> {
     public boolean validateObject(PooledObject<FTPClient> pooledObject) {
         try {
             logger.debug("validate object ftp client {} ", pooledObject.getObject().toString());
+            FTPClient ftpClient = pooledObject.getObject();
+            if (ftpClient == null || !ftpClient.isConnected()) {
+                return false;
+            }
+            ftpClient.changeWorkingDirectory("/");
             return pooledObject.getObject().sendNoOp();
         } catch (IOException e) {
             throw new RuntimeException("Failed to validate client: " + e, e);

atms-api/src/main/java/pwc/taxtech/atms/common/ftp/WrapFtpClient.java

+package pwc.taxtech.atms.common.ftp;
+
+import org.apache.commons.net.ftp.FTPClient;
+import org.apache.commons.pool2.impl.GenericObjectPool;
+
+public class WrapFtpClient implements AutoCloseable {
+    FTPClient ftpClient;
+    GenericObjectPool<FTPClient> pool;
+
+    public WrapFtpClient(GenericObjectPool<FTPClient> pool) throws Exception {
+        this.pool = pool;
+        this.ftpClient = pool.borrowObject();
+    }
+
+    public FTPClient getFtpClient() {
+        return ftpClient;
+    }
+
+    @Override
+    public void close() throws Exception {
+        ftpClient.completePendingCommand();
+        pool.returnObject(ftpClient);
+    }
+}