springboot整合Thrift

最新推荐文章于 2024-06-06 10:02:44 发布
最新推荐文章于 2024-06-06 10:02:44 发布
阅读量2k 收藏 11
点赞数 3
分类专栏： spring 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37482956/article/details/123596724
版权

什么是Thrift

Thrift是一种接口描述语言和二进制通讯协议，它被用来定义和创建跨语言的服务。它被当作一个远程过程调用（RPC）框架来使用，是由Facebook为“大规模跨语言服务开发”而开发的。它通过一个代码生成引擎联合了一个软件栈，来创建不同程度的、无缝的跨平台高效服务，可以使用C#、C++（基于POSIX兼容系统）、Cappuccino、Cocoa、Delphi、Erlang、Go、Haskell、Java、Node.js、OCaml、Perl、PHP、Python、Ruby和Smalltalk。虽然它以前是由Facebook开发的，但它现在是Apache软件基金会的开源项目了。

架构

Thrift包含一套完整的栈来创建客户端和服务端程序。顶层部分是由Thrift定义生成的代码。而服务则由这个文件客户端和处理器代码生成。在生成的代码里会创建不同于内建类型的数据结构，并将其作为结果发送。协议和传输层是运行时库的一部分。有了Thrift，就可以定义一个服务或改变通讯和传输协议，而无需重新编译代码。除了客户端部分之外，Thrift还包括服务器基础设施来集成协议和传输，如阻塞、非阻塞及多线程服务器。栈中作为I/O基础的部分对于不同的语言则有不同的实现，如下官方示意图

img

支持的通讯协议

  • TBinaryProtocol
    一种简单的二进制格式，简单，但没有为空间效率而优化。比文本协议处理起来更快，但更难于调试。
  • TCompactProtocol
    更紧凑的二进制格式，处理起来通常同样高效。
  • TDebugProtocol
    一种人类可读的文本格式，用来协助调试。
  • TDenseProtocol
    与TCompactProtocol类似，将传输数据的元信息剥离。
  • TJSONProtocol
    使用JSON对数据编码。
  • TSimpleJSONProtocol
    一种只写协议，它不能被Thrift解析，因为它使用JSON时丢弃了元数据。适合用脚本语言来解析

支持的传输协议

  • TFileTransport
    该传输协议会写文件。
  • TFramedTransport
    当使用一个非阻塞服务器时，要求使用这个传输协议。它按帧来发送数据，其中每一帧的开头是长度信
  • TMemoryTransport
    使用存储器映射输入输出。（Java的实现使用了一个简单的ByteArrayOutputStream。）
  • TSocket
    使用阻塞的套接字I/O来传输。
  • TZlibTransport
    用zlib执行压缩。用于连接另一个传输协议。

支持的服务模型

  • TNonblockingServer
    一个多线程服务器，它使用非阻塞I/O（Java的实现使用了NIO通道）。TFramedTransport必须跟这个服务器配套使用。
  • TSimpleServer
    一个单线程服务器，它使用标准的阻塞I/O。测试时很有用。
  • TThreadPoolServer
    一个多线程服务器，它使用标准的阻塞I/O
  • THsHaServer
    YHsHa引入了线程池去处理（需要使用TFramedTransport数据传输方式），其模型把读写任务放到线程池去处理;Half-sync/Half-async（半同步半异步）的处理模式;Half-sync是在处理IO时间上（sccept/read/writr io）,Half-async用于handler对RPC的同步处理

Thrift的优点

  1. 跟一些替代选择，比如SOAP相比，跨语言序列化的代价更低，因为它使用二进制格式。
  2. 它有一个又瘦又干净的库，没有编码框架，没有XML配置文件。
  3. 绑定感觉很自然。例如，Java使用java.util.ArrayList；C++使用std::vectorstd::string。
  4. 应用层通讯格式与序列化层通讯格式是完全分离的。它们都可以独立修改。
  5. 预定义的序列化格式包括：二进制格式、对HTTP友好的格式，以及紧凑的二进制格式。
  6. 兼作跨语言文件序列化。
  7. 协议使用软版本号机制软件版本管理[需要解释]。Thrift不要求一个中心化的和显式的版本号机制，例如主版本号/次版本号。松耦合的团队可以轻松地控制RPC调用的演进。
  8. 没有构建依赖也不含非标准化的软件。不存在不兼容的软件许可证混用的情况

SpringBoot整合Thrift

