Protobuf в Go и новый Opaque API

var req logpb.LogEntry
flag.StringVar(&req.BackendServer, "backend", os.Getenv("HOST"), "...")
flag.Parse() // заполняет поле BackendServer из флага -backend

// Вместо прямого доступа к полям
logEntry.SetIPAddress(req.GetIPAddress())
// Вместо логической ошибки сравнения указателей
if logEntry.GetDeviceType() == logpb.LogEntry_DESKTOP { 
    // корректное сравнение
}

edition = "2023";  // преемник proto2 и proto3
 
package log;
 
message LogEntry {
  string backend_server = 1;
  uint32 request_size = 2;
  string ip_address = 3;
}

package logpb
 
type LogEntry struct {
    BackendServer *string
    RequestSize   *uint32
    IPAddress     *string
    // ...внутренние поля опущены...
}
 
func (l *LogEntry) GetBackendServer() string { ... }
func (l *LogEntry) GetRequestSize() uint32   { ... }
func (l *LogEntry) GetIPAddress() string     { ... }

package logpb
 
type LogEntry struct {
    xxx_hidden_BackendServer *string // больше не экспортируется
    xxx_hidden_RequestSize   uint32  // больше не экспортируется
    xxx_hidden_IPAddress     *string // больше не экспортируется
    // ...внутренние поля опущены...
}
 
func (l *LogEntry) GetBackendServer() string { ... }
func (l *LogEntry) HasBackendServer() bool   { ... }
func (l *LogEntry) SetBackendServer(string)  { ... }
func (l *LogEntry) ClearBackendServer()      { ... }
// ...и так далее для каждого поля...

// Ошибка при использовании Open Struct API
if msg.DeviceType == logpb.LogEntry_DESKTOP.Enum() { 
    // Это сравнивает адреса указателей, а не значения!
    // Поскольку Enum() каждый раз создает новый указатель, условие всегда ложно.
}
 
// Корректно в любом API
if msg.GetDeviceType() == logpb.LogEntry_DESKTOP {
    // Сравнение значений, аксессор раскрывает указатель
}

// С Open Struct API
log.IPAddress = req.IPAddress // копируется только указатель, обе структуры указывают на одну строку
 
// С Opaque API
log.SetIPAddress(req.GetIPAddress()) // копируется значение, а не указатель

         │ Open Struct API │             Opaque API             │
         │    allocs/op    │  allocs/op   vs base               │
Prod#1          360.3k ± 0%       360.3k ± 0%  +0.00% (p=0.002 n=6)
Search#1       1413.7k ± 0%       762.3k ± 0%  -46.08% (p=0.002 n=6)
Search#2        314.8k ± 0%       132.4k ± 0%  -57.95% (p=0.002 n=6)

         │ Open Struct API │             Opaque API            │
         │   user-sec/op   │ user-sec/op  vs base              │
Prod#1         55.55m ± 6%        55.28m ± 4%  ~ (p=0.180 n=6)
Search#1       324.3m ± 22%       292.0m ± 6%  -9.97% (p=0.015 n=6)
Search#2       67.53m ± 10%       45.04m ± 8%  -33.29% (p=0.002 n=6)

type Message interface {
    ProtoMessage()
}

type Message interface {
    ProtoReflect() protoreflect.Message
    XXX_Method() // маркерный метод
}

func (m *LogEntry) GetBackendServer() string {
    if m.HasBackendServer() {
        return *m.xxx_hidden_BackendServer
    }
    return ""
}

func PrintFields(message proto.Message) {
    m := message.ProtoReflect()
    m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
        fmt.Printf("%s: %v\n", fd.Name(), v)
        return true
    })
}

// Потенциальная ошибка с Open Struct API
message1.Name = message2.Name // Копируется указатель!
*message1.Name = "New name"   // Изменяется значение и в message2

// Безопасно с Opaque API
message1.SetName(message2.GetName()) // Копируется значение, а не указатель

// Ошибка в Open Struct API
if msg.Status == proto.Status_OK.Enum() { // Сравниваются указатели, результат всегда false
  // Код не будет выполнен
}
 
// Правильно в Open Struct API
if msg.GetStatus() == proto.Status_OK { 
  // Корректное сравнение значений
}

if msg.HasName() {
  // Поле "name" явно установлено (возможно, пустой строкой)
  name := msg.GetName()
  // ...
} else {
  // Поле "name" не установлено
}

// Типобезопасная обработка поля с использованием protoreflect
m := msg.ProtoReflect()
if fd := m.Descriptor().Fields().ByName("device_type"); fd != nil {
  if m.Has(fd) {
    deviceType := m.Get(fd).Enum() // Безопасно получаем enum значение
    // ...
  }
}

