Thrift 基本使用

最新推荐文章于 2024-08-23 08:50:08 发布
最新推荐文章于 2024-08-23 08:50:08 发布
阅读量2k 收藏
点赞数 1
分类专栏： 服务框架 文章标签： thrift 服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiyongxuan/article/details/47661271
版权

数据类型

  1. 基本类型：
    • bool：布尔值，true 或 false，对应 Java 的 boolean
    • byte：8 位有符号整数，对应 Java 的 byte
    • i16：16 位有符号整数，对应 Java 的 short
    • i32：32 位有符号整数，对应 Java 的 int
    • i64：64 位有符号整数，对应 Java 的 long
    • double：64 位浮点数，对应 Java 的 double
    • string：utf-8编码的字符串，对应 Java 的 String
  2. 结构体类型：
    • struct：定义公共的对象，类似于 C 语言中的结构体定义，在 Java 中是一个 JavaBean
  3. 容器类型：
    • list：对应 Java 的 ArrayList
    • set：对应 Java 的 HashSet
    • map：对应 Java 的 HashMap
  4. 异常类型：
    • exception：对应 Java 的 Exception
  5. 服务类型：
    • service：对应服务的类

编写步骤

  1. 服务端：

    • 实现服务处理接口impl
    • 创建TProcessor
    • 创建TServerTransport
    • 创建TProtocol
    • 创建TServer
    • 启动Server

  2. 客户端

    • 创建Transport
    • 创建TProtocol
    • 基于TTransport和TProtocol创建 Client
    • 调用Client的相应方法

  3. 传输协议

    • TBinaryProtocol : 二进制格式.
    • TCompactProtocol : 压缩格式
    • TJSONProtocol : JSON格式
    • TSimpleJSONProtocol : 提供JSON只写协议, 生成的文件很容易通过脚本语言解析

传输方式

  • TSocket- 使用堵塞式I/O进行传输，也是最常见的模式。
  • TFramedTransport- 使用非阻塞方式，按块的大小，进行传输，类似于Java中的NIO。
  • TFileTransport- 顾名思义按照文件的方式进程传输，虽然这种方式不提供Java的实现，但是实现起来非常简单。
  • TMemoryTransport- 使用内存I/O，就好比Java中的ByteArrayOutputStream实现。
  • TZlibTransport- 使用执行zlib压缩，不提供Java的实现。

服务端类型

  • TSimpleServer - 单线程服务器端使用标准的堵塞式I/O。
  • TThreadPoolServer - 多线程服务器端使用标准的堵塞式I/O。
  • TNonblockingServer – 多线程服务器端使用非堵塞式I/O，并且实现了Java中的NIO通道。

实例演示 - 准备工作

  1. 创建脚本

创建文件demoHello.thrift

namespace java com.fengtang.thrift.demo //定义生成代码的命名空间，与package相对应。
//代码生成的类名，你的业务逻辑代码需要实现代码生成的HelloWorldService.Iface接口
service  HelloWorldService {
    //方法名称和方法中的入参
    string sayHello(1:string username)
}
  1. 生成代码

使用thrift-0.9.2.exe 生成代码，执行命令

thrift-0.9.2.exe -r -gen java ./demoHello.thrift

生成后的截图

3.将代码拷入IDEA

使用maven解决依赖关系

        <dependency>
            <groupId>org.apache.thrift</groupId>
            <artifactId>libthrift</artifactId>
            <version>0.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.5.8</version>
        </dependency>

实现接口Iface

package com.fengtang.thrift.demo.service;

import com.fengtang.thrift.demo.HelloWorldService;
import org.apache.thrift.TException;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 */

public class HelloWorldImpl implements HelloWorldService.Iface {

    public HelloWorldImpl() {
    }
    @Override
    public String sayHello(String username) throws TException {
        return "Hi," + username + " I'm the server ...";
    }

}

实例演示 - 分别测试不同类型的客户端和服务端模型

编写TSimpleServer服务端和客户端测试