为什么会出现RPC框架

  1. 高级语言越来越丰富，同时学习的成本越来越低，从而出现编程语言的百花齐放，同时，每种语言都有其在特定场景下的优势性，因此一个企业的系统架构可能存在这各种各样的编程语言发挥着光和热。因此跨语言间的通讯必须存在一个桥梁；
  2. 微服务的盛行，使得服务逐渐模块化，功能化；单个服务仅仅实现某个特定的功能或者模块，因此使得服务间的调用变得常见且频繁；
  3. 网络的发展速度快于了硬件的发展速度，使得服务承载负载压力越来越大；因此高性能且快速响应的服务调用成了必须去面对的问题
  4. 传统的Http请求能面对跨语言的问题，但是性能远远无法达到高并发的要求
  5. 多个服务会使用到相同的数据，比如用户；因此就需要将起模块化，统一对外提供服务

常见的RPC框架集成套路

  1. 编写接口代码生成文件(用于生成客户端服务端代码)
  2. 使用开源框架提供的工具，生成各种语言下的客户端、服务器源代码
  3. 基于服务器端源代码启动并配置业务代码
  4. 客户端基于生成的客户端代码，向远端服务器获取对应的数据；整个过程相当于于调用一个本地方法

开撸

官网下载代码生成工具

官网地址

image-20211020115159453

本示例模拟的业务场景

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lcs01vgk-1647677064392)(img/20190917193852890.png)]

  1. thrift client ： 用于对外提供接口，getStudentByName(根据名字获取学生信息)、save(保存学生信息)
  2. thrift server： 真正getStudentByName和save操作的服务提供者
  3. APP ： 服务使用者

最终实现的基础效果

img

img

编写接口代码生成文件

  • thrift支持的数据类型
    当一个RPC框架支持的语言越多，那么他支持的数据类型就会越少，为什么？因为支持数据必须是所有支持都有的，因此语言越多，交集就越少，以下是thrift支持的数据类型：

bool: A boolean value (true or false)
byte: An 8-bit signed integer
i16: A 16-bit signed integer
i32: A 32-bit signed integer
i64: A 64-bit signed integer
double: A 64-bit floating point number
string: A text string encoded using UTF-8 encoding

  • 编写脚本
    创建student.thrift
    注：如果在Idea里面创建一个thrift文件的话，工具会提醒你安装插件，安装之后，编写脚本会有响应的提醒

    // 这里指明代码生成后，所处的文件路径
namespace java com.yyds.thriftserver.shriftcode
namespace py py.com.yyds.thriftserver.shriftcode

// 将thrif数据格式转成java 习惯的格式
typedef i16 short
typedef i32 int
typedef i64 long
typedef string String
typedef bool boolean

// 定义学生类
struct Student {
    //optional 可选 非必传
    1:optional String name ,
    2:optional int age,
    3:optional String address
}

// 定义数据异常
exception DataException {
    1:optional int code;
    2:optional String message;
    3:optional String dateTime;
}

// 定义操作学生的服务
service StudentService {
    //根据名称获取学生信息 返回一个学生对象  抛出DataException异常
    //required 必传项
    Student getStudentByName(1:required String name) throws (1:DataException dataException),

    // 保存一个学生信息，无返回值 抛出异常
    void save(1:required Student student) throws (1:DataException dataException)

}

  • 生成源代码

    语法: thrift --gen <language> <Thrift filename>

img

​

  • 文件说明
    DataException.java ： 异常对象
    Student.java ： 交互的数据模型对象
    StudentService.java ： 服务对象，提供了接口，客户端连接相关方法

thrift-server服务

  • 通过Idea创建一个基础的Maven项目

  • pom文件中添加thrift资源库

    <!--thrift 相关资源-->
<dependency>
    <groupId>org.apache.thrift</groupId>
    <artifactId>libthrift</artifactId>
    <version>0.12.0</version>
</dependency>

  • 将上面生成的代码拷贝至项目中

image-20211021103552391

  • 实现业务逻辑

    创建一个Server服务，实现StudentService.Iface接口，同时这个接口添加@Service注解，将其交由Spring管理

    @Service
public class MyServerServiceImpl implements StudentService.Iface {
    @Override
    public Student getStudentByName(String name) throws DataException, TException {
        System.out.println("服务端收到客户端获取用户名:" + name + "信息");
        Student student = new Student();

        // 模拟数据
        student.setName(name);
        student.setAge(30);
        student.setAddress("西安");

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("模拟获取成功并返回：" + student);

        return student;
    }

