1. 按照惯例，这里也从一个Hello项目开始，本项目定义了一个Hello Service，客户端发送包含字符串名字的请求，服务端返回Hello消息。
    3. 流程：
    5. 编写.proto描述文件
    6. 编译生成.pb.go文件
    7. 服务端实现约定的接口并提供服务
    8. 客户端按照约定调用.pb.go文件中的方法请求服务
    9. 项目结构：
    11. |—— hello/
    12.     |—— client/
    13.         |—— main.go   // 客户端
    14.     |—— server/
    15.         |—— main.go   // 服务端
    16. |—— proto/
    17.     |—— hello/
    18.         |—— hello.proto   // proto描述文件
    19.         |—— hello.pb.go   // proto编译后文件
    20. Step1：编写描述文件：hello.proto
    22. syntax = "proto3"; // 指定proto版本
    23. package hello;     // 指定默认包名
    25. // 指定golang包名
    26. option go_package = "hello";
    28. // 定义Hello服务
    29. service Hello {
    30.     // 定义SayHello方法
    31.     rpc SayHello(HelloRequest) returns (HelloResponse) {}
    32. }
    34. // HelloRequest 请求结构
    35. message HelloRequest {
    36.     string name = 1;
    37. }
    39. // HelloResponse 响应结构
    40. message HelloResponse {
    41.     string message = 1;
    42. }
    44. hello.proto文件中定义了一个Hello Service，该服务包含一个SayHello方法，同时声明了HelloRequest和HelloResponse消息结构用于请求和响应。客户端使用HelloRequest参数调用SayHello方法请求服务端，服务端响应HelloResponse消息。一个最简单的服务就定义好了。
    46. Step2：编译生成.pb.go文件
    48. $ cd proto/hello
    50. # 编译hello.proto
    51. $ protoc -I . --go_out=plugins=grpc:. ./hello.proto
    52. 在当前目录内生成的hello.pb.go文件，按照.proto文件中的说明，包含服务端接口HelloServer描述，客户端接口及实现HelloClient，及HelloRequest、HelloResponse结构体。
    54. 注意：不要手动编辑该文件
    56. Step3：实现服务端接口 server/main.go
    58. package main
    60. import (
    61.     "fmt"
    62.     "net"
    64.     pb "github.com/jergoo/go-grpc-example/proto/hello" // 引入编译生成的包
    65.     "golang.org/x/net/context"
    66.     "google.golang.org/grpc"
    67.     "google.golang.org/grpc/grpclog"
    68. )
    70. const (
    71.     // Address gRPC服务地址
    72.     Address = "127.0.0.1:50052"
    73. )
    75. // 定义helloService并实现约定的接口
    76. type helloService struct{}
    78. // HelloService Hello服务
    79. var HelloService = helloService{}
    81. // SayHello 实现Hello服务接口
    82. func (h helloService) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
    83.     resp := new(pb.HelloResponse)
    84.     resp.Message = fmt.Sprintf("Hello %s.", in.Name)
    86.     return resp, nil
    87. }
    89. func main() {
    90.     listen, err := net.Listen("tcp", Address)
    91.     if err != nil {
    92.         grpclog.Fatalf("Failed to listen: %v", err)
    93.     }
    95.     // 实例化grpc Server
    96.     s := grpc.NewServer()
    98.     // 注册HelloService
    99.     pb.RegisterHelloServer(s, HelloService)
    101.     grpclog.Println("Listen on " + Address)
    102.     s.Serve(listen)
    103. }
    104. 服务端引入编译后的proto包，定义一个空结构用于实现约定的接口，接口描述可以查看hello.pb.go文件中的HelloServer接口描述。实例化grpc Server并注册HelloService，开始提供服务。
    106. 运行：
    108. $ go run main.go
    109. Listen on 127.0.0.1:50052  //服务端已开启并监听50052端口
    110. Step4：实现客户端调用 client/main.go
    112. package main
    114. import (
    115.     pb "github.com/jergoo/go-grpc-example/proto/hello" // 引入proto包
    116.     "golang.org/x/net/context"
    117.     "google.golang.org/grpc"
    118.     "google.golang.org/grpc/grpclog"
    119. )
    121. const (
    122.     // Address gRPC服务地址
    123.     Address = "127.0.0.1:50052"
    124. )
    126. func main() {
    127.     // 连接
    128.     conn, err := grpc.Dial(Address, grpc.WithInsecure())
    129.     if err != nil {
    130.         grpclog.Fatalln(err)
    131.     }
    132.     defer conn.Close()
    134.     // 初始化客户端
    135.     c := pb.NewHelloClient(conn)
    137.     // 调用方法
    138.     req := &pb.HelloRequest{Name: "gRPC"}
    139.     res, err := c.SayHello(context.Background(), req)
    141.     if err != nil {
    142.         grpclog.Fatalln(err)
    143.     }
    145.     grpclog.Println(res.Message)
    146. }
    147. 客户端初始化连接后直接调用hello.pb.go中实现的SayHello方法，即可向服务端发起请求，使用姿势就像调用本地方法一样。
    149. 运行：
    151. $ go run main.go
    152. Hello gRPC.    // 接收到服务端响应
    153. 如果你收到了"Hello gRPC"的回复，恭喜你已经会使用github.com/jergoo/go-grpc-example/proto/hello了。
    155. 建议到这里仔细看一看hello.pb.go文件中的内容，对比hello.proto文件，理解protobuf中的定义转换为golang后的结构。