javaftpclient池_FTPClient，连接池实现

直接贴代码&＃xff1a;

import org.apache.commons.net.ftp.FTPClient;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import java.io.*;

/**

* FTP工具类

*/

&＃64;Component

public class FtpUtil {

/**

* 注入连接池对象

*/

&＃64;Autowired

private FTPClientPool ftpClientPool;

/**

* Description: 获取FTP文件流

* filePath格式 /xxx/xxx

*/

public byte[] getFileSteam(String filePath, String ftpName) throws Exception {

InputStream in &＃61; null;

byte[] bytes &＃61; null ;

FTPClient ftpClient &＃61; getFtpClient();

try {

// 使用相对路径

filePath &＃61; filePath.substring(1);

// 切换FTP目录

boolean change &＃61; ftpClient.changeWorkingDirectory(new String((filePath).getBytes("utf-8"), "iso-8859-1"));

if (change) {

in &＃61; ftpClient.retrieveFileStream(new String(ftpName.getBytes("utf-8"), "iso-8859-1"));

bytes &＃61; readStream(in);

} else {

throw new RuntimeException("获取文件输入流失败----原因----切换工作目录失败");

}

} catch (Exception e) {

throw new RuntimeException("获取文件输入流失败");

} finally {

ftpClientPool.returnObject(ftpClient);

in.close();

}

return bytes;

}

/**

* 输入流转输出流

*/

public static byte[] readStream(InputStream inStream) throws Exception {

ByteArrayOutputStream outStream &＃61; new ByteArrayOutputStream();

byte[] buffer &＃61; new byte[1024];

int len &＃61; -1;

while ((len &＃61; inStream.read(buffer)) !&＃61; -1) {

outStream.write(buffer, 0, len);

}

outStream.close();

inStream.close();

return outStream.toByteArray();

}

/**

* 从连接池获取对象

*/

public FTPClient getFtpClient() throws Exception {

return ftpClientPool.borrowObject();

}

}

import org.apache.commons.net.ftp.FTPClient;

import org.apache.commons.pool.ObjectPool;

import org.apache.commons.pool.PoolableObjectFactory;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import java.io.IOException;

import java.util.NoSuchElementException;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

/**

* FTP连接池

*/

&＃64;Component

