GRPC使用之HelloWorld

已于 2024-07-05 11:23:26 修改
阅读量735 收藏 26
点赞数 25
CC 4.0 BY-SA版权
文章标签： rpc java
于 2024-07-05 11:15:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/randavy/article/details/140203224

使用grpc的好处是提供高效的序列化能力，能够跨语言进行调用。这一节我们来学习grpc的入门应用，整篇文章分成3部分:

  1. 接口定义，使用grpc的IDL，创建proto文件，编译/生成grpc文件
  2. 服务端开发，处理客户端请求，并返回响应
  3. 客户端开发，发送请求，并接收服务端响应

根据上面的拆分，我们将grpc的项目拆分为3个工程，分别是:

  1. demo-grpc-proto，用于存放.proto文件，生成jar包供其他工程使用
  2. demo-grpc-server，引用proto，创建grpc的server
  3. demo-grpc-client，引用proto，调用grpc的server端

1. 接口定义

1. 初始化项目

先通过mvn archetype:generate从quickstart生成一个极简的Maven项目

mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes 
    -DarchetypeArtifactId=maven-archetype-quickstart 
    -DarchetypeVersion=1.4 
    -DgroupId=org.keyniu 
    -DartifactId=DemoGrpcProto 
    -Dversion=0.1 
    -Dpackage=org.keyniu 
    -DinteractiveMode=false

引入grpc的Maven依赖以及打包插件，插件略复杂，主要的目的是为了将grpc生成的代码直接打包进当前工程的jar，暂时忽略具体含义即可。

<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>

    <groupId>org.keyniu.proto</groupId>
    <artifactId>demo-grpc-proto</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>DemoGrpcProto</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
            <version>1.64.0</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>1.64.0</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>1.64.0</version>
        </dependency>
        <dependency> <!-- necessary for Java 9+ -->
            <groupId>org.apache.tomcat</groupId>
            <artifactId>annotations-api</artifactId>
            <version>6.0.53</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
        <testSourceDirectory>${basedir}/src/test/java</testSourceDirectory>

        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.7.1</version>
            </extension>
        </extensions>
        <plugins>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.25.1:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.64.0:exe:${os.detected.classifier}</pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                    <generatedSourcesDirectory>${project.build.directory}/generated-sources/protobuf/grpc-java</generatedSourcesDirectory>
                    <generatedSourcesDirectory>${project.build.directory}/generated-sources/protobuf/java</generatedSourcesDirectory>
                </configuration>
            </plugin>

            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                    <archive>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </archive>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

2. 编辑proto文件

proto文件定义了grpc的接口、出参、入参，这里我们定义了4个接口，分别是对应grpc basic tutorial的4种模式:

  1. 基本调用
  2. Server端Streaming
  3. Client端Streaming
  4. 双向Streaming
    文件名是helloworld.proto，路径是 src/main/proto/helloworld.proto，文件内容:
syntax = "proto3";

option java_multiple_files = true;
option java_package = "org.keyniu.grpc.generate";
//option java_outer_classname = "HelloWorldProto";
//option objc_class_prefix = "HLW";