    @Override
    public void save(Student student) throws DataException, TException {
        System.out.println("服务端收到客户端请求保存学生信息：" + student);
        //模拟耗时
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("模拟保存成功!!!");
    }
}

  • 配置文件添加端口及线程池基础配置

    server:
  thrift:
    port: 8899 #监听的端口
    min-thread-pool: 100  #线程池最小线程数
    max-thread-pool: 1000 #线程池最大线程数

  • 创建服务对象

    这里使用的是半同步半异步的THsHaServer，代码本身不多，大部分都是注释；同时将代码交由Spring管理

    package com.yyds.thrift.server;

import com.yyds.service.MyServerServiceImpl;
import com.yyds.thriftserver.thriftcode.StudentService;
import org.apache.thrift.TProcessorFactory;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.THsHaServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TNonblockingServerSocket;
import org.apache.thrift.transport.TTransportException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ThriftServer2 {
    //监听的端口
    @Value("${server.thrift.port}")
    private Integer port;

    //线程池最小线程数
    @Value("${server.thrift.min-thread-pool}")
    private Integer minThreadPool;

    //线程池最大线程数
    @Value("${server.thrift.max-thread-pool}")
    private Integer maxThreadPool;

    //业务服务对象
    @Autowired
    MyServerServiceImpl myServerService;

    public void start() {
        try {
            //thrift支持的scoker有很多种
            //非阻塞的socker
            TNonblockingServerSocket socket = new TNonblockingServerSocket(port);
            //THsHaServer 一个高可用的server
            //minWorkerThreads 最小的工作线程2
            //maxWorkerThreads 最大的工作线程4
            //如果这里Args不使用executorService指定线程池的话，创建THsHaServer会创建一个默认的LinkedBlockingQueue
            THsHaServer.Args arg = new THsHaServer.Args(socket).minWorkerThreads(minThreadPool).maxWorkerThreads(maxThreadPool);
            //可以自定义指定线程池
            //ExecutorService pool = Executors.newFixedThreadPool(minThreadPool);
            //arg.executorService(pool);

            //Processor处理区  用于处理业务逻辑
            //泛型就是实现的业务
            StudentService.Processor<MyServerServiceImpl> processor = new StudentService.Processor<MyServerServiceImpl>(myServerService);

            //---------------thrift传输协议------------------------------
            //1. TBinaryProtocol      二进制传输协议
            //2. TCompactProtocol     压缩协议 他是基于TBinaryProtocol二进制协议在进一步的压缩，使得体积更小
            //3. TJSONProtocol        Json格式传输协议
            //4. TSimpleJSONProtocol  简单JSON只写协议，生成的文件很容易通过脚本语言解析，实际开发中很少使用
            //5. TDebugProtocol       简单易懂的可读协议，调试的时候用于方便追踪传输过程中的数据
            //-----------------------------------------------------------
            //设置工厂
            //协议工厂 TCompactProtocol压缩工厂  二进制压缩协议
            arg.protocolFactory(new TCompactProtocol.Factory());
            //---------------thrift传输格式------------------------------


            //---------------thrift数据传输方式------------------------------
            //1. TSocker            阻塞式Scoker 相当于Java中的ServerSocket
            //2. TFrameTransport    以frame为单位进行数据传输，非阻塞式服务中使用
            //3. TFileTransport     以文件的形式进行传输
            //4. TMemoryTransport   将内存用于IO,Java实现的时候内部实际上是使用了简单的ByteArrayOutputStream
            //5. TZlibTransport     使用zlib进行压缩，与其他传世方式联合使用；java当前无实现所以无法使用
            //传输工厂 更加底层的概念
            arg.transportFactory(new TFramedTransport.Factory());
            //arg.transportFactory(new TTransportFactory());
            //---------------thrift数据传输方式------------------------------

            //设置处理器(Processor)工厂
            arg.processorFactory(new TProcessorFactory(processor));

            //---------------thrift支持的服务模型------------------------------
            //1.TSimpleServer  简单的单线程服务模型，用于测试
            //2.TThreadPoolServer 多线程服务模型，使用的标准的阻塞式IO;运用了线程池，当线程池不够时会创建新的线程,当线程池出现大量空闲线程，线程池会对线程进行回收
            //3.TNonBlockingServer 多线程服务模型，使用非阻塞式IO（需要使用TFramedTransport数据传输方式）
            //4.THsHaServer YHsHa引入了线程池去处理（需要使用TFramedTransport数据传输方式），其模型把读写任务放到线程池去处理;Half-sync/Half-async（半同步半异步）的处理模式;Half-sync是在处理IO时间上（sccept/read/writr io）,Half-async用于handler对RPC的同步处理
            //----------------------------
            //根据参数实例化server
            //半同步半异步的server
            TServer server = new THsHaServer(arg);
            //---------------thrift支持的服务模型------------------------------

            System.out.println("thrift server started; port:" + port);
            //启动server
            // 异步非阻塞的死循环
            server.serve();
        } catch (TTransportException e) {
            e.printStackTrace();
        }
    }
}

  • 启动类中添加Server的启动配置

    @SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    /**
     * 向Spring注册一个Bean对象
     * initMethod = "start"  表示会执行名为start的方法
     * start方法执行之后，就会阻塞接受客户端的请求
     *
     * @return
     */
    @Bean(initMethod = "start")
    public ThriftServer2 init() {
        ThriftServer2 thriftServer = new ThriftServer2();
        return thriftServer;
    }
}

  • 启动项目
    到此，服务端的项目就已经配置完成了，启动服务出现下图剪头所指向的日志即可；

