需要首先进行说明的是，为了方便打印日志，下面的代码都是引入了lombok之后的代码，因为我们需要使用到它的Slf4j，lombok插件依赖如下。

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

引入protobuf-java以及grpc相关的依赖

        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.17.3</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
            <version>1.41.0</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>1.41.0</version>
        </dependency>

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>1.41.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>

如何引入GRPC的代码生成器工具呢？Github官方推荐使用的是如下这样的方式，也可以是类似的gradle方式，gradle方式好像用的也比较多。

    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>
        <plugins>
            <!--    默认情况下需要把.proto文件放到src/main/proto下
                    生成的代码会默认放到target/generated-sources/protobuf-->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocArtifact>
                        com.google.protobuf:protoc:3.17.3:exe:${os.detected.classifier}
                    </protocArtifact>
                    <pluginId>grpc-java</pluginId>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

但是直接加入到maven依赖中却是很多报错...比如找不到org.xolstice.maven.plugins插件和无法解析符号 'os.detected.classifier'。

第一个找不到插件的原因是Aliyun仓库没这个jar包，需要添加一个中央仓库。

    <repositories>
        <!--    只有中央仓库中才有ProtoBuf的编译插件...    -->
        <repository>
            <id>central-repos</id>
            <name>Central Repository</name>
            <url>http://repo.maven.apache.org/maven2</url>
        </repository>
    </repositories>

第二个原因是在编译时需要指定参数，但是我们并未进行配置，可以在properties中进行配置...

    <properties>
        <java.version>11</java.version>
        <!--     ProtoBuf生成插件需要使用到这个属性的配置   -->
        <os.detected.classifier>osx-x86_64</os.detected.classifier>
    </properties>

os.detected.classifier指定你所在的平台可选osx-x86_64、windows-x86_64、linux-x86_64等选项。

到这里，pom.xml已经不报错了~

image.png

我们尝试去进行编译一波！这里需要用到的是protobuf:compile和protobuf:compile-custom这两个任务去进行执行

image.png

编译成功！在target目录下也得到了我们想要的生成的代码！

image.png

需要注意的是，如果只使用protobuf:compile任务去执行的话，就是就是和我们使用protoc命令去进行编译没什么区别，不会将service进行编译，于是就需要使用到第二个插件，也就是之前配置的io.grpc:protoc-gen-grpc-java:1.41.0:exe:${os.detected.classifier}，这个配置就表示使用另外一个任务去生成Service。因此才生成了上面的UserServiceGrpc这样一个类。(我最开始一直没想到这个，看别人都是用的gradle去构建的，没有坑，没看到使用maven的教程，因此在这里折腾了好久，想去编译源码了，但是又编译失败了！！！)

如果我们使用protoc命令去进行编译的话，还需要指定使用的插件grpc-java才能编译出来service，不然也是不会编译service的。但是这个插件需要下载grpc-java的源码去进行编译，这里面有坑并不好办。

编写我们自定义的Service去实现XXXServiceImplBase(如果没有这个类，你可能是生成service时生成失败了，需要回到之前去检查一遍)。

