1. 引入依赖

1.1 引入包

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <protobuf.version>3.16.0</protobuf.version>
    </properties>

<dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
            <version>1.38.0</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>1.38.0</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>1.38.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>

        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java-util</artifactId>
            <version>${protobuf.version}</version>
        </dependency>

1.2. 引入插件

<build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</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.12.0:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.38.0:exe:${os.detected.classifier}</pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2. 定义proto文件

2.1 安装插件

image.png

2.2 创建proto文件

在main下创建proto文件夹，用于存放proto文件，然后创建user_infomation.proto文件，内容如下：

syntax = "proto3";

option java_multiple_files = true;
option java_package = "com.mrtang.demo";
option java_outer_classname = "UserInfomationProto";
option objc_class_prefix = "RTG";

package userinformation;

service UserInfomation {
    rpc getUser(UserParam) returns (User) {};
}

message User {

    int32 user_id = 5;

    string user_name = 1;

    int32 age = 2;

    string email = 3;

    string phone_no = 4;
}

message UserParam {
    int32 user_id = 1;
}

编辑完成后，进行编译会生成相关类

image.png

3. 创建服务器端

package com.mrtang.demo;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.examples.routeguide.RouteGuideGrpc;
import io.grpc.stub.StreamObserver;

import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class UserVisitServer {

    private static final Logger logger = Logger.getLogger(UserVisitServer.class.getName());

    private int port;

    private final Server server;

    public UserVisitServer(int port) {
        this.port = port;
        ServerBuilder<?> serverBuilder = ServerBuilder.forPort(port);
        server = serverBuilder.addService(new UserInfomationService())
                .build();

    }

    public void start() throws IOException {
        server.start();
        logger.info("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread() {

            @Override
            public void run() {
                System.err.println("*** gRPC server 关闭中 ... ");
                try {
                    UserVisitServer.this.stop();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.err.println("服务器已关闭 ...");
            }
        });
    }

    public void stop() throws InterruptedException {
        server.shutdown().awaitTermination(60, TimeUnit.SECONDS);
    }

    private void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }



    public static void main(String[] args) throws IOException, InterruptedException {
        UserVisitServer userServer = new UserVisitServer(8005);
        userServer.start();
        userServer.blockUntilShutdown();
    }

    private static class UserInfomationService extends UserInfomationGrpc.UserInfomationImplBase {

        @Override
        public void getUser(UserParam request, StreamObserver<User> responseObserver) {
            responseObserver.onNext(selectUserById(request.getUserId()));
            responseObserver.onCompleted();
        }

        private User selectUserById(Integer userId) {
            if (Objects.equals(userId, 1)) {
                return User.newBuilder().setUserId(1).setUserName("李白").setAge(38).setEmail("cecjoe@111.com").build();
            } else if (Objects.equals(userId, 2)) {
                return User.newBuilder().setUserId(2).setUserName("杜甫").setAge(52).setEmail("86wanganshi@111.com").build();
            }
            return null;
        }
    }
}

4. 创建客户端

package com.mrtang.demo;

import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import java.util.logging.Level;
import java.util.logging.Logger;

public class UserVisitClient {

    private static final Logger logger = Logger.getLogger(UserVisitServer.class.getName());

    private final UserInfomationGrpc.UserInfomationBlockingStub blockingStub;
    private final UserInfomationGrpc.UserInfomationStub asyncStub;

    public UserVisitClient(Channel channel) {
        blockingStub = UserInfomationGrpc.newBlockingStub(channel);
        asyncStub = UserInfomationGrpc.newStub(channel);
    }

    public void getUser(int userId) {
        UserParam userParam = UserParam.newBuilder().setUserId(userId).build();
        User user = blockingStub.getUser(userParam);
        info("user: name: {0}, age: {1}, email: {2}", user.getUserName(), user.getAge(), user.getEmail());
    }

    private void info(String msg, Object... params) {
        logger.log(Level.INFO, msg, params);
    }

    public static void main(String[] args) {
        String target = "localhost:8005";
        ManagedChannel channel = ManagedChannelBuilder.forTarget(target).usePlaintext().build();
        UserVisitClient client = new UserVisitClient(channel);
        client.getUser(2);
    }
}