參考：

1. java下使用gRPC的helloworld的demo實現https://blog.csdn.net/u013992365/article/details/81698531#%E6%96%B0%E5%BB%BA%E4%B8%80%E4%B8%AA%E6%99%AE%E9%80%9A%E7%9A%84maven%E9%A1%B9%E7%9B%AE
2. grpc官方文件中文版http://doc.oschina.net/grpc?t=58008
3. 示例：https://github.com/grpc/grpc-java/tree/master/examples/src/main/java/io/grpc/examples

具體實施步驟：

1、新建一個普通的Maven專案：

點選下一步，再點選Finsh。

2、配置pom檔案，匯入grpc的依賴和外掛

全部的pom內容如下：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4. <modelVersion>4.0.0</modelVersion>
6. <groupId>com.grpcprojects</groupId>
7. <artifactId>grpcExercise3</artifactId>
8. <version>1.0-SNAPSHOT</version>
10. <properties>
11. <grpc-version>1.20.0</grpc-version>
12. </properties>
14. <dependencies>
15. <dependency>
16. <groupId>io.grpc</groupId>
17. <artifactId>grpc-core</artifactId>
18. <version>${grpc-version}</version>
19. </dependency>
20. <dependency>
21. <groupId>io.grpc</groupId>
22. <artifactId>grpc-netty-shaded</artifactId>
23. <version>${grpc-version}</version>
24. </dependency>
25. <dependency>
26. <groupId>io.grpc</groupId>
27. <artifactId>grpc-protobuf</artifactId>
28. <version>${grpc-version}</version>
29. </dependency>
30. <dependency>
31. <groupId>io.grpc</groupId>
32. <artifactId>grpc-stub</artifactId>
33. <version>${grpc-version}</version>
34. </dependency>
35. </dependencies>
37. <build>
38. <extensions>
39. <extension>
40. <groupId>kr.motd.maven</groupId>
41. <artifactId>os-maven-plugin</artifactId>
42. <version>1.5.0.Final</version>
43. </extension>
44. </extensions>
46. <plugins>
47. <plugin>
48. <groupId>org.xolstice.maven.plugins</groupId>
49. <artifactId>protobuf-maven-plugin</artifactId>
50. <version>0.5.1</version>
51. <configuration>
52. <protocArtifact>com.google.protobuf:protoc:3.7.1:exe:${os.detected.classifier}</protocArtifact>
53. <pluginId>grpc-java</pluginId>
54. <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.9.1:exe:${os.detected.classifier}</pluginArtifact>
55. <protoSourceRoot>src/main/proto</protoSourceRoot>
56. </configuration>
57. <executions>
58. <execution>
59. <goals>
60. <goal>compile</goal>
61. <goal>compile-custom</goal>
62. </goals>
63. </execution>
64. </executions>
65. </plugin>
66. <plugin>
67. <groupId>org.apache.maven.plugins</groupId>
68. <artifactId>maven-compiler-plugin</artifactId>
69. <version>3.6.1</version>
70. <configuration>
71. <source>1.8</source>
72. <target>1.8</target>
73. </configuration>
74. </plugin>
75. </plugins>
76. </build>
78. </project>

新增好依賴之後的顯示：

新增之後選擇右下鍵出現的import change，就能在Maven Projects中看到新增的依賴了。

3、編寫helloworld.proto檔案

在專案main目錄下新建一個proto資料夾，再在此資料夾下建立一個helloworld.proto檔案

helloworld.proto（跟官網上的一樣）中的程式碼如下：

1. syntax = "proto3";
3. option java_multiple_files = true;
4. option java_package = "io.grpc.examples.helloworld";
5. option java_outer_classname = "HelloWorldProto";
6. option objc_class_prefix = "HLW";
8. package helloworld;
10. // The greeting service definition.
11. service Greeter {
12. // Sends a greeting
13. rpc SayHello (HelloRequest) returns (HelloReply) {}
14. }
16. // The request message containing the user's name.
17. message HelloRequest {
18. string name = 1;
19. }
21. // The response message containing the greetings
22. message HelloReply {
23. string message = 1;
24. }

