Java常用工具库

import java.util.Random;

/**
 * RPCClient：模拟一个RPC的客户端，存在生命周期： <br/>
 * 初始化、连接 -> 远程调用 -> 断连、销毁 <br/>
 * 初始化、连接过程比较昂贵，所以需要对象池进行缓存复用这个RPC链接 <br/>
 */
public class RPCClient {
    private String ip;
    private int port;
    private boolean connected = false;

    private RPCClient(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    public static RPCClient build(String ip, int port) {
        RPCClient client = new RPCClient(ip, port);
        client.connect();
        return client;
    }

    // 模拟网络延迟
    private void netDelay() {
        try {
            Thread.sleep((new Random().nextInt(200)));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 模拟连接
    private boolean connect() {
        this.netDelay();
        this.connected = (new Random()).nextDouble() >= 0.05; // 模拟连接失败
        System.out.println(String.format("连接到 %s:%d", ip, port));
        return this.connected;
    }

    // 模拟远程方法调用
    public <T> T call(String method, Object arg, Class<T> retType) {
        this.netDelay();
        System.out.println(String.format("调用 %s 方法", method));
        return (T) null;
    }

    // 模拟关闭连接
    public void close() {
        this.netDelay();
        System.out.println(String.format("从 %s:%d 断开连接", ip, port));
        this.connected = false;
    }

    public boolean isConnected() {
        return connected;
    }
}

    // 或者继承 org.apache.commons.pool2.BasePooledObjectFactory
    public static class RPCClientFactory implements PooledObjectFactory<RPCClient> {

        private String ip;
        private int port;

        public RPCClientFactory(String ip, int port) {
            this.ip = ip;
            this.port = port;
        }

        @Override
        public void destroyObject(PooledObject<RPCClient> p) throws Exception {
            p.getObject().close();
        }

        @Override
        public PooledObject<RPCClient> makeObject() throws Exception {
            // 构造器
            return new DefaultPooledObject<>(RPCClient.build(ip, port));
        }

        @Override
        public boolean validateObject(PooledObject<RPCClient> p) {
            // 验证对象是否有效
            return p.getObject().isConnected();
        }

        @Override
        public void activateObject(PooledObject<RPCClient> p) throws Exception {
            // 对象被取出 （objectPool.borrowObject 调用）时，执行的操作
            System.out.println("对象被取出，执行的操作");
        }

        @Override
        public void passivateObject(PooledObject<RPCClient> p) throws Exception {
            // 对象被取出 （objectPool.returnObject 调用）时，执行的操作
            System.out.println("对象被归还，执行的操作");
        }
    }

        String ip = "127.0.0.1";
        int port = 5432;

        GenericObjectPoolConfig<RPCClient> config = new GenericObjectPoolConfig<>();
        // ===== 对象池大小相关配置 =====
        // 最大空闲数
        config.setMaxIdle(5);
        // 最小空闲数, 池中只有一个空闲对象的时候，池会在创建一个对象，并借出一个对象，从而保证池中最小空闲数为1
        config.setMinIdle(1);
        // 最大池对象总数
        config.setMaxTotal(20);
        // ===== 逐出相关配置 =====
        // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
        config.setMinEvictableIdleTimeMillis(
        // 当idle池的大于MinIdle部分的对象的 逐出连接的最小空闲时间 默认-1，永久不会逐出
        config.setSoftMinEvictableIdleTimeMillis(18000001800000);
        // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
        config.setTimeBetweenEvictionRunsMillis(1800000 * 2L);
        // 每次逐出检查时 逐出的最大数目 默认3
        config.setNumTestsPerEvictionRun(3);
        // ===== 有效性测试相关配置 =====
        // 在获取对象的时候检查有效性, 默认false
        config.setTestOnBorrow(true);
        // 在归还对象的时候检查有效性, 默认false
        config.setTestOnReturn(false);
        // 在空闲时检查有效性, 默认false
        config.setTestWhileIdle(false);
        // ====== 其他配置 =====
        // 最大等待时间， 默认的值为-1，表示无限等待。
        config.setMaxWaitMillis(5000);
        // 是否启用后进先出, 默认true
        config.setLifo(true);
        // 连接耗尽时是否阻塞, false报异常,true阻塞直到超时, 默认true
        config.setBlockWhenExhausted(true);
        ObjectPool<RPCClient> pool = new GenericObjectPool<>(new RPCClientFactory(ip, port), config);

            RPCClient client = null;
            try {
                client = pool.borrowObject();
                client.call("测试", null, void.class);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (client != null) {
                    try {
                        pool.returnObject(client);
                        System.out.println("---");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        pool.close(); // 关闭对象池