Thrift 基本使用

最新推荐文章于 2023-04-13 14:19:22 发布
最新推荐文章于 2023-04-13 14:19:22 发布
阅读量1.9k 收藏
点赞数 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

韦轩
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
thrift-typescript:从Thrift IDL文件生成TypeScript
05-24
节俭的打字稿 从Thrift IDL文件生成TypeScript。 安装 $ npm install --save @creditkarma/thrift-typescript 用法 Thrift TypeScript提供JavaScript和命令行API。 给定以下文件 节俭/简单 struct MyStruct { 1 : required i32 id, 2 : required bool field1, # 3 : required string field, 4 : required i16 field, } 您可以通过命令行生成TypeScript： $ thrift-typescript --target apache --rootDir . --sourceDir thrift --outDir codegen simple.thri
Thrift介绍以及Java中使用Thrift实现RPC示例
BADAO_LIUMANG_QIZHI的博客
09-20 3858
场景 Thrift Thrift最初由Facebook研发，主要用于各个服务之间的RPC通信，支持跨语言，常用的语言比如C++, Java, Python,PHP, Ruby, Erlang，Perl，Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, and OCaml都支持。 Thrift是一个典型的CS(客户端/服务端)结构，客户端和服务端可以使用不同的语言开发。既然客户端和服务端能使用不同的语言开发，那么一定就要有一种中间语言来关联客户端和服
RPC——Thrift框架
qq_41134008的博客
03-29 134
1、Thrift基本了解 Thrift是由脸书开发的 Thrift实现了一种接口描述语言和二进制通讯协议，用来定义和创建跨语言的服务。 Thrift的基础库程序中已经提供了用于RPC通讯的底层基本消息协议和传输工具。 Thrift允许我们使用一种独立于任何编程语言的新的语言来定义接口服务。 我们使用Thrift的接口定义语言将接口定义在一个文本文件中，然后使用Thrift提供的编译 器根据这个文件...
thrift调用流程分析
weixin_34248118的博客
05-02 501
由于工作需要使用thrift，并且需要根据需求修改thrift源码，因此必须熟悉thrift执行的流程。以下是根据thrift源码阅读而得出流程分析。 thrift协议栈概述 thrift是一个rpc框架，开发者可以通过thrift自带的接口定义语言（IDL）来自动生成客户端和服务端的rpc代码。thrift协议栈如下图所示： 在cli...
字节都在用的代码自动生成
a1014981613的博客
04-13 223
如果有一份接口定义，前端和后端都能基于此生成相应端的代码，不仅能降低前后端沟通成本，而且还能提升研发效率。 字节内部的 RPC 定义主要基于 thrift 实现，thrift 定义了数据结构和函数，那么是否可以用来作为接口定义提供给前端使用呢？如果可以作为接口定义，是不是也可以通过接口定义自动生成请求接口的代码呢？答案是肯定的，字节内部已经衍生出了多个基于 thrift 的代码生成工具，本篇文章主要介绍如何通过 thrift 生成前端接口调用的代码。
Thrift简介以及服务器和客户端的编写运行演示
AILIKES
05-17 343
第一部分： thrift的基本介绍以及安装1.1 简介         thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引 擎，以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, and OCam...
Thrift介绍与应用（三）—hbase的thrift接口
热门推荐
guxch的专栏
09-29 5万+
一、概述 Hbase是目前比较火的列存储数据库，由于Hbase是用Java写的，因此它原生地提供了Java接口，对非Java程序人员，怎么办呢？幸好它提供了thrift接口服务器，因此也可以采用其他语言来编写Hbase的客户端，本文即是Hbase C++接口的介绍。 目前的Hbase（0.94.11，本文即基于此版本）有两套thrift接口（可以叫thrift1和thrift2）,它们并不兼容
thrift初步了解
10-20
生成使用thrift需要的jar包： 下载Ant后, 配置环境变量， ANT_HOME=Ant解压路径。 下载thrift后使用ant编译需要的jar文件。 cmd， 进入build.xml目录， ant -buildfile build.xml thrift协议protocol： ...
Apache Thrift环境配置
01-10
安装Thrift的官方文档...当我看到windows安装需要Cygwin或MinGW时，我就直接放弃在windows中配置的想法了，直接打开虚拟机用CentOS进行安装，使用一堆命令安装毕竟比windows方便。 CentOS安装Thrift 官方文档地址： ...
thrift入门
09-28
thrift基础入门，讲解thrift基本语法
Thrift源码+库文件，解压后可直接使用
09-19
Apache的开源远程调用库Thrift,最初是由Facebook开发 解压后可以直接使用(需要搭配VS2010,boost)
最新的thrift整合库libthrift-0.9.1.jar
06-12
thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, and OCaml 这些编程语言间无缝结合的、高效的服务。
thrift-zookeeper-rpc
03-08
对于Thrift服务化的改造，主要是客户端，可以从如下几个方面进行： 1.服务端的服务注册，客户端自动发现，无需手工修改配置，这里我们使用zookeeper，但由于zookeeper本身提供的客户端使用较为复杂，因此采用curator...
simple_thrift
06-07
这些场景下，LAMP基本上搞定了所有问题，然而在一些场景下，系统的复杂度较高，业务逻辑较多，性能要求较高，这时候系统的分层和模块化势在必行，这时候thrift就派上用场了。thrift的使用不仅仅将各种语言黏合在我们...
Basic-Thrift-Tutorial:C ++基本节俭教程
05-21
编译thrift --gen cpp hello.thrift文件thrift --gen cpp hello.thrift 编译服务器g++ gen-cpp/hello_types.cpp gen-cpp/HelloSvc.cpp server.cpp -o server -lthrift 编译客户端g++ gen-cpp/hello_types.cpp gen-...
php-thrift-sql：一个通过Thrift连接到Hive或ImpalaPHP库
01-30
版本兼容性该库当前针对以下数据库版本的Thrift定义进行编译： Apache Hive 1.1.0 （ ） Apache Impala 2.12.0 （ ） 使用以下编译器和基本PHP类： Apache Thrift 0.12.0 （ ）使用范例推荐的使用此库的方法是通过...
thrift白皮书（中文版)
03-24
中文版，介绍thrift的设计目的，设计原理以及其基本结构。
Thrift RPC Erlang库大量数据时出错的解决
01-06
我们项目的各个server之间是使用thrift rpc库来互相rpc的，我们使用的版本是0.9.2, 我制定了统一的消息格式，控制和包装好整个rpc的使用方法，来方便我们服务端的开发人员来使用，一开始因为rpc的数据量很少，所以...
ThriftBook:《 Apache Thrift程序员指南》中示例的源代码
05-06
本部分还介绍了基本的Apache Thrift设置和调试。第二部分-编程Apache Thrift 本部分深入研究Apache Thrift框架的每一层，详细检查传输，协议，类型，服务，服务器和Apache Thrift接口定义语言。 这些章节中的示例...
thrift 0.9.3 文档
最新发布
05-17
Thrift 0.9.3 是一款流行的跨语言 RPC（远程过程调用）框架。该框架支持多种语言，包括Java、Python、C++、PHP等等。通过 Thrift，开发人员可以轻松地定义客户端和服务端之间的接口，以及生成对应的代码。这样，服务端和客户端就可以通过自动生成的代码直接通信，而无需做复杂的网络编程。 Thrift 0.9.3 包含多种协议和传输方式。其中，协议指定了数据以何种方式进行编码和解码，比如二进制格式、JSON格式等等；传输方式指定了数据在网络中的传输方式，可以选择使用 TSocket、THttpClient、TServerSocket 等等。 除了基本的 RPC 功能外，Thrift 还提供了多种扩展功能，例如支持异步调用、支持压缩/解压缩、支持安全认证等等。此外，Thrift 还支持自定义各种类型和结构体，可以根据具体业务需求灵活应用。 在使用 Thrift 0.9.3 时，需要先定义接口，并使用 Thrift 的 IDL（Interface Definition Language）描述语言进行编写。然后，使用 Thrift 提供的命令行工具生成对应的代码，在代码中就可以调用定义好的接口进行数据传输和处理。 总之，Thrift 0.9.3 是一款功能强大的跨语言 RPC 框架，为开发人员提供了高效、简便的服务端-客户端通信解决方案。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值