TSimpleServer 简单的单线程服务模型，一般用于测试

服务端


package com.fengtang.thrift.demo.server;

import com.fengtang.thrift.demo.HelloWorldService;
import com.fengtang.thrift.demo.service.HelloWorldImpl;
import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TSimpleServer;
import org.apache.thrift.transport.TServerSocket;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 * TSimpleServer 简单的单线程服务模型
 */
public class TSimpServer {
    public static final int SERVER_PORT = 8090;

    /**
     * 创建TProcessor
     * 创建TServerTransport
     * 创建TProtocol
     * 创建TServer
     * 启动Server
     */
    public void startServer() {
        System.out.println("TSimpleServer start ....");

        try {
            //创建TProcessor
            TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
                    new HelloWorldImpl());
            //创建TServerTransport
            TServerSocket serverTransport = new TServerSocket(SERVER_PORT);
            TServer.Args tArgs = new TServer.Args(serverTransport);
            tArgs.processor(tprocessor);
            tArgs.protocolFactory(new TBinaryProtocol.Factory());
            //创建TServer
            TServer server = new TSimpleServer(tArgs);
            server.serve();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        TSimpServer server = new TSimpServer();
        server.startServer();
    }
}

客户端

package com.fengtang.thrift.demo.client;

import com.fengtang.thrift.demo.HelloWorldService;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 */
public class TSimpleClient {
    public static final String SERVER_IP = "localhost";
    public static final int SERVER_PORT = 8090;
    public static final int TIMEOUT = 30000;

    /**
     * @param userName
     */
    public void startClient(String userName) {
        TTransport transport = null;
        try {
            transport = new TSocket(SERVER_IP, SERVER_PORT, TIMEOUT);
            // 协议要和服务端一致
            TProtocol protocol = new TBinaryProtocol(transport);
            HelloWorldService.Client client = new HelloWorldService.Client(protocol);
            transport.open();
            long start = System.currentTimeMillis();
            String result = client.sayHello(userName);
            System.out.println("Total time is " + (System.currentTimeMillis() - start) + " ms ");
            System.out.println("Thrift client result : \n" + result);
        } catch (TTransportException e) {
            e.printStackTrace();
        } catch (TException e) {
            e.printStackTrace();
        } finally {
            if (null != transport) {
                transport.close();
            }
        }
    }

    public static void main(String[] args) {
        TSimpleClient client = new TSimpleClient();
        client.startClient("Nicholas");
    }
}

运行结果截图

1
11

编写TThreadPoolServer服务端和客户端测试

TThreadPoolServer 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求

服务端

package com.fengtang.thrift.demo.server;

import com.fengtang.thrift.demo.HelloWorldService;
import com.fengtang.thrift.demo.service.HelloWorldImpl;
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;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 * 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。
 */
public class TThrPoolServer {
    public static final int SERVER_PORT = 8090;
    public void startServer() {
        try {
            System.out.println("HelloWorld TThreadPoolServer start ....");

            TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
                    new HelloWorldImpl());

            TServerSocket serverTransport = new TServerSocket(SERVER_PORT);
            TThreadPoolServer.Args ttpsArgs = new TThreadPoolServer.Args(
                    serverTransport);
            ttpsArgs.processor(tprocessor);
            ttpsArgs.protocolFactory(new TBinaryProtocol.Factory());

            // 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。
            TServer server = new TThreadPoolServer(ttpsArgs);
            server.serve();
        } catch (Exception e) {
            System.out.println("Server start error!!!");
            e.printStackTrace();
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        TThrPoolServer server = new TThrPoolServer();
        server.startServer();
    }
}

客户端

package com.fengtang.thrift.demo.client;

import com.fengtang.thrift.demo.HelloWorldService;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 */
public class TThreadPoolClient {
    public static final String SERVER_IP = "localhost";
    public static final int SERVER_PORT = 8090;
    public static final int TIMEOUT = 30000;

