nsqd解析:nsqd-protocolV2

最新推荐文章于 2022-05-10 20:37:12 发布
最新推荐文章于 2022-05-10 20:37:12 发布
阅读量1k 收藏 1
点赞数
分类专栏： nsq解析 文章标签： golang 后端 nsq 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nercoeus/article/details/103990156
版权

protocol_v2 协议

  一个客户端只能订阅一个 channel,客户端可以向 nsqd 发送指令完成指定操作并返回结果,nsqd 可以向客户端推送消息.

IOLoop 操作

  从上一节我们了解到,nsqd 每和一个客户端建立 TCP 连接都会创建一个 protocolV2 struct,里面仅仅包含所处语境即 nsqd,然后执行 IOLoop 操作进行 nsqd 和客户端的通信.所以只需要从 IOLoop 入手便可以一览 nsqd 与客户端之间的消息处理:

// 建立连接后的进行 IOLoop 操作,接收消息,每一个客户端 TCP 连接对应一个 protocolV2
func (p *protocolV2) IOLoop(conn net.Conn) error {
	var err error
	var line []byte
	var zeroTime time.Time
	// 获取一个 ClientID
	clientID := atomic.AddInt64(&p.ctx.nsqd.clientIDSequence, 1)
	// 创建一个 client 用来代理这个客户端
	client := newClientV2(clientID, conn, p.ctx)
	// 将这个客户端添加到 nsqd 中进行管理
	p.ctx.nsqd.AddClient(client.ID, client)

	// 首先创建一个 messagePumpStartedChan channel,并把它传入到 messagePump 中
	// 下面阻塞在从 messagePumpStartedChan 中获取消息,但其实这个 channel 在 messagePump 中关闭了
	// 这是为了保证让 IOLoop 中的 for 循环和 messagePump 中的 for 循环同步运行.
	// IOLoop 中的 for 循环时接收客户端的请求并进行解析,处理请求,最后给客户端响应.
	// messagePump 中的 for 循环会从内存和 disk 中获取准备好的 message 返回给客户.
	// 如果不添加 messagePumpStartedChan 一般会导致 IOLoop 中的 for 循环先执行,但是 messagePump 还没有准备好
	messagePumpStartedChan := make(chan bool)
	go p.messagePump(client, messagePumpStartedChan)
	<-messagePumpStartedChan

	for {
		// 根据心跳间隔设置 ReadDeadline 时间
		if client.HeartbeatInterval > 0 {
			client.SetReadDeadline(time.Now().Add(client.HeartbeatInterval * 2))
		} else {
			client.SetReadDeadline(zeroTime)
		}

		// 读取一个指令
		line, err = client.Reader.ReadSlice('\n')
		if err != nil {
			if err == io.EOF {
				err = nil
			} else {
				err = fmt.Errorf("failed to read command - %s", err)
			}
			break
		}

		// 删除指令末尾的 '\n'
		line = line[:len(line)-1]
		// 可能还需要修剪一下 '\r'
		if len(line) > 0 && line[len(line)-1] == '\r' {
			line = line[:len(line)-1]
		}
		// 按照空格进行划分
		params := bytes.Split(line, separatorBytes)

		p.ctx.nsqd.logf(LOG_DEBUG, "PROTOCOL(V2): [%s] %s", client, params)

		var response []byte
		// 执行客户端对应的操作,✨✨✨
		response, err = p.Exec(client, params)
		if err != nil {
			ctx := ""
			if parentErr := err.(protocol.ChildErr).Parent(); parentErr != nil {
				ctx = " - " + parentErr.Error()
			}
			p.ctx.nsqd.logf(LOG_ERROR, "[%s] - %s%s", client, err, ctx)
			// 将错误发送给客户端
			sendErr := p.Send(client, frameTypeError, []byte(err.Error()))
			if sendErr != nil {
				p.ctx.nsqd.logf(LOG_ERROR, "[%s] - %s%s", client, sendErr, ctx)
				break
			}

			// FatalClientErr 类型的错误应关闭连接
			if _, ok := err.(*protocol.FatalClientErr); ok {
				break
			}
			continue
		}
		// 将执行后的结果返回给客户端
		if response != nil {
			err = p.Send(client, frameTypeResponse, response)
			if err != nil {
				err = fmt.Errorf("failed to send response - %s", err)
				break
			}
		}
	}
	// 退出循环
	p.ctx.nsqd.logf(LOG_INFO, "PROTOCOL(V2): [%s] exiting ioloop", client)
	conn.Close()
	// 关闭 client 的所有监听 goroutine
	close(client.ExitChan)
	if client.Channel != nil {
		// 如果客户端监听的 channel 不为空,从 channel 移除这个客户端
		client.Channel.RemoveClient(client.ID)
	}
	// 从 nsqd 移除这个客户端
	p.ctx.nsqd.RemoveClient(client.ID)
	return err
}