msg.SetAge("30") // Ошибка компиляции: нельзя передать строку в метод, ожидающий int32

edition = "2023";
 
package notification;
 
message NotificationEvent {
  string user_id = 1;
  string message = 2;
  EventType event_type = 3;
  int64 timestamp = 4;
 
  enum EventType {
    UNKNOWN = 0;
    EMAIL = 1;
    SMS = 2;
    PUSH = 3;
  }
}

// Создание события
event := &notificationpb.NotificationEvent{
    UserId:    proto.String("user123"),
    Message:   proto.String("Привет, мир!"),
    EventType: notificationpb.NotificationEvent_EMAIL.Enum(),
    Timestamp: proto.Int64(time.Now().Unix()),
}
 
// Доступ к полям
userId := event.GetUserId()
if event.EventType != nil && *event.EventType == notificationpb.NotificationEvent_SMS {
    // Специальная обработка SMS
}
 
// Изменение полей
event.Message = proto.String("Изменённое сообщение")

// Создание события
event := &notificationpb.NotificationEvent{}
event.SetUserId("user123")
event.SetMessage("Привет, мир!")
event.SetEventType(notificationpb.NotificationEvent_EMAIL)
event.SetTimestamp(time.Now().Unix())
 
// Доступ к полям
userId := event.GetUserId()
if event.HasEventType() && event.GetEventType() == notificationpb.NotificationEvent_SMS {
    // Специальная обработка SMS
}
 
// Изменение полей
event.SetMessage("Изменённое сообщение")

// Гибридный API
type NotificationEvent struct {
    UserId    *string
    Message   *string
    EventType *NotificationEvent_EventType
    Timestamp *int64
    // ... скрытые поля ...
}
 
func (m *NotificationEvent) GetUserId() string { ... }
func (m *NotificationEvent) HasUserId() bool { ... }
func (m *NotificationEvent) SetUserId(string) { ... }
func (m *NotificationEvent) ClearUserId() { ... }
// ... и т.д. для других полей ...

//go:build protoopaque

message Order {
  string order_id = 1;
  Customer customer = 2;
  repeated Item items = 3;
  
  message Customer {
    string id = 1;
    string name = 2;
  }
  
  message Item {
    string item_id = 1;
    int32 quantity = 2;
    double price = 3;
  }
}

order := &orderpb.Order{}
order.SetOrderId("ORD-12345")
 
// Создание вложенного сообщения
customer := &orderpb.Order_Customer{}
customer.SetId("CUST-789")
customer.SetName("Иван Петров")
order.SetCustomer(customer)
 
// Работа с повторяющимся полем
item := &orderpb.Order_Item{}
item.SetItemId("ITEM-001")
item.SetQuantity(2)
item.SetPrice(15.99)
order.AddItems(item)

if order.HasCustomer() {
    customer := order.GetCustomer()
    if customer.HasName() {
        fmt.Printf("Заказ для: %s\n", customer.GetName())
    } else {
        fmt.Println("Клиент без имени")
    }
} else {
    fmt.Println("Неизвестный клиент")
}

message LargeMessage {
  string id = 1;
  bytes payload = 2;
  DetailedData details = 3 [lazy = true];
  
  message DetailedData {
    // много полей, которые редко используются
    repeated Metric metrics = 1;
    bytes raw_data = 2;
    // ...
  }
}

data := getMessageFromSomewhere()
msg := &mypb.LargeMessage{}
err := proto.Unmarshal(data, msg, protolazy.WithoutLazy())

data, err := proto.Marshal(order)
if err != nil {
    return fmt.Errorf("ошибка маршалинга заказа: %w", err)
}
 
// ...
 
newOrder := &orderpb.Order{}
if err := proto.Unmarshal(data, newOrder); err != nil {
    return fmt.Errorf("ошибка демаршалинга заказа: %w", err)
}

func processAnyMessage(msg proto.Message) {
    m := msg.ProtoReflect()
    
    // Получение имени типа сообщения
    msgName := string(m.Descriptor().Name())
    fmt.Printf("Обработка сообщения типа: %s\n", msgName)
    
    // Обход всех установленных полей
    m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
        fieldName := string(fd.Name())
        fmt.Printf("Поле: %s, Значение: %v\n", fieldName, v)
        return true  // продолжить обход
    })
}

edition = "2023";
 
package tracking;
 
