【Kafka】Golang中使用Kafka基于发布订阅模式实现消息队列

前言

在以前的定义中，Kafka被定义为一个分布式的基于发布/订阅模式的消息队列（Message
Queue），主要应用于大数据实时处理领域，当然我们知道kafka的作用远不止用于消息队列，kafka作为消息队列主要是基于点对点模式和基于发布订阅模式，其中，点对点模式表现为：消费者主动拉取数据，消息收到后清除消息。而发布订阅表现为：

• 可以有多个topic主题（浏览、点赞、收藏、评论等）。
• 消费者消费数据之后，不删除数据。
• 每个消费者相互独立，都可以消费到数据。

在上篇文章Docker安装kafka、搭建kafka集群中，我们利用docker搭建了kafka集群，在本文中，我们将基于kafka的发布订阅模式，在Golang中使用kafka来实现消息队列。

一、生产者

生产者的实现有两种方式，一种是基于同步消息模式，另一种则是基于异步消息模式。同步消息模式发送完一条消息需要进行确认消息是否到达存储。异步消息模式和同步消息模式的过程大致相似，只不过异步消息生产者不需要在每次发送之后等待接收消息状态（是否成功），下面简单总结下两者的构建步骤。

同步消息模式：

• 构建集群brokers和同步生产者配置config。
• 连接kafka,使用配置构建一个同步生产者。
• 构建发送的消息，每次发送都要重新构建。
• 发送消息，发送后能获取到消息发送的分区和偏移。

异步消息模式：

• 构建集群brokers和异步生产者配置config。
• 连接kafka，使用配置构建一个异步生产者。
• 因为是异步发送，因此需要先启动协程，从不同通道中接收消息状态。
• 构建消息，将消息发送到通道中。

最后，无论是同步生产者还是异步生产者，都别忘了进行资源关闭。

package main

import (
	"fmt"
	"github.com/Shopify/sarama"
	"time"
)

// 基于sarama第三方库开发的kafka client
var brokers = []string{"IP:9092", "IP:9093", "IP:9094"}
var topic = "hello_kafka0"

// 同步消息模式
func syncProducer(config *sarama.Config) {
	// 连接kafka,使用配置构建一个同步生产者
	syncProducer, err := sarama.NewSyncProducer(brokers, config)
	if err != nil {
		fmt.Println("syncProducer closed,err:", err)
		return
	}
	defer syncProducer.Close()
	//构建发送消息
	srcValue := "test syncProducer send msg, i = %d"
	for i := 0; i < 5; i++ {
		value := fmt.Sprintf(srcValue, i)
		msg := &sarama.ProducerMessage{
			Topic: topic,
			Value: sarama.ByteEncoder(value),
		}
		// 发送消息，并获取消息存储的分区和偏移
		partition, offset, err := syncProducer.SendMessage(msg)
		if err != nil {
			fmt.Println("send msg failed,err:", err)
			return
		}
		fmt.Printf("send success, partition:%v offset:%v\n", partition, offset)
	}
}