这个函数是用来从客户端接收指令并进行处理,主要工作有:

  1. 创建一个 client 用来管理客户端
  2. 启动 goroutine 执行 messagePump,并阻塞等待 messagePump 中的 for 同步运行
  3. 在一个 for 循环中不断处理客户端传过来的指令,并将处理结果进行返回

messagePump 操作

  和 IOLoop 同步执行的还有 messagePump,是用来将内存和 disk 中获取准备好的 message 返回给客户.

func (p *protocolV2) messagePump(client *clientV2, startedChan chan bool) {
	var err error
	// 从内存获取消息的通道
	var memoryMsgChan chan *Message
	// 从磁盘获取消息的通道
	var backendMsgChan chan []byte
	// 订阅的频道
	var subChannel *Channel
	// 解决消息延迟的问题,强制刷新
	var flusherChan <-chan time.Time
	var sampleRate int32

	subEventChan := client.SubEventChan
	identifyEventChan := client.IdentifyEventChan
	outputBufferTicker := time.NewTicker(client.OutputBufferTimeout)
	heartbeatTicker := time.NewTicker(client.HeartbeatInterval)
	heartbeatChan := heartbeatTicker.C
	msgTimeout := client.MsgTimeout

	// 用来强制刷新消息给客户端,两种情况不会进行强制刷新:
	// 1. 客户端没有准备好接收消息
	// 2. buffer 中没有消息,怎么刷都没用
	flushed := true

	// 通知 IOLoop 开始执行
	close(startedChan)

  到这里 messagePump 的准备工作就已经做完了,最后 close startedChan 同时启动 IOLoop 和 messagePump 中的 for 循环

	for {
		if subChannel == nil || !client.IsReadyForMessages() {
			// 客户端暂时还不能接收消息
			memoryMsgChan = nil
			backendMsgChan = nil
			// 不允许强制刷消息给客户端
			flusherChan = nil
			// 强制刷新客户端
			client.writeLock.Lock()
			err = client.Flush()
			client.writeLock.Unlock()
			if err != nil {
				goto exit
			}
		
			flushed = true
		} else if flushed {
			// channel 中不是很堵,暂时关闭强制刷新,仅接收 channel 内存通道和磁盘通道即可
			memoryMsgChan = subChannel.memoryMsgChan
			backendMsgChan = subChannel.backend.ReadChan()
			flusherChan = nil
		} else {
			// channel 中有大消息,打开强制刷新定时器
			memoryMsgChan = subChannel.memoryMsgChan
			backendMsgChan = subChannel.backend.ReadChan()
			flusherChan = outputBufferTicker.C
		}

  在这个 for 循环中,每次开始执行 select 之前需要先对客户端的情况进行判断,有如下三种情况:

  1. 客户端没有订阅 channel 或者客户端还没有准备好接收消息,在 select 中等待 subEventChan 和 ReadyStateChan 的消息,用来加载 客户端订阅的 channel 消息通道和知晓客户端已经准备好接受消息.
  2. 客户端可以接受消息,但是 channel 中已经没有消息了,不需要开启强制刷新,仅从 channel 的两个通道中正常获取消息即可
  3. 客户端可以接收消息,并且 channel 中有很多消息等待投递,可以打开 flusherChan 进行手动刷新

  这里处理初始化时属于第一种情况,订阅 channel 后就一直在 2,3 之间进行切换.是怎么判断 channel 的通道中是否有消息需要进行强制刷新呢?如果从内存通道中获取消息就表示目前 channel 情况还正常,一旦开始从 backend 中获取消息就表示 channel 中已经积压了大量的消息,需要打开强制刷新.默认刷新频率为:250ms,通过强制刷新把 client 写缓冲区中的消息推送给客户端,让 client 可以更快的从 channel 中获取消息

		select {
		case <-flusherChan:
			// 强制刷新 client 的写缓冲区
			client.writeLock.Lock()
			err = client.Flush()
			client.writeLock.Unlock()
			if err != nil {
				goto exit
			}
			flushed = true
		case <-client.ReadyStateChan:
		case subChannel = <-subEventChan:
			// 仅订阅一次 channel 之后即使调用 SUB 也不会切换频道
			subEventChan = nil
		case identifyData := <-identifyEventChan:
			// 验证确认客户端,仅触发一次
			// 就是设置各种触发间隔
			identifyEventChan = nil

			outputBufferTicker.Stop()
			if identifyData.OutputBufferTimeout > 0 {
				outputBufferTicker = time.NewTicker(identifyData.OutputBufferTimeout)
			}

			heartbeatTicker.Stop()
			heartbeatChan = nil
			if identifyData.HeartbeatInterval > 0 {
				heartbeatTicker = time.NewTicker(identifyData.HeartbeatInterval)
				heartbeatChan = heartbeatTicker.C
			}

			if identifyData.SampleRate > 0 {
				sampleRate = identifyData.SampleRate
			}

			msgTimeout = identifyData.MsgTimeout
		case <-heartbeatChan:
			// 发送心跳消息给客户端
			err = p.Send(client, frameTypeResponse, heartbeatBytes)
			if err != nil {
				goto exit
			}
		case b := <-backendMsgChan:  // 从 channel 磁盘消息缓冲区中接收消息
			if sampleRate > 0 && rand.Int31n(100) > sampleRate {
				continue
			}
			// 先 decode 消息
			msg, err := decodeMessage(b)
			if err != nil {
				p.ctx.nsqd.logf(LOG_ERROR, "failed to decode message - %s", err)
				continue
			}
			msg.Attempts++
			// 放进到待确认列表并发送给客户端
			subChannel.StartInFlightTimeout(msg, client.ID, msgTimeout)
			client.SendingMessage()
			err = p.SendMessage(client, msg)
			if err != nil {
				goto exit
			}
			flushed = false
		case msg := <-memoryMsgChan:  // 从 channel 内存消息缓冲区中接收消息
			if sampleRate > 0 && rand.Int31n(100) > sampleRate {
				continue
			}
			msg.Attempts++
			// 添加到待确认列表并发送给客户端
			subChannel.StartInFlightTimeout(msg, client.ID, msgTimeout)
			client.SendingMessage()
			err = p.SendMessage(client, msg)
			if err != nil {
				goto exit
			}
			flushed = false
		case <-client.ExitChan:
			// 退出循环
			goto exit
		}
	}

整个阻塞在 select 有 8 种情况:

  1. 强制刷新消息给客户端
  2. 客户端准备就绪等待接收消息
  3. 客户端订阅频道,加载 channel 消息接收列表(仅能订阅一次 channel)
  4. 验证链接时执行的操作,设置消息循环的各种定时器间隔(只可以确认一次)
  5. 给客户端发送心跳消息
  6. 从磁盘队列接收消息
  7. 从内存队列接收消息
  8. 退出 messagePump
exit:
	p.ctx.nsqd.logf(LOG_INFO, "PROTOCOL(V2): [%s] exiting messagePump", client)
	heartbeatTicker.Stop()
	outputBufferTicker.Stop()
	if err != nil {
		p.ctx.nsqd.logf(LOG_ERROR, "PROTOCOL(V2): [%s] messagePump error - %s", client, err)
	}
}

  收尾工作就是停止几个定时器并退出即可.在 messagePump 中获取了消息之后会调用 SendMessage 来吧消息发送给客户端:

func (p *protocolV2) SendMessage(client *clientV2, msg *Message) error {
	var buf = &bytes.Buffer{}
	// 消息放到 buf 中
	_, err := msg.WriteTo(buf)
	if err != nil {
		return err
	}
	// 调用 Send 发送
	err = p.Send(client, frameTypeMessage, buf.Bytes())
	if err != nil {
		return err
	}

	return nil
}
// 向 client 发送消息
func (p *protocolV2) Send(client *clientV2, frameType int32, data []byte) error {
	client.writeLock.Lock()

	var zeroTime time.Time
	// 写超时设置
	if client.HeartbeatInterval > 0 {
		client.SetWriteDeadline(time.Now().Add(client.HeartbeatInterval))
	} else {
		client.SetWriteDeadline(zeroTime)
	}

	_, err := protocol.SendFramedResponse(client.Writer, frameType, data)
	if err != nil {
		client.writeLock.Unlock()
		return err
	}
	// frameTypeMessage : 发送给客户端的消息立即刷新
	// frameTypeResponse : 客户端指令返回不会立即刷新
	if frameType != frameTypeMessage {
		err = client.Flush()
	}

	client.writeLock.Unlock()

	return err
}

  nsqd 对每个客户端使用两个 gououtine 分别执行 IOLoop 和 messagePump 就完成了二者之间的指令和消息传递.代码很容易理清楚.