    /**
     * @param userName
     */
    public void startClient(String userName) {
        TTransport transport = null;
        try {
            transport = new TSocket(SERVER_IP, SERVER_PORT, TIMEOUT);
            // 协议要和服务端一致
            TProtocol protocol = new TBinaryProtocol(transport);
            HelloWorldService.Client client = new HelloWorldService.Client(protocol);
            transport.open();
            long start = System.currentTimeMillis();
            String result = client.sayHello(userName);
            System.out.println("Total time is " + (System.currentTimeMillis() - start) + " ms ");
            System.out.println("Thrift client result : \n" + result);
        } catch (TTransportException e) {
            e.printStackTrace();
        } catch (TException e) {
            e.printStackTrace();
        } finally {
            if (null != transport) {
                transport.close();
            }
        }
    }

    public static void main(String[] args) {
        TSimpleClient client = new TSimpleClient();
        client.startClient("Nicholas");
    }
}

运行截图

2

22

编写TNonblockingServer服务端和客户端测试

TNonblockingServer 使用非阻塞式IO，服务端和客户端需要指定 TFramedTransport 数据传输的方式。

服务端

package com.fengtang.thrift.demo.server;

import com.fengtang.thrift.demo.HelloWorldService;
import com.fengtang.thrift.demo.service.HelloWorldImpl;
import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.TNonblockingServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TNonblockingServerSocket;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 * 使用非阻塞式IO，服务端和客户端需要指定 TFramedTransport 数据传输的方式。
 */
public class TNonbloServer {
    public static final int SERVER_PORT = 8090;

    public void startServer() {
        try {
            System.out.println("HelloWorld TNonblockingServer start ....");

            TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
                    new HelloWorldImpl());

            TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(
                    SERVER_PORT);
            TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(
                    tnbSocketTransport);
            tnbArgs.processor(tprocessor);
            tnbArgs.transportFactory(new TFramedTransport.Factory());
            tnbArgs.protocolFactory(new TCompactProtocol.Factory());

            // 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
            TServer server = new TNonblockingServer(tnbArgs);
            server.serve();
        } catch (Exception e) {
            System.out.println("Server start error!!!");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        TNonbloServer server = new TNonbloServer();
        server.startServer();
    }
}

客户端

package com.fengtang.thrift.demo.client;

import com.fengtang.thrift.demo.HelloWorldService;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 */
public class TNonblockingClient {
    public static final String SERVER_IP = "localhost";
    public static final int SERVER_PORT = 8090;
    public static final int TIMEOUT = 30000;

    /**
     * @param userName
     */
    public void startClient(String userName) {
        TTransport transport = null;
        try {
            transport = new TFramedTransport(new TSocket(SERVER_IP,
                    SERVER_PORT, TIMEOUT));
            // 协议要和服务端一致
            TProtocol protocol = new TCompactProtocol(transport);
            HelloWorldService.Client client = new HelloWorldService.Client(
                    protocol);
            transport.open();
            String result = client.sayHello(userName);
            System.out.println("Thrify client result =: " + result);
        } catch (TTransportException e) {
            e.printStackTrace();
        } catch (TException e) {
            e.printStackTrace();
        } finally {
            if (null != transport) {
                transport.close();
            }
        }
    }

    public static void main(String[] args) {
        TNonblockingClient client = new TNonblockingClient();
        client.startClient("Nicholas");

    }
}

运行截图

3

33

编写THsHaServer服务端和客户端测试

THsHaServer 半同步半异步的服务端模型，需要指定为： TFramedTransport 数据传输的方式。

服务端

package com.fengtang.thrift.demo.server;

import com.fengtang.thrift.demo.HelloWorldService;
import com.fengtang.thrift.demo.service.HelloWorldImpl;
import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.THsHaServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TNonblockingServerSocket;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 * 半同步半异步的服务端模型，需要指定为： TFramedTransport 数据传输的方式。
 */
public class ThshaServer {
    public static final int SERVER_PORT = 8090;

