Thrift学习笔记（4）--实现Thrift客户端连接池

最新推荐文章于 2022-10-15 18:11:52 发布
最新推荐文章于 2022-10-15 18:11:52 发布
阅读量2.2k 收藏 2
点赞数
分类专栏： RPC-THrift 文章标签： thrift
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014315941/article/details/53282872
版权

实现Thrift客户端连接池

提到池一般做过Java开发的肯定会想到ObjectPool，Apache Commons项目确实给我们的开发得来了很大的便利性，其中的pool项目正是我们实现thrift连接池的基础，当然也离不了spring。

1、在工程中添加连接池依赖jar包：

<dependency>
    <groupId>commons-pool</groupId>
    <artifactId>commons-pool</artifactId>
    <version>1.6</version>
</dependency>

2、创建服务端服务提供者实现

package com.thrift.server;

import com.service.demo.Hello;
import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TThreadPoolServer;
import org.apache.thrift.transport.TServerSocket;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * 服务端服务提供者
 */
public class UserServiceServer {
    /** 服务的端口 */
    private int servicePort;
    @Autowired
    private Hello.Iface iface;

    public void start() {
        try {
            TServerSocket serverTransport = new TServerSocket(servicePort);
            // 关联处理器与 服务的实现
            TProcessor processor = new Hello.Processor<Hello.Iface>(iface);
            // TBinaryProtocol 二进制编码格式进行数据传输
            // 设置协议工厂为 TBinaryProtocol.Factory
            TBinaryProtocol.Factory proFactory = new TBinaryProtocol.Factory(true, true);
            TThreadPoolServer.Args args = new TThreadPoolServer.Args(serverTransport);
            args.processor(processor);
            args.protocolFactory(proFactory);
            // 多线程服务器端使用标准的阻塞式 I/O
            TServer server = new TThreadPoolServer(args);
            System.out.println("Starting server on port " + servicePort + "......");
            server.serve();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public int getServicePort() {
        return servicePort;
    }

    public void setServicePort(int servicePort) {
        this.servicePort = servicePort;
    }
}

3、配置server spring，applicationContext-server.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.thrift.*"/>
    <context:component-scan base-package="com.service.*"/>
    <!-- 服务端接口配置 -->
    <bean id="userServiceServer" class="com.thrift.server.UserServiceServer">
        <property name="servicePort" value="7911" />
    </bean>
    <bean id="helloWorldImpl" class="com.service.demo.impl.HelloServiceImpl"/>
  </beans>

4、创建服务端启动类

package com.thriftServer;

import com.thrift.server.UserServiceServer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by ssjk on 2016/10/21.
 */
public class PoolServerTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext-server.xml");
        UserServiceServer userServiceServer = (UserServiceServer) context.getBean("userServiceServer");
        userServiceServer.start();
    }
}

5、创建连接池实现实现工厂
（1）创建ThriftPoolableObjectFactory.java

package com.thrift.pool;

import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by ssjk on 2016/10/21.
 */

public class ThriftPoolableObjectFactory implements PoolableObjectFactory<TTransport> {

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

