Grpc quick practice

Record Grpc Use , from grpc maven Compile the plug-in to the client server implementation .

proto and Service Definition

src/main/proto/AgentModel.proto

Model definition 2 Entity , Parameter and return value .

syntax = "proto3";
option java_package = "com.jimo.grpc";

message AgentInfo {
    
  string name = 1;
  sint32 index = 2;
}

message ReportResponse {
    
  bool ok = 1;
  string msg = 2;
}
src/main/proto/AgentService.proto

 Define one on the service side report Method .

syntax = "proto3";

option java_package = "com.jimo.grpc";

import "AgentModel.proto";

service Agent {
    
  rpc report(AgentInfo) returns (ReportResponse) {
    }
}

compile

Join in maven plug-in unit , Compile at the same time proto Document and grpc.

        <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:${protoc.version}:exe:${os.detected.classifier}
                    </protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}
                    </pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>

If you want to use offline proto Executable files , You can change to a local path ：

            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocExecutable>D:\software\protoc.exe</protocExecutable>
                    <pluginId>grpc-java</pluginId>
                    <pluginExecutable>D:\software\protoc-gen-grpc-java.exe</pluginExecutable>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

Run on the command line mvn compile Can compile protobuf and grpc Class , The structure is as follows ：

└─target
    ├─generated-sources
    │  ├─annotations
    │  └─protobuf
    │      ├─grpc-java
    │      │  └─com
    │      │      └─jimo
    │      │          └─grpc
    │      │                  AgentGrpc.java
    │      │
    │      └─java
    │          └─com
    │              └─jimo
    │                  └─grpc
    │                          AgentModel.java
    │                          AgentService.java

Server implementation

First implement the processing logic of the service ： AgentServiceImpl Inherit GRPC Generated abstract classes .

import com.jimo.grpc.AgentGrpc;
import com.jimo.grpc.AgentModel;
import io.grpc.stub.StreamObserver;

public class AgentServiceImpl extends AgentGrpc.AgentImplBase {
    

    @Override
    public void report(AgentModel.AgentInfo request, StreamObserver<AgentModel.ReportResponse> responseObserver) {
    
        AgentModel.ReportResponse response = AgentModel.ReportResponse.newBuilder().setOk(true).setMsg(request.getName()).build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

Then start a service ：

public static void main(String[] args) throws IOException, InterruptedException {
    
    Server server = ServerBuilder.forPort(8000)
            .addService(new AgentServiceImpl())
            .build().start();
    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    
        try {
    
            server.shutdown().awaitTermination(10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    }));
    System.out.println("Listening on 8000...");
    server.awaitTermination();
}

Client implementation

Clients generally share one Channel, So it came in . And then through Stub call .

import com.jimo.grpc.AgentGrpc;
import com.jimo.grpc.AgentModel;
import io.grpc.Channel;

public class AgentClient {
    

    private final AgentGrpc.AgentBlockingStub stub;

    public AgentClient(Channel channel) {
    
        stub = AgentGrpc.newBlockingStub(channel);
    }

    public void report() {
    
        AgentModel.ReportResponse res = stub.report(AgentModel.AgentInfo.newBuilder().setName("app01").setIndex(98).build());
        System.out.println(" Reply received ：" + res);
    }
}

Clients share one Channel Creation and invocation of ：

public static void main(String[] args) throws InterruptedException {
    

    // channel It's better to create one , Can share , It's thread safe 
    ManagedChannel channel = ManagedChannelBuilder
            .forAddress("localhost", 8000)
            //  The default is SSL/TLS, Here there is no 
            .usePlaintext()
            .build();

    AgentClient agentClient = new AgentClient(channel);
    agentClient.report();
    agentClient.report();

    // channel By default, it will wait for a period of time to close , If you don't use it, you'd better close it in time , Otherwise it will take up TCP Connect 
    channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
}

More questions

1、 We need to intercept the request , Do some AOP How to deal with things ？—- use ClientInterceptor

2、 On the above client side AgentGrpc.newBlockingStub(channel), There are several more Stub, What's the difference? , How do you use it? ？

3、 How to realize the network and protocol of communication between client and server ？ Why is the client Channel It will automatically turn off ？

Bury the pit first .