Grpc message sending of vertx

Introduce

Vert.x gRPC modular , It will Google gRPC Programming style and Vert.x Consistent style . gRPC It's a high performance 、 Open source 、 General purpose RPC frame , It is an interprocess communication technology , from Google Introduction , be based on HTTP2 Protocol standard design and development , By default Protocol Buffers Data serialization protocol , Support multiple development languages .gRPC Provides a simple way to accurately define Services , And automatically generate a reliable function library for the client and server . stay gRPC The client can directly call remote programs on different servers , Using gestures looks like calling a local program , Easily realize the connection of remote services 、 call 、 Operation and commissioning , It's easy to build distributed applications and services . And a lot of RPC The system is the same , The server is responsible for implementing the defined interface and processing the client's request , The client directly calls the required services according to the interface description . The client and server can use... Respectively gRPC Different language implementations supported .

1. maven Project dependence

<dependencies>
	<dependency>
		<groupId>io.vertx</groupId>
		<artifactId>vertx-core</artifactId>
	</dependency>
	<dependency>
		<groupId>io.vertx</groupId>
		<artifactId>vertx-grpc</artifactId>
	</dependency>
	<dependency>
		<groupId>io.vertx</groupId>
		<artifactId>vertx-config-yaml</artifactId>
	</dependency>
	<dependency>
		<groupId>com.fasterxml.jackson.core</groupId>
		<artifactId>jackson-databind</artifactId>
	</dependency>
	<dependency>
		<groupId>com.lance.common</groupId>
		<artifactId>vertx-common-core</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</dependency>
</dependencies>

2.vertx Start public class

public class StartApplication {
  public static void runClustered(Class<? extends AbstractVerticle> clazz) {
    run(clazz, new VertxOptions(), null, true);
  }

  public static void run(Class<? extends AbstractVerticle> clazz) {
    run(clazz, new VertxOptions(), null, false);
  }

  public static void run(Class<? extends AbstractVerticle> clazz, DeploymentOptions options) {
    run(clazz, new VertxOptions(), options, false);
  }

  public static void run(Class<? extends AbstractVerticle> clazz, VertxOptions options, DeploymentOptions deploymentOptions, boolean clustered) {
    run(clazz.getName(), options, deploymentOptions, clustered);
  }

  public static void run(String className, VertxOptions options, DeploymentOptions deploymentOptions, boolean clustered) {
    if (options == null) {
      // Default parameter
      options = new VertxOptions();
    }

    Consumer<Vertx> runner = vertx -> {
      try {
        if (deploymentOptions != null) {
          vertx.deployVerticle(className, deploymentOptions);
        } else {
          vertx.deployVerticle(className);
        }
      } catch (Throwable t) {
        log.error("Vertx deploy fail: ", t);
      }
    };

    if (clustered) {
      Vertx.clusteredVertx(options, res -> {
        if (res.succeeded()) {
          Vertx vertx = res.result();
          runner.accept(vertx);
        } else {
          res.cause().printStackTrace();
        }
      });
    } else {
      Vertx vertx = Vertx.vertx(options);
      runner.accept(vertx);
    }
  }
}

3.Grpc Server side

public class HelloServer extends AbstractVerticle {

  public static void main(String[] args) {
    StartApplication.run(HelloServer.class);
  }

  @Override
  public void start() {
    // Create the server
    VertxServer server = VertxServerBuilder.forAddress(vertx, RpcConst.HOST, RpcConst.PORT)
        .addService(new VertxGreeterGrpc.GreeterVertxImplBase() {
          @Override
          public Future<Hello.HelloReply> sayHello(Hello.HelloRequest request) {
            log.info("Hello {}", request.getName());
            String message = "Thanks " + request.getName();
            return Future.succeededFuture(Hello.HelloReply.newBuilder().setMessage(message).build());
          }
        })
        .build();

    // start the server
    server.start(ar -> {
      if (ar.failed()) {
        log.error("Grpc server start fail: ", ar.cause());
      } else {
        log.info("Grpc server[port: {}] start success.", server.getPort());
      }
    });
  }
}

4.Grpc client

public class HelloClient extends AbstractVerticle {

  public static void main(String[] args) {
    StartApplication.run(HelloClient.class);
  }

  @Override
  public void start() {
    // Create the channel
    ManagedChannel channel = VertxChannelBuilder
        .forAddress(vertx, RpcConst.HOST, RpcConst.PORT)
        .usePlaintext()
        .build();

    VertxGreeterGrpc.GreeterVertxStub stub = VertxGreeterGrpc.newVertxStub(channel);
    Hello.HelloRequest request = Hello.HelloRequest.newBuilder().setName("Jim Green").build();

    stub.sayHello(request).onComplete(asyncResponse -> {
      if (asyncResponse.succeeded()) {
        log.info("Got the server response: {}", asyncResponse.result().getMessage());
      } else {
        log.error("Could not reach server fail: ", asyncResponse.cause());
      }
    });
  }
}

5.Proto file

syntax = "proto3";

option java_multiple_files = false;
option java_outer_classname = "Hello";
package com.lance.grpc.hello.gen;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

6. journal

2022-02-13 20:22:19.301  INFO 21 --- [ntloop-thread-1] com.lance.grpc.hello.HelloClient        ---[  38] : Got the server response: Thanks .Jim Green

2022-02-13 20:21:42.852  INFO 21 --- [ntloop-thread-1] com.lance.grpc.hello.HelloServer        ---[  45] : Grpc server[port: 18006] start success.
2022-02-13 20:22:19.254  INFO 21 --- [ntloop-thread-1] com.lance.grpc.hello.HelloServer        ---[  33] : Hello Jim Green

7. Full address of the project

Vertx And Grpc message sending Github Address

Vertx And Grpc message sending Gitee Address