Go中使用訊息佇列實現微服務之間非同步資料處理

package main 

import ( 
 <font>"fmt" 
 "time"
 ) 

type Order struct { 
ID         int
 Product    string
 Quantity   int
 Timestamp time.Time 
} 

func  main () { 
 // 示例：建立訂單並將其傳送以進行處理<i>
order := Order{ 
  ID:         1 , 
  Product:    "Laptop" , 
  Quantity:   2 , 
  Timestamp: time.Now(), 
} 

processOrder(order) 
} 

func  processOrder (order Order) { 
 // 訂單處理將在此處進行，例如儲存到資料庫<i>
fmt.Printf ( “已處理訂單：%v\n”，訂單) 
}

package main 

import ( 
 <font>"encoding/json" 
 "fmt" 
 "log" 
 "time" 

 "github.com/nsqio/go-nsq"
 ) 

type Order struct { 
ID         int
 Product    string
 Quantity   int
 Timestamp time.Time 
} 

func  main () { 
 // 示例：建立訂單並將其傳送到佇列<i>
order := Order{ 
  ID:         1 , 
  Product:    "Laptop" , 
  Quantity:   2 , 
  Timestamp: time.Now(), 
} 

err := sendToQueue(order) 
 if err != nil { 
  log.Fatal(err) 
} 
} 

func  sendToQueue (order Order)  error { 
 // 將訂單序列化為 JSON<i>
 orderJSON, err := json.Marshal(order) 
 if err != nil { 
  return err 
} 

 // 連線到 NSQ 並將訂單傳送到佇列<i>
config := nsq.NewConfig() 
Producer, err := nsq.NewProducer( "localhost:4150" , config) 
 if err != nil { 
  return err 
} 
 defer Producer.Stop() 

err = Producer.Publish( "order_topic" , orderJSON) 
 if err != nil { 
  return err 
} 

fmt.Println( "訂單傳送到佇列：" , order) 

 return  nil
 }

<font>// 微服務中的訂單處理示例<i>
func  processOrder (order Order) { 
    // 非同步訂單處理<i>
    err := sendToQueue(order) 
    if err != nil { 
        log.Println( "Failed to send order to the queue:" , err) 
    } 

    // 即時確認訂單收據<i>
    fmt.Println( "訂單已收到：" , order) 
}

err := nsq.NewConsumer( <font>"order_topic" , "order_channel" , config) 
    if err != nil { 
        log.Fatal(err ) 
    } 

    // 為佇列中的訂單設定一個處理程式<i>
    Consumer.AddHandler(nsq.HandlerFunc( func (message *nsq.Message)  error { 
        var order Order 
        err := json.Unmarshal(message.Body, &order) 
        if err ! = nil { 
            log.Println( "無法解組訂單：" , err) 
            return err 
        } 

        // 執行必要的訂單處理操作<i>
        fmt.Println( "處理佇列中的訂單：" , order) 

        return  nil
     })) 

    // 開始the handler<i>
     err = Consumer.ConnectToNSQD( "localhost:4150" ) 
    if err != nil { 
        log.Fatal(err) 
    } 

    // 無限迴圈處理來自佇列的訊息<i>
    <- make ( chan  struct {}) 
}

<font>// Example: Logging errors during order publishing to the queue<i>
func sendToQueue(order Order) error {
    // ...<i>
    err := producer.Publish("order_topic", orderJSON)
    if err != nil {
        log.Println("Failed to publish order to the queue:", err)
        return err
    }
    // ...<i>
    return nil
}

<font>// 示例：出現錯誤時重試訂單提交<i>
func  retrySendToQueue (order Order)  error { 
    attempts := 3 
    for i := 1 ; 我<=嘗試；i++ { 
        err := sendToQueue(order) 
        if err == nil { 
            return  nil
         } 

        log.Printf( "重試 %d 失敗。在下一次嘗試之前等待...\n" , i) 
        time.Sleep(time.Second * 5 ) 
    } 

    log.Println( "所有重試嘗試均失敗。無法將訂單傳送到佇列。" ) 
    return fmt.Errorf( "在 %d 次嘗試後無法傳送訂單" , attempts) 
}

<font>// 示例：處理無效訂單<i>
func  processOrder (order Order) { 
    if isValidOrder(order) { 
        err := sendToQueue(order) 
        if err != nil { 
            log.Println( "無法將有效訂單傳送到佇列:" , err) 
        } 
    } else { 
        log.Println( "收到無效訂單。忽略。" ) 
    } 
}

<font>// 示例：使用 pprof 進行程式碼分析<i>
import ( 
_ "net/http/pprof" 
 "net/http"
 ) 

func  main () { 
 go  func () { 
  log.Println(http.ListenAndServe( "localhost:6060" , nil ) ) 
}() 

 // 這裡是你的程式碼<i>
}

<font>// 示例：使用 Prometheus 在微服務中收集指標<i>
import ( 
 "github.com/prometheus/client_golang/prometheus" 
 "github.com/prometheus/client_golang/prometheus/promhttp"
 ) 

var ( 
ordersProcessed = prometheus.NewCounter(prometheus.CounterOpts{ 
  Name: "orders_processed_total" , 
  Help: "已處理訂單總數。" , 
}) 
) 

func  init () { 
prometheus.MustRegister(ordersProcessed) 
} 

// 示例：處理訂單時遞增計數器<i>
func  processOrder (order Order) { 
 // ...<i>
 ordersProcessed.Inc() 
 // ...<i>
 }

<font>// 示例：使用支援批次操作的庫進行佇列操作<i>
import  "github.com/nsqio/go-nsq" 

func  sendBatchToQueue (orders []Order)  error { 
    // 將訂單序列化為 JSON<i>
     orderJSON, err := json.Marshal (orders) 
    if err != nil { 
        return err 
    } 

    // 連線到 NSQ 並將訂單傳送到佇列<i>
    config := nsq.NewConfig() 
    Producer, err := nsq.NewProducer( "localhost:4150" , config) 
    if err != nil { 
        return err 
    } 
    defer Producer.Stop() 

    err = Producer.Publish( "order_topic" , OrdersJSON) 
    if err != nil { 
        return err 
    } 

    fmt.Println( "訂單傳送到佇列：" , orders) 

    return 無
}