image-20211021110538347

thrift-client客户端服务

  • 项目创建

    由于这个项目是一个中间服务，是thrift-server的客户端，是APP的服务端；因为要向APP提供接口，因此这里就创建一个基础的Web服务

  • pom文件中添加thrift资源库

    <!--thrift 相关资源-->
<dependency>
    <groupId>org.apache.thrift</groupId>
    <artifactId>libthrift</artifactId>
    <version>0.12.0</version>
</dependency>

  • 将上面生成的代码拷贝至项目中

image-20211021113646046

  • 配置服务端信息

    server:
  port: 8887 #当前服务监听的端口，给APP端提供服务的接口
  thrift:
    host: 'localhost' #远端thrift服务IP
    port: 8899 #远端thrift服务端口

  • 创建一个远端连接对象

    public class ThriftClient {

    private String host;

    private Integer port;

    private TTransport tTransport;

    private TProtocol tProtocol;

    private StudentService.Client client;

    private void init() {
        tTransport = new TFramedTransport(new TSocket(host, port), 600);
        //协议对象 这里使用协议对象需要和服务器的一致
        tProtocol = new TCompactProtocol(tTransport);
        client = new StudentService.Client(tProtocol);
    }

    public StudentService.Client getService() {
        return client;
    }

    public void open() throws TTransportException {
        if (null != tTransport && !tTransport.isOpen())
            tTransport.open();
    }

    public void close() {
        if (null != tTransport && tTransport.isOpen())
            tTransport.close();
    }

    public void setHost(String host) {
        this.host = host;
    }

    public void setPort(Integer port) {
        this.port = port;
    }
}

  • 创建一个连接自动注入帮助类

    该类用于将ThriftClient注入到Spring容器，交由Spring管理，同时每一个request请求都创建一个新的ThriftClient连接；

    @Configuration
public class ThriftClientConfig {
    //服务端的地址
    @Value("${server.thrift.host}")
    private String host;

    //服务端的端口
    @Value("${server.thrift.port}")
    private Integer port;

    //初始化Bean的时候调用对象里面的init方法
    @Bean(initMethod = "init")
    //每次请求实例化一个新的ThriftClient连接对象
    @Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
    public ThriftClient init() {
        ThriftClient thriftClient = new ThriftClient();
        thriftClient.setHost(host);
        thriftClient.setPort(port);
        return thriftClient;
    }
}

  • 定义调用远端服务的service接口

    public interface StudentServiceInf {

    //根据名称获取学生信息
    Student getStudentByName(String name);

    //保存学生信息
    void save(Student student);
}

  • 添加Service的具体实现

    @Service
public class StudentServiceImpl implements StudentServiceInf {
    @Autowired
    ThriftClient thriftClient;

    @Override
    public Student getStudentByName(String name) {
        try {
            thriftClient.open();
            System.out.println("客户端请求用户名为:" + name + "的数据");
            Student student = thriftClient.getService().getStudentByName(name);
            System.out.println("获取成功！！！服务端返回的对象:" + student);
            return student;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            thriftClient.close();
        }
        return null;
    }

