golang中使用消息名称创建protobuf消息

func UnmarshalString(str string, pb proto.Message) error

package rpc;

message RPCMessage  {
    // 消息头部
    required Head head = 1;
    // 消息内容
    required Body body = 2;
};

message Head {
    // 请求 uuid
    required string session_no = 1;
    // 请求消息类型
    required int32 message_type = 2;
};

message Body {
    extensions 1000 to max;
};

message ResponseCode {
    required int32 retcode = 1;            // 返回码
    optional string error_messgae = 2;     // 返回失败时，错误信息
};

package rpc.account;

import "rpc.proto";

enum MessageType {
    CREATE_ACCOUNT_REQUEST = 1001;
    CREATE_ACCOUNT_RESPONSE = 1002;
    DELETE_ACCOUNT_REQUEST = 1003;
    DELETE_ACCOUNT_RESPONSE = 1004;
    // ...
};

extend rpc.Body {
    optional CreateAccountRequest create_account_request = 1001;
    optional CreateAccountResponse create_account_response = 1002;
    // ...
};

// account 相关操作接口
message CreateAccountRequest {
    required string email = 1;
    optional string name = 2;    // 不指定则为 email
    optional string passwd = 3;  // 初始密码为 email
};

message CreateAccountResponse {
    required ResponseCode rc = 1;
};
// ...

// CreateAccountRequest 结构体定义
type CreateAccountRequest struct {
	Email            *string `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
	Name             *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
	Passwd           *string `protobuf:"bytes,3,opt,name=passwd" json:"passwd,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

// proto.Message 接口指定的函数
func (m *CreateAccountRequest) Reset()                    { *m = CreateAccountRequest{} }
func (m *CreateAccountRequest) String() string            { return proto.CompactTextString(m) }
func (*CreateAccountRequest) ProtoMessage()               {}

// extension type 定义
var E_CreateAccountRequest = &proto.ExtensionDesc{
	ExtendedType:  (*rpc.Body)(nil),
	ExtensionType: (*CreateAccountRequest)(nil),
	Field:         1001,
	Name:          "rpc.account.create_account_request",
	Tag:           "bytes,1001,opt,name=create_account_request",
	Filename:      "account.proto",
}

// 注册定义结构到 proto
func init() {
	proto.RegisterType((*CreateAccountRequest)(nil), "rpc.account.CreateAccountRequest")
	proto.RegisterEnum("rpc.account.MessageType", MessageType_name, MessageType_value)
	proto.RegisterExtension(E_CreateAccountRequest)
}

// github.com/golang/protobuf/proto/properties.go 中
func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
	if _, ok := enumValueMaps[typeName]; ok {
		panic("proto: duplicate enum registered: " + typeName)
	}
	enumValueMaps[typeName] = valueMap
}

// EnumValueMap returns the mapping from names to integers of the
// enum type enumType, or a nil if not found.
func EnumValueMap(enumType string) map[string]int32 {
	return enumValueMaps[enumType]
}


func RegisterType(x Message, name string) {
	if _, ok := protoTypes[name]; ok {
		// TODO: Some day, make this a panic.
		log.Printf("proto: duplicate proto type registered: %s", name)
		return
	}
	t := reflect.TypeOf(x)
	protoTypes[name] = t
	revProtoTypes[t] = name
}

// MessageName returns the fully-qualified proto name for the given message type.
func MessageName(x Message) string {
	type xname interface {
		XXX_MessageName() string
	}
	if m, ok := x.(xname); ok {
		return m.XXX_MessageName()
	}
	return revProtoTypes[reflect.TypeOf(x)]
}

// MessageType returns the message type (pointer to struct) for a named message.
func MessageType(name string) reflect.Type { return protoTypes[name] }

//  github.com/golang/protobuf/proto/extensions.go 中
// RegisterExtension is called from the generated code.
func RegisterExtension(desc *ExtensionDesc) {
	st := reflect.TypeOf(desc.ExtendedType).Elem()
	m := extensionMaps[st]
	if m == nil {
		m = make(map[int32]*ExtensionDesc)
		extensionMaps[st] = m
	}
	if _, ok := m[desc.Field]; ok {
		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
	}
	m[desc.Field] = desc
}

// RegisteredExtensions returns a map of the registered extensions of a
// protocol buffer struct, indexed by the extension number.
// The argument pb should be a nil pointer to the struct type.
func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
	return extensionMaps[reflect.TypeOf(pb).Elem()]
}

// message id -> *proto.ExtensionDesc
// 记录 rpc.Body 的拓展消息
var RPCMessageBodyExtensions map[int32]*proto.ExtensionDesc

func init() {
	RPCMessageBodyExtensions = proto.RegisteredExtensions((*rpc.Body)(nil))
}

// some utils for UMessage

// msgName: rpc.account.create_account_request
func GetRPCMessageObjectByName(msgName string) (msg proto.Message, err error) {
	msgType := reflect.TypeOf(GetRPCMessageExtension(msgName).ExtensionType)
	if msgType == nil {
		err = fmt.Errorf("can‘t find message type")
		return
	}
	// msgType is pointer
	msg = reflect.Indirect(reflect.New(msgType.Elem())).Addr().Interface().(proto.Message)
	return
}

// msgName: rpc.account.create_account_request
// namePrefix: rpc.account
// name: create_account_request
func GetNamePrefix(msgName string) (prefix string) {
	items := strings.Split(msgName, ".")
	prefix = strings.Join(items[0:len(items)-1], ".")
	return
}

func GetName(msgName string) (name string) {
	items := strings.Split(msgName, ".")
	name = items[len(items)-1]
	return
}

func GetRPCMessageId(msgName string) (msgId int32) {
	msgTypeName := GetNamePrefix(msgName) + ".MessageType"
	mapMsgNameId := proto.EnumValueMap(msgTypeName)
	msgId = mapMsgNameId[strings.ToUpper(GetName(msgName))]
	return
}

func GetRPCMessageExtension(msgName string) (extension *proto.ExtensionDesc) {
	msgId := GetRPCMessageId(msgName)
	extension = RPCMessageBodyExtensions[msgId]
	return
}