RocketMQ 5.0 gRPC 协议 Go SDK 使用

已于 2023-09-06 19:14:41 修改
阅读量1.4k 收藏 3
点赞数
分类专栏： RocketMQ 文章标签： rocketmq golang 开发语言
于 2023-08-30 14:57:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsjzzcbq/article/details/132536158
版权

RocketMQ5.0 gRPC 协议go客户端使用，gRPC SDK 仅支持版本大于等于5.0的服务端

gRPC SDK和原来的 Remoting SDK的关系，看下面官网截图

目前gRPC 协议客户端还没有完善，go 只有 SimpleConsumer

目录

1、安装RocketMQ5.0

2、 Go SDK 使用

2.1、普通消息

2.2、顺序消息

2.3、延时消息

2.4、事物消息

1、安装RocketMQ5.0

安装过程可以看笔者的《linux 安装 RocketMQ》，这篇文章中使用的是RocketMQ 4.9.4版本，换成5的版本安装依然是可以的，文章地址：https://blog.csdn.net/wsjzzcbq/article/details/125562966

区别是启动方式改变了，增加了 proxy 的启动，下面是启动方式

进入bin目录

先启动 nameserver

nohup sh mqnamesrv &

然后启动 broker

nohup sh mqbroker -n localhost:9876 --enable-proxy &

这里 gRPC 默认的端口是8081，如果想使用其他端口，需要修改conf目录下的 rmq-proxy.json 配置文件，如将 gRPC端口修改为 8086，需要在rmq-proxy.json文件中添加 grpcServerPort": 8086

grpcServerPort": 8086

如下面截图

rmq-proxy.json 文件

添加端口配置

配置完成后，需要在启动 broker的命令上添加配置文件路径 

nohup sh mqbroker -n localhost:9876 -pc /usr/local/rocketmq/rocketmq-all-5.0.0-bin-release/conf/rmq-proxy.json --enable-proxy &

这样启动后，gRPC端口为 8086

同时注意，如果想让客户端连接服务端，要开放防火墙端口

 firewall-cmd --zone=public --add-port=8081/tcp --permanent
 firewall-cmd --reload

查看防火墙端口

firewall-cmd --zone=public --list-ports

笔者使用默认的8081端口

2、 Go SDK 使用

Go版本要求 1.11+

安装 Go SDK

go get -u github.com/apache/rocketmq-clients/golang/v5

创建 topic

在 bin 目录下

笔者创建的 topic 名称为 demo_topic

sh ./mqadmin updatetopic -n localhost:9876 -c DefaultCluster -t demo_topic

查看 topic

sh ./mqadmin topicList -n localhost:9876

创建消费者组

在bin目录下

笔者创建名称为 demo_group 的消费者组

sh ./mqadmin updateSubGroup -n localhost:9876 -c DefaultCluster -g demo_group

当然，创建 topic 和消费者组通过 RocketMQ Dashboard 更加方便

2.1、普通消息

消费者

package normal

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"time"
)

var (
	// maximum waiting time for receive func
	awaitDuration = time.Second * 5
	// maximum number of messages received at one time
	maxMessageNum int32 = 16
	// invisibleDuration should > 20s
	invisibleDuration = time.Second * 20
	// receive messages in a loop
)

func Consumer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many consumers, singleton pattern is more recommended.
	simpleConsumer, err := golang.NewSimpleConsumer(&golang.Config{
		Endpoint:      Endpoint,
		ConsumerGroup: ConsumerGroup,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithAwaitDuration(awaitDuration),
		golang.WithSubscriptionExpressions(map[string]*golang.FilterExpression{
			Topic: golang.SUB_ALL,
		}),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start simpleConsumer
	err = simpleConsumer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop simpleConsumer
	defer simpleConsumer.GracefulStop()

	go func() {
		for {
			fmt.Println("开始接受消息")
			mvs, err := simpleConsumer.Receive(context.TODO(), maxMessageNum, invisibleDuration)
			if err != nil {
				fmt.Println(err)
			}
			fmt.Println(len(mvs))
			// ack message
			for _, mv := range mvs {
				//消息内容
				fmt.Println(string(mv.GetBody()))
				simpleConsumer.Ack(context.TODO(), mv)
				fmt.Println(mv)
			}
			fmt.Println("wait a moment")
			fmt.Println()
			time.Sleep(time.Second * 3)
		}
	}()
	// run for a while
	time.Sleep(time.Minute)
}

生产者

同步发送消息

package normal

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"strconv"
	"time"
)