@Slf4j
public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {

    // 客户端发送一个正常的数据，服务器端也正常返回一个正常的数据
    @Override
    public void getRealNameByUsername(UserGrpcPOJO.Request request, StreamObserver<UserGrpcPOJO.Response> responseObserver) {
        log.info("接收到客户端的请求:[{}]", request);
        responseObserver.onNext(UserGrpcPOJO.Response.newBuilder().setId(1).setRealName("zhangsan").build());
        responseObserver.onCompleted();
    }

    // 客户端发送一个正常的数据，服务器端返回一个流式的数据
    @Override
    public void getUsersByAge(UserGrpcPOJO.UserRequest request, StreamObserver<UserGrpcPOJO.UserResponse> responseObserver) {
        log.info("接收到客户端的请求:[{}]", request);
        for (int i = 0; i < 5; i++) {
            responseObserver.onNext(UserGrpcPOJO.UserResponse.newBuilder().setName("wanna-" + i).setAge(request.getAge()).build());
        }
        responseObserver.onCompleted();
    }

    // 客户端发送一个流式的数据，服务器端返回一个正常的数据
    @Override
    public StreamObserver<UserGrpcPOJO.UserRequest> getUsersWrapperByAges(StreamObserver<UserGrpcPOJO.UserResponseList> responseObserver) {
        return new StreamObserver<UserGrpcPOJO.UserRequest>() {
            @Override
            public void onNext(UserGrpcPOJO.UserRequest value) {
                log.info("接收到客户端的数据:[{}]", value);
            }

            @Override
            public void onError(Throwable t) {
                log.info("在处理客户端数据时发生了异常:原因是:[{}]", t.getMessage());
            }

            @Override
            public void onCompleted() {
                List<UserGrpcPOJO.UserResponse> list = Arrays.asList(
                        UserGrpcPOJO.UserResponse.newBuilder().setId(1).setName("wanna1").build(),
                        UserGrpcPOJO.UserResponse.newBuilder().setId(2).setName("wanna2").build(),
                        UserGrpcPOJO.UserResponse.newBuilder().setId(3).setName("wanna3").build()
                );

                UserGrpcPOJO.UserResponseList responseList = UserGrpcPOJO.UserResponseList.newBuilder().addAllUserResponse(list).build();

                responseObserver.onNext(responseList);  // 响应客户端
                responseObserver.onCompleted();
            }
        };
    }

    @Override
    public StreamObserver<UserGrpcPOJO.StreamRequest> biTalk(StreamObserver<UserGrpcPOJO.StreamResponse> responseObserver) {
        return new StreamObserver<UserGrpcPOJO.StreamRequest>() {
            @Override
            public void onNext(UserGrpcPOJO.StreamRequest value) {
                log.info("接收到客户端的数据:[{}]", value);
                responseObserver.onNext(UserGrpcPOJO.StreamResponse.newBuilder().setResponseInfo("wanna").build());
            }

            @Override
            public void onError(Throwable t) {
                log.info("在处理客户端数据时发生了异常:原因是:[{}]", t.getMessage());
            }

            @Override
            public void onCompleted() {
                responseObserver.onCompleted();
            }
        };
    }
}

编写一个demo的Server

@Slf4j
public class GrpcServer {
    private io.grpc.Server server;

    private void start() throws Exception {
        this.server = io.grpc.ServerBuilder.forPort(8899).addService(new UserServiceImpl()).build().start();

        // 添加关闭服务器的回调，将server(socket)关闭掉...
        Runtime.getRuntime().addShutdownHook(new Thread(this::stop));
        log.info("启动服务器完成...");
    }

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

    private void awaitTermination() throws Exception {
        if (this.server != null) {
            this.server.awaitTermination();
        }
    }

    public static void main(String[] args) throws Exception {
        GrpcServer server = new GrpcServer();
        server.start();

        server.awaitTermination();   // 在这阻塞住，等着客户端的连接
    }
}

编写一个demo的Client

@Slf4j
public class GrpcClient {
    public static void main(String[] args) throws Exception {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 8899).usePlaintext().build();

        // 使用阻塞的方式...
        UserServiceGrpc.UserServiceBlockingStub blockingStub = UserServiceGrpc.newBlockingStub(channel);
        UserGrpcPOJO.Response response = blockingStub.getRealNameByUsername(UserGrpcPOJO.Request.newBuilder().setUsername("wanna").build());
        log.info("1-接收到客户端的消息:[{}]", response);

        Iterator<UserGrpcPOJO.UserResponse> responses = blockingStub.getUsersByAge(UserGrpcPOJO.UserRequest.newBuilder().setAge(20).build());
        while (responses.hasNext()) {
            UserGrpcPOJO.UserResponse resp =  responses.next();
            log.info("2--接收到客户端的消息:[{}]", resp);
        }