public class FTPClientPool implements ObjectPool, InitializingBean {

/**

* FTP连接池默认大小

*/

private static final int DEFAULT_POOL_SIZE &＃61; 5;

private final BlockingQueue pool;

&＃64;Autowired

private FtpClientFactory factory;

public FTPClientPool() throws Exception {

this.pool &＃61; new ArrayBlockingQueue(DEFAULT_POOL_SIZE);;

}

public void initPool() throws Exception {

for(int i &＃61; 0 ; i

addObject();

}

}

&＃64;Override

public FTPClient borrowObject() throws Exception, NoSuchElementException, IllegalStateException {

// 从连接池拿出一个连接&＃xff0c;连接池中连接对象减一

FTPClient client &＃61; pool.take();

if (client &＃61;&＃61; null) {

throw new RuntimeException("从连接池获取连接失败&＃xff01;");

}

return client;

}

&＃64;Override

public void returnObject(FTPClient obj) throws Exception {

if (obj !&＃61; null) {

try {

// 归还连接

factory.passivateObject(obj);

// 将连接还给队列

pool.offer(obj);

} catch (IOException e) {

e.printStackTrace();

}

}

}

/**

* 移除无效的客户端

* &＃64;param obj

* &＃64;throws Exception

*/

&＃64;Override

public void invalidateObject(FTPClient obj) throws Exception {

pool.remove(obj);

}

&＃64;Override

public void addObject() throws Exception, IllegalStateException, UnsupportedOperationException {

this.pool.offer(factory.makeObject());

}

&＃64;Override

public int getNumIdle() throws UnsupportedOperationException {

return 0;

}

&＃64;Override

public int getNumActive() throws UnsupportedOperationException {

return 0;

}

&＃64;Override

public void clear() throws Exception, UnsupportedOperationException {

pool.clear();

}

&＃64;Override

public void close() throws Exception {

while(pool.iterator().hasNext()){

FTPClient client &＃61; pool.take();

factory.destroyObject(client);

}

}

&＃64;Override

public void setFactory(PoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {

}

/**

* 连接池对象销毁前关闭连接

*/

&＃64;Override

protected void finalize() throws Throwable {

super.finalize();

close();

}

&＃64;Override

public void afterPropertiesSet() throws Exception {

initPool();

}

}

import org.apache.commons.net.ftp.FTP;

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;

&＃64;Component

public class FtpClientFactory implements PoolableObjectFactory {

&＃64;Autowired

private FTPConfig ftpConfig;

&＃64;Override

public FTPClient makeObject() throws Exception {

FTPClient ftpClient &＃61; new FTPClient();

ftpClient.setConnectTimeout(1000);

try {

ftpClient.connect(ftpConfig.getIp(), ftpConfig.getPort());

int reply &＃61; ftpClient.getReplyCode();

if (!FTPReply.isPositiveCompletion(reply)) {

throw new RuntimeException("ftpClient连接失败!");

}

boolean result &＃61; ftpClient.login(ftpConfig.getUsername(), ftpConfig.getPassword());

if (!result) {

throw new RuntimeException("ftpClient登陆失败!");

}

if (FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"))) {// 开启服务器对UTF-8的支持&＃xff0c;如果服务器支持就用UTF-8编码&＃xff0c;否则就使用本地编码(GBK).

ftpClient.setControlEncoding("UTF-8");

}

ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

ftpClient.setBufferSize(1024);

ftpClient.enterLocalPassiveMode(); //ftp被动连接模式

reply &＃61; ftpClient.getReplyCode();

if (!FTPReply.isPositiveCompletion(reply)) {

throw new RuntimeException("ftpClient连接失败!");

}

} catch (IOException e) {

ftpClient.disconnect();

e.printStackTrace();

} catch (Exception e) {

ftpClient.disconnect();

e.printStackTrace();

}

return ftpClient;

}

/**

* 关闭连接

* &＃64;param obj

* &＃64;throws Exception

*/

&＃64;Override

public void destroyObject(FTPClient obj) throws Exception {

try {

if (obj !&＃61; null && obj.isConnected()) {

obj.logout();

}

} catch (IOException io) {

io.printStackTrace();

} finally {

// 注意,一定要在finally代码中断开连接&＃xff0c;否则会导致占用ftp连接情况

try {

obj.disconnect();

} catch (IOException io) {

io.printStackTrace();

}

}

}

&＃64;Override

public boolean validateObject(FTPClient obj) {

try {

return obj.sendNoOp();

} catch (IOException e) {

throw new RuntimeException("Failed to validate client: " &＃43; e, e);

}

}

&＃64;Override

public void activateObject(FTPClient obj) throws Exception {

}

/**

* 归还连接

* &＃64;param obj

* &＃64;throws Exception

*/

&＃64;Override

public void passivateObject(FTPClient obj) throws Exception {

try {

if (obj !&＃61; null && obj.isConnected()) {

obj.completePendingCommand();

obj.changeWorkingDirectory("/");

}

} catch (IOException io) {

io.printStackTrace();

}

}

}

import lombok.Data;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.PropertySource;

import org.springframework.stereotype.Component;

&＃64;Component

&＃64;PropertySource("classpath:application-ftp.yml")

&＃64;ConfigurationProperties(prefix &＃61; "ftp")

&＃64;Data

public class FTPConfig {

private String ip;

private int port;

private String username;

private String password;

}

以上就是FTPClient连接池全部实现。

但是有个问题&＃xff0c;测试环境用的是XLight FTP Server&＃xff0c;用同一个账号连接&＃xff0c;最多只能同时连5个&＃xff0c;希望知道的大佬告知怎么设置。