const (
	ConsumerGroup = "demo_group"
	Topic         = "demo_topic"
	Endpoint      = "192.168.5.14:8081"
	AccessKey     = "xxxxxx"
	SecretKey     = "xxxxxx"
)

func ProducerStart() {
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()

	// In most case, you don't need to create many producers, singleton pattern is more recommended.
	producer, err := golang.NewProducer(&golang.Config{
		Endpoint: Endpoint,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithTopics(Topic),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start producer
	err = producer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop producer
	defer producer.GracefulStop()

	for i := 0; i < 5; i++ {
		// new a message
		msg := &golang.Message{
			Topic: Topic,
			Body:  []byte("消息内容 窗外下着潇潇雨 : " + strconv.Itoa(i+10)),
		}
		// set keys and tag
		msg.SetKeys("a", "b")
		msg.SetTag("ab")
		// send message in sync
		resp, err := producer.Send(context.TODO(), msg)
		if err != nil {
			log.Fatal(err)
		}
		for i := 0; i < len(resp); i++ {
			fmt.Printf("%#v\n", resp[i])
		}
		// wait a moment
		time.Sleep(time.Second * 1)
	}
}

笔者消费者和生产者代码在同一包下，故 ConsumerGroup、Topic、Endpoint都放在了生产者常量里

下面分别创建生产者和消费者的测试代码

package normal

import "testing"

func TestProducerStart(t *testing.T) {
	ProducerStart()
}
package normal

import "testing"

func Test_consumer(t *testing.T) {
	Consumer()
}

工程结构看下图

先启动消费者建立topic和消费者组的绑定关系，再启动生产者发送消息

运行效果

异步发送消息

生成者

package normal

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"strconv"
	"time"
)

func AsyncProducer() {

	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many producers, singleton pattern is more recommended.
	producer, err := golang.NewProducer(&golang.Config{
		Endpoint: Endpoint,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithTopics(Topic),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start producer
	err = producer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop producer
	defer producer.GracefulStop()
	for i := 0; i < 5; i++ {
		// new a message
		msg := &golang.Message{
			Topic: Topic,
			Body:  []byte("花月两模糊,隔窗看欲无 : " + strconv.Itoa(i)),
		}
		// set keys and tag
		msg.SetKeys("a", "b")
		msg.SetTag("ab")
		//异步发送消息
		producer.SendAsync(context.TODO(), msg, func(ctx context.Context, resp []*golang.SendReceipt, err error) {
			if err != nil {
				log.Fatal(err)
			}
			for i := 0; i < len(resp); i++ {
				fmt.Println("回调")
				fmt.Printf("%#v\n", resp[i])
			}
		})
		// wait a moment
		time.Sleep(time.Second * 1)
	}

	time.Sleep(time.Minute * 1)
}

 测试代码

package normal

import "testing"

func TestAsyncProducer(t *testing.T) {
	AsyncProducer()
}

测试

2.2、顺序消息

Apache RocketMQ 顺序消息的顺序关系通过消息组（MessageGroup）判定和识别，发送顺序消息时需要为每条消息设置归属的消息组，相同消息组的多条消息之间遵循先进先出的顺序关系，不同消息组、无消息组的消息之间不涉及顺序性

顺序消息仅支持使用MessageType为FIFO的主题，即顺序消息只能发送至类型为顺序消息的主题中，发送的消息的类型必须和主题的类型一致

创建顺序消息的 topic

./mqadmin updateTopic -c DefaultCluster -t FIFO_Demo_Topic -o true -n localhost:9876 -a +message.type=FIFO

创建新的消费者组

sh ./mqadmin updateSubGroup -n localhost:9876 -c DefaultCluster -g fifo_demo_group

生产者

package fifo

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"strconv"
	"time"
)

const (
	ConsumerGroup = "fifo_demo_group"
	Topic         = "FIFO_Demo_Topic"
	Endpoint      = "192.168.5.14:8081"
	AccessKey     = "xxxxxx"
	SecretKey     = "xxxxxx"
)

func FifoProducer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many producers, singleton pattern is more recommended.
	producer, err := golang.NewProducer(&golang.Config{
		Endpoint: Endpoint,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithTopics(Topic),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start producer
	err = producer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop producer
	defer producer.GracefulStop()
	for i := 0; i < 5; i++ {
		// new a message
		msg := &golang.Message{
			Topic: Topic,
			Body:  []byte("长相思，长相思。若问相思甚了期，除非相见时: " + strconv.Itoa(i)),
		}
		// set keys and tag
		msg.SetKeys("a", "b")
		msg.SetTag("ab")
		msg.SetMessageGroup("fifo")
		// send message in sync
		resp, err := producer.Send(context.TODO(), msg)
		if err != nil {
			log.Fatal(err)
		}
		for i := 0; i < len(resp); i++ {
			fmt.Printf("%#v\n", resp[i])
		}
		// wait a moment
		time.Sleep(time.Second * 1)
	}
}

消费者

package fifo

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"time"
)

var (
	// maximum waiting time for receive func
	awaitDuration = time.Second * 5
	// maximum number of messages received at one time
	maxMessageNum int32 = 16
	// invisibleDuration should > 20s
	invisibleDuration = time.Second * 20
	// receive messages in a loop
)

func Consumer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many consumers, singleton pattern is more recommended
	simpleConsumer, err := golang.NewSimpleConsumer(&golang.Config{
		Endpoint:      Endpoint,
		ConsumerGroup: ConsumerGroup,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithAwaitDuration(awaitDuration),
		golang.WithSubscriptionExpressions(map[string]*golang.FilterExpression{
			Topic: golang.SUB_ALL,
		}),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start simpleConsumer
	err = simpleConsumer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop simpleConsumer
	defer simpleConsumer.GracefulStop()

	go func() {
		for {
			fmt.Println("开始接受消息")
			mvs, err := simpleConsumer.Receive(context.TODO(), maxMessageNum, invisibleDuration)
			if err != nil {
				fmt.Println(err)
			}
			fmt.Println(len(mvs))
			// ack message
			for _, mv := range mvs {
				//消息内容
				fmt.Println(string(mv.GetBody()))
				simpleConsumer.Ack(context.TODO(), mv)
				fmt.Println(mv)
			}
			fmt.Println("wait a moment")
			fmt.Println()
			time.Sleep(time.Second * 3)
		}
	}()
	// run for a while
	time.Sleep(time.Minute)
}

测试代码

package fifo

import "testing"

func TestFifoProducer(t *testing.T) {
	FifoProducer()
}

package fifo

import "testing"

func TestConsumer(t *testing.T) {
	Consumer()
}

运行效果

2.3、延时消息

定时消息仅支持在 MessageType为Delay 的主题内使用，即定时消息只能发送至类型为定时消息的主题中，发送的消息的类型必须和主题的类型一致

创建延迟topic

./mqadmin updateTopic -c DefaultCluster -t Delay_Demo_Topic -n localhost:9876 -a +message.type=DELAY

查看topic

sh ./mqadmin topicList -n localhost:9876

创建新的消费者组

sh ./mqadmin updateSubGroup -n localhost:9876 -c DefaultCluster -g delay_demo_group

生产者

package delay

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"strconv"
	"time"
)

const (
	ConsumerGroup = "delay_demo_group"
	Topic         = "Delay_Demo_Topic"
	Endpoint      = "192.168.5.14:8081"
	AccessKey     = "xxxxxx"
	SecretKey     = "xxxxxx"
)

func DelayProducer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many producers, singleton pattern is more recommended.
	producer, err := golang.NewProducer(&golang.Config{
		Endpoint: Endpoint,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithTopics(Topic),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start producer
	err = producer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop producer
	defer producer.GracefulStop()
	for i := 0; i < 1; i++ {
		// new a message
		msg := &golang.Message{
			Topic: Topic,
			Body:  []byte("长相思，长相思。欲把相思说似谁，浅情人不知 : " + strconv.Itoa(i)),
		}
		// set keys and tag
		msg.SetKeys("a", "b")
		msg.SetTag("ab")
		// 设置延时时间 5 秒钟
		msg.SetDelayTimestamp(time.Now().Add(time.Second * 10))
		// send message in sync
		resp, err := producer.Send(context.TODO(), msg)
		log.Println("延时消息发送完成")
		if err != nil {
			log.Fatal(err)
		}
		for i := 0; i < len(resp); i++ {
			fmt.Printf("%#v\n", resp[i])
		}
		// wait a moment
		time.Sleep(time.Second * 1)
	}
}

消费者

package delay

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"time"
)

var (
	// maximum waiting time for receive func
	awaitDuration = time.Second * 1
	// maximum number of messages received at one time
	maxMessageNum int32 = 16
	// invisibleDuration should > 20s
	invisibleDuration = time.Second * 10
	// receive messages in a loop
)

func Consumer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many consumers, singleton pattern is more recommended
	simpleConsumer, err := golang.NewSimpleConsumer(&golang.Config{
		Endpoint:      Endpoint,
		ConsumerGroup: ConsumerGroup,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithAwaitDuration(awaitDuration),
		golang.WithSubscriptionExpressions(map[string]*golang.FilterExpression{
			Topic: golang.SUB_ALL,
		}),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start simpleConsumer
	err = simpleConsumer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop simpleConsumer
	defer simpleConsumer.GracefulStop()

	go func() {
		for {
			mvs, err := simpleConsumer.Receive(context.TODO(), maxMessageNum, invisibleDuration)
			if err != nil {
				fmt.Println(err)
			}
			// ack message
			for _, mv := range mvs {
				//消息内容
				log.Println(string(mv.GetBody()))
				simpleConsumer.Ack(context.TODO(), mv)
			}
			//fmt.Println("wait a moment")
			//fmt.Println()
			//time.Sleep(time.Second * 3)
		}
	}()
	// run for a while
	time.Sleep(time.Minute)
}

测试代码

package delay

import "testing"

func TestDelayProducer(t *testing.T) {
	DelayProducer()
}

package delay

import "testing"

func TestConsumer(t *testing.T) {
	Consumer()
}

测试

因为SimpleConsumer有20秒的 invisibleDuration，因此打印出的延时时间是30秒

2.4、事物消息

创建事物topic

./mqadmin updatetopic -n localhost:9876 -t Transaction_Demo_Topic -c DefaultCluster -a +message.type=TRANSACTION

查看topic

sh ./mqadmin topicList -n localhost:9876

创建消费者组

sh ./mqadmin updateSubGroup -n localhost:9876 -c DefaultCluster -g transaction_demo_group

生产者

3、事物消息

创建事物topic

./mqadmin updatetopic -n localhost:9876 -t Transaction_Demo_Topic -c DefaultCluster -a +message.type=TRANSACTION

查看topic

sh ./mqadmin topicList -n localhost:9876

创建新的消费者组

sh ./mqadmin updateSubGroup -n localhost:9876 -c DefaultCluster -g transaction_demo_group

生产者

事物相关内容已经写在代码里

package transaction

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"strconv"
	"time"
)

const (
	ConsumerGroup = "transaction_demo_group"
	Topic         = "Transaction_Demo_Topic"
	Endpoint      = "192.168.5.14:8081"
	AccessKey     = "xxxxxx"
	SecretKey     = "xxxxxx"
)

func TransactionProducer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many producers, singleton pattern is more recommended.
	producer, err := golang.NewProducer(&golang.Config{
		Endpoint: Endpoint,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithTransactionChecker(&golang.TransactionChecker{
			Check: func(msg *golang.MessageView) golang.TransactionResolution {
				fmt.Println("检查本地事物是否已经提交")
				log.Printf("check transaction message: %v", msg)
				return golang.COMMIT
			},
		}),
		golang.WithTopics(Topic),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start producer
	err = producer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop producer
	defer producer.GracefulStop()
	for i := 0; i < 1; i++ {
		// new a message
		msg := &golang.Message{
			Topic: Topic,
			Body:  []byte("相思只在，丁香枝上，豆蔻梢头 : " + strconv.Itoa(i)),
		}
		// set keys and tag
		msg.SetKeys("a", "b")
		msg.SetTag("ab")
		// send message in sync
		transaction := producer.BeginTransaction()
		resp, err := producer.SendWithTransaction(context.TODO(), msg, transaction)
		if err != nil {
			log.Fatal(err)
		}
		for i := 0; i < len(resp); i++ {
			fmt.Printf("%#v\n", resp[i])
		}
		// 提交本地事物，如果这里调用RollBack则消息会被取消，消费者不能消费
		//如果调用Commit则消息会被消费者消费
		//如果什么都没调用，相当于UNKNOWN，rocektmq会回调上面 TransactionChecker判断事物状态
		//err = transaction.RollBack()
		err = transaction.Commit()
		if err != nil {
			log.Fatal(err)
		}
		// wait a moment
		time.Sleep(time.Second * 1)
	}

	time.Sleep(time.Minute)
}

消费者

package transaction

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"time"
)

var (
	// maximum waiting time for receive func
	awaitDuration = time.Second * 1
	// maximum number of messages received at one time
	maxMessageNum int32 = 16
	// invisibleDuration should > 20s
	invisibleDuration = time.Second * 10
	// receive messages in a loop
)

func Consumer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many consumers, singleton pattern is more recommended
	simpleConsumer, err := golang.NewSimpleConsumer(&golang.Config{
		Endpoint:      Endpoint,
		ConsumerGroup: ConsumerGroup,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithAwaitDuration(awaitDuration),
		golang.WithSubscriptionExpressions(map[string]*golang.FilterExpression{
			Topic: golang.SUB_ALL,
		}),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start simpleConsumer
	err = simpleConsumer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop simpleConsumer
	defer simpleConsumer.GracefulStop()

	go func() {
		for {
			mvs, err := simpleConsumer.Receive(context.TODO(), maxMessageNum, invisibleDuration)
			if err != nil {
				fmt.Println(err)
			}
			// ack message
			for _, mv := range mvs {
				//消息内容
				log.Println(string(mv.GetBody()))
				simpleConsumer.Ack(context.TODO(), mv)
			}
			//fmt.Println("wait a moment")
			//fmt.Println()
			//time.Sleep(time.Second * 3)
		}
	}()
	// run for a while
	time.Sleep(time.Minute)
}

测试代码

package transaction

import "testing"

func TestTransactionProducer(t *testing.T) {
	TransactionProducer()
}

package transaction

import "testing"

func TestConsumer(t *testing.T) {
	Consumer()
}

测试

这里测试本地事物正常提交的情况

下面测试本地事物是未知，rocketmq回调生成者方法检查的情况

修改生成者代码

将事物提交部分注释掉

package transaction

import (
	"context"
	"fmt"
	"github.com/apache/rocketmq-clients/golang/v5"
	"github.com/apache/rocketmq-clients/golang/v5/credentials"
	"log"
	"os"
	"strconv"
	"time"
)

const (
	ConsumerGroup = "transaction_demo_group"
	Topic         = "Transaction_Demo_Topic"
	Endpoint      = "192.168.5.14:8081"
	AccessKey     = "xxxxxx"
	SecretKey     = "xxxxxx"
)

func TransactionProducer() {
	// log to console
	os.Setenv("mq.consoleAppender.enabled", "true")
	golang.ResetLogger()
	// In most case, you don't need to create many producers, singleton pattern is more recommended.
	producer, err := golang.NewProducer(&golang.Config{
		Endpoint: Endpoint,
		Credentials: &credentials.SessionCredentials{
			AccessKey:    AccessKey,
			AccessSecret: SecretKey,
		},
	},
		golang.WithTransactionChecker(&golang.TransactionChecker{
			Check: func(msg *golang.MessageView) golang.TransactionResolution {
				fmt.Println("检查本地事物是否已经提交")
				log.Printf("check transaction message: %v", msg)
				return golang.COMMIT
			},
		}),
		golang.WithTopics(Topic),
	)
	if err != nil {
		log.Fatal(err)
	}
	// start producer
	err = producer.Start()
	if err != nil {
		log.Fatal(err)
	}
	// graceful stop producer
	defer producer.GracefulStop()
	for i := 0; i < 1; i++ {
		// new a message
		msg := &golang.Message{
			Topic: Topic,
			Body:  []byte("相思只在，丁香枝上，豆蔻梢头 : " + strconv.Itoa(i)),
		}
		// set keys and tag
		msg.SetKeys("a", "b")
		msg.SetTag("ab")
		// send message in sync
		transaction := producer.BeginTransaction()
		resp, err := producer.SendWithTransaction(context.TODO(), msg, transaction)
		if err != nil {
			log.Fatal(err)
		}
		for i := 0; i < len(resp); i++ {
			fmt.Printf("%#v\n", resp[i])
		}
		// 提交本地事物，如果这里调用RollBack则消息会被取消，消费者不能消费
		//如果调用Commit则消息会被消费者消费
		//如果什么都没调用，相当于UNKNOWN，rocektmq会回调上面 TransactionChecker判断事物状态
		//err = transaction.RollBack()
		//err = transaction.Commit()
		//if err != nil {
		//	log.Fatal(err)
		//}
		// wait a moment
		time.Sleep(time.Second * 1)
	}

	time.Sleep(time.Minute)
}

测试

至此完

悟世君子
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
全面升级 —— Apache RocketMQ 5.0 SDK 的新面貌
阿里巴巴中间件
10-29 394
引言Aliware长久以来，RocketMQ 易于部署、高性能、高可用的架构，支撑了数十年来集团内外海量的业务场景。时至今日，为了迎接如今云原生时代的新挑战，我们重磅推出了 RocketM...
RocketMq Remoting协议 与 gRPC协议
qq_34253002的博客
11-28 1147
RocketMQ 项目自诞生之初演进到当前5.x版本，根据底层通信协议的差异主要支持两个系列的客户端SDK，分别是Remoting协议和gRPC协议。
rocketmq-client-go:Apache RocketMQ Go客户端
04-28
RocketMQ Client Go 完全支持产品的RocketMQ Client，它几乎支持Apache RocketMQ的全部功能，例如发布和订阅消息，ACL，跟踪等。 ，我们诚挚地邀请您花点时间对您的使用情况进行反馈。 或者如果您接受，则转到 。 特征 对于2.0.0版本，它支持： 以同步模式发送消息 以异步模式发送消息 以单向方式发送消息 发送有条理的消息 使用推送模型消费消息 发布消息和子消息的消息跟踪 生产者和消费者的ACL 如何使用 RocketMQ Go Client简介中提供了分步说明 请咨询RocketMQ快速入门以设置rocketmq代理和名称服务器。 Apache RocketMQ社区 RocketMQ社区项目 联系我们 邮件列表： https : //rocketmq.apache.org/about/contact/ 主页： https ： //ro
手把手教你SpringBoot集成RocketMq5.0，gRPC协议
相信自己会飞的猪
07-05 4402
springboot集成rocket5.0，使用gRpc协议
Apache RocketMQ Go 客户端SDK教程
最新发布
gitblog_00444的博客
08-07 498
Apache RocketMQ Go 客户端SDK教程 rocketmq-client-goApache RocketMQ go client项目地址:https://gitcode.com/gh_mirrors/ro/rocketmq-client-go 1. 项目介绍 Apache RocketMQ 是一个高性能、高可靠性的分布式消息中间件，支持发布订阅模型以及点对点的消息传递。Rocket...
RocketMQ5.0安装和配置
u010711867的博客
02-23 2506
RocketMQ5.0安装配置
RocketMQ 5.0 无状态实时性消费详解
阿里云云栖号
07-18 678
SimpleConsumer 客户端采用了无状态的 pop 机制，彻底解决了在客户端发布消息、上下线时可能出现的负载均衡问题。然而，这种新机制也带来了一个新的挑战：当客户端数量较少且消息数量较少时，可能会出现消息消费延时的情况。
大数据生态的Apache RocketMQ5.0
ApacheRocketMQ的博客
11-10 535
随着 RocketMQ 5.0 的发布，RocketMQ 在处理消息、事件和流上实现了统一，有了越来越强大的优势，使企业上云更省钱、更省时，也更省人力，一起来看看大数据生态中的 RocketMQ 5.0 吧~
Springboot 集成 RocketMq5+ （gRPC 协议）
qq_34253002的博客
12-11 1247
RocketMq是阿里出品（基于MetaQ）的开源中间件，已捐赠给Apache基金会并成为Apache的顶级项目。基于java语言实现，十万级数据吞吐量，ms级处理速度，分布式架构，功能强大，扩展性强。
云原生消息、事件、流超融合平台——RocketMQ 5.0 初探
阿里云技术
10-11 255
今天分享的主题是云原生消息事件流超融合平台 RocketMQ 5.0 初探，内容主要分为三个部分： 首先，带大家回顾业务消息领域首选 RocketMQ 4 发展历史以及 4.x 版本的演进与发展。 其次，会为大家详细介绍 RocketMQ 5.0 发展情况以及一些新特性。 最后，会为大家介绍 RocketMQ 5.0 的发展路线图，方便社区小伙伴能够一起参与进来到 5.0 的贡献中来。 RocketMQ 发展历程 RocketMQ 自诞生以来前后经历了四代架构，并伴随着企业IT 架构不断发展，
大数据生态中的 RocketMQ 5.0
阿里巴巴云原生的博客
11-09 1656
随着RocketMQ 5.0的发布，RocketMQ 在处理消息、事件和流上实现了统一，有了越来越强大的优势，存储和计算分离的特性也使其能提供更低的成本，使企业上云更省钱、更省力，也更省人力。
go使用rocketmq
热门推荐
哇哦~
04-25 1万+
下载 go get -u -v github.com/apache/rocketmq-client-go/v2 初始化 type MqConf struct { NameServers []string `mapstructure:"nameServers"` } var ( MqProducer rocketmq.Producer MqPushConsum...
Go项目（rocketmq）
Roy的博客
03-22 503
使用 rocketmq 实现分布式事务
RocketMQ 多语言 SDK 开源贡献召集令
阿里巴巴云原生的博客
01-09 487
我们欢迎任何形式的贡献，包括且不限于新 feature、bugfix、代码优化、生态集成、测试工作、文档撰写。更加欢迎能够认领一个完整的特定语言实现的同学！不要犹豫，欢迎大家以 issue/pull request 的形式将你的想法反馈到社区，一起来建设更好的 RocketMQ！
RocketMQ 5.x如何使用GRPC方式发送消费消息
念念不忘，必有回响
08-10 650
可以看到我们使用GRPC的方式消费和发送消息都成功了，但是需要注意的是目前还不是很稳定，有一些bug，生产使用还是需要谨慎。
go集成rocketmq
一个菜鸟的博客
07-16 2144
go集成rocketmq发送普通消息,延时消息,事务消息,以及消费各种消息类型。
RocketMq使用（5.0）
我的技术博客
12-09 4129
这一部分我们可以结合一下管理控制台，先来理解下RocketMQ的一些重要的基础概念：官方文档-消息发送领域模型：https://rocketmq.apache.org/zh/docs/domainModel/01main整个消息流程（大致，错了勿怪）1、部署时Broker会根据配置的nameserver地址，将自身的名称，地址等信息注册到nameserver上，每个nameserver上都具备了全量的broker信息。一般只要一台nameserver和一台broker master 节点正常，整个集群就可以
【消息队列】RocketMQ 快速入门 - 基于go语言调用
Jzin的博客
02-11 2055
RocketMQ 是一个强大的消息中间件，为大规模分布式系统提供高效、可靠和可扩展的消息。
安装RocketMQ（踩坑+解决方案）
weixin_65403042的博客
04-24 518
使用rz命令上传RocketMQ压缩文件。访问RocketMQ可视化面板。安装RocketMQ可视化面板。解压RocketMQ。启动RocketMQ。成功点开添加主题功能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悟世君子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值