// 异步消息模式
func asyncProducer(config *sarama.Config) {
	// 连接kafka,使用配置构建一个异步的生产者
	asyncProducer, err := sarama.NewAsyncProducer(brokers, config)
	if err != nil {
		fmt.Println("asyncProducer closed,err:", err)
		return
	}
	defer asyncProducer.AsyncClose() //异步关闭
	fmt.Println("start goroutine...")
	// 异步发送，因此接收需要先启动协程，从通道中进行接收
	go func(producer sarama.AsyncProducer) {
		for {
			select {
			case suc := <-producer.Successes():
				fmt.Println("offset: ", suc.Offset, "timestamp:", suc.Timestamp.String(), "partition:", suc.Partition)
			case fail := <-producer.Errors():
				fmt.Println("err: ", fail.Err)
			}
		}
	}(asyncProducer)
	//每500ms构建一条消息进行发送,注意消息每次都需要重新构建
	for i := 0; i < 5; i++ {
		time.Sleep(500 * time.Millisecond)
		timeNow := time.Now()
		value := "this is a message " + timeNow.Format("14:49:05")
		msg := &sarama.ProducerMessage{ //消息需要每次进行构建
			Topic: topic,
			Value: sarama.ByteEncoder(value), //将字符串转化为字节数组
		}
		asyncProducer.Input() <- msg // 使用通道进行发送
	}
}
func main() {
	config := sarama.NewConfig()                              //创建一个sarama的config对象
	config.Producer.RequiredAcks = sarama.WaitForAll          //发送完数据需要isr中的节点，理解为leader和flower都需要回复确认
	config.Producer.Partitioner = sarama.NewRandomPartitioner //新选一个patition
	//是否等待成功和失败后的响应,只有上面的RequireAcks设置不是NoReponse这里才有用.
	config.Producer.Return.Errors = true               //接收错误
	config.Producer.Return.Successes = true            //成功交付的消息将在success channel返回
	config.Version = sarama.V3_2_0_0                   //指定版本
	config.Producer.Retry.Max = 10                     //最大重试时间
	config.Producer.MaxMessageBytes = 32 * 1024 * 1024 // 最大的消息缓冲字节 默认为100*1024*1024
	syncProducer(config)
	//asyncProducer(config)
}

二、消费者

消费者构建的一般步骤为：

• 构建集群brokers和消费者配置config。
• 利用配置构建消费者。
• 根据topic主题信息获取该主题存在的所有分区信息。
• 针对每个分区，创建一个分区消费者进行消费，分区消费者接收消息进行消费。

此外，消费者还可以加入给定主题列表的消费者集群，并通过 ConsumerGroupHandler 启动阻塞的 ConsumerGroupSession，下面也给出了实现。

package main

import (
	"context"
	"fmt"
	"github.com/Shopify/sarama"
	"sync"
	"time"
)

// kafka消费者消费消息
var topic string = "hello_kafka0"
var brokers = []string{"10.227.4.92:9092", "10.227.4.92:9093", "10.227.4.92:9094"}
var topics = []string{"hello_kafka0"}

// 普通消费者
func ordinaryConsumer(wg *sync.WaitGroup, groupId string) {
	defer wg.Done() //计数减1
	config := sarama.NewConfig()
	config.Consumer.Return.Errors = true                                   //是否接收错误
	config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategyRange //消费者组的消费策略
	config.Consumer.MaxWaitTime = 500 * time.Second                        //消费者拉取的最大等待时间
	config.Version = sarama.V3_2_0_0
	config.Consumer.Group.InstanceId = groupId
	consumer, err := sarama.NewConsumer(brokers, config)
	if err != nil {
		fmt.Println("fail to start consumer,err:%v\n", err)
		return
	}
	defer consumer.Close()
	partitionList, err := consumer.Partitions(topic) //根据topic获取到所有的分区
	if err != nil {
		fmt.Printf("fail to get list of partition:err%v\n", err)
		return
	}
	for partition := range partitionList { //遍历所有的分区
		//对每个分区创建一个分区消费者,Offset这里指定为获取所有消息，只获取最新的采用OffsetNewest
		partConsumer, err := consumer.ConsumePartition(topic, int32(partition), sarama.OffsetOldest)
		if err != nil {
			fmt.Printf("failed to start consumer for partition %d,err:%v\n", partition, err)
			return
		}
		defer partConsumer.AsyncClose()
		// 方式1、采用for range方式获取，获取完毕就结束
		go func(sarama.PartitionConsumer) {
			for msg := range partConsumer.Messages() {
				fmt.Printf("Partition:%d Offset:%d Key:%v Value:%v\n",
					msg.Partition, msg.Offset, msg.Key, string(msg.Value))
			}
		}(partConsumer)
		time.Sleep(3 * time.Second) //延迟主线程，防止协程还没运行
		// 方式2、采用for select方式获取，一直阻塞等待获取

		// 信号关闭触发
		//	signals := make(chan os.Signal, 1)
		//	signal.Notify(signals, os.Interrupt)
		//Loop:
		//	for {
		//		select {
		//		case msg := <-partConsumer.Messages():
		//			fmt.Printf("Partition:%d Offset:%d Key:%v Value:%v\n",
		//				msg.Partition, msg.Offset, msg.Key, string(msg.Value))
		//		case err := <-partConsumer.Errors():
		//			fmt.Println(err.Err)
		//		case <-signals:
		//			break Loop
		//		}
		//	}
	}
}

