通常一个对象创建/销毁的时候非常耗时，我们不会频繁的创建销毁它，而是考虑复用。复用对象的一种做法就是对象池，将创建好的对象放入池中维护起来，下次再用的时候直接拿池中已经创建好的对象继续用
GenericObjectPool
GenericObjectPool是一个通用对象池框架，我们可以借助它实现一个健壮的对象池
维护一个对象池需要实现以下基本的功能：
创建对象
借出对象
验证对象
归还对象
销毁对象
GenericObjectPool 需要通过构造器注入一个PooledObjectFactory对象，而PooledObjectFactory中提供了维护对象池的方法
public interface PooledObjectFactory<T> {
PooledObject<T> makeObject() throws Exception;
void destroyObject(PooledObject<T> var1) throws Exception;
boolean validateObject(PooledObject<T> var1);
void activateObject(PooledObject<T> var1) throws Exception;
void passivateObject(PooledObject<T> var1) throws Exception;
}
以Socket连接池为例
public class ConnectionFactory extends BasePooledObjectFactory<Socket> {
// 创建socket对象
public Socket create() throws Exception {
String[] ipAndPort = host.split(":");
if (ipAndPort.length < 2) {
throw new ParseHostException();
}
Integer port = Integer.parseInt(ipAndPort[1]);
Socket socket = new Socket(ipAndPort[0], port);
socket.setSoTimeout(timeOut);
return socket;
}
// 包装为可维护的对象
public PooledObject<Socket> wrap(Socket socket) {
return new DefaultPooledObject<Socket>(socket);
}
/**
* 能关的都给他关了
* @param pooledObject
* @throws Exception
*/
public void destroyObject(PooledObject<Socket> pooledObject) throws Exception {
Socket socket = pooledObject.getObject();
if (socket != null) {
socket.getInputStream().close();
socket.getOutputStream().close();
socket.close();
}
}
// 验证对象，Pool对象可以设置借出归还时候是否需要验证对象
public boolean validateObject(PooledObject<Socket> pooledObject) {
Socket socket = pooledObject.getObject();
return socket != null && !socket.isClosed() && socket.isConnected();
}
/**
* 钝化归还对象，说白了就是对归还的对象清理
* 清空输入流，避免因为上一个请求字节未读取完导致inputStream非空，对下一个产生影响
* @param p
* @throws Exception
*/
@Override
public void passivateObject(PooledObject<Socket> p) throws Exception {
Socket socket = p.getObject();
InputStream inputStream = socket.getInputStream();
int available = inputStream.available();
if (available > 0) {
inputStream.skip(available);
}
}
}
有了上面的ConnectionFactory，就可以创建对象池了
public class ConnectionPoolExecutor implements Executor {
private GenericObjectPool<Socket> connectionPool = new GenericObjectPool<>(new ConnectionFactory());
private String host;
private int timeOut = 5000;
// 池的大小
private int poolSize = 5;
// 最少空闲对象个数
private int miniIdle = 0;
// 最大空闲对象个数
private int maxIdle = poolSize;
// 驱除策略，对象池内部维护了一个定时线程，如果配置了此属性，会定时调用此类来校验对象是否可用
private String evictionPolicyClassName;
// 驱除对象的定时线程执行间隔
private int timeBetweenEvictionRunsMillis=5000;
// 驱除对象的定时线程每次校验对象个数
private int numTestsPerEvictionRun = 1;
public ConnectionPoolExecutor() {
this.connectionPool.setTestOnBorrow(true);
this.connectionPool.setTestOnReturn(true);
this.connectionPool.setTestWhileIdle(true);
}
public void execute(Command command) throws ExecutionException {
try {
Socket socket = this.connectionPool.borrowObject();
InputStream inputStream = socket.getInputStream();
command.request(inputStream);
command.response(socket.getOutputStream());
this.connectionPool.returnObject(socket);
} catch (Exception e) {
throw new ExecutionException(e);
} finally {
}
}
public void dispose() {
this.connectionPool.close();
}
//....以下省略
上面的代码可以看到一个Executor接口，这是为了增强代码扩展性，抽象出来的接口
public interface Executor {
void execute(Command command) throws ExecutionException;
void dispose();
}
public interface Command {
void request(InputStream inputStream);
void response(OutputStream outputStream);
}
我们最终的目的是为了对外提供阻塞长连接服务，但socket对象池并非唯一实现方式。参考Command模式，我们只需要实现不同的executor就可以扩展不同的socket创建方式
/**
* 提供阻塞式socket服务
*/
public interface ServiceProvider {
void sendSimpleCommand();
}
public class ServiceProviderImpl implements ServiceProvider {
private Executor executor;
private void setExecutor(Executor executor) {
this.executor = executor;
}
public void sendSimpleCommand() {
try {
executor.execute(new Command() {
public void request(InputStream inputStream) {
}
public void response(OutputStream outputStream) {
}
});
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