    /** 服务的IP */
    private String serviceIP;
    /** 服务的端口 */
    private int servicePort;
    /** 超时设置 */
    private int timeOut;
    public ThriftPoolableObjectFactory(String serviceIP, int servicePort, int timeOut) {
        super();
        this.serviceIP = serviceIP;
        this.servicePort = servicePort;
        this.timeOut = timeOut;
    }
    public TTransport makeObject() throws Exception {
        try {
            TTransport transport = new TSocket(this.serviceIP, this.servicePort, this.timeOut);
            transport.open();
            return transport;
        } catch (Exception e) {
            logger.error("error ThriftPoolableObjectFactory()", e);
            throw new RuntimeException(e);
        }
    }
    /**
     * 销毁对象
     */
    public void destroyObject(TTransport tTransport) throws Exception {
        if (tTransport.isOpen()) {
            tTransport.close();
        }
    }
    /**
     * 检验对象是否可以由pool安全返回
     */
    public boolean validateObject(TTransport tTransport) {
        try {
            if (tTransport instanceof TSocket) {
                TSocket thriftSocket = (TSocket) tTransport;
                if (thriftSocket.isOpen()) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * 激活对象
     */
    public void activateObject(TTransport tTransport) throws Exception {

    }
    /**
     * 使无效 以备后用
     */
    public void passivateObject(TTransport tTransport) throws Exception {

    }
}

（2）创建连接池接口和实现类
连接池接口

package com.thrift.iface;

import org.apache.thrift.transport.TSocket;

/**
 * 连接池接口
 */
public interface  ConnectionProvider {
    /**
     * 取链接池中的一个链接
     * @return TSocket
     */
    TSocket getConnection();

    /**
     * 返回链接
     * @param socket
     */
    void returnCon(TSocket socket);
}

连接池接口实现类：ConnectionProviderImpl.java

package com.thrift.ifaceImp;

import com.thrift.iface.ConnectionProvider;
import com.thrift.pool.ThriftPoolableObjectFactory;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Repository;

/**
 * 连接池实现
 */
@Repository
public class ConnectionProviderImpl implements ConnectionProvider, InitializingBean, DisposableBean {
    /** 服务的IP地址 */
    private String serviceIP;
    /** 服务的端口 */
    private int servicePort;
    /** 连接超时配置 */
    private int conTimeOut;
    /** 可以从缓存池中分配对象的最大数量 */
    private int maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;
    /** 缓存池中最大空闲对象数量 */
    private int maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;
    /** 缓存池中最小空闲对象数量 */
    private int minIdle = GenericObjectPool.DEFAULT_MIN_IDLE;
    /** 阻塞的最大数量 */
    private long maxWait = GenericObjectPool.DEFAULT_MAX_WAIT;

    /** 从缓存池中分配对象，是否执行PoolableObjectFactory.validateObject方法 */
    private boolean testOnBorrow = GenericObjectPool.DEFAULT_TEST_ON_BORROW;
    private boolean testOnReturn = GenericObjectPool.DEFAULT_TEST_ON_RETURN;
    private boolean testWhileIdle = GenericObjectPool.DEFAULT_TEST_WHILE_IDLE;

    /** 对象缓存池 */
    private ObjectPool<TTransport> objectPool = null;
    public TSocket getConnection() {
        try {
            // 从对象池取对象
            TSocket socket = (TSocket) objectPool.borrowObject();
            return socket;
        } catch (Exception e) {
            throw new RuntimeException("error getConnection()", e);
        }
    }

    public void returnCon(TSocket socket) {
        try {
            // 将对象放回对象池
            objectPool.returnObject(socket);
        } catch (Exception e) {
            throw new RuntimeException("error returnCon()", e);
        }
    }

    public void destroy() throws Exception {
        try {
            objectPool.close();
        } catch (Exception e) {
            throw new RuntimeException("erorr destroy()", e);
        }
    }

    public void afterPropertiesSet() throws Exception {
// 对象池
        objectPool = new GenericObjectPool<TTransport>();
        //
        ((GenericObjectPool<TTransport>) objectPool).setMaxActive(maxActive);
        ((GenericObjectPool<TTransport>) objectPool).setMaxIdle(maxIdle);
        ((GenericObjectPool<TTransport>) objectPool).setMinIdle(minIdle);
        ((GenericObjectPool<TTransport>) objectPool).setMaxWait(maxWait);
        ((GenericObjectPool<TTransport>) objectPool).setTestOnBorrow(testOnBorrow);
        ((GenericObjectPool<TTransport>) objectPool).setTestOnReturn(testOnReturn);
        ((GenericObjectPool<TTransport>) objectPool).setTestWhileIdle(testWhileIdle);
        ((GenericObjectPool<TTransport>) objectPool).setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_BLOCK);
        // 设置factory
        ThriftPoolableObjectFactory thriftPoolableObjectFactory = new ThriftPoolableObjectFactory(serviceIP, servicePort, conTimeOut);
        objectPool.setFactory(thriftPoolableObjectFactory);
    }
    public String getServiceIP() {
        return serviceIP;
    }

    public void setServiceIP(String serviceIP) {
        this.serviceIP = serviceIP;
    }

    public int getServicePort() {
        return servicePort;
    }

    public void setServicePort(int servicePort) {
        this.servicePort = servicePort;
    }

    public int getConTimeOut() {
        return conTimeOut;
    }

    public void setConTimeOut(int conTimeOut) {
        this.conTimeOut = conTimeOut;
    }

    public int getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public int getMaxIdle() {
        return maxIdle;
    }

    public void setMaxIdle(int maxIdle) {
        this.maxIdle = maxIdle;
    }

    public int getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public long getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(long maxWait) {
        this.maxWait = maxWait;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public ObjectPool<TTransport> getObjectPool() {
        return objectPool;
    }

    public void setObjectPool(ObjectPool<TTransport> objectPool) {
        this.objectPool = objectPool;
    }
}

6、创建连接池管理类

package com.thrift.controller;

import com.thrift.iface.ConnectionProvider;
import org.apache.thrift.transport.TSocket;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 连接池管理
 */
@Service
public class ConnectionManager {
    /** 日志记录器 */
    private final Logger logger = LoggerFactory.getLogger(getClass());
    /** 保存local对象 */
    ThreadLocal<TSocket> socketThreadSafe = new ThreadLocal<TSocket>();

    /** 连接提供池 */
    @Autowired(required=true)
    private ConnectionProvider connectionProvider;

    public ConnectionProvider getConnectionProvider() {
        return connectionProvider;
    }

    public void setConnectionProvider(ConnectionProvider connectionProvider) {
        this.connectionProvider = connectionProvider;
    }

    public TSocket getSocket() {
        TSocket socket = null;
        try {
            socket = connectionProvider.getConnection();
            socketThreadSafe.set(socket);
            return socketThreadSafe.get();
        } catch (Exception e) {
            logger.error("error ConnectionManager.invoke()", e);
        } finally {
            connectionProvider.returnCon(socket);
            socketThreadSafe.remove();
        }
        return socket;
    }

}

7、创建客户端实现类

package com.thrift.client;

import com.service.demo.Hello;
import com.thrift.controller.ConnectionManager;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TTransportException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Created by ssjk on 2016/10/21.
 */
@Service
public class UserServiceClient {
    @Autowired
    private ConnectionManager connectionManager;

    public void invoke() {
       try {
           TProtocol protocol = new TBinaryProtocol(connectionManager.getSocket());
           Hello.Client client = new Hello.Client(protocol);
           System.out.println(client.helloString("连接池测试"));
       }catch (Exception e){
           e.printStackTrace();
       }
    }
}

8、客户端spring配置，applicationContext-client.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <description>thrift配置文件 </description>
    <context:component-scan base-package="com.thrift.*" />
    <!-- 连接池配置 -->
    <bean id="connectionProvider" class="com.thrift.ifaceImp.ConnectionProviderImpl">
        <property name="serviceIP" value="127.0.0.1" />
        <property name="servicePort" value="7911" />
        <property name="maxActive" value="10" />
        <property name="maxIdle" value="10" />
        <property name="testOnBorrow" value="true" />
        <property name="testOnReturn" value="true" />
        <property name="testWhileIdle" value="true" />
        <property name="conTimeOut" value="2000" />
    </bean>
</beans>

9、创建客户端启动类

package com.thriftClient;

import com.thrift.client.UserServiceClient;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by ssjk on 2016/10/21.
 */
public class PoolClientTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext-client.xml");
        UserServiceClient userServiceClient = (UserServiceClient) context.getBean(UserServiceClient.class);
        userServiceClient.invoke();
    }
}

10、最后启动服务端PoolServerTest.java 然后启动客户端PoolClientest.java调用

参考资料：
http://blog.csdn.net/column/details/slimina-thrift.html

阿狸小镇
关注
专栏目录
[Spark版本更新]--2.3.0发行说明
欢迎来到我的博客，一起探索代码里的世界！
03-03 1万+
自从2017年12月1日发布spark-2.2.1以来，已有3个月时间。2018年2月28日，spark官方发布了一个大版本Spark-2.3.0，解决了1399个大大小小的问题。一、DataBricks做了相关说明今天，我们很高兴地宣布Databricks上的Apache Spark 2.3.0作为其Databricks Runtime 4.0的一部分。我们要感谢Apache Spark社区为S...
thrift服务集成spring及连接池
04-01
thrift是为了解决facebook系统中各系统间大数据量的传输通信以及系统之间语言环境不同需要跨平台的特性。thrift服务支持多种程序语言。比webservice简单方便。thrift集成spring。thrift集成连接池。使通信服务更简单。
java thrift连接池_由浅入深了解Thrift之客户端连接池化
weixin_29689845的博客
02-16 474
一、问题描述在上一篇《由浅入深了解Thrift之服务模型和序列化机制》文章中，我们已经了解了thrift的基本架构和网络服务模型的优缺点。如今的互联网圈中，RPC服务化的思想如火如荼。我们又该如何将thrift服务化应用到我们的项目中哪？实现thrift服务化前，我们先想想这几个问题：服务注册、服务发现、服务健康检测、服务“Load Balance”、隐藏client和server端的交互细节、服...
Thrift客户端连接池设计
lansebolangcjl的专栏
10-11 4590
连接池的作用就是为了提高性能。 连接池的作用：连接池是将已经创建好的连接保存在池中，当有请求来时，直接使用已经创建好的连接对Server端进行访问。这样省略了创建连接和销毁连接的过程。这样性能上得到了提高。 基本原理是这样的： （1）建立连接池对象（服务器启动）。 （2）按照事先指定的参数创建初始数量的连接（即：空闲连接数）。 （3）对于一个访问请求，直接从连接池中得到一个连接。如果
由浅入深了解Thrift之客户端连接池化续
weixin_30364147的博客
11-21 200
前文《由浅入深了解Thrift之客户端连接池化》中我们已经实现了服务调用端 连接的池化，实现的过于简陋，离实际的项目运用还很遥远。本文将在进一步改造，主要是两方面：1、服务端如何注册多个服务 2、调用端如何获取服务对象而不是服务连接 一、实现思路 1、通过spring配置文件，配置服务类 2、反射生成服务类实例，依次注册服务 调用端获取服务对象亦是如此，废话...
rpc框架之 thrift连接池实现
weixin_34061555的博客
09-27 174
接前一篇rpc框架之HA/负载均衡构架设计 继续，写了一个简单的thrift 连接池： 先做点准备工作： package yjmyzz; public class ServerInfo { public String getHost() { return host; } public void setHost(String ho...
grpc学习笔记--Java版
Darren's Thought
11-15 5738
这几天由于工作的原因，涉及到系统之间的通信，rpc调用方式不失为内部系统之间的一种高效简单的方式，至于rpc是什么，这里不多说，自行Google去。 在比较了Thrift（Apache开源项目）和grpc（谷歌去年开源的一个项目）后，选择了grpc，这里不想多说它们两个之间的区别。 在阅读下面代码之前你先要去了解一下protocol buffer 本文涉及的程序，用的开发工具是idea2016
Elasticsearch-7.1.x学习笔记
醉殇无痕的博客
06-13 1万+
文章目录1. 单节点安装2. ES安装head插件3. Elasticsearch Rest基本操作REST介绍CURL创建索引库查询索引-GETDSL查询MGET查询HEAD的使用ES更新索引ES删除索引ES批量操作-bulkES版本控制4. Elasticsearch 核心概念Clustershardsreplicasrecoverygatewaydiscovery.zenTransportS...
RPC入门学习笔记
12-05
5. 性能优化：包括减少网络开销、缓存策略、连接池等。 六、RPC测试 在实际开发中，对RPC服务的测试至关重要，包括功能测试、性能测试和压力测试。例如，模拟高并发场景，验证服务的稳定性和吞吐量。 总结，RPC是...
java学习笔记01
SQ_1224的博客
08-19 311
java学习笔记
thrift-connection-pool
06-01
节俭连接池 使用 Apache commons-pool2 的 Thrift 连接池的实现。 此实现创建 TSocket 的实例并将它们池化。 以下代码片段显示了如何创建 TSocketProvider 的实例 GenericObjectPoolConfig config = new GenericObjectPoolConfig (); // The followings are the minimum required settings to configure a pool config . setTestOnBorrow( true ); config . setTestOnCreate( true ); config . setTestOnReturn( true ); config
基于thrift开发的客户端和服务端
10-14
一个简单的demo，关于使用thrift进行跨语言服务间的通信
thriftpool:Thrift RPC连接池，java实现，基于apache commons pool
07-11
储蓄池 Thrift RPC连接池，java实现，基于apache commons pool
thrift客户端连接池封装
weixin_30896825的博客
11-30 135
本篇只是在实际中使用的一个例子，thrift具体的源码分析请参考网上其它同行的高见。可以参考：http://www.ibm.com/developerworks/cn/java/j-lo-apachethrift/。在使用的过程中发现，thrift的一个客户端不是线程安全的，如果有多个线程同时请求信息就会报错。我加了一个thrift客户端连接池，每个线程可以从thrift客户端连接池中获取一个th...
Thrift连接池优化
热门推荐
chen7253886的博客
10-10 1万+
背景众所周知，thrift是一款很优秀的rpc框架，公司今年在部门间推行thrift框架来提高部门间的通信效率，作者本人的工作内容主要是作为客户端(本人所在组为服务端，对于提供服务的其他部门来说是客户端)调用其他部门的接口，在工作过程中发现thrift有个较大的弊端，一般情况下服务端会向客户端提供一组服务IP，所有的负载均衡工作，连接是否可用等工作都需要客户端自己来维护，而apach
Thrift 客户端 JAVA
蜗牛水里爬
11-30 653
import org.apache.commons.lang3.StringUtils; import org.apache.thrift.protocol.TBinaryProtocol; import org.apache.thrift.protocol.TProtocol; import org.apache.thrift.transport.TTransport; import org.a
wealoha thrift-client-pool 总结
weixin_30659829的博客
11-20 149
DefaultEvictionPolicy类是EvictionPolicy接口的实现主要描述，pool中那些idel对象会被Evict，回收。关键代码如下： public boolean evict(EvictionConfig config, PooledObject<T> underTest, int idleCount) { ...
Thrift客户端服务器示例
最新发布
weixin_45724872的博客
10-15 670
Thrift
[转]Thrift连接池实现
weixin_33777877的博客
04-22 227
简介 Thrift是Facebook的核心框架之一，使不同的开发语言开发的系统可以通过该框架实现彼此的通信，类似于webservice，但是Thrift提供了近乎变态的效率和开发的方便性，是webservice所不能比拟的。给分布式开发带来了极大的方便。但是这柄利器也有一些不完美。   问题 首先文档相当的少，只有一个wiki网站提供相应的帮助。这对于Thrift的推广极为不利。 其次框...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值