重要的地方來了，編譯helloworld.proto檔案，編譯此檔案有兩種方法，第一種使用protoc.exe和protoc-gen-grpc-java外掛進行編譯。第二種方法是用剛才在專案裡邊新增的外掛進行編譯。下邊分別進行說明：

第一種：使用protoc.exe和protoc-gen-grpc-java外掛進行編譯

下載protoc.exe 工具 ， 下載地址：https://github.com/protocolbuffers/protobuf/releases

下載protoc-gen-grpc 外掛 , 下載地址:http://jcenter.bintray.com/io/grpc/protoc-gen-grpc-java/

將protoc.exe和protoc-gen-grpc外掛放到main目錄中：

在專案的terminal視窗中執行如下兩條指令：

執行完每條指令之後，視窗應該不會出現任何資訊，在專案檔案目錄中會新增如下檔案：

第二種方法：用剛才在專案裡邊新增的外掛進行編譯

在分割線下邊

4、新增客戶端和服務端程式碼

我是直接從官網上直接拿過來的程式碼，分別為HelloWorldClient.java和HelloWorldServer.java

HelloWorldClient.java程式碼如下：

1. /*
2. * Copyright 2015 The gRPC Authors
3. *
4. * Licensed under the Apache License, Version 2.0 (the "License");
5. * you may not use this file except in compliance with the License.
6. * You may obtain a copy of the License at
7. *
8. * http://www.apache.org/licenses/LICENSE-2.0
9. *
10. * Unless required by applicable law or agreed to in writing, software
11. * distributed under the License is distributed on an "AS IS" BASIS,
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. * See the License for the specific language governing permissions and
14. * limitations under the License.
15. */
17. package helloworld;
19. import io.grpc.ManagedChannel;
20. import io.grpc.ManagedChannelBuilder;
21. import io.grpc.StatusRuntimeException;
22. import io.grpc.examples.helloworld.GreeterGrpc;
23. import io.grpc.examples.helloworld.HelloReply;
24. import io.grpc.examples.helloworld.HelloRequest;
26. import java.util.concurrent.TimeUnit;
27. import java.util.logging.Level;
28. import java.util.logging.Logger;
30. /**
31. * A simple client that requests a greeting from the {@link HelloWorldServer}.
32. */
33. public class HelloWorldClient {
34. private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());
36. private final ManagedChannel channel;
37. private final GreeterGrpc.GreeterBlockingStub blockingStub;
39. /** Construct client connecting to HelloWorld server at {@code host:port}. */
40. public HelloWorldClient(String host, int port) {
41. this(ManagedChannelBuilder.forAddress(host, port)
42. // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
43. // needing certificates.
44. .usePlaintext()
45. .build());
46. }
48. /** Construct client for accessing HelloWorld server using the existing channel. */
49. HelloWorldClient(ManagedChannel channel) {
50. this.channel = channel;
51. blockingStub = GreeterGrpc.newBlockingStub(channel);
52. }
54. public void shutdown() throws InterruptedException {
55. channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
56. }
58. /** Say hello to server. */
59. public void greet(String name) {
60. logger.info("Will try to greet " + name + " ...");
61. HelloRequest request = HelloRequest.newBuilder().setName(name).build();
62. HelloReply response;
63. try {
64. response = blockingStub.sayHello(request);
65. } catch (StatusRuntimeException e) {
66. logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
67. return;
68. }
69. logger.info("Greeting: " + response.getMessage());
70. }
72. /**
73. * Greet server. If provided, the first element of {@code args} is the name to use in the
74. * greeting.
75. */
76. public static void main(String[] args) throws Exception {
77. HelloWorldClient client = new HelloWorldClient("localhost", 50051);
78. try {
79. /* Access a service running on the local machine on port 50051 */
80. String user = "world";
81. if (args.length > 0) {
82. user = args[0]; /* Use the arg as the name to greet if provided */
83. }
84. client.greet(user);
85. } finally {
86. client.shutdown();
87. }
88. }
89. }

