0
点赞
收藏
分享

微信扫一扫

grpc在java中的应用过程记录

zhongjh 2022-11-19 阅读 87
springmavenjava虚拟化云计算


grpc spring boot server 端和 grpc spring boot client端 hello world示例。

idea新建project ,名称为com.xxx.grpc,项目名demo，然后在这个项目的src\main下面新建 proto文件夹，放入grpc的接口描述文件，在项目管理器项目名称位置点鼠标右键，new module，新建一个server子模块，再新建一个client子模块。

项目结构如下图：

grpc在java中的应用过程记录_maven

上图中的grpcdemo就是我项目名称，在src\mian\proto下面放置了供客户端和服务器端共同使用的Service.proto文件，同时项目内有一个client子模块，一个server子模块。

Service.proto文件的内容如下：

syntax = "proto3";
package proto;

option java_package = "com.test.rpc";
option java_multiple_files = false;


// 定义通用的 Grpc 请求体
message Request {
    int32 serialize = 1;
    bytes request = 2;
}

// 定义通用的 Grpc 响应体
message Response {
    bytes response = 1;
}


// 定义通用的 Grpc 服务
service CommonService {
    // 处理请求
    rpc Handle ( Request ) returns ( Response );
}

message SayHelloRequest{
    bytes name=1;
}

message SayHelloResponse{
    bytes result=1;
}

service SayHelloService{
    rpc SayHello(SayHelloRequest) returns (SayHelloResponse);
}

 

上面这个是服务接口描述文件，需要借助maven工具去生成java代码供服务端去实现及供客户端进行调用，配置过程如下：

打开 根项目的pom.xml文件，我的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.xxx.grpc</groupId>
  <artifactId>demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>demo</name>
  <description>Demo project for Spring Boot</description>

  <properties>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>


    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-netty-shaded</artifactId>
      <version>1.20.0</version>
    </dependency>
    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-protobuf</artifactId>
      <version>1.20.0</version>
    </dependency>
    <dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-stub</artifactId>
      <version>1.20.0</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>

      <plugin>
        <groupId>org.xolstice.maven.plugins</groupId>
        <artifactId>protobuf-maven-plugin</artifactId>
        <version>0.5.1</version>
        <configuration>
          <protocArtifact>com.google.protobuf:protoc:3.7.1:exe:${os.detected.classifier}</protocArtifact>
          <pluginId>grpc-java</pluginId>
          <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.20.0:exe:${os.detected.classifier}</pluginArtifact>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
              <goal>compile-custom</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>


    <extensions>
      <extension>
        <groupId>kr.motd.maven</groupId>
        <artifactId>os-maven-plugin</artifactId>
        <version>1.5.0.Final</version>
      </extension>
    </extensions>


  </build>

</project>

以上是整个根项目maven的配置文件，主要是增加了几个grpc的依赖（io.grpc那三个），增加了一个plugin，增加了一个extensions配置，刷新maven配置，让开发工具加载maven依赖及插件。

然后在maven工具里面生成java 代码，方法是在maven的protobuf插件上面先点击run protobuf:compile，再点击 run protobuf:compile-custom,如下图：

grpc在java中的应用过程记录_java_02

正常情况下会在target下面生成grpc的java调用接口等代码，如下图：

grpc在java中的应用过程记录_maven_03

然后到server子模块内编写服务器端代码，新建一个实现服务接口功能的类，用于实现grpc里面定义的接口功能，如下：

package com.xxx.grpc;

import com.google.protobuf.ByteString;
import com.test.rpc.Service;

import java.io.UnsupportedEncodingException;

/**
 * Created by Administrator on 2019/4/12.
 */
public class SayHelloImpl extends com.test.rpc.SayHelloServiceGrpc.SayHelloServiceImplBase {

    public void sayHello(com.test.rpc.Service.SayHelloRequest request,
                         io.grpc.stub.StreamObserver<com.test.rpc.Service.SayHelloResponse> responseObserver) {
        // 获取数据信息
        try {
            String name =request.getName().toString("utf-8");
            // 计算数据
            Service.SayHelloResponse response = Service.SayHelloResponse.newBuilder()
                    .setResult(ByteString.copyFrom("hello from java:"+name,"utf-8"))
                    .build();
            responseObserver.onNext(response);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        // 返回数据，完成此次请求
        responseObserver.onCompleted();
    }

}

然后再编写加载服务功能的启动代码，整个server的spring boot启动程序代码如下：

package com.xxx.grpc;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

@SpringBootApplication
public class ServerApplication {
  private static final Logger log = Logger.getLogger(ServerApplication.class.getName());