service OrderTrackingService {
  rpc TrackOrder(TrackOrderRequest) returns (TrackOrderResponse);
  rpc BatchTrackOrders(BatchTrackOrdersRequest) returns (stream TrackOrderResponse);
  rpc SubscribeToUpdates(SubscriptionRequest) returns (stream OrderUpdate);
}
 
message TrackOrderRequest {
  string order_id = 1;
}
 
message TrackOrderResponse {
  string order_id = 1;
  OrderStatus status = 2;
  Location current_location = 3;
  int64 estimated_delivery_time = 4;
}
 
message BatchTrackOrdersRequest {
  repeated string order_ids = 1;
}
 
message SubscriptionRequest {
  repeated string order_ids = 1;
  bool include_location_updates = 2;
}
 
message OrderUpdate {
  string order_id = 1;
  OrderStatus status = 2;
  optional Location location = 3;
  int64 timestamp = 4;
}
 
enum OrderStatus {
  UNKNOWN = 0;
  PROCESSING = 1;
  SHIPPED = 2;
  IN_TRANSIT = 3;
  DELIVERED = 4;
}
 
message Location {
  string facility_id = 1;
  string facility_name = 2;
  string city = 3;
  string country = 4;
  double latitude = 5;
  double longitude = 6;
}

type trackingServer struct {
    // Реализация интерфейса trackingpb.OrderTrackingServiceServer
    trackingpb.UnimplementedOrderTrackingServiceServer
    
    orderDB OrderDatabase
}
 
func (s *trackingServer) TrackOrder(ctx context.Context, req *trackingpb.TrackOrderRequest) (*trackingpb.TrackOrderResponse, error) {
    orderID := req.GetOrderId()
    
    order, err := s.orderDB.GetOrder(ctx, orderID)
    if err != nil {
        return nil, status.Errorf(codes.NotFound, "order %s not found", orderID)
    }
    
    // Создание ответа напрямую через литерал структуры
    resp := &trackingpb.TrackOrderResponse{
        OrderId:              proto.String(order.ID),
        Status:               trackingpb.OrderStatus(order.Status).Enum(),
        EstimatedDeliveryTime: proto.Int64(order.EstimatedDelivery),
    }
    
    if order.CurrentFacility != nil {
        resp.CurrentLocation = &trackingpb.Location{
            FacilityId:   proto.String(order.CurrentFacility.ID),
            FacilityName: proto.String(order.CurrentFacility.Name),
            City:         proto.String(order.CurrentFacility.City),
            Country:      proto.String(order.CurrentFacility.Country),
        }
    }
    
    return resp, nil
}

func (s *trackingServer) TrackOrder(ctx context.Context, req *trackingpb.TrackOrderRequest) (*trackingpb.TrackOrderResponse, error) {
    orderID := req.GetOrderId()
    
    order, err := s.orderDB.GetOrder(ctx, orderID)
    if err != nil {
        return nil, status.Errorf(codes.NotFound, "order %s not found", orderID)
    }
    
    // Создание ответа через сеттеры
    resp := &trackingpb.TrackOrderResponse{}
    resp.SetOrderId(order.ID)
    resp.SetStatus(trackingpb.OrderStatus(order.Status))
    resp.SetEstimatedDeliveryTime(order.EstimatedDelivery)
    
    if order.CurrentFacility != nil {
        location := &trackingpb.Location{}
        location.SetFacilityId(order.CurrentFacility.ID)
        location.SetFacilityName(order.CurrentFacility.Name)
        location.SetCity(order.CurrentFacility.City)
        location.SetCountry(order.CurrentFacility.Country)
        resp.SetCurrentLocation(location)
    }
    
    return resp, nil
}

func (s *trackingServer) SubscribeToUpdates(req *trackingpb.SubscriptionRequest, stream trackingpb.OrderTrackingService_SubscribeToUpdatesServer) error {
    orderIDs := req.GetOrderIds()
    includeLocation := req.GetIncludeLocationUpdates()
    
    for updates := range s.orderDB.SubscribeToUpdates(stream.Context(), orderIDs) {
        for _, update := range updates {
            msg := &trackingpb.OrderUpdate{}
            msg.SetOrderId(update.OrderID)
            msg.SetStatus(trackingpb.OrderStatus(update.Status))
            msg.SetTimestamp(update.Timestamp)
            
            if includeLocation && update.Location != nil {
                loc := &trackingpb.Location{}
                loc.SetFacilityId(update.Location.ID)
                loc.SetFacilityName(update.Location.Name)
                loc.SetCity(update.Location.City)
                loc.SetCountry(update.Location.Country)
                
                if update.Location.Coordinates != nil {
                    loc.SetLatitude(update.Location.Coordinates.Latitude)
                    loc.SetLongitude(update.Location.Coordinates.Longitude)
                }
                
                msg.SetLocation(loc)
            }
            
            if err := stream.Send(msg); err != nil {
                return err
            }
        }
    }
    
    return nil
}