HelloWorldServer.java程式碼如下：

1. /*
2. * Copyright 2015 The gRPC Authors
3. *
4. * Licensed under the Apache License, Version 2.0 (the "License");
5. * you may not use this file except in compliance with the License.
6. * You may obtain a copy of the License at
7. *
8. * http://www.apache.org/licenses/LICENSE-2.0
9. *
10. * Unless required by applicable law or agreed to in writing, software
11. * distributed under the License is distributed on an "AS IS" BASIS,
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. * See the License for the specific language governing permissions and
14. * limitations under the License.
15. */
17. package helloworld;
19. import io.grpc.Server;
20. import io.grpc.ServerBuilder;
21. import io.grpc.examples.helloworld.GreeterGrpc;
22. import io.grpc.examples.helloworld.HelloReply;
23. import io.grpc.examples.helloworld.HelloRequest;
24. import io.grpc.stub.StreamObserver;
25. import java.io.IOException;
26. import java.util.logging.Logger;
28. /**
29. * Server that manages startup/shutdown of a {@code Greeter} server.
30. */
31. public class HelloWorldServer {
32. private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
34. private Server server;
36. private void start() throws IOException {
37. /* The port on which the server should run */
38. int port = 50051;
39. server = ServerBuilder.forPort(port)
40. .addService(new GreeterImpl())
41. .build()
42. .start();
43. logger.info("Server started, listening on " + port);
44. Runtime.getRuntime().addShutdownHook(new Thread() {
45. @Override
46. public void run() {
47. // Use stderr here since the logger may have been reset by its JVM shutdown hook.
48. System.err.println("*** shutting down gRPC server since JVM is shutting down");
49. HelloWorldServer.this.stop();
50. System.err.println("*** server shut down");
51. }
52. });
53. }
55. private void stop() {
56. if (server != null) {
57. server.shutdown();
58. }
59. }
61. /**
62. * Await termination on the main thread since the grpc library uses daemon threads.
63. */
64. private void blockUntilShutdown() throws InterruptedException {
65. if (server != null) {
66. server.awaitTermination();
67. }
68. }
70. /**
71. * Main launches the server from the command line.
72. */
73. public static void main(String[] args) throws IOException, InterruptedException {
74. final HelloWorldServer server = new HelloWorldServer();
75. server.start();
76. server.blockUntilShutdown();
77. }
79. static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
81. @Override
82. public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
83. HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
84. responseObserver.onNext(reply);
85. responseObserver.onCompleted();
86. }
87. }
88. }

5、最終的檔案結構

6、執行服務端和客戶端程式碼

先執行HelloWorldServer.java,再HelloWorldClient.java，得如下執行結果，正面我們的gprc通訊成功了。

服務端顯示如下：

客戶端顯示如下：

步驟1,2和上邊完全相同，此處從步驟3的第二種方法開始說。

第二種方法：用剛才在專案裡邊新增的外掛進行編譯。

• 右擊Maven.Projects\protobuf\protobuf:compile，選擇run，生成用於序列化的java檔案。
• 再右擊Maven.Projects\protobuf\protobuf:compile-custom，選擇run，生成用於rpc的java程式碼。

執行完這兩步，會產生的檔案為：

但是在執行這兩步的過程中，控制檯會出現報錯的資訊，但是在後邊服務端和客戶端執行的時候並沒有報別的錯誤。

哪位大佬能解決這個問題，麻煩請告知一下，多謝了。

4、客戶端和服務端的程式碼和上邊寫的一樣

5、專案檔案目錄如下：

6、最後的執行結果（和上邊的執行結果一樣，並沒有報錯誤）

服務端的顯示：

客戶端的顯示：