golang gRPC使用

gRPC官方文档

gRPC官方文档，该文档详细地讲述了gRPC的相关概念和各个语言的使用方法：如C++、Java、go、python、Ruby等。
详细请见：http://grpc.mydoc.io/?t=58008

使用示例

定义protocol buffer，生成go代码

package helloworld;

option java_package = "com.example.pfmsg";
option java_outer_classname = "UserMessage";

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
 optional string name = 1;
}

// The response message containing the greetings
message HelloReply {
  optional string message = 1;
}

1. 安装go get -u github.com/golang/protobuf/{proto,protoc-gen-go}
2. 把$GOPATH/bin/添加到 PATH 环境变量中export PATH="$PATH:$GOPATH/bin”, 不然会报protoc-gen-go not find.
3. 执行：protoc –go_out=plugins=grpc:. *.proto；会生成helloworld.pb.go文件。如下所示：

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: helloworld.proto

/*
Package helloworld is a generated protocol buffer package.

It is generated from these files:
    helloworld.proto

It has these top-level messages:
    HelloRequest
    HelloReply
*/
package helloworld

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
    context "golang.org/x/net/context"
    grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// The request message containing the user's name.
type HelloRequest struct {
    Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
    XXX_unrecognized []byte  `json:"-"`
}

func (m *HelloRequest) Reset()                    { *m = HelloRequest{} }
func (m *HelloRequest) String() string            { return proto.CompactTextString(m) }
func (*HelloRequest) ProtoMessage()               {}
func (*HelloRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *HelloRequest) GetName() string {
    if m != nil && m.Name != nil {
        return *m.Name
    }
    return ""
}

// The response message containing the greetings
type HelloReply struct {
    Message          *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
    XXX_unrecognized []byte  `json:"-"`
}

func (m *HelloReply) Reset()                    { *m = HelloReply{} }
func (m *HelloReply) String() string            { return proto.CompactTextString(m) }
func (*HelloReply) ProtoMessage()               {}
func (*HelloReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *HelloReply) GetMessage() string {
    if m != nil && m.Message != nil {
        return *m.Message
    }
    return ""
}

func init() {
    proto.RegisterType((*HelloRequest)(nil), "helloworld.HelloRequest")
    proto.RegisterType((*HelloReply)(nil), "helloworld.HelloReply")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Greeter service

type GreeterClient interface {
    // Sends a greeting
    SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
}

type greeterClient struct {
    cc *grpc.ClientConn
}

func NewGreeterClient(cc *grpc.ClientConn) GreeterClient {
    return &greeterClient{cc}
}

func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
    out := new(HelloReply)
    err := grpc.Invoke(ctx, "/helloworld.Greeter/SayHello", in, out, c.cc, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}

// Server API for Greeter service

type GreeterServer interface {
    // Sends a greeting
    SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}

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

func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
    in := new(HelloRequest)
    if err := dec(in); err != nil {
        return nil, err
    }
    if interceptor == nil {
        return srv.(GreeterServer).SayHello(ctx, in)
    }
    info := &grpc.UnaryServerInfo{
        Server:     srv,
        FullMethod: "/helloworld.Greeter/SayHello",
    }
    handler := func(ctx context.Context, req interface{}) (interface{}, error) {
        return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
    }
    return interceptor(ctx, in, info, handler)
}

var _Greeter_serviceDesc = grpc.ServiceDesc{
    ServiceName: "helloworld.Greeter",
    HandlerType: (*GreeterServer)(nil),
    Methods: []grpc.MethodDesc{
        {
            MethodName: "SayHello",
            Handler:    _Greeter_SayHello_Handler,
        },
    },
    Streams:  []grpc.StreamDesc{},
    Metadata: "helloworld.proto",
}

func init() { proto.RegisterFile("helloworld.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
    // 161 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xc8, 0x48, 0xcd, 0xc9,
    0xc9, 0x2f, 0xcf, 0x2f, 0xca, 0x49, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x42, 0x88,
    0x28, 0xc9, 0x70, 0xf1, 0x78, 0x80, 0x78, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x42, 0x3c,
    0x5c, 0x2c, 0x79, 0x89, 0xb9, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x4a, 0xb2, 0x5c, 0x5c,
    0x50, 0xd9, 0x82, 0x9c, 0x4a, 0x21, 0x7e, 0x2e, 0xf6, 0xdc, 0xd4, 0xe2, 0xe2, 0xc4, 0x74, 0xa8,
    0xb4, 0x91, 0x27, 0x17, 0xbb, 0x7b, 0x51, 0x6a, 0x6a, 0x49, 0x6a, 0x91, 0x90, 0x1d, 0x17, 0x47,
    0x70, 0x62, 0x25, 0x58, 0xb1, 0x90, 0x84, 0x1e, 0x92, 0x95, 0xc8, 0xa6, 0x4b, 0x89, 0x61, 0x91,
    0x29, 0xc8, 0xa9, 0x54, 0x62, 0x70, 0x52, 0xe0, 0x12, 0x4c, 0xce, 0xcf, 0xd5, 0x4b, 0xad, 0x48,
    0xcc, 0x2d, 0xc8, 0x49, 0xd5, 0x2b, 0x48, 0xcb, 0x2d, 0x4e, 0x77, 0xe2, 0x0e, 0x2d, 0x4e, 0x2d,
    0xf2, 0x85, 0x58, 0x09, 0x08, 0x00, 0x00, 0xff, 0xff, 0xd9, 0x0b, 0xe7, 0x4e, 0xc8, 0x00, 0x00,
    0x00,
}

Client.go代码

package main

import (
    pb "github.com/hyperledger/fabric/guods_test/grpc_test/helloworld"
    "golang.org/x/net/context"
    "google.golang.org/grpc"
    "log"
    "os"
)

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("####### get server Greeting response: %s", *r.Message)
}

server.go 代码

package main

import (
    "fmt"
    pb "github.com/hyperledger/fabric/guods_test/grpc_test/helloworld"
    "golang.org/x/net/context"
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
    "log"
    "net"
)

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) {
    fmt.Println("######### get client request name :" + *in.Name)
    var reply = "hello" + *in.Name
    return &pb.HelloReply{Message: &reply}, 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)
    }
}

运行

分别执行server,client,结果如下：

目录结构：
root@gprc_test$ tree
.
├── client
├── client.go
├── helloworld
│   └── helloworld.pb.go
├── helloworld.proto
├── server
└── server.go

root@grpc_test$ ./server
######### get client request name :world

root@gprc_test$ ./client
2017/11/28 19:27:38 ####### get server Greeting response: helloworld