GolangとProtobuf

#   protobuf     
$ protoc --version
libprotoc 3.11.0
#        
$ protoc --help
.
.
.
 --cpp_out=OUT_DIR           Generate C++ header and source.
  --csharp_out=OUT_DIR        Generate C# source file.
  --java_out=OUT_DIR          Generate Java source file.
  --js_out=OUT_DIR            Generate JavaScript source.
  --objc_out=OUT_DIR          Generate Objective C header and source.
  --php_out=OUT_DIR           Generate PHP source file.
  --python_out=OUT_DIR        Generate Python source file.
  --ruby_out=OUT_DIR          Generate Ruby source file.
  @<filename>                 Read options and filenames from file. If a
                              relative file path is specified, the file
                              will be searched in the working directory.
                              The --proto_path option will not affect how
                              this argument file is searched. Content of
                              the file will be expanded in the position of
                              @<filename> as in the argument list. Note
                              that shell expansion is not applied to the
                              content of the file (i.e., you cannot use
                              quotes, wildcards, escapes, commands, etc.).
                              Each line corresponds to a single argument,
                              even if it contains spaces.

go get github.com/golang/protobuf/protoc-gen-go 

$GOPATH/src/github.com/golang/protobuf

syntax = "proto3"; //    protobuf3   
package example;

message Person {
    string name = 1;
    int32 age = 2;
    enum Gender {
        MALE = 0;
        FEMALE = 1;
        UNKNOWN = 2;
    }
    message Other {
        string addr = 1;
        string hobby = 2;
        Gender g = 3;
    }
    Other info = 3;

}

 protoc --go_out=. example/demo2.proto

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

package example

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

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type Person_Gender int32

const (
	Person_MALE    Person_Gender = 0
	Person_FEMALE  Person_Gender = 1
	Person_UNKNOWN Person_Gender = 2
)

var Person_Gender_name = map[int32]string{
	0: "MALE",
	1: "FEMALE",
	2: "UNKNOWN",
}

var Person_Gender_value = map[string]int32{
	"MALE":    0,
	"FEMALE":  1,
	"UNKNOWN": 2,
}

func (x Person_Gender) String() string {
	return proto.EnumName(Person_Gender_name, int32(x))
}

func (Person_Gender) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_80e54830e2bc2dba, []int{0, 0}
}

type Person struct {
	Name                 string        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Age                  int32         `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
	Info                 *Person_Other `protobuf:"bytes,3,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

func (m *Person) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Person.Unmarshal(m, b)
}
func (m *Person) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Person.Marshal(b, m, deterministic)
}
func (m *Person) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Person.Merge(m, src)
}
func (m *Person) XXX_Size() int {
	return xxx_messageInfo_Person.Size(m)
}
func (m *Person) XXX_DiscardUnknown() {
	xxx_messageInfo_Person.DiscardUnknown(m)
}

var xxx_messageInfo_Person proto.InternalMessageInfo

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

func (m *Person) GetAge() int32 {
	if m != nil {
		return m.Age
	}
	return 0
}

func (m *Person) GetInfo() *Person_Other {
	if m != nil {
		return m.Info
	}
	return nil
}

type Person_Other struct {
	Addr                 string        `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Hobby                string        `protobuf:"bytes,2,opt,name=hobby,proto3" json:"hobby,omitempty"`
	G                    Person_Gender `protobuf:"varint,3,opt,name=g,proto3,enum=example.Person_Gender" json:"g,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

package main

import (
	"GoNote/chapter10/demo9/example"
	"fmt"
	"github.com/golang/protobuf/proto"
	"log"
)

func main() {
	//         Person   
	//   Person                 
	d1 := example.Person{
		Name: "tom",
		Age:  99,
		Info: &example.Person_Other{
			Addr:  "beijing",
			Hobby: "code",
			G:     example.Person_MALE,
		},
	}
	//        
	d1Encode, err := proto.Marshal(&d1)
	if err != nil {
		log.Fatal(err.Error())
	}
	fmt.Println(d1Encode)
	//         
	d1Decode := example.Person{}
	err = proto.Unmarshal(d1Encode, &d1Decode)
	if err != nil {
		log.Fatal(err.Error())
	}
	fmt.Println(d1Decode.GetName())
	fmt.Println(d1Decode.GetAge())
	fmt.Println(d1Decode.GetInfo().GetG())
}

[10 3 116 111 109 16 99 26 15 10 7 98 101 105 106 105 110 103 18 4 99 111 100 101]
tom
99
MALE

|
|___example
|______demo3.proto
|______demo3.pb.go
|___main
|______demo3_server.go
|______demo3_client.go

syntax = "proto3"; //    protobuf3   
package example;

message Demo3Request {
    int64 id = 1;
}
message Demo3Response {
    string name = 1;
    int32 age = 2;
    enum Gender {
        MALE = 0;
        FEMALE = 1;
        UNKNOWN = 2;
    }
    message Other {
        string addr = 1;
        string hobby = 2;
        Gender g = 3;
    }
    Other info = 3;
}

protoc --go_out=. demo3.proto

package main

import (
	"GoNote/chapter10/demo9/example"
	"github.com/pkg/errors"
	"log"
	"net/http"
	"net/rpc"
)

type Demo3Service struct {
}

func (d *Demo3Service) GetUser(request example.Demo3Request, response *example.Demo3Response) error {
	//     
	//           
	datas := map[int64]example.Demo3Response{
		1: {Name: "AAA", Age: 999, Info: &example.Demo3Response_Other{Addr: "beijing", Hobby: "sport", G: example.Demo3Response_MALE}},
		2: {Name: "BBB", Age: 888, Info: &example.Demo3Response_Other{Addr: "  ", Hobby: "sport", G: example.Demo3Response_FEMALE}},
		3: {Name: "CCC", Age: 777, Info: &example.Demo3Response_Other{Addr: "wuhan", Hobby: "sport", G: example.Demo3Response_UNKNOWN}},
		4: {Name: "DDD", Age: 666, Info: &example.Demo3Response_Other{Addr: "  ", Hobby: "sport", G: example.Demo3Response_MALE}},
		5: {Name: "EEE", Age: 555, Info: &example.Demo3Response_Other{Addr: "", Hobby: "sport", G: example.Demo3Response_FEMALE}},
	}
	//         
	if value, ok := datas[request.GetId()]; ok {
		*response = value
	} else {
		return errors.New("not found")
	}
	return nil
}
func main() {
	rpc.Register(new(Demo3Service))
	rpc.HandleHTTP()
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Println(err.Error())
	}
}

package main

import (
	"GoNote/chapter10/demo9/example"
	"fmt"
	"log"
	"net/rpc"
)

func main() {
	client, err := rpc.DialHTTP("tcp", ":8080")
	if err != nil {
		log.Fatal(err.Error())
	}
	request := example.Demo3Request{Id: 1}
	var response example.Demo3Response
	err = client.Call("Demo3Service.GetUser", request, &response)
	if err != nil {
		log.Fatal(err.Error())
	}
	fmt.Println(response.GetName())
	fmt.Println(response.GetInfo().GetAddr())
}

AAA
beijing