    public void startServer() {
        try {
            System.out.println("HelloWorld THsHaServer start ....");

            TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
                    new HelloWorldImpl());

            TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(
                    SERVER_PORT);
            THsHaServer.Args thhsArgs = new THsHaServer.Args(tnbSocketTransport);
            thhsArgs.processor(tprocessor);
            thhsArgs.transportFactory(new TFramedTransport.Factory());
            thhsArgs.protocolFactory(new TBinaryProtocol.Factory());

            //半同步半异步的服务模型
            TServer server = new THsHaServer(thhsArgs);
            server.serve();

        } catch (Exception e) {
            System.out.println("Server start error!!!");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ThshaServer server = new ThshaServer();
        server.startServer();
    }
}

客户端

package com.fengtang.thrift.demo.client;

import com.fengtang.thrift.demo.HelloWorldService;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 */
public class THsHaClient {
    public static final String SERVER_IP = "localhost";
    public static final int SERVER_PORT = 8090;
    public static final int TIMEOUT = 30000;

    /**
     * @param userName
     */
    public void startClient(String userName) {
        TTransport transport = null;
        try {
            transport = new TFramedTransport(new TSocket(SERVER_IP,
                    SERVER_PORT, TIMEOUT));
            // 协议要和服务端一致
            TProtocol protocol = new TBinaryProtocol(transport);
            HelloWorldService.Client client = new HelloWorldService.Client(protocol);
            transport.open();
            String result = client.sayHello(userName);
            System.out.println("Thrify client result =: " + result);
        } catch (TTransportException e) {
            e.printStackTrace();
        } catch (TException e) {
            e.printStackTrace();
        } finally {
            if (null != transport) {
                transport.close();
            }
        }
    }


    public static void main(String[] args) {
        THsHaClient client = new THsHaClient();
        client.startClient("Nicholas");

    }
}

运行截图

4

44

异步客户端调用

服务端

package com.fengtang.thrift.demo.server;

import com.fengtang.thrift.demo.HelloWorldService;
import com.fengtang.thrift.demo.service.HelloWorldImpl;
import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.TNonblockingServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TNonblockingServerSocket;

/**
 * Create by fengtang
 * 2015/8/14 0014
 * Thrift
 */
public class AsynchronousServer {
    public static final int SERVER_PORT = 8090;

    public void startServer() {
        try {
            System.out.println("HelloWorld TNonblockingServer start ....");

            TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(new HelloWorldImpl());

            TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(
                    SERVER_PORT);
            TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(
                    tnbSocketTransport);
            tnbArgs.processor(tprocessor);
            tnbArgs.transportFactory(new TFramedTransport.Factory());
            tnbArgs.protocolFactory(new TCompactProtocol.Factory());

            // 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
            TServer server = new TNonblockingServer(tnbArgs);
            server.serve();
        } catch (Exception e) {
            System.out.println("Server start error!!!");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        AsynchronousServer server = new AsynchronousServer();
        server.startServer();
    }
}

客户端

package com.fengtang.thrift.demo.client;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import com.fengtang.thrift.demo.HelloWorldService;
import org.apache.thrift.TException;
import org.apache.thrift.async.AsyncMethodCallback;
import org.apache.thrift.async.TAsyncClientManager;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocolFactory;
import org.apache.thrift.transport.TNonblockingSocket;
import org.apache.thrift.transport.TNonblockingTransport;

import com.fengtang.thrift.demo.HelloWorldService.AsyncClient.sayHello_call;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 */
public class AsynchronousClient {

    public static final String SERVER_IP = "localhost";
    public static final int SERVER_PORT = 8090;
    public static final int TIMEOUT = 30000;