  private Server server;

  public static void main(String[] args) throws IOException, InterruptedException {
    final ServerApplication server = new ServerApplication();
    server.start();
    server.blockUntilShutdown();
  }

  private void start() throws IOException {
    int port = 41005;
    //1.forPort 指定监听客户端请求的端口
    //2.创建我们的服务端实现类的实例GreeterImpl并将传递给构建器的addService方法
    //3.调用build （）并 start（）在构建器上为我们的服务创建和启动RPC服务器
    server = ServerBuilder.forPort(port)
        .addService(new SayHelloImpl())
        .build()
        .start();
    log.info("Server stated , listener on port:" + port);
    //JVM关闭时调用的钩子
    Runtime.getRuntime().addShutdownHook(new Thread() {
      @Override
      public synchronized void start() {
        System.err.println("*** shutting down gRPC server since JVM is shutting down");
        ServerApplication.this.stop();
        System.err.println("*** server shut down");
      }
    });
  }

  private void stop() {
    if (null != server) {
      server.shutdown();
    }
  }

  /**
   * Await termination on the main thread since the grpc library uses daemon threads.
   *
   * @throws InterruptedException
   */
  private void blockUntilShutdown() throws InterruptedException {
    if (null != server) {
      server.awaitTermination();
    }
  }
}

现在会有编译错误，因为grpc自动编译生成的java代码在根项目里面呢，需要添加对根项目的maven引用，修改server子模块的maven配置文件，增加以下内容去对根项目进行引用：

<dependency>
      <groupId>com.xxx.grpc</groupId>
      <artifactId>demo</artifactId>
      <version>0.0.1-SNAPSHOT</version>
    </dependency>

刷新maven后服务器端程序即可正常编译启动。

接下来编写客户端调用程序，还是先修改client子模块的pom.xml文件，增加对根项目自动生成的grpc java stub代码的编译引用，同样也是增加上面的配置内容，这里就不再赘述。

编写客户端调用代码如下：

package com.xxx.grpc;

import com.google.protobuf.ByteString;
import com.test.rpc.SayHelloServiceGrpc;
import com.test.rpc.Service;
import io.grpc.netty.shaded.io.grpc.netty.NegotiationType;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;

@SpringBootApplication
public class ClientApplication {

  private static final String host="127.0.0.1";
  private static final int port=41005;

  public static void main(String[] args) {
    SpringApplication.run(ClientApplication.class, args);

    io.grpc.Channel channel = NettyChannelBuilder.forAddress(host, port)
        .negotiationType(NegotiationType.PLAINTEXT)
        .build();

    Service.SayHelloRequest req=Service.SayHelloRequest.newBuilder().setName(ByteString.copyFrom("测试", Charset.forName("utf-8"))).build();

    Service.SayHelloResponse result= SayHelloServiceGrpc.newBlockingStub(channel).sayHello(req);
    try {
      System.out.println(result.getResult().toString("utf-8"));
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    }

  }

}

启动服务器端程序，再启动客户端程序即可正常运行，把服务器端程序部署到其他机器，开放防火墙端口，客户端修改调用ip地址即可进行调用。

代码发布地址:​​https://github.com/peihexian/grpcdemo​​

 

 

 

 

举报

相关推荐

gRPC在Spring Cloud中的应用

grpcspringmaven服务端JavaScript前端开发

manjaro linux使用过程记录

linux

gtest和gmock在C++中的使用过程

c++linux#includebash测试用例编程语言

plotly使用过程中遇到的问题记录

python

java反射的使用过程

javaSystemjava反射构造方法虚拟化云计算

geoserver 使用过程中遇到的问题记录

geoserver重启Python后端开发

grpc在go和java之间进行互相调用的过程

springjavamaven云平台云计算

记录一次Nginx的使用过程

神经网络人工智能深度学习

python在使用过程中安装库的方法

python搜索命令行网络/安全

VS2010在使用过程中遇到的问题

解决方法一闪而过不执行JavaScript前端开发yyds干货盘点
0 条评论