[grpc development] go language builds simple server and client

gRPC Development :go Language to build simple server and client

preparation

---

• install protocol buffers

1. To protocol buffers To github To release Page download guide zip （ This article takes mac System installation protocol buffers For chestnuts , Other system method types ）

   

   1. After downloading, unzip and enter the unzipped directory
      Directly execute the following commands in turn protocol buffers Installation

      1. ./configure
      2. make
      3. make check
      4. sudo make install
      5. protoc --version  Test whether the installation is successful by checking the version 
      

      

• Install the third party required for this article go library

  go get -u google.golang.org/grpc # install gRPC library 
  go get -u github.com/golang/protobuf/protoc-gen-go # install go Linguistic protoc plug-in unit 
  

Start developing

---

1. Create a directory structure in the following format （ The structure of this article is not unique , Readers can find a better structure by themselves ）

   

   among ecommerce Directory is used to store automatically generated stub files

2. Get into service The directory is created by executing the following command go Of productinfo/service modular

   go mod init productinfo/service
   

   After successful execution, it will be in service Generate go.mod file

   

3. Defining services , stay ecommerce Create under directory product_info.proto And define the following services ( The service definitions of client and server are the same ）

   syntax = "proto3";
   
   package ecommerce;
   option go_package = "../ecommerce";
   
   service ProductInfo{
         
     rpc addProduct(Product) returns (ProductID);// Define add product 
     rpc getProduct(ProductID) returns(Product);// Define acquisition products , Only one parameter can be passed in and returned 
   }
   
   // Define the product message body , The same message body cannot have the same number 
   message Product {
         
     string id = 1;
     string name = 2;
     string description = 3;
     float price = 4 ;
   }
   
   // Define the product number message body 
   message ProductID{
         
     string value = 1;
   }
   

4. stay service Execute the following command under the directory to generate the service definition code

   protoc -I ecommerce ecommerce/product_info.proto --go_out=plugins=grpc:$PWD/ecommerce
   

   

   • The generated code is shown in the figure

     

5. Development server

   Server directory structure

   

   a. Server side processing function

   // service.go
   
   package main
   
   import (
   	"context"
   	"github.com/gofrs/uuid"
   	"google.golang.org/grpc/codes"
   	"google.golang.org/grpc/status"
   	pb "productinfo/service/ecommerce"
   )
   
   //  Used to implement ecommerce/product_info  Server for 
   type server struct {
         
   	productMap map[string]*pb.Product
   }
   
   /* Context  Object contains some metadata , For example, the identification of the end-user authorization token and the deadline of the request ,  This metadata will persist throughout the life of the request  */
   
   // AddProduct  Realization ecommerce.AddProduct Of AddProduct Method 
   func (s *server) AddProduct(ctx context.Context, in *pb.Product) (*pb.ProductID, error) {
         
   	out, err := uuid.NewV4() // To generate an item UID
   	if err != nil {
         
   		return nil, status.Errorf(codes.Internal, "Error while generating Product ID", err)
   	}
   	in.Id = out.String()
   	//  Initialize service , If the service is not initialized 
   	if s.productMap == nil {
         
   		s.productMap = make(map[string]*pb.Product)
   	}
   	s.productMap[in.Id] = in
   	return &pb.ProductID{
         Value: in.Id}, status.New(codes.OK, "").Err()
   }
   
   // GetProduct  Realization ecommerce.GetProduct Of GetProduct Method 
   func (s *server) GetProduct(ctx context.Context, in *pb.ProductID) (*pb.Product, error) {
         
   	value, exists := s.productMap[in.Value]
   	if exists {
         
   		return value, status.New(codes.OK, "").Err()
   	}
   	return nil, status.Errorf(codes.NotFound, "Product does not exits")
   }
   

   ---

   b. Server main function

   // main.go
   package main
   
   import (
   	"google.golang.org/grpc"
   	"log"
   	"net"
   	pb "productinfo/service/ecommerce"
   )
   
   const (
   	port = ":50051"
   )
   
   func main() {
         
   	lis, err := net.Listen("tcp", port) // stay 50051 Create on port gRPC service 
   	if err != nil {
         
   		log.Fatalf("failed to listen:%v", err)
   	}
   	s := grpc.NewServer()                      // Create a new gRPC example 
   	pb.RegisterProductInfoServer(s, &server{
         }) // Register the generated service to the new gRPC On 
   	log.Printf("Starting gRPC listener on port:%s", port)
   	//  Start listening for incoming messages on the specified port 
   	if err := s.Serve(lis); err != nil {
         
   		log.Fatalf("failed to serve %v", err)
   	}
   }
   

6. Development client
   Client directory structure

   

   a. Client main function

   //main.go
   package main
   
   import (
   	"context"
   	"google.golang.org/grpc"
   	"google.golang.org/grpc/credentials/insecure"
   	"log"
   	pb "productinfo/client/ecommerce"
   	"time"
   )
   
   const (
   	address = "localhost:50051"
   )
   
   func main() {
         
   	conn, err := grpc.Dial(address, grpc.WithTransportCredentials(insecure.NewCredentials())) // Establish a link between the client and the server 
   	if err != nil {
         
   		log.Fatalf("did not connect %v", err)
   	}
   	defer conn.Close()
   	c := pb.NewProductInfoClient(conn) // Pass the connection and create a stub file . This instance contains all the remote methods that can call the server 
   	name := "MacBook Pro 2021"
   	description := `Ultimate performance （ Ultimate performance ）`
   	price := float32(14000.0)
   	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
   	defer cancel()
   	//  The remote invocation AddProduct Method 
   	r, err := c.AddProduct(ctx, &pb.Product{
         Name: name, Description: description, Price: price})
   	if err != nil {
         
   		log.Fatalf("Could not add Product:%v", err)
   	}
   	log.Printf("Product ID:%s added successfully", r.Value)
   	//  The remote invocation GetProduct Method 
   	product, err := c.GetProduct(ctx, &pb.ProductID{
         Value: r.Value})
   	if err != nil {
         
   		log.Fatalf("Could not get Product:%v", err)
   	}
   	log.Printf("Product: %v ", product.String())
   }
   

Running results

---

Server side

---

client