protocol_v2 中客户端的指令

Exec

  在 IOLoop 中,没收到客户端传来的一条指令,都会解析完成后,通过 Exec 进行执行.判断指令的类型然后调用对应的函数执行即可.

// 执行客户端传递过来的指令
func (p *protocolV2) Exec(client *clientV2, params [][]byte) ([]byte, error) {
	// 认证一个客户端
	if bytes.Equal(params[0], []byte("IDENTIFY")) {
		return p.IDENTIFY(client, params)
	}
	err := enforceTLSPolicy(client, p, params[0])
	if err != nil {
		return nil, err
	}
	switch {
	// 确认收到一条消息
	case bytes.Equal(params[0], []byte("FIN")):
		return p.FIN(client, params)
	// 指定可同时处理的消息数量
	case bytes.Equal(params[0], []byte("RDY")):
		return p.RDY(client, params)
	// 消息重新加入 channel 发送
	case bytes.Equal(params[0], []byte("REQ")):
		return p.REQ(client, params)
	// 向 topic 推送一条消息
	case bytes.Equal(params[0], []byte("PUB")):
		return p.PUB(client, params)
	// 向 topic 推送多条消息
	case bytes.Equal(params[0], []byte("MPUB")):
		return p.MPUB(client, params)
	// 向 topic 推送一条延迟消息
	case bytes.Equal(params[0], []byte("DPUB")):
		return p.DPUB(client, params)
	// 不作处理
	case bytes.Equal(params[0], []byte("NOP")):
		return p.NOP(client, params)
	// 重置一个待确认消息的超时时间
	case bytes.Equal(params[0], []byte("TOUCH")):
		return p.TOUCH(client, params)
	// 订阅一个 channel
	case bytes.Equal(params[0], []byte("SUB")):
		return p.SUB(client, params)
	// 关闭客户端
	case bytes.Equal(params[0], []byte("CLS")):
		return p.CLS(client, params)
	// 授权一个客户端
	case bytes.Equal(params[0], []byte("AUTH")):
		return p.AUTH(client, params)
	}
	return nil, protocol.NewFatalClientErr(nil, "E_INVALID", fmt.Sprintf("invalid command %s", params[0]))
}

  这里的各个指令,基本都是先确认参数,然后调用对应的方法即可,不过多介绍,简单了解一下对应的含义及可:

指令例子操作执行的操作
FINFIN MessageID确认收到一条消息topic.FinishMessage
RDYRDY count指定可同时处理的消息数量client.SetReadyCount
REQREQ messageID timeoutMs消息重新加入 channel 发送client.Channel.RequeueMessage
PUBPUB topicName message向 topic 推送一条消息topic.PutMessage
MPUBMPUB topicName messages向 topic 推送多条消息topic.PutMessages
DPUBMPUB topicName timeoutMs message向 topic 推送一条延迟消息topic.PutMessage
NOPNOP无效指令不做处理
TOUCHTOUCH messageID重置一个待确认消息的超时时间client.Channel.TouchMessage
SUBSUB topicName channelName订阅一个 channelclient.SubEventChan <- channel 触发消息循环
CLSCLS关闭客户端client.StartClose
AUTHAUTH body授权一个客户端client.Auth
IDENTIFYIDENTIFY body认证一个客户端client.Identify