// The greeting service definition.
service Greeter {
  rpc sayHello (HelloRequest) returns (HelloReply) {}
  rpc sayHelloClientStream (stream HelloRequest) returns (HelloReply) {}
  rpc sayHelloServerStream (HelloRequest) returns (stream HelloReply) {}
  rpc sayHelloBiStream (stream HelloRequest) returns (stream 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;
}

3. 编译proto文件

通过Maven命令，生成grpc的请求/响应对象，以及grpc调用对象

mvn protobuf:compile protobuf:compile-custom

生成的文件结构如下在这里插入图片描述

4. 打包代码

protobuff-maven-plugin生成的代码默认在target/generated-source/protobuff/java下，该代码不会打包到当前工程的jar中，解决方案有两种

1. 换生成目录

可以将生成代码的目录放到src/main/java下，这样我们在package的时候就会包含这部分代码。通过pom.xml指定生成目录

<plugin>  
	<groupId>org.xolstice.maven.plugins</groupId>  
	<artifactId>protobuf-maven-plugin</artifactId>  
	<version>0.6.1</version>  
	<configuration>  
		<protocArtifact>com.google.protobuf:protoc:3.25.1:exe:${os.detected.classifier}</protocArtifact>  
		<pluginId>grpc-java</pluginId>  
		<pluginArtifact>io.grpc:protoc-gen-grpc-java:1.64.0:exe:${os.detected.classifier}</pluginArtifact>  
		<outputDirectory>src/main/java</outputDirectory>  
	</configuration>  
	<executions>  
		<execution>  
			<goals>  
				<goal>compile</goal>  
				<goal>compile-custom</goal>  
			</goals>  
		</execution>  
	</executions>  
</plugin>
2. 改编译插件

直接将代码生成到src/main/java下的问题是生成的代码和手动编辑的代码冲突，而且我们无法分辨哪些是生成的，哪些自己编辑的。前面我们给出的完整配置，目的就是打包的时候将generated-source种protobuff的代码包含在jar中

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
        <source>${maven.compiler.source}</source>
        <target>${maven.compiler.target}</target>
        <generatedSourcesDirectory>${project.build.directory}/generated-sources/protobuf/grpc-java</generatedSourcesDirectory>
        <generatedSourcesDirectory>${project.build.directory}/generated-sources/protobuf/java</generatedSourcesDirectory>
    </configuration>
</plugin>

正常的执行mvn clean package就能完成打包，打包后的文件结构如下图所示
在这里插入图片描述

2. 服务端

1. 初始化项目

通过achetype:generate生成一个最简单的项目

mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes 
    -DarchetypeArtifactId=maven-archetype-quickstart 
    -DarchetypeVersion=1.4 
    -DgroupId=org.keyniu.server
    -DartifactId=demo-grpc-server 
    -Dversion=0.1 
    -Dpackage=org.keyniu.server
    -DinteractiveMode=false

之前我们创建了接口定义的项目demo-grpc-proto，在demo-grpc-server要引入它的依赖

<dependency>
	<groupId>org.keyniu.proto</groupId>
    <artifactId>demo-grpc-proto</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

2. 实现Server

proto生成的时候，根据我们定义的service名称(例子中是Greeter)， 自动生成了一个GreeterGrpc类
在这里插入图片描述

要实现service Greeter服务端的逻辑，需要继承Greeter.GreeterImplBase类，下面我们来看一下每个方法的具体实现

public class GreeterServer extends GreeterGrpc.GreeterImplBase {
    public void sayHello(HelloRequest request, StreamObserver<HelloReply> observer) {
        super.sayHello(request, observer);
    }
    public StreamObserver<HelloRequest> sayHelloClientStream(StreamObserver<HelloReply> responseObserver) {
        return super.sayHelloClientStream(responseObserver);
    }
    public void sayHelloServerStream(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
        super.sayHelloServerStream(request, responseObserver);
    }
    public StreamObserver<HelloRequest> sayHelloBiStream(StreamObserver<HelloReply> responseObserver) {
        return super.sayHelloBiStream(responseObserver);
    }
}
1. 基本调用

基本调用的实现逻辑清晰，通过处理入参HelloRequest，生成响应HelloReply，StreamObserver.onNext返回响应，onCompleted通知框架grpc调用结束。

    public void sayHello(HelloRequest request, StreamObserver<HelloReply> observer) {
        String message = "hello " + request.getName();
        observer.onNext(HelloReply.newBuilder().setMessage(message).build());
        observer.onCompleted();
    }
2. Server端Streaming

Server端Streaming和基本调用类似，只是多个响应时要多次调用onNext，onCompleted同样是在grpc请求完整结束之后调用

    public void sayHelloServerStream(HelloRequest request, StreamObserver<HelloReply> observer) {
        String name = request.getName();
        for(char c : name.toCharArray()) {
            String message = "hello " + String.valueOf(c);
            observer.onNext(HelloReply.newBuilder().setMessage(message).build());
        }
        observer.onCompleted();
    }
3. Client端Streaming

Client端Streaming是通过返回一个StreamObserver回调对象给框架实现的，每收到一个请求框架就回调返回对象的onNext方法，客户端发送参数结束之后会调用onCompleted方法，详细的流程看代码会更清晰。

    public StreamObserver<HelloRequest> sayHelloClientStream(StreamObserver<HelloReply> observer) {
        return new StreamObserver<HelloRequest>() {
            private List<String> names = new ArrayList<String>();
            public void onNext(HelloRequest request) {
                names.add(request.getName());
            }
            public void onError(Throwable t) {
                t.printStackTrace();
            }
            public void onCompleted() {
                String message = "hello " + String.join(",", names);
                observer.onNext(HelloReply.newBuilder().setMessage(message).build());
                observer.onCompleted();
            }
        };
    }
4. 双向Streaming

我们已经看到过Client和Server端各自的Streaming实现了，双向Streaming其实就是两者的结合，应该说StreamObserver的抽象还是很实用的。

    public StreamObserver<HelloRequest> sayHelloBiStream(StreamObserver<HelloReply> observer) {
        return new StreamObserver<HelloRequest>() {
            public void onNext(HelloRequest request) {
                String message = "hello " + request.getName();
                observer.onNext(HelloReply.newBuilder().setMessage(message).build());
            }
            public void onError(Throwable t) {
                t.printStackTrace();
            }
            public void onCompleted() {
                observer.onCompleted();
            }
        };
    }

3. 启动服务

通过ServerBuilder创建服务，将我们的GreeterServer作为服务注册

public class Main {
    public static void main(String[] args) throws IOException {
        Server server = ServerBuilder.forPort(2333)
                .addService(new GreeterServer())
                .build();
        server.start();
        System.out.println("server started....");
    }
}

启动后发现server started服务就算启动完成了。
在这里插入图片描述

3. 客户端

首先是创建和grpc服务的Channel，通过ManagedChannel创建，后续的调用都是通Stub完成的，支持的Stub有两种

  1. BlockingStub，同步调用
  2. async Stub，异步调用
ManagedChannel channel = ManagedChannelBuilder.forAddress("127.0.0.1", 2333).usePlaintext().build();
GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
GreeterGrpc.GreeterStub async = GreeterGrpc.newStub(channel);

如果不是Client端不是Stream，都可以通过BlockingStub实现，我们来分别看一下

1. 基本调用

HelloRequest request = HelloRequest.newBuilder().setName("randy").build();
HelloReply reply = stub.sayHello(request);
System.out.println(reply.getMessage());

2. Server端Streaming

直接响应一个Iterator，Iterator中是服务器的多个响应值

Iterator<HelloReply> replies = stub.sayHelloServerStream(request);
while (replies.hasNext()) {
    HelloReply aReply = replies.next();
    System.out.println(aReply.getMessage());
}

3. Client端Streaming

Client端Streaming需要接着async stub完成，我们曾经看到过两个StreamObserver，在客户端的时候，客户端的StreamObserver是用来发送数据的，服务端的StreamObserver用来接收服务器数据；在服务端的时候则相反。

StreamObserver<HelloReply> serverObserver = new StreamObserver<HelloReply>() { // 接收服务端响应的回调
    public void onNext(HelloReply helloReply) {
        System.out.println(helloReply.getMessage());
    }
    public void onError(Throwable t) {
        t.printStackTrace();
    }
    public void onCompleted() {
        System.out.println("server complete");
    }
};
StreamObserver<HelloRequest> requestObserver = async.sayHelloClientStream(serverObserver); // 返回客户端StreamObserver
requestObserver.onNext(HelloRequest.newBuilder().setName("randy").build());  // 客户端StreamObserver.onNext用来发送数据
requestObserver.onNext(HelloRequest.newBuilder().setName("zhangsan").build());
requestObserver.onCompleted();

4. 双向Streaming

理解了Client端Streaming，双向Streaming就好理解了，唯一的不同是serverObserver的onNext方法会有多次回调

StreamObserver<HelloReply> serverObserver = new StreamObserver<HelloReply>() { // 接收服务端响应的回调
    public void onNext(HelloReply helloReply) {
        System.out.println(helloReply.getMessage());
    }
    public void onError(Throwable t) {
        t.printStackTrace();
    }
    public void onCompleted() {
        System.out.println("server complete");
    }
};
requestObserver = async.sayHelloBiStream(serverObserver);
requestObserver.onNext(HelloRequest.newBuilder().setName("randy").build());
requestObserver.onNext(HelloRequest.newBuilder().setName("zhangsan").build());
requestObserver.onCompleted();

A. 参考资料

  1. what is grpc
    1. https://grpc.io/docs/what-is-grpc/introduction/
  2. basic tutorial
    1. https://grpc.io/docs/languages/java/basics/
  3. proto buff overview
    1. https://protobuf.dev/overview/
  4. proto3 guide
    1. https://protobuf.dev/programming-guides/proto3/
  5. Java Generated
    1. https://protobuf.dev/reference/java/java-generated/
  6. Github
    1. https://github.com/grpc/grpc-java
randy.lou
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值