    /**
     * @param userName
     */
    public void startClient(String userName) {
        try {
            TAsyncClientManager clientManager = new TAsyncClientManager();
            TNonblockingTransport transport = new TNonblockingSocket(SERVER_IP,
                    SERVER_PORT, TIMEOUT);

            TProtocolFactory tprotocol = new TCompactProtocol.Factory();
            HelloWorldService.AsyncClient asyncClient = new HelloWorldService.AsyncClient(
                    tprotocol, clientManager, transport);
            System.out.println("Client start .....");

            CountDownLatch latch = new CountDownLatch(1);
            AsynCallback callBack = new AsynCallback(latch);
            System.out.println("call method sayHello start ...");
            asyncClient.sayHello(userName, callBack);
            System.out.println("call method sayHello .... end");
            boolean wait = latch.await(30, TimeUnit.SECONDS);
            System.out.println("latch.await =:" + wait);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("startClient end.");
    }

    public class AsynCallback implements AsyncMethodCallback<sayHello_call> {
        private CountDownLatch latch;

        public AsynCallback(CountDownLatch latch) {
            this.latch = latch;
        }

        @Override
        public void onComplete(sayHello_call response) {
            System.out.println("onComplete");
            try {
                System.out.println("AsynCall result =:"
                        + response.getResult().toString());
            } catch (TException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                latch.countDown();
            }
        }

        @Override
        public void onError(Exception exception) {
            System.out.println("onError :" + exception.getMessage());
            latch.countDown();
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        AsynchronousClient client = new AsynchronousClient();
        client.startClient("Michael");

    }

}

运行截图

5

55

韦轩
关注
专栏目录
Thrift基本原理以及使用介绍
weixin_42642341的博客
11-28 2301
Thrift 初识Thrift Thrift是一个跨语言通信的RPC软件，最初是由FaceBook开发的，现在是Apache的一个顶级项目。 Thrift概念： Thrift 最初是由 Facebook 开发用做系统内各语言之间的 RPC 通信的一个可扩展且跨语言的软件框架，它结合了功能强大的软件堆栈和代码生成引擎，允许定义一个简单的定义文件中的数据类型和服务接口，以作为输入文件，编译器生...
学习了--Thrift的入门与基本使用
cssnnd的博客
09-13 492
官网 : http://thrift.apache.org/
thrift的使用介绍
03-28
NULL 博文链接：https://gemantic.iteye.com/blog/1199214
Thrift使用指南
有时间就有历史，有历史就有传奇。
10-31 347
1. 内容概要 本文档比较全面的介绍了thrift（关于thrift框架的介绍，参考我这篇文章：Thrift框架介绍 ）语法，代码生成结构和应用经验。本文主要讲述的对象是thrift文件，并未涉及其client和server的编写方法（关于client和server的编写方法，可参考我这篇文章：使用Thrift RPC编写程序 ）。 本文档大部分内容翻译自文章：...
Thriftpy：Python中强大的Thrift库
最新发布
gitblog_00119的博客
08-23 288
Thriftpy：Python中强大的Thrift库 thriftpy项目地址:https://gitcode.com/gh_mirrors/thr/thriftpy 项目介绍 Thriftpy是基于Apache Thrift的一个Python实现，旨在提供高效、易用的RPC框架支持。它简化了服务间通信的过程，特别适合构建分布式系统。Thriftpy支持自动生成客户端和服务端代码，拥有良好的性能...
thrift数据类型
伯诚的Blog
12-12 8889
1 前言 　　Thrift是facebook技术核心框架之一，不同开发语言开发的服务可以通过该框架实现通信。Thrift通过接口定义语言 (interface definition language，IDL) 来定义数据类型和服务，Thrift接口定义文件由Thrift代码编译器生成thrift目标语言的代码（目前支持C++,Java, Python, PHP, Ruby, Erlang,
Apache Thrift 的基本使用
留歌__36的博客
05-23 545
Apache Thrift 的基本使用 可以先看看官网是如何介绍的 The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services th...
thrift 使用
isrun的博客
04-09 306
thrift也是一个rpc调用框架,在这里写点自己的经验,帮助自己复习.1.支持的协议: TBinaryProtocol - 一种直接的二进制格式，将数值编码为二进制，而不是转换为文本。 TCompactProtocol - 非常高效，密集的数据编码（详见下文）。 TDenseProtocol - 类似于TCompactProtocol，但从传输内容中除去元信息...
C++（Qt）下的thrift的使用示例
09-03
总的来说，“C++（Qt）下的thrift的使用示例”涵盖了在Qt环境下集成Thrift服务的基本步骤，包括安装依赖、编写IDL、生成代码、实现服务和客户端，以及利用Qt的特性来优化通信过程。理解并掌握这些知识，将有助于你在...
Thrift 使用
02-21
一、Thrift的基本概念 1. IDL（Interface Definition Language）：Thrift使用类似C++的语法来定义服务接口和数据结构，这被称为IDL文件。例如，你可以定义一个服务和它的方法，以及结构体（struct）来传递数据。 2...
Thrift框架使用分享
12-18
Thrift的类型系统包含了基本类型、结构体、容器类型、异常和服务定义，基本类型有bool, byte, i16, i32, i64, double, string等，用户自定义结构体使用struct关键字声明，容器类型包括list, set, map等。异常的声明...
windows环境下thrift.exe的使用
07-12
windows环境下thrift.exe开发thrift
thrift使用
panda-star的博客
04-03 379
thrift使用 文章目录thrift使用一、简介二、创建thrift服务三、调用thrift服务四、实例4.1 添加maven依赖4.2 定义服务MathService.thrift4.3 生成服务的需实现的接口MathService.java4.4 实现步骤2生成的接口，MathService.Iface4.5 启动服务4.6、调用服务 一、简介 thrift是一种RPC框架的实现，它的特点是...
[thrift] thrift基本原理及使用
热门推荐
zkp_java的专栏
08-20 7万+
Thrift架构 thrift主要用于各个服务之间的RPC通信，支持跨语言。thrift是一个典型的CS结构，客户端和服务端可以使用不同的语言开发，thrift通过IDL(Interface Description Language)来关联客户端和服务端。thrift的整体架构图如下图所示 如下图所示为thrift的网络栈结构 thirft使用socket进行数据传输，数据以特定的格...
thrift简单使用
BrownWong的专栏
06-09 417
1. 安装 brew install thrift pip install thrift 2. 编写thrift服务 helloworld.thrift service HelloWorld { string ping(), string say(1:string msg) } 3. 自动生成代码 执行以下命令： thrift -gen py hello...
thrift使用介绍
我爱逛菜园
07-25 1025
写的ppt，不再摘抄出来了，直接上图。
thrift 实例
marho
04-25 905
Thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, and OCaml 等等编程语言间无缝结合的、高效的服务。Thrift最初由facebook
thrift 介绍及其使用
daemon365的博客
06-08 1055
Thrift是Facebook于2007年开发的跨语言的rpc服框架，提供多语言的编译功能，并提供多种服务器工作模式；用户通过Thrift的IDL（接口定义语言）来描述接口函数及数据类型，然后通过Thrift的编译环境生成各种语言类型的接口文件，用户可以根据自己的需要采用不同的语言开发客户端代码和服务器端代码。例如，我想开发一个快速计算的RPC服务，它主要通过接口函数getInt对外提供服务，这个RPC服务的getInt函数使用用户传入的参数，经过复杂的计算，计算出一个整形值返回给用户；
thrift 的简单实用案例
av1900的博客
11-23 1785
thrift 的简单实用案例           thrift是由facebook 开发的一套跨语言的rpc服务框架，在2007年捐献给Apache软件基金会，它结合了软件堆栈和强大的代码生成引擎。以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltal...
Windows下Thrift安装与使用指南
Thrift 在 Windows 平台下的安装和使用需要一定的技术基础和经验，但通过这篇文章，读者可以了解 Thrift 的安装和使用过程，并掌握 Thrift 的基本概念和原理。 Thrift 的优点包括跨语言支持、平台无关、灵活的IDL ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值