这里面比较特别的是 IDENTIFY 和 AUTH 两个操作.
  client 和 nsqd 建立连接后,client 立即通过命令 IDENTIFY 将认证信息发给 nsqd,如果 nsqd 在启动的时候指定了授权地址,nsqd 就会告诉 client 你需要认证,client 就会通过命令 AUTH 将秘钥发给 nsqd,nsqd 去授权地址进行验证,验证通过后,就可以进行正常的消息发布和订阅了

小结

  整个协议的流程基本看完了,其实说起来就是通过 IOLoop 和 messagePump 进行 nsqd 和 client 的通信:

  • IOLoop 负责让 nsqd 执行 client 传过来的指令
  • messagePump 给客户端推送消息

最后附上 github 的 nsqd 的源码解析地址:https://github.com/nercoeus/nsq_source_note

NSQ 源码分析之NSQD--ProtocolV2
H_L_S的专栏
03-14 305
今天来说说NSQD.TCPServer中的核心函数IOLoop的具体实现，IOLoop主要的工作是接收和响应客户的命令。同时开启messagePump goroutine进行心跳检查，给订阅者发生消息等操作。 详细流程参考https://blog.csdn.net/H_L_S/article/details/104709619中的逻辑流程图。 主要代码文件： 1.nsqd/protoc...
NSQ 源码分析之NSQD--消息协议 Message
H_L_S的专栏
04-03 423
今天主要讲的是 NSQD中消息协议 Message，Message主要作用是对客户端发送过来的消息进行Message封装，然后等待消费者消费或者将 Message转换为字节流发送客户端。 主要代码文件： 1.nsqd/message.go Message结构体 type MessageID [MsgIDLength]byte // 定义消息 ID 类型 type Mess...
nsq 源码分析之tcp协议部分
weixin_42847874的博客
05-22 213
最近刚好看到其他几个项目有socket 编程，然后，想了下，在golang 中还没用过socket tcp 编程，于是看了一些im 的协议解析过程，都不是太满意，不是太通用，刚好看到nsq，发现nsq 这部分真是简单粗暴。还用的是标准库的一些东西，非常通用。 该文章后续仍在不...
NSQ源码分析之nsqd
Think Different.
09-29 676
概述 最近想通过观察分析NSQ的源码，来更进一步学习golang，编程嘛，就是多看、多写、多思考，没有捷径。 什么是NSQ 引用官方文档的话：NSQ is a realtime distributed messaging platform designed to operate at scale, handling billions of messages per day. NSQ特性和使用 网上很多介绍NSQ的文章，这里就不再赘述。 文章链接 NSQ的架构 文本源码分析的思路就是根据NSQ的不同功能模块，
golang源码阅读-nsq-消费者代码
无
07-19 525
1. 基本使用 // 消费者 type ConsumerT struct{} // 主函数 func main() { fmt.Println("---------- start --------") InitConsumer("test", "test-channel", "0.0.0.0:4161") for { time.Sleep(time.Second * 10) } } //接收到消息时， 会调用这个方法,处理消息 func (*ConsumerT) HandleMessa
nsqd-to-librato:将 NSQ 统计信息发送到 librato
06-17
它由两个主要组件组成：nsqd 和 nsqlookupd。nsqd 负责接收、存储和分发消息，而 nsqlookupd 提供服务发现功能，帮助生产者和消费者找到彼此。在大数据和实时分析领域，NSQ 因其高性能、可扩展性和易用性而受到广泛...
nsqd-discovery:使用DNS条目动态配置NSQ
05-14
NSQD的DNS配置 使用DNS A记录中的IP地址动态配置nsqd 。 阅读有关更多信息。 设置 在AWS Route 53中创建一个专用区域 创建一个具有地址的记录集 添加一个带有nsqlookupd IP列表的A记录 注意：步骤3应该是自动化的。 ...
高性能消息中间件 NSQ 解析-nsqd 的实现介绍
aoho求索
03-25 866
我们在前面介绍了 nsq 的相关概念以及 nsq 的安装与应用。从本篇开始将会结合源码介绍 nsq 的实现细节。nsq 中单个 nsqd 可以有多个 topic，每个 topic 可以有多...
go-start-nsq:帮助程序启动 nsqd nsqlookupd nsqadmin 节点以进行本地开发
06-28
启动 nsqd / nsqlookupd / nsqadmin 节点进行本地开发的小助手程序。 安装 $ go get github.com/segmentio/go-start-nsq 用法 一个 NSQD： $ go-start-nsq 三个 NSQD 节点： $ go-start-nsq -n 3 执照 麻省...
nsq之nsqd执行流程（包括订阅消息，发布消息等内容）
m0_37343985的博客
03-26 2577
nsqd是就是我们平时所说的broker，接下来我们就来看一下它是怎么设计的，下面的Main方法就是nsqd启动的入口 func (n *NSQD) Main() error { ctx := &context{n} exitCh := make(chan error) var once sync.Once exitFunc := func(err error) { once...
nsq auth 权限认证服务
05-10
nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务nsq auth 权限认证服务
nsqd解析:nsqd链接的建立
nercoeus的博客
01-15 769
在 nsqd 中,每个 nsqd 节点初始化时会默认监听两个端口: [nsqd] INFO: TCP: listening on [::]:4150 TCP 连接 [nsqd] INFO: HTTP: listening on [::]:4151 HTTP 连接   那么这两个端口有什么作用呢?nsqd 是怎么和 lookupd 以及客户端进行通信的呢?如何处理新到达的链接呢?在 ...
NSQ 源码阅读（三）TCP Handler
weixin_34092370的博客
08-03 555
tcp handler tcp handler 处理每一个tcp connection type tcpServer struct { ctx *context } func (p *tcpServer) Handle(clientConn net.Conn) { p.ctx.nsqd.logf("TCP: new cl...
nsq源码阅读 nsqd源码三 tcp.go
aslackers的专栏
11-21 772
NSQ的TCP逻辑都是这样的，调用internal/protocol/tcp_server.go中的TCPServer: func TCPServer(listener net.Listener, handler TCPHandler, l app.Logger) 接受客户端连接，在这里客户端为consumer，调用TCPHandler.Handle处理业务逻辑，TCPHandler.Ha
nsq 快速入门经验分享
热门推荐
panshiqu的专栏
11-24 1万+
nsq 是什么东西，这里就不长篇大论啦我在 Mac 上尝试 nsq.io 中提供的 QUICK START 遇到问题，这里作简要说明
golang源码阅读-nsq-生产者代码
无
07-03 772
1.基本使用 var producer *nsq.Producer // 主函数 func main() { strIP1 := "127.0.0.1:4150" InitProducer(strIP1) running := true //读取控制台输入 reader := bufio.NewReader(os.Stdin) for running { data, _, _ := reader.ReadLine() command := string(data) if
NSQ详细教程3 Auth权限验证测试
zhangxm_qz的博客
05-10 1395
文章目录Auth 认证方式验证准备启动认证服务启动nsq服务编写nsq测试程序消息发送测试修改客户端密码测试消息消费测试TLS证书验证 Auth 认证方式验证 认证原理参考上一篇文章 准备启动认证服务 我这里已经编译好一个，可以直接下载使用 点击下载 也可以自己开发或自行到github下载 将程序上传并赋予执行权限如下: [root@localhost nsq]# ll total 9436 drwxr-xr-x. 2 root wheel 154 Aug 16 2021 bin -rw-r--r
nsqd read i/o timeout & PostgreSQL执行超时问题排查
weixin_41935140的博客
03-18 1720
问题排查及解决思路：nsqd 出现ERROR: client(ip:port) - failed to read command - read tcp ip:4150->ip:port: i/o timeout，排查发现Postgresql执行超时，最终完美解决
docker-compose 怎么部署nsq
最新发布
03-21
2. 在终端中进入包含docker-compose.yml文件的目录，并运行以下命令启动NSQ服务： ```bash docker-compose up -d ``` 这将会启动NSQ的三个组件：nsqlookupd、nsqd和nsqadmin。其中，nsqlookupd是NSQ的查找服务，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值