自定义Thrift连接池

自定义Thrift连接池

Thrift作为一个高性能的RPC框架,广泛应用于后端服务的进程间接口调用场景中。对于Java开发者而言,thrift客户端调用框架并没有提供相关的连接池能力进行使用,对于性能要求较高的用户可以自定义Thrift连接池以满足自身的需求,本着不重复造轮子的原则,笔者使用apache commons-pools2实现了一套自定义的Thrift连接池供大家参考。
关于apache commons-pools2的相关知识,大家可以参考这篇博文:http://blog.csdn.net/amon1991/article/details/77110657


1、创建池对象工厂

PooledObjectFactory(池对象工厂)是commons-pools2中的一个概念,用于控制整个池对象的整个生命周期。

在我们的实例中,这个池对象就是TProtocol对象,准确来说,commons-pools2管理的对象其实是TProtocol在池中的封装对象,也就是实例中通过wrap(TProtocol protocol)方法包裹后生成的对象PooledObject,这个封装的对象保有实际被包装对象的复杂的状态信息,这个状态信息在判断对象是否存活,是否可以被销毁时起到了关键作用。下面给出实际的新建Thfift池对象工厂代码,笔者使用的是TMultiplexedProtocol对象,使用其他TProtocol对象的参考这种写法即可。

代码块

public class TProtocolFactory extends BasePooledObjectFactory<TProtocol>{

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private static final int TIMEOUT = 3000000; // 超时时间
    private static final int MAX_LENGTH = 1638400000; // 单次最大传输的数据量(1.6G)

    public static final String PI_SERVICE = "PiService";
    public static final String OPC_SERVICE = "OpcService";

    private String host;
    private int port;
    private boolean keepAlive = true; // 是否持有Thrift连接,不持有则钝化时释放连接
    private String sourceType; // PI数据源还是OPC数据源


    public TProtocolFactory(String host, int port, boolean keepAlive, String sourceType) {
        this.host = host;
        this.port = port;
        this.keepAlive = keepAlive;
        this.sourceType = sourceType;
    }

    private TProtocolFactory() {
    }

    /**
     * 创建新对象
     * @return
     * @throws Exception
     */
    @Override
    public TProtocol create() throws Exception {

        TSocket tSocket = new TSocket(host, port,TIMEOUT );
        TTransport tTransport = new TFramedTransport(tSocket,MAX_LENGTH);

        if (null!= tTransport && !tTransport.isOpen()){
            tTransport.open();
        }

        TProtocol protocol = new TCompactProtocol(tTransport);

        if (null != sourceType) {

            if (sourceType.equals(PI_SERVICE)){
                return new TMultiplexedProtocol(protocol,PI_SERVICE);
            }else if (sourceType.equals(OPC_SERVICE)){
                return new TMultiplexedProtocol(protocol,OPC_SERVICE);
            }else {
                return  null;
            }

        }else {
            return null;
        }

    }

    /**
     * 将对象放入对象池前先包装对象,好让对象池可以管理
     * @param protocol
     * @return
     */
    @Override
    public PooledObject<TProtocol> wrap(TProtocol protocol) {
        return new DefaultPooledObject<>(protocol);
    }

    /**
     * 对象钝化(即:从激活状态转入非激活状态,returnObject时触发)
     * @param pooledObject
     * @throws TTransportException
     */
    @Override
    public void passivateObject(PooledObject<TProtocol> pooledObject) throws TTransportException {

        if (null!= pooledObject.getObject()){
            if (!keepAlive) {
                pooledObject.getObject().getTransport().flush();
                pooledObject.getObject().getTransport().close();
            }
        }

    }

    /**
     * 对象激活(borrowObject时触发)
     * @param pooledObject
     * @throws TTransportException
     */
    @Override
    public void activateObject(PooledObject<TProtocol> pooledObject) throws TTransportException {

        if (!pooledObject.getObject().getTransport().isOpen()) {
            pooledObject.getObject().getTransport().open();
        }

    }

    /**
     * 对象销毁(clear时会触发)
     * @param pooledObject
     * @throws TTransportException
     */
    @Override
    public void destroyObject(PooledObject<TProtocol> pooledObject) throws TTransportException {

        if (null!= pooledObject.getObject()){
            if (pooledObject.getObject().getTransport().isOpen()) {
                pooledObject.getObject().getTransport().flush();
                pooledObject.getObject().getTransport().close();
            }
        }

        pooledObject.markAbandoned();

    }

    /**
     * 验证对象的有效性
     * @param pooledObject
     * @return
     */
    @Override
    public boolean validateObject(PooledObject<TProtocol> pooledObject) {

        if (pooledObject.getObject() != null) {
            if (pooledObject.getObject().getTransport().isOpen()) {
                return true;
            }

            try {
                pooledObject.getObject().getTransport().open();
                return true;
            } catch (TTransportException e) {
                logger.error(e.getMessage());
            }
        }

        return false;

    }


}

2、创建对象池实例

Object Pool(对象池)是实际管理所有池对象的容器,主要的方法是borrowObject、returnObject,一个是从池中获取对象,另一个是使用完对象后将对象归还到池中,当然,该容器还提供了一些基本的方法用于获取当前存活的对象数,空闲的对象数等信息,这些信息可用于自定义销毁对象策略等实现。

由于笔者的代码中用到了Spring框架,所以外部代码获取连接池实例使用的是Spring容器管理的单例实例。注意,在对象池的使用上,必须保证对象池是线程安全的,否则可能在多线程环境导致对象池维护的数据产生不一致的问题。假设没有使用Spring框架,笔者推介使用一个饿汉模式的单例来维护pool对象即可。

@Component
public class OPCTProtocolPool {

    @Autowired
    private PiDataSourceConf piDataSource;

    @Autowired
    private ObjectPoolConfig objectPoolConfig;


    private ObjectPool<TProtocol> pool;

    /**
     * 获取 thrift 连接对象池
     * @return
     */
    public ObjectPool<TProtocol> getPool() {

        if (pool == null){

            GenericObjectPoolConfig poolConfig = objectPoolConfig.getGenericObjectPoolConfig();

            // 第一次加载对象池
            pool = new GenericObjectPool<>(new TProtocolFactory(piDataSource.getIp(), piDataSource.getPort(), true ,TProtocolFactory.OPC_SERVICE), poolConfig);

        }

        return pool;

    }



}

以上代码中,GenericObjectPoolConfig 对象可以设置连接池的参数,比如最大连接数、最大空闲数、超时时间等信息,具体可以参考commons-pools中的通用配置即可。

3、使用对象池使用TProtocol对象

完成上面两步之后,就可以从对象池中非常简单的获取TProtocol对象了,获取对象使用如下代码:

TProtocol protocol = protocolPool.getPool().borrowObject();

使用完对象后,必须使用同一个对象池返回使用的对象,否则这个对象就在进程中失控了:

protocolPool.getPool().returnObject(protocol);
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值