grpc基于golang和java的简单实现

grpc基于golang和java的简单实现gRPC是一种高性能、开源的远程过程调用（RemoteProcedureCall）框架，它可以使客户端和服务器之间的通信更加方便和高效。它使用ProtocolBuffers（简称protobuf）作为数据序列化语言，支持多种编程语言的实现，包括Golang和Java。

在Golang中实现gRPC非常简单，并且性能出色。首先，我们需要定义一个.proto文件来描述通信协议和消息格式。比如，我们可以创建一个"to"文件，定义一个简单的HelloWorld服务：

```protobuf

syntax="proto3";

packagehello;

serviceHelloWorld{

rpcSayHello(HelloMessage)returns(HelloResponse){}

}

messageHelloMessage{

stringname=1;

}

messageHelloResponse{

stringmessage=1;

}

```

然后，我们可以使用gRPC的插件生成Golang的代码。在命令行中执行以下命令：

```shell

$protoc-I=.--go_out=.--go-grpc_out=.to

```

这将在当前目录下生成hello.pb.go和hello_grpc.pb.go两个文件，它们包含了Golang对应的服务和消息的定义。

接下来，我们可以编写一个服务器来实现HelloWorld服务：

```go

packagemain

import(

"context"

"log"

"net"

"/grpc"

pb"path/to/generated/files"

)

typeserverstruct{}

func(s*server)SayHello(ctxcontext.Context,req*pb.HelloMessage)(*pb.HelloResponse,error){

message:="Hello,"+req.Name

return&pb.HelloResponse{Message:message},nil

}

funcmain(){

listener,err:=net.Listen("tcp",":50051")

iferr!=nil{

log.Fatalf("failedtolisten:%v",err)

}

srv:=grpc.NewServer()

pb.RegisterHelloWorldServer(srv,&server{})

log.Println("Listeningon:50051...")

iferr:=srv.Serve(listener);err!=nil{

log.Fatalf("failedtoserve:%v",err)

}

}

```

我们首先创建了一个自定义的服务器类型server，实现了HelloWorld服务中定义的接口。在SayHello方法中，我们根据请求参数构造了响应消息。

然后，我们通过grpc.NewServer()创建了一个gRPC服务器，并使用pb.RegisterHelloWorldServer方法将我们的自定义服务器注册到gRPC服务器中。

最后，我们使用srv.Serve(listener)来启动我们的gRPC服务器，并监听在50051端口上。

接下来，我们可以编写一个Golang的客户端来调用我们的HelloWorld服务：

```go

packagemain

import(

"context"

"log"

"/grpc"

pb"path/to/generated/files"

)

funcmain(){

conn,err:=grpc.Dial("localhost:50051",grpc.WithInsecure())

iferr!=nil{

log.Fatalf("didnotconnect:%v",err)

}

deferconn.Close()

client:=pb.NewHelloWorldClient(conn)

req:=&pb.HelloMessage{Name:"Alice"}

res,err:=client.SayHello(context.Background(),req)

iferr!=nil{

log.Fatalf("Failedtosayhello:%v",err)

}

log.Println(res.Message)

}

```

我们首先通过grpc.Dial函数与gRPC服务器建立连接，并创建一个HelloWorld的客户端。然后，我们可以构造请求消息，并通过client.SayHello方法调用远程的SayHello方法。

最后，我们可以通过运行客户端程序来调用服务器的HelloWorld服务，输出结果为"Hello,Alice"。

在Java中实现gRPC也非常简单，并且与Golang版的实现类似。首先，我们需要创建一个"to"文件，与Golang版的定义相同。

然后，我们需要在Java中配置相应的依赖。我们可以使用Maven来管理依赖，以下是一个简单的pom.xml文件示例：

```xml

<project>

<modelVersion>4.0.0</modelVersion>

<groupId>com.example</groupId>

<artifactId>grpc-demo</artifactId>

<version>1.0-SNAPSHOT</version>

<properties>

<java.version>1.8</java.version>

<grpc.version>1.38.0</grpc.version>

</properties>

<dependencies>

<dependency>

<groupId>io.grpc</groupId>

<artifactId>grpc-all</artifactId>

<version>${grpc.version}</version>

</dependency>

</dependencies>

</project>

```

在Java中，我们可以使用protobuf插件生成相应的Java代码。我们可以使用以下命令来生成Java代码：

```shell

$protoc-I=.--java_out=.--grpc_java_out=.to

```

这将在当前目录下生成一个hello.pb和一个helloGrpc.java文件，它们包含了Java对应的服务和消息的定义。

接下来，我们可以编写一个服务器来实现HelloWorld服务：

```java

importio.grpc.Server;

importio.grpc.ServerBuilder;

importio.grpc.stub.StreamObserver;

publicclassHelloWorldServer{

privatefinalintport;

privatefinalServerserver;

publicHelloWorldServer(intport){

this.port=port;

this.server=ServerBuilder.forPort(port).addService(newHelloWorldImpl()).build();

}

publicvoidstart()throwsException{

server.start();

System.out.println("Serverstarted,listeningonport"+port);

}

publicvoidstop(){

if(server!=null){

server.shutdown();

}

}

privatestaticclassHelloWorldImplextendsHelloWorldGrpc.HelloWorldImplBase{

@Override

publicvoidsayHello(HelloMessagerequest,StreamObserver<HelloResponse>responseObserver){

Stringmessage="Hello,"+request.getName();

HelloResponseresponse=HelloResponse.newBuilder().setMessage(message).build();

responseObserver.onNext(response);

responseObserver.onCompleted();

}

}

publicstaticvoidmain(String[]args)throwsException{

HelloWorldServerserver=newHelloWorldServer(50051);

server.start();

server.blockUntilShutdown();

}

}

```

我们首先创建了一个HelloWorldServer类，它包含了服务器的实现和启动逻辑。我们在构造函数中使用ServerBuilder创建一个服务器，并指定监听的端口。

然后，我们创建了一个内部类HelloWorldImpl，它继承了自动生成的HelloWorldGrpc.HelloWorldImplBase类，并实现了HelloWorld服务中定义的方法。

在sayHello方法中，我们根据请求参数构造了响应消息，并使用responseObserver返回响应。

最后，我们在main方法中创建了一个HelloWorldServer实例，并启动服务器。

接下来，我们可以编写一个Java的客户端来调用我们的HelloWorld服务：

```java

importio.grpc.ManagedChannel;

importio.grpc.ManagedChannelBuilder;

publicclassHelloWorldClient{

publicstaticvoidmain(String[]args){

ManagedChannelchannel=ManagedChannelBuilder.forAddress("localhost",50051)

.usePlaintext()

.build();

HelloWorldGrpc.HelloWorldBlockingStubblockingStub=HelloWorldGrpc.newBlockingStub(channel);

HelloMessagerequest=HelloMessage.newBuilder().setName("Alice").build();

HelloResponseresponse=blockingStub.sayHello(request);

System.out.println(response.getMessage());

channel.shutdown();

}

}

```

我们首先使用ManagedChannelBuilder来构建一个与服务器的连接