    @Override
    public void save(Student student) {
        try {
            thriftClient.open();
            System.out.println("客户端请求保存对象:" + student);
            thriftClient.getService().save(student);
            System.out.println("保存成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            thriftClient.close();
        }
    }
}

  • 创建前端Controller对象
    用于对移动端提供接口

    @RestController
public class TestController {

    @Autowired
    StudentServiceInf studentService;

    @GetMapping("get")
    public Student getStudeByName(String name) {
        return studentService.getStudentByName(name);
    }

    @GetMapping("save")
    public Student save() {
        //直接模拟前端传递的数据
        Student student = new Student();
        student.setName("AAA");
        student.setAge(10);
        student.setAddress("BBB");
        //调用保存服务
        studentService.save(student);
        return student;
    }
}

  • 启动服务

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cLppLsWC-1647677064402)(img/image-20211021114542968.png)]

  • 测试

    image-20211021114627418

image-20211021114720034

Thrift客户端连接池

上面的示例中，每次前端有请求上来的时候，thrift-client都是与thrift-server创建了一个新的连接，用完就直接关闭掉；Thrift框架本身是没有提供客户端的连接池的，但是，实际使用中，如果每次建立一个socket连接用完就释放掉，再次使用再次建立连接的话，其实很浪费性能；因此，连接池就是提升性能的一种很好的手段；一个Service建立一个连接之后，放在一个池子里面，需要使用的时候就直接拿出来用，用完再还回去；如果一定时间内一直没有人使用，就把资源释放掉；以上是连接池的一个基本思路；Apache Commons Pool为我们提供了一个基础的框架，使得我们能够很轻松、快速的就实现一个连接池的功能；下面我们就来通过Apache Commons Pool实现一个thrift客户端的连接池。

引入资源

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

