gRPC learning three: the first trial of GO version gRPC development

Welcome to my GitHub

https://github.com/zq2599/blog_demos

Content: Classification and summary of all original articles and supporting source code, involving Java, Docker, Kubernetes, DevOPS, etc.;

Welcome to my GitHub

Here is a classification and summary of all original (including supporting source code): 160bffd81533b1 https://github.com/zq2599/blog_demos

Links to gRPC learning series articles

1. deploy and set up GO
2. GO's gRPC development environment preparation
3. test GO version gRPC development
4. Actual combat four types of service methods
5. gRPC-Gateway combat
6. gRPC-Gateway integrated swagger

Overview of this article

• This article is the third part of the "gRPC learning" series. The gRPC development environment has been prepared in the previous article. Today, let's develop a server-side application and a client that remotely call it with gRPC;
• The content and steps of the actual combat today are shown in the following figure:

Source download

• The source code in this actual combat can be downloaded from GitHub, the address and link information are shown in the following table ( https://github.com/zq2599/blog_demos):

name	link	Remarks
Project homepage	https://github.com/zq2599/blog_demos	The project's homepage on GitHub
git warehouse address (https)	https://github.com/zq2599/blog_demos.git	The warehouse address of the source code of the project, https protocol
git warehouse address (ssh)	[e-mail]:zq2599/blog_demos.git	The warehouse address of the source code of the project, ssh protocol

• There are multiple folders in this git project. The application of this chapter is under the <font color="blue">go-source</font> folder, as shown in the red box in the following figure:

• There are multiple subfolders in <font color="blue">go-source</font>. The source code of this article is in <font color="red">helloworld</font>, as shown in the red box as shown below:

Environment related

• The next development is carried out under the directory of <font color="red">$GOPATH</font>, my real directory here is <font color="blue">/home/golang/gopath</font> ；
• Create a new <font color="red">helloworld</font> directory under the <font color="blue">/home/golang/gopath/src</font> directory as the directory for the next actual combat;
• After completing all the development of this article, the final contents of the <font color="blue">$GOPATH/src/helloworld</font> directory are as follows:

[golang@centos7 src]$ tree helloworld/
helloworld/
├── client
│   └── client.go
├── helloworld.pb.go
├── helloworld.proto
└── server
    └── server.go

2 directories, 4 files

Write proto file

• The proto file is used to describe information related to remote services, such as method signatures, data structures, etc. The proto file in this article is named <font color="blue">helloworld.proto</font>, and the location is <font color="red ">$GOPATH/src/helloworld</font>, the content is as follows:

// 协议类型
syntax = "proto3";

// 包名
package helloworld;

// 定义的服务名
service Greeter {
  // 具体的远程服务方法
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// SayHello方法的入参，只有一个字符串字段
message HelloRequest {
  string name = 1;
}

// SayHello方法的返回值，只有一个字符串字段
message HelloReply {
  string message = 1;
}

Generate go source code according to proto

1. In the directory where <font color="blue">helloworld.proto</font> is located, execute the following command:

protoc --go_out=plugins=grpc:. helloworld.proto

2. If there is no syntax error in helloworld.proto, the file <font color="blue">helloworld.pb.go</font> will be generated in the current directory, which is the code automatically generated by the tool protoc-gen-go, and the generated code inside It will be used in the development of server and client;
3. The following is a code snippet of <font color="blue">helloworld.pb.go</font>, which is used for service registration. The input parameter is GreeterServer which is an interface. It can be inferred from this that: on the server side, the specific business code comes Implement the GreeterServer interface, and call the RegisterGreeterServer method to register, so that the service called remotely by the client can implement business functions:

func RegisterGreeterServer(s *grpc.Server, srv GreeterServer) {
    s.RegisterService(&_Greeter_serviceDesc, srv)
}

type GreeterServer interface {
    // 具体的远程服务方法
    SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}

4. With the help of GoLand's Structure panel, you can further observe helloworld.pb.go:

Write server code server.go and start

1. Create a new folder <font color="red">server</font> in the <font color="blue">$GOPATH/src/helloworld</font> directory, and create a new <font color="red under this folder ">server.go</font>, the content is as follows, detailed notes have been added:

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "helloworld"
)

const (
    port = ":50051"
)

// 定义结构体，在调用注册api的时候作为入参，
// 该结构体会带上SayHello方法，里面是业务代码
// 这样远程调用时就执行了业务代码了
type server struct {
    // pb.go中自动生成的，是个空结构体
    pb.UnimplementedGreeterServer
}

// 业务代码在此写，客户端远程调用SayHello时，
// 会执行这里的代码
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    // 打印请求参数
    log.Printf("Received: %v", in.GetName())
    // 实例化结构体HelloReply，作为返回值
    return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
    // 要监听的协议和端口
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    // 实例化gRPC server结构体
    s := grpc.NewServer()

    // 服务注册
    pb.RegisterGreeterServer(s, &server{})

    log.Println("开始监听，等待远程调用...")

    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

2. Execute <font color="blue">go run server.go</font> in the directory where server.go is located, and the console prompt is as follows:

[golang@centos7 server]$ go run server.go 
2020/12/13 08:20:32 开始监听，等待远程调用...

3. At this point, the gRPC server has been started and can respond to remote calls. Next, develop client code;

Write the client code client.go and start

1. Open another console;
2. Create a new folder <font color="red">client</font> in the <font color="blue">$GOPATH/src/helloworld</font> directory, and create a new <font color="red under this folder ">client.go</font>, the content is as follows, detailed notes have been added:

package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    pb "helloworld"
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    // 远程连接服务端
    conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }

    // main方法执行完毕后关闭远程连接
    defer conn.Close()

    // 实例化数据结构
    c := pb.NewGreeterClient(conn)

    // 远程调用的请求参数，如果没有从命令行传入，就用默认值
    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }

    // 超时设置
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)

    defer cancel()

    // 远程调用
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }

    // 将服务端的返回信息打印出来
    log.Printf("Greeting: %s", r.GetMessage())
}

3. Execute <font color="blue">go run client.go</font> in the directory where client.go is located, and it will immediately initiate a remote call to the server. The console prompts as follows, you can see that you get the return information from the server <font color= "blue">Hello world</font>:

[golang@centos7 client]$ go run client.go
2020/12/13 08:38:05 Greeting: Hello world

4. Go to the console of the server again and look at it. Through the log, it is found that the business code is executed and the parameters of the remote request are received:

[golang@centos7 server]$ go run server.go 
2020/12/13 08:20:32 开始监听，等待远程调用...
2020/12/13 08:38:05 Received: world

5. Go back to the client console, try with parameters on the command line, enter <font color="blue">go run client.go abc</font>, and the response from the server is as follows:

[golang@centos7 client]$ go run client.go abc
2020/12/13 08:56:36 Greeting: Hello abc

6. Go to the console of the server to check again, and successfully received <font color="blue">abc</font>:

[golang@centos7 server]$ go run server.go 
2020/12/13 08:20:32 开始监听，等待远程调用...
2020/12/13 08:38:05 Received: world
2020/12/13 08:56:36 Received: abc

• At this point, a conventional gRPC development combat has been completed, I hope to give you some reference, and we will continue to study in depth in the next article;

You are not alone, Xinchen and original are with you all the way

1. Java series
2. Spring series
3. Docker series
4. kubernetes series
5. database + middleware series
6. DevOps series

Welcome to pay attention to the public account: programmer Xin Chen

Search for "Programmer Xin Chen" on WeChat, I am Xin Chen, and I look forward to traveling the Java world with you...
https://github.com/zq2599/blog_demos