        // 使用异步的方式...
        UserServiceGrpc.UserServiceStub stub = UserServiceGrpc.newStub(channel);
        StreamObserver<UserGrpcPOJO.UserResponseList> responseStreamObserver = new StreamObserver<UserGrpcPOJO.UserResponseList>() {
            @Override
            public void onNext(UserGrpcPOJO.UserResponseList value) {
                log.info("3---接受到服务器端的数据:[{}]", value);
            }

            @Override
            public void onError(Throwable t) {
                log.info("3---处理服务器的数据失败，原因是[{}]", t.getMessage());
            }

            @Override
            public void onCompleted() {
                log.info("3---处理服务器端的数据完成...");
            }
        };
        StreamObserver<UserGrpcPOJO.UserRequest> wrapperByAges = stub.getUsersWrapperByAges(responseStreamObserver);
        for (int i = 0; i < 5; i++) {
            wrapperByAges.onNext(UserGrpcPOJO.UserRequest.newBuilder().setAge(20).build());
        }
        wrapperByAges.onCompleted();

        StreamObserver<UserGrpcPOJO.StreamResponse> responseObserver = new StreamObserver<UserGrpcPOJO.StreamResponse>() {
            @Override
            public void onNext(UserGrpcPOJO.StreamResponse value) {
                log.info("4----接受到服务器端的数据:[{}]", value);
            }

            @Override
            public void onError(Throwable t) {
                log.info("4----处理服务器的数据失败，原因是[{}]", t.getMessage());
            }

            @Override
            public void onCompleted() {
                log.info("4----处理服务器端的数据完成...");
            }
        };
        StreamObserver<UserGrpcPOJO.StreamRequest> requestStreamObserver = stub.biTalk(responseObserver);
        for (int i = 0; i < 5; i++) {
            requestStreamObserver.onNext(UserGrpcPOJO.StreamRequest.newBuilder().setRequestInfo("wanna").build());
        }
        requestStreamObserver.onCompleted();

        TimeUnit.SECONDS.sleep(1000);
    }
}

把Server和Client启动起来

image.png

image.png

运行成功，到这里，我们的一个简单GRPC的程序就写完了！

还有个问题，就是你使用了这个maven编译插件之后，默认会在target目录下生成一份文件，如果你将生成的代码拷贝到src目录下，那么就在进行build时就会出现类重复的情况，因为build会执行compile-custom任务生成代码，但是你src目录也有相应的代码，类重复很好理解。

那么我们有什么办法吗？办法其实是有的，就是修改输出路径，直接将代码生成到src目录下不就行了吗？但是这个相关的资料并不好找。得查看该插件的官网https://www.xolstice.org/protobuf-maven-plugin/compile-custom-mojo.html自己去查看英文文档，相信不少人对英文文档已经劝退了！(要想成为一个强的程序员，英文阅读能力必须有！！！都给我冲！！！)

我们来查看官网的这两个配置项

image.png

我们首先要注意的就是outputDirectory这个配置项，用来指定输出路径，默认是${project.build.directory}/generated-sources/protobuf/<pluginId>，我们需要指定为src/main/java。到这里暂时先别忙着操作，先把下面看完。

上面的操作中默认clearOutputDirectory为true，会把即将输出的目录下的代码以及其它文件全部直接清空掉！并且不能回退！很恶心的，我们就需要去指定它为false才能达成我们想要的目的！具体参考下面的配置文件即可。

                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.17.3:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.41.0:exe:${os.detected.classifier}</pluginArtifact>
                    <!--         指定输出的base基础路径           -->
                    <outputDirectory>src/main/java</outputDirectory>
                    <!--          是否清除输出目录下的文件，默认为true，表示会将指定的输出路径下的全部文件都进行清空
                              如果自己配置了outputDirectory，请将这项配置改为false-->
                    <clearOutputDirectory>false</clearOutputDirectory>
                </configuration>

再按照之前的方式去进行编译就好了！执行compile和compile-custom这两个任务生成对应的Message和Service。

有需要更多配置的也可以去官网查看相关的配置项，有大佬愿意去看源码也可以看看Github中这个插件的源码https://github.com/xolstice/protobuf-maven-plugin了解和学习更多相关的知识！