// 消费者组,ConsumerGroup负责将主题和分区的处理划分为一组进程（consumer组的成员）
type consumerGroupHandler struct{}

// ConsumerGroupClaim 负责处理来自消费者组中给定主题和分区的Kafka消息
// ConsumerGroupHandler 实例用于处理单个主题/分区声明。 它还为您的消费者组会话生命周期提供钩子，并允许您在消费循环之前或之后触发逻辑。
func (consumerGroupHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
func (consumerGroupHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
func (handler consumerGroupHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {
	for msg := range claim.Messages() {
		fmt.Printf("Message topic:%q partition:%d offset:%d value:%s\n", msg.Topic, msg.Partition, msg.Offset, msg.Value)
		sess.MarkMessage(msg, "") //标记这条消息已经消费
	}
	return nil
}
func groupConsumer(wg *sync.WaitGroup, groupId string) {
	defer wg.Done()
	config := sarama.NewConfig()
	config.Version = sarama.V3_2_0_0
	config.Consumer.Return.Errors = true

	consumerGroup, err := sarama.NewConsumerGroup(brokers, groupId, config)
	if err != nil {
		fmt.Println("consumerGroup start failed", err)
		return
	}
	defer func() { _ = consumerGroup.Close() }()
	// 启动协程从错误通道中接收错误信息
	go func() {
		for err := range consumerGroup.Errors() {
			fmt.Println("ERROR", err)
		}
	}()
	// 迭代消费者会话
	ctx := context.Background()
	//`应该在无限循环中调用Consume，当服务器端重新平衡发生时，需要重新创建consumer会话以获取新的声明
	for {
		handler := consumerGroupHandler{}
		err := consumerGroup.Consume(ctx, topics, handler)
		if err != nil {
			fmt.Println("the Consume failed", err)
			return
		}
	}
}
func main() {
	var wg = &sync.WaitGroup{}
	wg.Add(2)
	//go ordinaryConsumer(wg, "tt")
	go groupConsumer(wg, "cc") //通过mark消息已经消费，因此相同消费者组中不会有两个消费者消费到相同的消息
	go groupConsumer(wg, "cc")
	wg.Wait()
}

三、源码简单解读

在上面中，我们发现，无论是生产者还是消费者，都有相应的配置config，而这些配置来自于sarama.NewConfig()中：

c.Net.MaxOpenRequests = 5
c.Net.DialTimeout = 30 * time.Second
c.Net.ReadTimeout = 30 * time.Second
c.Net.WriteTimeout = 30 * time.Second
c.Net.SASL.Handshake = true
// 元数据配置
c.Metadata.Retry.Max = 3
c.Metadata.Retry.Backoff = 250 * time.Millisecond
c.Metadata.RefreshFrequency = 10 * time.Minute
c.Metadata.Full = true
// 生产者配置
c.Producer.MaxMessageBytes = 1000000 //最大消息字节
c.Producer.RequiredAcks = WaitForLocal //消息确认策略
c.Producer.Timeout = 10 * time.Second //超时时间
c.Producer.Partitioner = NewHashPartitioner  //分区器，用于选择主题的分区，策略如下
# sarama.NewManualPartitioner() //返回一个手动选择分区的分割器,也就是获取msg中指定的`partition`
# sarama.NewRandomPartitioner() //通过随机函数随机获取一个分区号
# sarama.NewRoundRobinPartitioner() //环形选择,也就是在所有分区中循环选择一个
# sarama.NewHashPartitioner() //通过msg中的key生成hash值,选择分区,

c.Producer.Retry.Max = 3 //重试次数
c.Producer.Retry.Backoff = 100 * time.Millisecond
c.Producer.Return.Errors = true  //是否接收返回的错误消息,当发生错误时会放到Error这个通道中.从它里面获取错误消息

//消费者抓取数据配置
c.Consumer.Fetch.Min = 1
c.Consumer.Fetch.Default = 32768

c.Consumer.Retry.Backoff = 2 * time.Second //失败后再次尝试的间隔时间
c.Consumer.MaxWaitTime = 250 * time.Millisecond  //最大等待时间
c.Consumer.MaxProcessingTime = 100 * time.Millisecond
c.Consumer.Return.Errors = false  //是否接收返回的错误消息,当发生错误时会放到Error这个通道中.从它里面获取错误消息
c.Consumer.Offsets.CommitInterval = 1 * time.Second // 提交跟新Offset的频率
c.Consumer.Offsets.Initial = OffsetNewest // 指定Offset,也就是从哪里获取消息,默认时从主题的开始获取.

c.ClientID = defaultClientID
c.ChannelBufferSize = 256  //通道缓存大小
c.Version = minVersion //指定kafka版本,不指定,使用最小版本,高版本的新功能可能无法正常使用.
c.MetricRegistry = metrics.NewRegistry()

生产者消息结构ProducerMessage ：

// ProducerMessage is the collection of elements passed to the Producer in order to send a message.
type ProducerMessage struct {
	Topic string // 消息主题
	// The partitioning key for this message. Pre-existing Encoders include
	// StringEncoder and ByteEncoder.
	Key Encoder // 消息的分区key的编码方式，这个key用于选择分区,和分割器的NewHashPartitioner联合使用,决定当前消息被保存在哪个分区
	// The actual message to store in Kafka. Pre-existing Encoders include
	// StringEncoder and ByteEncoder.
	Value Encoder //消息的内容

	// The headers are key-value pairs that are transparently passed
	// by Kafka between producers and consumers.
	Headers []RecordHeader //在生产者和消费者之间传递的键值对

	// This field is used to hold arbitrary data you wish to include so it
	// will be available when receiving on the Successes and Errors channels.
	// Sarama completely ignores this field and is only to be used for
	// pass-through data.
	Metadata interface{} //sarama 用于传递数据使用

	// Below this point are filled in by the producer as the message is processed
	//Offset、Partition和Timestamp的内容都是由生产者返回后的内容填充.
	// Offset is the offset of the message stored on the broker. This is only
	// guaranteed to be defined if the message was successfully delivered and
	// RequiredAcks is not NoResponse.
	Offset int64 //偏移 
	// Partition is the partition that the message was sent to. This is only
	// guaranteed to be defined if the message was successfully delivered.
	Partition int32
	// Timestamp can vary in behavior depending on broker configuration, being
	// in either one of the CreateTime or LogAppendTime modes (default CreateTime),
	// and requiring version at least 0.10.0.
	//
	// When configured to CreateTime, the timestamp is specified by the producer
	// either by explicitly setting this field, or when the message is added
	// to a produce set.
	//
	// When configured to LogAppendTime, the timestamp assigned to the message
	// by the broker. This is only guaranteed to be defined if the message was
	// successfully delivered and RequiredAcks is not NoResponse.
	Timestamp time.Time

	retries        int // 重试次数
	flags          flagSet
	expectation    chan *ProducerError
	sequenceNumber int32
	producerEpoch  int16
	hasSequence    bool
}

消费者消息结构ConsumerMessage：

// ConsumerMessage encapsulates a Kafka message returned by the consumer.
type ConsumerMessage struct {
	Headers        []*RecordHeader // only set if kafka is version 0.11+
	Timestamp      time.Time       // only set if kafka is version 0.10+, inner message timestamp
	BlockTimestamp time.Time       // only set if kafka is version 0.10+, outer (compressed) block timestamp
    Key, Value     []byte  //key和保存的值
    Topic          string //要消费的主题
    Partition      int32 //要消费的分区
    Offset         int64 //要消费的消息的位置,从哪里开始消费,最开始的,还是最后的
}

四、参考

1、https://pkg.go.dev/github.com/Shopify/sarama#section-readme