RPC框架之Thrift—实现Go和Java远程过程调用

+-------------------------------------------+
| Server                                    |
| (single-threaded, event-driven etc)       |
+-------------------------------------------+
| Processor                                 |
| (compiler generated)                      |
+-------------------------------------------+
| Protocol                                  |
| (JSON, compact etc)                       |
+-------------------------------------------+
| Transport                                 |
| (raw TCP, HTTP etc)                       |
+-------------------------------------------+
复制代码

interface TProcessor {
    bool process(TProtocol in, TProtocol out) throws TException
}
复制代码

go get -u github.com/apache/thrift
复制代码

namespace go hello
struct HelloReq {
    1: string msg;
}
struct HelloResp {
    1: string msg;
}
service HelloService {
    //返回值类型 方法名(参数序号：参数类型 参数名);
    HelloResp Hello(1: HelloReq req);
}
复制代码

thrift -r --gen go hello.thrift
复制代码

type HelloServiceImpl struct {
}
func (e *HelloServiceImpl) Hello(ctx context.Context, req *hello.HelloReq) (*hello.HelloResp, error) {
   fmt.Printf("message from client: %v\n", req.GetMsg())
   res := &hello.HelloResp{
      Msg: "Hi Client ~",
   }
   return res, nil
}
func main() {
    transport, err := thrift.NewTServerSocket(":9898")
    if err != nil {
        panic(err)
    }
    handler := &HelloServiceImpl{}
    processor := hello.NewHelloServiceProcessor(handler)
    //也可以选择Framed传输协议，但是必须确保服务端和客户端的传输协议一致
    transportFactory := thrift.NewTBufferedTransportFactory(1024)
    //应对Java客户端
    //factory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
    //可以选择任意一种编码协议，但是必须确保服务端和客户端的编码协议一致
    protocolFactory := thrift.NewTBinaryProtocolFactoryConf(&thrift.TConfiguration{}) //布尔参数strictRead, strictWrite，读和写时是否加入版本校验。
    server := thrift.NewTSimpleServer4(
        processor,
        transport,
        transportFactory,
        //factory,
        protocolFactory,
    )
    if err := server.Serve(); err != nil {
        panic(err)
    }
}
复制代码

func main() {
    transportFactory := thrift.NewTBufferedTransportFactory(1024)
    //可以选择任意一种通信协议，但是必须确保服务端和客户端的通信协议一致
    protocolFactory := thrift.NewTBinaryProtocolFactoryConf(&thrift.TConfiguration{}) //布尔参数strictRead, strictWrite，读和写时是否加入版本校验。
    //Java服务端
    //factory := thrift.NewTCompactProtocolFactoryConf(&thrift.TConfiguration{})
    transport:= thrift.NewTSocketConf("127.0.0.1:9898",&thrift.TConfiguration{})
    useTransport, err := transportFactory.GetTransport(transport)
    client := hello.NewHelloServiceClientFactory(useTransport, protocolFactory)
    if err := transport.Open(); err != nil {
        fmt.Fprintln(os.Stderr, "Error opening socket to 127.0.0.1:9898", " ", err)
        os.Exit(1)
    }
    defer transport.Close()
    req := &hello.HelloReq{Msg: "Hello Server ~"}
    res, err := client.Hello(context.Background(), req)
    if err != nil {
        log.Println("Echo failed:", err)
        return
    }
    log.Println("response:", res.Msg)
}
复制代码

<dependency>
    <groupId>org.apache.thrift</groupId>
    <artifactId>libthrift</artifactId>
    <version>0.15.0</version>
</dependency>
复制代码

namespace java hello
struct HelloReq {
    1: string msg;
}
struct HelloResp {
    1: string msg;
}
service HelloService {
    HelloResp Hello(1: HelloReq req);
}
复制代码

thrift -r --gen java hello.thrift
复制代码

public class ThriftServer {
    public static void main(String[] args) throws TTransportException {
        //设置服务器端口  TNonblockingServerSocket-非堵塞服务模型
        TNonblockingServerSocket serverSocket = new TNonblockingServerSocket(8899);
        //参数设置
        THsHaServer.Args arg = new THsHaServer.Args(serverSocket).minWorkerThreads(2).maxWorkerThreads(4);
        //处理器
        //PersonService.Processor<PersonServiceImpl> processor = new PersonService.Processor<>(new PersonServiceImpl());
        HelloService.Processor<HelloServiceImpl> processor = new HelloService.Processor<>(new HelloServiceImpl());
        arg.protocolFactory(new TCompactProtocol.Factory());
        arg.transportFactory(new TFramedTransport.Factory());
        arg.processorFactory(new TProcessorFactory(processor));
        TServer server = new THsHaServer(arg);
        System.out.println("Thrift 服务端启动成功");
        server.serve();
    }
}
//Handler
class HelloServiceImpl implements HelloService.Iface {
    @Override
    public HelloResp Hello(HelloReq req) throws TException {
        System.out.println(req.msg);
        return new HelloResp("Hello Client ~");
    }
}
复制代码

public class ThriftClient {
    public static void main(String[] args) throws TException {
        TTransport transport = new TFramedTransport(new TSocket("localhost", 8899), 600);
        TProtocol protocol = new TCompactProtocol(transport);
        HelloService.Client client = new HelloService.Client(protocol);
        transport.open();
        String msg = client.Hello(new HelloReq("Hi Server ~")).msg;
        System.out.println(msg);
        transport.close();
    }
}
复制代码

public class ThriftClientGo {
    public static void main(String[] args) throws TTransportException {
        TTransport transport = new TFramedTransport(new TSocket("127.0.0.1", 9898), 8000);
        TBinaryProtocol binaryProtocol = new TBinaryProtocol(transport);
        HelloService.Client client = new HelloService.Client(binaryProtocol);
        try {
            transport.open();
            String msg = client.Hello(new HelloReq("Hi Server~")).msg;
            System.out.println(msg);
        }catch (Exception ex){
            throw new RuntimeException(ex.getMessage(),ex);
        }finally {
            transport.close();
        }
    }
}
复制代码