微服务_GRPC环境的搭建及远程调用

三.GRPC

gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。

RPC

RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。

gRPC默认使用protoBuf.

gRPC环境的搭建:

//TODO

运行demo进行测试:

• 启动服务端

$ cd $GOPATH/src/google.golang.org/grpc/examples/helloworld/greeter_server
$ go run main.go

• 启动客户端

$ cd $GOPATH/src/google.golang.org/grpc/examples/helloworld/greeter_client
$ go run main.go

客户端输出hello world 表示测试成功.

测试代码介绍:

服务端:

//go:generate protoc -I ../helloworld --go_out=plugins=grpc:../helloworld ../helloworld/helloworld.proto

package main

import (
	"log"
	"net"
	"golang.org/x/net/context"
	"google.golang.org/grpc"
	pb "google.golang.org/grpc/examples/helloworld/helloworld"
	"google.golang.org/grpc/reflection"
)

const (
	port = ":50051"
)

// server is used to implement helloworld.GreeterServer.
type server struct{}

// SayHello implements helloworld.GreeterServer
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
	lis, err := net.Listen("tcp", port)
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterGreeterServer(s, &server{})
	// Register reflection service on gRPC server.
	reflection.Register(s)
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

客户端:

package main

import (
	"log"
	"os"
	"golang.org/x/net/context"
	"google.golang.org/grpc"
	pb "google.golang.org/grpc/examples/helloworld/helloworld"
)

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

func main() {
	// Set up a connection to the server.
	conn, err := grpc.Dial(address, grpc.WithInsecure())
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	c := pb.NewGreeterClient(conn)

	// Contact the server and print out its response.
	name := defaultName
	if len(os.Args) > 1 {
		name = os.Args[1]
	}
	r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", r.Message)
}

gRPC的远程调用

定义服务service

service SearchService {
	//rpc 服务的函数名 （传入参数）返回（返回参数）
  rpc Search (SearchRequest) returns (SearchResponse);
}

• 创建一个my_hello文件夹
• 添加一个hello.proto文件

syntax = "proto3";

package my_hello;

service Helloserver {
//创建接口
    rpc Getadd(Hellorequest) returns(Helloresponse) {}
}

//传入
message Hellorequest {
    int64 num = 1 ;
}

//传出
message Helloresponse {
    int64 size = 1 ;
}

• 编译hello.proto文件

$ protoc --go_out=./ *.proto #不加grpc插件
$ protoc --go_out=plugins=grpc:./ *.proto #添加grpc插件 (这里使用这个)

得到 hello.pb.go文件

• 在my_hello同级目录创建一个srv文件夹
• 添加srv.go文件

package main

import (
	"context"
	pb "../my_hello"  //pb是给my_hello包一个别名
	"net"
	"fmt"
	"google.golang.org/grpc"  //注意包的名称
)

//1.结构体
type Server struct {
}

//2.结构体的方法实现
func (this *Server) Getadd(ctx context.Context, in *pb.Hellorequest) (*pb.Helloresponse, error) {

	return &pb.Helloresponse{Size:10000 + in.Num}, nil

}

func main() {
	//3.创建网络连接
	ln, err := net.Listen("tcp", "127.0.0.1:12345")
	if err != nil {
		fmt.Println("网络创建失败",err)
		return
	}
	defer ln.Close()

	//4.创建grpc，得到一个grpc的句柄
	srv := grpc.NewServer()

	//5.将grpc与结构体进行注册
	pb.RegisterHelloserverServer(srv, &Server{})

	//6.监听网络连接
	err = srv.Serve(ln)
	if err != nil {
		fmt.Println("网络监听失败",err)
	}
}

• 在my_hello同级目录创建一个cli文件夹
• 添加cli.go文件

package main

import (
	pb "../my_hello"
	"google.golang.org/grpc"
	"fmt"
	"context"
)

func main() {

	//1.连接服务
	conn, err := grpc.Dial("127.0.0.1:12345",grpc.WithInsecure())
	if err != nil {
		fmt.Println("连接服务器失败",err)
		return
	}
	defer conn.Close()

	//2.创建句柄
	cli := pb.NewHelloserverClient(conn)

	//3.远程调用函数
	out, err := cli.Getadd(context.Background(), &pb.Hellorequest{Num:318}) //给定一个数值
	if err != nil {
		fmt.Println("远程调用失败",err)
		return
	}
	fmt.Println("结果为：",out)
}

先运行srv.go,在运行cli.go

在客户端得到输出结果为:

结果为： size:10318 

表明服务端与客户端数据相通.