【源码阅读】 protobuf 中的 any 包

path: google/protobuf/any.proto
在 anypb 中 Any 包含两个字段
type_url 充当消息全局唯一标识符并解析为该消息的类型
value 任意序列化的消息（字节）

message Any {
	string type_url = 1;
	bytes value = 2;
}

package ptypes

import (
	"fmt"
	"strings"

	"github.com/golang/protobuf/proto"
	"google.golang.org/protobuf/reflect/protoreflect"
	"google.golang.org/protobuf/reflect/protoregistry"

	anypb "github.com/golang/protobuf/ptypes/any"
)

const urlPrefix = "type.googleapis.com/"

// AnyMessageName 方法，返回 anypb.Any 消息中包含的消息名称
func AnyMessageName(any *anypb.Any) (string, error) {
     
	name, err := anyMessageName(any)
	return string(name), err
}

// anyMessageName 方法，返回 anypb.Any 消息中包含的消息名称
// 如果获取的消息名称是无效在，则返回错误
func anyMessageName(any *anypb.Any) (protoreflect.FullName, error) {
     
	if any == nil {
     
		return "", fmt.Errorf("message is nil")
	}
	name := protoreflect.FullName(any.TypeUrl)
	if i := strings.LastIndex(any.TypeUrl, "/"); i >= 0 {
     
		name = name[i+len("/"):]
	}
	if !name.IsValid() {
     
		return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
	}
	return name, nil
}

// MarshalAny 方法，将消息 m 序列化到 any 中，用于消息传递。
// 即泛型的转换，与 UnmarshalAny 为一组序列化方法
func MarshalAny(m proto.Message) (*anypb.Any, error) {
     
	switch dm := m.(type) {
     
	case DynamicAny:
		m = dm.Message
	case *DynamicAny:
		if dm == nil {
     
			return nil, proto.ErrNil
		}
		m = dm.Message
	}
	b, err := proto.Marshal(m)
	if err != nil {
     
		return nil, err
	}
	return &anypb.Any{
     TypeUrl: urlPrefix + proto.MessageName(m), Value: b}, nil
}

// Empty 方法，用于判断 any 消息中的消息是否存在于全局注册表中
// 如果在全局注册表中找到相应的消息类型，则返回对应的消息类型
// 如果无法在全局注册表中找到相应的消息类型，则返回 `protoregistry.NotFound`
func Empty(any *anypb.Any) (proto.Message, error) {
     
	name, err := anyMessageName(any)
	if err != nil {
     
		return nil, err
	}
	mt, err := protoregistry.GlobalTypes.FindMessageByName(name)
	if err != nil {
     
		return nil, err
	}
	return proto.MessageV1(mt.New().Interface()), nil
}

// UnmarshalAny 方法，将消息 any 进行反序列化并判断是否匹配 m 消息。
// 即泛型的转换，与 MarshalAny 为一组序列化方法
// 如果 m 消息并不与 any 消息匹配，或者在反序列化时出现错误，将返回一个错误
// 
// 当消息 m 是一个无法解析的动态消息（*DynamicAny），同样也会返回一个错误 `protoregistry.NotFound`
func UnmarshalAny(any *anypb.Any, m proto.Message) error {
     
	if dm, ok := m.(*DynamicAny); ok {
     
		if dm.Message == nil {
     
			var err error
			dm.Message, err = Empty(any)
			if err != nil {
     
				return err
			}
		}
		m = dm.Message
	}

	anyName, err := AnyMessageName(any)
	if err != nil {
     
		return err
	}
	msgName := proto.MessageName(m)
	if anyName != msgName {
     
		return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName)
	}
	return proto.Unmarshal(any.Value, m)
}

// Is 方法，判断 any 消息是否包含指定类型 m 的消息（断言）
func Is(any *anypb.Any, m proto.Message) bool {
     
	if any == nil || m == nil {
     
		return false
	}
	name := proto.MessageName(m)
	if !strings.HasSuffix(any.TypeUrl, name) {
     
		return false
	}
	return len(any.TypeUrl) == len(name) || any.TypeUrl[len(any.TypeUrl)-len(name)-1] == '/'
}

// DynamicAny 方法，传递给 UnmarshalAny 一个 anypb.Any 中自动分配的任意指定类型消息的值
// 待分配的消息存储在嵌入的 proto.Message 中
//
// Example:
//   var x ptypes.DynamicAny
//   if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
//   fmt.Printf("unmarshaled message: %v", x.Message)
type DynamicAny struct{
      proto.Message }

func (m DynamicAny) String() string {
     
	if m.Message == nil {
     
		return ""
	}
	return m.Message.String()
}
func (m DynamicAny) Reset() {
     
	if m.Message == nil {
     
		return
	}
	m.Message.Reset()
}
func (m DynamicAny) ProtoMessage() {
     
	return
}
func (m DynamicAny) ProtoReflect() protoreflect.Message {
     
	if m.Message == nil {
     
		return nil
	}
	return dynamicAny{
     proto.MessageReflect(m.Message)}
}

type dynamicAny struct{
      protoreflect.Message }

func (m dynamicAny) Type() protoreflect.MessageType {
     
	return dynamicAnyType{
     m.Message.Type()}
}
func (m dynamicAny) New() protoreflect.Message {
     
	return dynamicAnyType{
     m.Message.Type()}.New()
}
func (m dynamicAny) Interface() protoreflect.ProtoMessage {
     
	return DynamicAny{
     proto.MessageV1(m.Message.Interface())}
}

type dynamicAnyType struct{
      protoreflect.MessageType }

func (t dynamicAnyType) New() protoreflect.Message {
     
	return dynamicAny{
     t.MessageType.New()}
}
func (t dynamicAnyType) Zero() protoreflect.Message {
     
	return dynamicAny{
     t.MessageType.Zero()}
}