message ProcessOrderRequest {
  string order_id = 1;
  Customer customer = 2 [lazy = true]; // Большой объект, редко используемый полностью
  repeated OrderItem items = 3 [lazy = true]; // Может содержать сотни элементов
  PaymentInfo payment = 4;
}

// До миграции
transaction := &paymentpb.Transaction{
    TransactionId: proto.String(generateId()),
    Amount:        proto.Float64(amount),
    Currency:      proto.String(currency),
    Status:        paymentpb.TransactionStatus_PENDING.Enum(),
    Timestamp:     proto.Int64(time.Now().Unix()),
    Customer: &paymentpb.Customer{
        Id:    proto.String(customer.Id),
        Email: proto.String(customer.Email),
    },
}
 
// После миграции
transaction := &paymentpb.Transaction{}
transaction.SetTransactionId(generateId())
transaction.SetAmount(amount)
transaction.SetCurrency(currency)
transaction.SetStatus(paymentpb.TransactionStatus_PENDING)
transaction.SetTimestamp(time.Now().Unix())
 
customer := &paymentpb.Customer{}
customer.SetId(customer.Id)
customer.SetEmail(customer.Email)
transaction.SetCustomer(customer)

       │ Open Struct API │        Opaque API         │
       │    allocs/op    │ allocs/op   vs base       │
Prod#1        360.3k ± 0%    360.3k ± 0%    +0.00%
Search#1     1413.7k ± 0%    762.3k ± 0%    -46.08%
Search#2      314.8k ± 0%    132.4k ± 0%    -57.95%

       │ Open Struct API │        Opaque API        │
       │   user-sec/op   │ user-sec/op  vs base     │
Prod#1       55.55m ± 6%      55.28m ± 4%     ~
Search#1     324.3m ± 22%     292.0m ± 6%    -9.97%
Search#2     67.53m ± 10%     45.04m ± 8%    -33.29%

            │   nolazy    │            lazy            │
            │   sec/op    │   sec/op     vs base       │
Unmarshal/lazy-24   6.742µ ± 0%   2.816µ ± 0%  -58.23%
 
            │    nolazy    │            lazy             │
            │     B/op     │     B/op      vs base       │
Unmarshal/lazy-24   3.666Ki ± 0%   1.814Ki ± 0%  -50.51%
 
            │   nolazy    │           lazy            │
            │  allocs/op  │ allocs/op   vs base       │
Unmarshal/lazy-24   64.000 ± 0%   8.000 ± 0%  -87.50%

                    │ Open Struct API │       Opaque API          │
                    │ req/sec/core    │ req/sec/core   улучшение  │
Каталог товаров           4,230             4,870         +15.1%
Корзина покупателя        3,850             5,120         +33.0%
Обработка платежей        2,740             3,310         +20.8%

                    │ Open Struct API │       Opaque API       │
Число инстансов     │ запросов/сек    │ запросов/сек          │
       5                  8,450             10,230
      10                 16,340             20,115
      20                 30,780             39,850

message Transaction {
  string transaction_id = 1;
  double amount = 2;
  string currency = 3;
  // Часто используемые поля
  
  TransactionDetails details = 10 [lazy = true];
  // Редко используемые подробности
}
 
message TransactionDetails {
  // Множество редко используемых полей
  repeated string tags = 1;
  string note = 2;
  repeated Receipt receipts = 3;
  // ...
}

service DataProcessor {
  rpc ProcessLargeData(stream DataChunk) returns (ProcessingResult);
}
 
message DataChunk {
  bytes data = 1;
  int32 sequence_number = 2;
}

var messagePool = sync.Pool{
  New: func() interface{} {
      return &mypb.SomeMessage{}
  },
}
 
func processRequest() {
  msg := messagePool.Get().(*mypb.SomeMessage)
  defer func() {
      // Очистить сообщение перед возвратом в пул
      msg.Reset()
      messagePool.Put(msg)
  }()
  
  // Использовать сообщение
  // ...
}

type ColumnStorage struct {
  UserIds    []string
  Timestamps []int64
  Actions    []int32
  // ...
}

func processItems(items []*mypb.Item) {
  result := &mypb.ProcessedItems{}
  // Предварительная резервация ёмкости для слайса
  result.ReserveResults(len(items))
  
  for _, item := range items {
      // Обработка и добавление результатов
  }
  
  return result
}