连接池编码

  • 创建一个客户端的连接对象

    public class TTSocket {
    //thrift socket对象
    private TSocket tSocket;

    // 传输对象
    private TTransport tTransport;

    // 协议对象
    private TProtocol tProtocol;

    // 服务客户端对象
    private StudentService.Client client;

    /**
     * 构造方法初始化各个连接对象
     *
     * @param host server的地址
     * @param port server的端口
     */
    public TTSocket(String host, Integer port) {
        tSocket = new TSocket(host, port);
        tTransport = new TFramedTransport(tSocket, 600);
        //协议对象 这里使用协议对象需要和服务器的一致
        tProtocol = new TCompactProtocol(tTransport);
        client = new StudentService.Client(tProtocol);
    }

    /**
     * 获取服务客户端对象
     *
     * @return
     */
    public StudentService.Client getService() {
        return client;
    }

    /**
     * 打开通道
     *
     * @throws TTransportException
     */
    public void open() throws TTransportException {
        if (null != tTransport && !tTransport.isOpen())
            tTransport.open();
    }

    /**
     * 关闭通道
     */
    public void close() {
        if (null != tTransport && tTransport.isOpen())
            tTransport.close();
    }

    /**
     * 判断通道是否是正常打开状态
     *
     * @return
     */
    public boolean isOpen() {
        Socket socket = tSocket.getSocket();
        if (socket.isConnected() && !socket.isClosed())
            return true;
        return false;
    }
}

  • 创建一个工厂对象

    public class ThriftClientConnectPoolFactory {

    /**
     * 对象池
     */
    public GenericObjectPool pool;

    /**
     * 实例化池工厂帮助类
     *
     * @param config
     * @param ip
     * @param port
     */
    public ThriftClientConnectPoolFactory(GenericObjectPool.Config config, String ip, int port) {
        ConnectionFactory factory = new ConnectionFactory(ip, port);
        //实例化池对象
        this.pool = new GenericObjectPool(factory, config);
        //设置获取对象前校验对象是否可以
        this.pool.setTestOnBorrow(true);
    }

    /**
     * 在池中获取一个空闲的对象
     * 如果没有空闲且池子没满，就会调用makeObject创建一个新的对象
     * 如果满了，就会阻塞等待，直到有空闲对象或者超时
     *
     * @return
     * @throws Exception
     */
    public TTSocket getConnect() throws Exception {
        return (TTSocket) pool.borrowObject();
    }

    /**
     * 将对象从池中移除
     *
     * @param ttSocket
     */
    public void invalidateObject(TTSocket ttSocket) {
        try {
            pool.invalidateObject(ttSocket);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 将一个用完的对象返还给对象池
     *
     * @param ttSocket
     */
    public void returnConnection(TTSocket ttSocket) {
        try {
            pool.returnObject(ttSocket);
        } catch (Exception e) {
            if (ttSocket != null) {
                try {
                    ttSocket.close();
                } catch (Exception ex) {
                    //
                }
            }
        }
    }

    /**
     * 池里面保存的对象工厂
     */
    class ConnectionFactory extends BasePoolableObjectFactory {
        //远端地址
        private String host;

        //端口
        private Integer port;

        /**
         * 构造方法初始化地址及端口
         *
         * @param ip
         * @param port
         */
        public ConnectionFactory(String ip, int port) {
            this.host = ip;
            this.port = port;
        }

        /**
         * 创建一个对象
         *
         * @return
         * @throws Exception
         */
        @Override
        public Object makeObject() throws Exception {
            // 实例化一个自定义的一个thrift 对象
            TTSocket ttSocket = new TTSocket(host, port);
            // 打开通道
            ttSocket.open();
            return ttSocket;
        }

        /**
         * 销毁对象
         *
         * @param obj
         */
        public void destroyObject(Object obj) {
            try {
                if (obj instanceof TTSocket) {
                    //尝试关闭连接
                    ((TTSocket) obj).close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        /**
         * 校验对象是否可用
         * 通过 pool.setTestOnBorrow(boolean testOnBorrow) 设置
         * 设置为true这会在调用pool.borrowObject()获取对象之前调用这个方法用于校验对象是否可用
         *
         * @param obj 待校验的对象
         * @return
         */
        public boolean validateObject(Object obj) {
            if (obj instanceof TTSocket) {
                TTSocket socket = ((TTSocket) obj);
                if (!socket.isOpen()) {
                    return false;
                }
                return true;
            }
            return false;
        }
    }
}

  • 修改ThriftClientConfig，将池工厂对象通过Spring管理

    @Configuration
public class ThriftClientConfig {
    //服务端的地址
    @Value("${server.thrift.host}")
    private String host;

    //服务端的端口
    @Value("${server.thrift.port}")
    private Integer port;

    //初始化Bean的时候调用对象里面的init方法
    @Bean(initMethod = "init")
    //每次请求实例化一个新的ThriftClient连接对象
    @Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
    public ThriftClient init() {
        ThriftClient thriftClient = new ThriftClient();
        thriftClient.setHost(host);
        thriftClient.setPort(port);
        return thriftClient;
    }

    @Bean
    public ThriftClientConnectPoolFactory ThriftClientPool() {
        //对象池的配置对象
        //这里测试就直接使用默认的配置
        //可以通过config 设置对应的参数
        //参数说明见  http://commons.apache.org/proper/commons-pool/api-1.6/org/apache/commons/pool/impl/GenericObjectPool.html
        GenericObjectPool.Config config = new GenericObjectPool.Config();
        //创建一个池工厂对象
        ThriftClientConnectPoolFactory thriftClientConnectPoolFactory = new ThriftClientConnectPoolFactory(config, host, port);
        //交由Spring管理
        return thriftClientConnectPoolFactory;
    }
}

  • 使用示例

    @Service
public class StudentServiceImpl implements StudentServiceInf {
    //每次创建一个新的连接的工具类
    //@Autowired
    //ThriftClient thriftClient;

    /**
     * 连接池
     */
    @Autowired
    ThriftClientConnectPoolFactory thriftClientPool;

    @Override
    public Student getStudentByName(String name) {

        TTSocket ttSocket = null;
        try {
            //通过对象池，获取一个服务客户端连接对象
            ttSocket = thriftClientPool.getConnect();
            System.out.println(ttSocket);
            System.out.println("客户端请求用户名为:" + name + "的数据");
            //调用远端对象
            Student student = ttSocket.getService().getStudentByName(name);
            System.out.println("获取成功！！！服务端返回的对象:" + student);
            //用完之后把对象还给对象池
            thriftClientPool.returnConnection(ttSocket);
            return student;
        } catch (Exception e) {
            e.printStackTrace();
            //出现异常则将当前对象从池子移除
            thriftClientPool.invalidateObject(ttSocket);
        } finally {
        }
        return null;
    }

    @Override
    public void save(Student student) {
        TTSocket ttSocket = null;
        try {
            ttSocket = thriftClientPool.getConnect();
            System.out.println("客户端请求保存对象:" + student);
            ttSocket.getService().save(student);
            System.out.println("保存成功！！！");
            thriftClientPool.returnConnection(ttSocket);
        } catch (Exception e) {
            e.printStackTrace();
            thriftClientPool.returnConnection(ttSocket);
        } finally {
        }
    }
}

  • 测试

    img

    测试两个并发的情况下，如图所示的两个对象具体复用了

    img

参考

今晚打老虎_头很铁
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
海豚：基于spring boot支持thrift序列化的http的微服务框架
02-06
海豚 基于spring boot支持thrift序列化的http的微服务框架 特征 支持thrift序列化的http协议 兼容spring cloud ribbon配置 支持基于ribbon负载均衡的retryRetryLoadBalancerInterceptor 快速开始 客户 1.springboot启动时加上支持EnableTHttpInject注解 @EnableTHttpInject 2. EnableTHttpInject之后，就可以这样使用http的thriftclient @THttpInject ( backupServers = { " localhost:909
Thrift+SpringBoot+RocketMQ+Elasticsearch+C#
08-07
Thrift+SpringBoot+RocketMQ+Elasticsearch+C#； 1.通过thrift的RPC实现C#与java通信， 2.阿里巴巴RocketMQ实现高并发数据消息队列 3.Elasticsearch实现对数据全文检索
Apache Thrift 官网学习 五 SpringBoot整合Thrift
长安不及十里的博客
03-06 507
文章目录五 SpringBoot整合Thrift5.1 先建Maven项目5.2 定义thrift文件5.3 Server代码5.4 Client代码5.5 测试 五 SpringBoot整合Thrift 5.1 先建Maven项目 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <a
SpringBoot集成Thrift
lyj2018gyq的博客
06-05 567
前言：编写一个微服务，即能提供http调用，也可提供rpc调用，并且在rpc调用时采用pb进行序列化。 一、项目结构 thrift-test - .idea - pom.xml - thrift-client - src - thrift-server server端提供服务，client端进行调用 二、Server端 2.1 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://m
探索高效服务通信：Apache Thrift与Spring Boot的完美结合
最新发布
gitblog_00066的博客
06-06 291
探索高效服务通信：Apache Thrift与Spring Boot的完美结合 项目地址:https://gitcode.com/aatarasoff/spring-thrift-starter 在当今快节奏的技术世界里，构建高性能、可扩展的服务架构是每个开发者面临的挑战。幸运的是，开源社区总能提供创新解决方案，比如【Apache Thrift Starter for Spring Boot】——...
SpringBoot 整合Thymeleaf教程及使用
大新软件老杨
11-27 9453
Thymeleaf 是一款用于渲染 XML/XHTML/HTML5 内容的模板引擎。它与 JSP，Velocity，FreeMaker 等模板引擎类似，也可以轻易地与 Spring MVC 等 Web 框架集成。与其它模板引擎相比，Thymeleaf 最大的特点是，即使不启动 Web 应用，也可以直接在浏览器中打开并正确显示模板页面。
撸一个自己的文件下载器
夏至的稻穗的博客
01-04 2万+
欢迎转载，也请保留这段申明 ，原文地址：https://mp.csdn.net/mdeditor/81051646 开发中，我们常常会需要有apk升级，或者下载某个文件的问题。所以这里就写了个通用的文件下载的功能 ZDloader。通过这篇文章你将看到 常用框架 API 接口设计 多线程下载原理与实现 后台下载，界面退出之后，进来继续显示下载UI的原理 工程链接如下：https://git...
基于springboot的thrift的rpc, 服务发现基于etcd，路由基于ribbon.zip
04-08
可以用于毕业设计（项目源码+项目说明）目前在window10/11测试环境一切正常，用于演示的图片和部署教程说明都在压缩包里
thrift-0.11.0
06-10
Thrift是Facebook开源的一款高性能、跨语言的服务框架，其核心理念是通过定义一种中间语言（IDL，Interface Definition Language）来描述服务接口，并自动生成不同编程语言的代码，从而实现不同语言之间的通信。...
Java基于Spring Boot、Thrift、Zookeeper实现的RPC框架
12-18
基于Thrift、zookeeper的rpc实现 基于注解配置ThriftService、ThriftReference 基于权重的简单负载均衡 使用TMultiplexedProcessor发布多个服务
撸了一个APP
热门推荐
weixin_34161064的博客
11-09 5万+
利用周末和节假日的时间撸了一个APP，免费+内购模式，持续更新维护中，虽然忙一点，累一点，但是挺有成就感的。 版本下载地址： itunes.apple.com/cn/app/id14… 关于苹果审核 最初的提交版本的时候也是被拒了N次，后来添加审核开关配置，做了一些应对审核的处理，现在提交版本基本上没有被拒过，一般第二天就通过了。(后面会单独总结一篇审核相关的文章) 现在正在做的 ...
spring与thrift集成
08-14
http://my.oschina.net/penngo/blog/492253文章源码
【JAVA】thrift接口开发手把手教程（注解方式）server端
qq_34335450的博客
11-27 2637
博主第一次开发thrift接口，用的注解方式，记录一下 step 1 biz层 配置thrift client bean (一个端口支持多个服务) @Configuration public class ThriftServerConfig { @Autowired TYourServiceImpl1 tYourService1; @Autowired TYourServiceImpl2 tYourService2; @Bean(name = "serverPubl
调用web service方法进行全文检索_一种通用的thrift service调用之gateway源码分析
weixin_39958559的博客
11-29 190
thrift是一种常用的微服务rpc通信协议。启动的thirft service，将其自己的服务地址、端口、私有tag(用于区分不同的标签，多人开发时候会有多个不同的服务)等信息注册到zookeeper中。thrift 调用时候，gateway会根据调用的service name，在zookeeper中找到与之对应的host、port等信息，然后进行rpc调用。这个通用的thrift s...
java thrift spring_spring与thrift集成
weixin_31439907的博客
02-13 244
spring与thrift集成，可以使服务调用和发布更方便。本文代码是在上篇基础上改进，部分代码介绍请参考上一篇Thrift的java和php数据交互(http://my.oschina.net/penngo/blog/489311)服务器端spring配置xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="ht...
SpringBoot 结合 Thrift 构建远程服务调用
Zoey~~
07-09 2523
什么是Thrift? Thrift 的跨语言特性 thrift通过一个中间语言IDL(接口定义语言)来定义RPC的数据类型和接口,这些内容写在以.thrift结尾的文件中,然后通过特殊的编译器来生成不同语言的代码,以满足不同需要的开发者,比如java开发者,就可以生成java代码,c++开发者可以生成c++代码,生成的代码中不但包含目标语言的接口定义,方法,数据类型,还包含有RPC协议层和传输层的...
基于 SpringBoot 手写 RPC 框架
日有寸进
06-20 1469
目录文件目录Messageconsumer@EnableRpcConsumer@ReferenceReferenceInvokeProxyRpcHandlerprovider@EnableRpcProvider@ServiceBeanMethodInitialMediatorMediatorServiceHandlerSocketServerInitial示例consumer启动类配置文件TestControllerprovider启动类配置文件ExampleServiceImpl结果 文件目录 Mess
gRPC, Thrift和Dubbo等3种RPC框架的比较
我爱娃娃菜的博客
02-17 2万+
gRPC是Google开源的一款RPC框架（Go版本的实现），以protobuf作为IDL，通过protoc来编译框架代码。gRPC的Java实现的底层网络库是基于Netty开发而来，其Go实现是基于net库。Thrift是Apache的一个项目(http://thrift.apache.org)，前身是Facebook开发的一个RPC框架，采用thrift作为IDL。Dubbo是Alibaba开发
springboot和thrift
05-19
Spring Boot和Thrift是两个不同的技术，它们可以在一起使用来构建分布式系统。 Spring Boot是一个基于Spring框架的开发工具，它简化了Spring应用程序的构建和部署过程。它提供了一系列的开箱即用的功能，如自动配置、监控、健康检查等，让开发者能够更加专注于业务逻辑的开发。 Thrift是一种高效的可扩展的远程过程调用（RPC）协议，它支持多种语言，包括Java。Thrift提供了强大的序列化和反序列化机制，使得跨语言的通信变得非常容易。 在使用Spring Boot和Thrift来构建分布式系统时，通常会先使用Thrift定义接口，然后使用Thrift生成Java代码。然后，在Spring Boot应用程序中，可以使用Thrift生成的Java代码来实现RPC客户端和服务器端。这样，客户端和服务器端就可以通过Thrift协议进行通信，实现分布式系统的功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值