Communication Protocol

Configuration of Communication Protocol

The Dubbo-go framework provides two built-in protocols: triple and dubbo. In addition, the framework offers various ways to extend protocol access.

  • triple, a high-performance communication protocol based on HTTP/1 and HTTP/2, 100% compatible with gRPC, supports Unary, Streaming, and other communication modes; supports publishing REST-style HTTP services.
  • dubbo, a high-performance private communication protocol based on TCP, with the disadvantage of poor universality, more suitable for use between Dubbo SDKs;
  • Any protocol extension, by extending the protocol, it can support any RPC protocol. The official ecosystem provides support for JsonRPC, thrift, etc.

In this document, we will introduce the usage of the triple protocol, how to achieve mutual calls with existing dubbo2 systems, and extend support for more protocols. For more principled introductions, please refer to Protocol Specification or related documents in dubbo java .

triple Protocol

The triple protocol supports two development modes: protobuf and non-protobuf. We recommend using the protobuf mode for service development.

Currently, most of our examples use this mode, you can refer to Quick Start to learn complete development examples. Here are the basic steps:

  1. First, define the service using protobuf
  1. syntax = "proto3";
  2. package greet;
  3. option go_package = "github.com/apache/dubbo-go-samples/helloworld/proto;greet";
  5. message GreetRequest {
  6.   string name = 1;
  7. }
  9. message GreetResponse {
  10.   string greeting = 1;
  11. }
  13. service GreetService {
  14.   rpc Greet(GreetRequest) returns (GreetResponse) {}
  15. }
  1. Install the protoc plugin, compile and generate the code:
  1. protoc --go_out=. --go_opt=paths=source_relative \
  2.     --go-triple_out=. --go-triple_opt=paths=source_relative \
  3.     proto/greet.proto
  1. Publish service on the server side
  1. srv, err := server.NewServer(
  2.     server.WithServerProtocol(
  3.         protocol.WithPort(20000),
  4.         protocol.WithTriple(),
  5.     ),
  6. )
  8. greet.RegisterGreetServiceHandler(srv, &GreetTripleServer{})
  1. Client calls the service
  1. cli, err := client.NewClient(
  2.     client.WithClientURL("127.0.0.1:20000"),
  3. )
  5. svc, err := greet.NewGreetService(cli)
  6. resp, err := svc.Greet(context.Background(), &greet.GreetRequest{Name: "hello world"})

dubbo-java Intercommunication System

If both java and go use the triple+protobuf mode, they can clearly call each other directly.

However, the problem is that many java users use the triple non-protobuf mode, and some older version users use the dubbo tcp protocol. For this business, we can implement protocol mutual calls using the following coding modes of the dubbo-go framework:

  1. Define services

Directly use struct to define the service:

  1. type GreetProvider struct {
  2. }
  4. func (*GreetProvider) SayHello(req string, req1 string, req2 string) (string, error) {
  5.     return req + req1 + req2, nil
  6. }
  1. Publish service on the server

Specify the protocol to be published, which can be dubbo, triple or other protocols. Please note that WithInterface("GreetProvider") must be consistent with the service name on the dubbo-java side (e.g., keep the full path name in java):

  1. ins, err := dubbo.NewInstance(
  2.     dubbo.WithName("dubbo_server"),
  3.     dubbo.WithProtocol(
  4.         protocol.WithTriple(),
  5.         protocol.WithPort(20001)),
  6. )
  8. srvDubbo, err := ins.NewServer()
  9. if err != nil {
  10.     panic(err)
  11. }
  12. if err = srvDubbo.Register(&GreetProvider{}, nil, server.WithInterface("GreetProvider")); err != nil {
  13.     panic(err)
  14. }
  15. if err = srvDubbo.Serve(); err != nil {
  16.     logger.Error(err)
  17. }
  1. Client calls the service

Specify the protocol to be called, which can be dubbo, triple, or other protocols. Please note that WithInterface("GreetProvider") must be consistent with the service name on the dubbo-java side (e.g., keep the full path name in java):

  1. cliDubbo, _ := client.NewClient(
  2.     client.WithClientProtocolTriple(),
  3.     client.WithClientSerialization(constant.Hessian2Serialization),
  4. )
  6. connDubbo, _ := cliDubbo.Dial("GreetProvider")
  7. ipanic(err)
  8. }
  9. var respDubbo string
  10. if err = connDubbo.CallUnary(context.Background(), []interface{}{"hello", "new", "dubbo"}, &respDubbo, "SayHello"); err != nil {
  11.     logger.Errorf("GreetProvider.Greet err: %s", err)
  12.     return
  13. }

Protocol Extension

The Dubbo framework supports protocol extensions. Currently, the officially supported protocols in the ecosystem include:

  • triple
  • dubbo
  • jsonrpc

In some scenarios, you can publish services of multiple protocols simultaneously within one application or call services with different protocols simultaneously. Here is a usage example for multi-protocol publishing for reference.

Feedback

Was this page helpful?

Yes No

Last modified September 30, 2024: Update & Translate Overview Docs (#3040) (d37ebceaea7)