学习：Spark Master Worker 进程通讯项目

最新推荐文章于 2021-04-21 22:27:20 发布
最新推荐文章于 2021-04-21 22:27:20 发布
阅读量168 收藏 1
点赞数
分类专栏： Scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44007155/article/details/102164562
版权

项目的意义

  1. 深入理解 Spark 的 Master 和 Worker 的通讯机制
  2. 加深对主从服务 心跳检测机制(HeartBeat)的理解，方便以后 spark 源码二次开发。

项目需求分析

在这里插入图片描述

  1. worker 注册到 Master, Master 完成注册，并回复 worker 注册成功
  2. worker 定时发送心跳，并在 Master 接收到
  3. Master 接收到 worker 心跳后，要更新该 worker 的最近一次发送心跳的时间
  4. 给 Master 启动定时任务，定时检测注册的 worker 有哪些没有更新心跳,并将其从 hashmap 中删
    除
  5. master worker 进行分布式部署(Linux 系统)
实现功能 1-Worker 完成注册

worker 注册到 Master, Master 完成注册，并回复 worker 注册成功
在这里插入图片描述
在这里插入图片描述
SparkMaster


import akka.actor.{Actor, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.xyq.sparkmasterworker.common.{RegisterWorkerInfo, RegisteredWorkerInfo, WorkerInfo}

import scala.collection.mutable

//创建MasterActor,实现其receive方法
class MasterActor extends Actor{
  //创建一个HashMap用于存放worker的注册信息
  val workers =  mutable.Map[String,WorkerInfo]()

  override def receive: Receive = {
    case "start" => println("master服务器启动了")
    case RegisterWorkerInfo(id,cpu,ram)  =>{
      println("接收到注册消息")
      if (!workers.contains(id)){
        //创建 WorkerInfo 对象
        val workerInfo = new WorkerInfo(id,cpu,ram)
        //加入到 workers
        workers += ((id,workerInfo))
        println("服务器的 workers=" + workers)
        //回复一个消息，说注册成功
        sender() ! RegisteredWorkerInfo

      }
    }
  }
}

object SparkMaster extends App{

  //创建ActorSystem
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=127.0.0.1
       |akka.remote.netty.tcp.port=10005
""".stripMargin)
  val sparkMasterSystem =ActorSystem("SparkMaster", config)

  //创建masterActor对象，及其引用
  private val masterActorRef = sparkMasterSystem.actorOf(Props[MasterActor], "MasterActor-01")

  //启动masterActor
  masterActorRef ! "start"
}

SparkWorker


import akka.actor.{Actor, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.xyq.sparkmasterworker.common.{RegisterWorkerInfo, RegisteredWorkerInfo}

//创建MasterActor,实现其receive方法
class WorkerActor(masterHost:String,masterPort:Int) extends Actor{
  //masterActorRef是Master的引用
  var masterActorRef:ActorSelection=_
  //创建一个id,用于标识一个worker
  val id = java.util.UUID.randomUUID().toString()

  //preStart()方法，用于创建masterActorRef
  override def preStart(): Unit = {
    println("preStart()调用")
    masterActorRef = context.actorSelection(s"akka.tcp://SparkMaster@${masterHost}:${masterPort}/user/MasterActor-01")
  }

  override def receive: Receive = {
    case "start" => {
      println("WokerActor启动了")
      //发送一个注册消息
      masterActorRef ! RegisterWorkerInfo(id,16,16*1024)
    }
      //worker收到注册成功消息后，做出回应
    case RegisteredWorkerInfo =>{
      println("workerid="+id+"注册成功！")
    }
  }
}

object WorkerActor extends App{

  val workerHost = "127.0.0.1"
  val workerPort = 10001
  val masterHost = "127.0.0.1"
  val masterPort = 10005
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=127.0.0.1
       |akka.remote.netty.tcp.port=10002
""".stripMargin)
  //创建 ActorSystem
  val sparkWorkerSystem =ActorSystem("SparkWorker",config)
  //创建workerActor的引用
   val workerActor0Ref = sparkWorkerSystem.actorOf(Props(new WorkerActor(masterHost,masterPort)),"workerActor01")
  workerActor0Ref ! "start"
}

MessageProtocol

// worker 注册信息
case class RegisterWorkerInfo(id: String, cpu: Int, ram: Int)

// 这个是 WorkerInfo, 这个信息将来是保存到 master 的 hm(该 hashmap 是用于管理 worker)
//这个 WorkerInfo 还会扩展（比如增加 worker 上一次的心跳时间）
class WorkerInfo(val id: String, val cpu: Int, val ram: Int)

// 当 worker 注册成功，服务器返回一个 RegisteredWorkerInfo 对象
case object RegisteredWorkerInfo
实现功能 2-Worker 定时发送心跳

worker 定时发送心跳给 Master，Master 能够接收到,并更新 worker 上一次心跳时间
思路分析：在这里插入图片描述

MessageProtocol

package com.xyq.sparkmasterworker.common

// worker 注册信息
case class RegisterWorkerInfo(id: String, cpu: Int, ram: Int)

// 这个是 WorkerInfo, 这个信息将来是保存到 master 的 hm(该 hashmap 是用于管理 worker)
//这个 WorkerInfo 还会扩展（比如增加 worker 这一次的心跳时间）
class WorkerInfo(val id: String, val cpu: Int, val ram: Int){
  var lastHeartBeat : Long = System.currentTimeMillis()
}

// 当 worker 注册成功，服务器返回一个 RegisteredWorkerInfo 对象
case object RegisteredWorkerInfo

//worker 每隔一定时间由定时器发给自己的一个消息
case object SendHeartBeat
//worker 每隔一定时间由定时器触发，而向 master 发现的协议消息
case class HeartBeat(id: String)

SparkWorker

package com.xyq.sparkmasterworker.worker

import akka.actor.{Actor, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.xyq.sparkmasterworker.common.{RegisterWorkerInfo, RegisteredWorkerInfo, SendHeartBeat,HeartBeat}
//时间单位
import scala.concurrent.duration._

//创建MasterActor,实现其receive方法
class WorkerActor(masterHost:String,masterPort:Int) extends Actor{
  //masterActorRef是Master的引用
  var masterActorRef:ActorSelection=_
  //创建一个id,用于标识一个worker
  val id = java.util.UUID.randomUUID().toString()

  //preStart()方法，用于创建masterActorRef
  override def preStart(): Unit = {
    println("preStart()调用")
    masterActorRef = context.actorSelection(s"akka.tcp://SparkMaster@${masterHost}:${masterPort}/user/MasterActor-01")
  }

  override def receive: Receive = {
    case "start" => {
      println("WokerActor启动了")
      //发送一个注册消息
      masterActorRef ! RegisterWorkerInfo(id,16,16*1024)


    }
      //worker收到注册成功消息后，做出回应
    case RegisteredWorkerInfo =>{
      println("workerid="+id+"注册成功！")

      //当注册成功后，就定义一个定时器,每隔一定时间，发送 SendHeartBeat 给自己
      import context.dispatcher
      // 说明
      //1. 0 millis  不延时，立即执行定时器
      //2. 3000 millis  表示每隔 3  秒执行一次
      //3. self: 表示发给自己
      //4. SendHeartBeat  发送的内容
      context.system.scheduler.schedule(0 millis, 3000 millis, self, SendHeartBeat)

    }
    case SendHeartBeat =>{
      println("worker = " + id + "给 master  发送心跳")
      masterActorRef ! HeartBeat(id)
    }
  }
}

object WorkerActor extends App{

  val workerHost = "127.0.0.1"
  val workerPort = 10001
  val masterHost = "127.0.0.1"
  val masterPort = 10005
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=127.0.0.1
       |akka.remote.netty.tcp.port=10002
""".stripMargin)
  //创建 ActorSystem
  val sparkWorkerSystem =ActorSystem("SparkWorker",config)
  //创建workerActor的引用
   val workerActor0Ref = sparkWorkerSystem.actorOf(Props(new WorkerActor(masterHost,masterPort)),"workerActor01")
  workerActor0Ref ! "start"
}

SparkMaster

package com.xyq.sparkmasterworker.master

import akka.actor.{Actor, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.xyq.sparkmasterworker.common.{HeartBeat, RegisterWorkerInfo, RegisteredWorkerInfo, WorkerInfo}

import scala.collection.mutable

//创建MasterActor,实现其receive方法
class MasterActor extends Actor{
  //创建一个HashMap用于存放worker的注册信息
  val workers =  mutable.Map[String,WorkerInfo]()

  override def receive: Receive = {
    case "start" => println("master服务器启动了")
    case RegisterWorkerInfo(id,cpu,ram)  =>{
      println("接收到注册消息")
      if (!workers.contains(id)){
        //创建 WorkerInfo 对象
        val workerInfo = new WorkerInfo(id,cpu,ram)
        //加入到 workers
        workers += ((id,workerInfo))
        println("服务器的 workers=" + workers)
        //回复一个消息，说注册成功
        sender() ! RegisteredWorkerInfo

      }
    }
    case HeartBeat(id)=>{
      //更新对应的 worker 的心跳时间
      //1.从 workers 取出 WorkerInfo
      val workerInfo = workers(id)
      workerInfo.lastHeartBeat = System.currentTimeMillis()
      println("master 更新了 " + id + " 心跳时间...")
    }
  }
}

object SparkMaster extends App{

  //创建ActorSystem
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=127.0.0.1
       |akka.remote.netty.tcp.port=10005
""".stripMargin)
  val sparkMasterSystem =ActorSystem("SparkMaster", config)

  //创建masterActor对象，及其引用
  private val masterActorRef = sparkMasterSystem.actorOf(Props[MasterActor], "MasterActor-01")

  //启动masterActor
  masterActorRef ! "start"
}
实现功能 3-Master 启动定时任务，定时检测注册的 worker

功能要求：Master 启动定时任务，定时检测注册的 worker 有哪些没有更新心跳，已经超时的 worker，将其从 hashmap 中删除掉
在这里插入图片描述
MessageProtocol

package com.xyq.sparkmasterworker.common

// worker 注册信息
case class RegisterWorkerInfo(id: String, cpu: Int, ram: Int)

// 这个是 WorkerInfo, 这个信息将来是保存到 master 的 hm(该 hashmap 是用于管理 worker)
//这个 WorkerInfo 还会扩展（比如增加 worker 这一次的心跳时间）
class WorkerInfo(val id: String, val cpu: Int, val ram: Int){
  var lastHeartBeat : Long = System.currentTimeMillis()
}

// 当 worker 注册成功，服务器返回一个 RegisteredWorkerInfo 对象
case object RegisteredWorkerInfo

//worker 每隔一定时间由定时器发给自己的一个消息
case object SendHeartBeat
//worker 每隔一定时间由定时器触发，而向 master 发现的协议消息
case class HeartBeat(id: String)


//master 给自己发送一个触发检查超时 worker 的信息
case object StartTimeOutWorker
// master 给自己发消息，检测 worker,对于心跳超时的.
case object RemoveTimeOutWorker

SparkMaster

package com.xyq.sparkmasterworker.master

import akka.actor.{Actor, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.xyq.sparkmasterworker.common._

import scala.collection.mutable

//时间单位
import scala.concurrent.duration._

//创建MasterActor,实现其receive方法
class MasterActor extends Actor{
  //创建一个HashMap用于存放worker的注册信息
  val workers =  mutable.Map[String,WorkerInfo]()

  override def receive: Receive = {
    case "start" =>{
      println("master服务器启动了")
      //这里开始。。
      self ! StartTimeOutWorker

    }
    case StartTimeOutWorker=>{
      println("开始了定时检测 worker 心跳的任务")
      import context.dispatcher
      //说明
      //1. 0 millis 不延时，立即执行定时器
      //2. 9000 millis 表示每隔 3 秒执行一次
      //3. self:表示发给自己
      //4. RemoveTimeOutWorker 发送的内容
      context.system.scheduler.schedule(0 millis, 9000 millis, self, RemoveTimeOutWorker)
    }

    case RemoveTimeOutWorker=>{
      //首先得到所有的 workers 的 所有 WorkerInfo
      val workerInfos = workers.values
      val nowTime = System.currentTimeMillis()
      //先把超时的所有 workerInfo,删除即可
      workerInfos.filter(workerInfo => (nowTime - workerInfo.lastHeartBeat) > 6000)
        .foreach(workerInfo=>workers.remove(workerInfo.id))
      println("当前有 " + workers.size + " 个 worker 存活的")
    }

    case RegisterWorkerInfo(id,cpu,ram)  =>{
      println("接收到注册消息")
      if (!workers.contains(id)){
        //创建 WorkerInfo 对象
        val workerInfo = new WorkerInfo(id,cpu,ram)
        //加入到 workers
        workers += ((id,workerInfo))
        println("服务器的 workers=" + workers)
        //回复一个消息，说注册成功
        sender() ! RegisteredWorkerInfo

      }
    }
    case HeartBeat(id)=>{
      //更新对应的 worker 的心跳时间
      //1.从 workers 取出 WorkerInfo
      val workerInfo = workers(id)
      workerInfo.lastHeartBeat = System.currentTimeMillis()
      println("master 更新了 " + id + " 心跳时间...")
    }
  }
}

object SparkMaster extends App{

  //创建ActorSystem
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=127.0.0.1
       |akka.remote.netty.tcp.port=10005
""".stripMargin)
  val sparkMasterSystem =ActorSystem("SparkMaster", config)

  //创建masterActor对象，及其引用
  private val masterActorRef = sparkMasterSystem.actorOf(Props[MasterActor], "MasterActor-01")

  //启动masterActor
  masterActorRef ! "start"
}

SparkWorker

package com.xyq.sparkmasterworker.worker

import akka.actor.{Actor, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.xyq.sparkmasterworker.common.{RegisterWorkerInfo, RegisteredWorkerInfo, SendHeartBeat,HeartBeat}
//时间单位
import scala.concurrent.duration._

//创建MasterActor,实现其receive方法
class WorkerActor(masterHost:String,masterPort:Int) extends Actor{
  //masterActorRef是Master的引用
  var masterActorRef:ActorSelection=_
  //创建一个id,用于标识一个worker
  val id = java.util.UUID.randomUUID().toString()

  //preStart()方法，用于创建masterActorRef
  override def preStart(): Unit = {
    println("preStart()调用")
    masterActorRef = context.actorSelection(s"akka.tcp://SparkMaster@${masterHost}:${masterPort}/user/MasterActor-01")
  }

  override def receive: Receive = {
    case "start" => {
      println("WokerActor启动了")
      //发送一个注册消息
      masterActorRef ! RegisterWorkerInfo(id,16,16*1024)


    }
      //worker收到注册成功消息后，做出回应
    case RegisteredWorkerInfo =>{
      println("workerid="+id+"注册成功！")

      //当注册成功后，就定义一个定时器,每隔一定时间，发送 SendHeartBeat 给自己
      import context.dispatcher
      // 说明
      //1. 0 millis  不延时，立即执行定时器
      //2. 3000 millis  表示每隔 3  秒执行一次
      //3. self: 表示发给自己
      //4. SendHeartBeat  发送的内容
      context.system.scheduler.schedule(0 millis, 3000 millis, self, SendHeartBeat)

    }
    case SendHeartBeat =>{
      println("worker = " + id + "给 master  发送心跳")
      masterActorRef ! HeartBeat(id)
    }
  }
}

object WorkerActor extends App{

  val workerHost = "127.0.0.1"
  val workerPort = 10001
  val masterHost = "127.0.0.1"
  val masterPort = 10005
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=127.0.0.1
       |akka.remote.netty.tcp.port=10004
""".stripMargin)
  //创建 ActorSystem
  val sparkWorkerSystem =ActorSystem("SparkWorker",config)
  //创建workerActor的引用
   val workerActor0Ref = sparkWorkerSystem.actorOf(Props(new WorkerActor(masterHost,masterPort)),"workerActor01")
  workerActor0Ref ! "start"
}
XYQ2022
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Spark】Spark 消息通信架构
w1992wishes的博客
11-15 2283
本篇结构： 前言 几个重要概念 Spark RpcEnv Spark RpcEndpoint Spark RpcEndpointRef RpcEnv 和 RpcEndpoint 关系类图 Dispatcher 和 Inbox Outbox 时序图 一、前言 在 Spark 事件总线 一篇中有介绍组件内之间的通信，那 Spark 集群内，各组件之间又是怎么通信的？ Spark 有内置的 RPC ...
spark 启动消息通信基本过程源码阅读(一)
u012133048的博客
12-26 295
spark 启动消息通信基本过程 spark启动过程主要是进程maste和worker之间的通信： 1、worker节点向master节点发送注册消息 2、注册成功后，返回注册成功消息或者失败消息。 3、worker定时发送心跳给master。 具体流程图如下所示： 1、 a)、当master启动后，随之启动各worker，worker启动时会创建通信环境RpcEnv...
Spark中master、worker、executor和driver的关系
热门推荐
hongmofang10的博客
11-28 2万+
刚刚接触Spark的时候对这些概念没有好好思考，走马观花似的扫过去了，后面碰到master、worker、executor和driver的时候，也就没想太多，最近刚刚跑通了一个spark项目，准备好好研究一下程序的运行原理，却突然发现对于master、worker、executor和driver一知半解，对这些概念没有很好地理解，实在难以深入学习spark，于是，查了一些资料，做了一些简单的记载供...
Spark-Core源码精读(1)、从start-all脚本到Master、work源码启动分析
qq_32736999的博客
12-30 293
首先来到这里的同学应该都学了spark相关知识，对于master跟work的启动注册源码感兴趣的可以往下看看 master的启动注册机制 首先看一下start-master.sh脚本 这是最后一行代码，可见他去调用了spark-daemen。Sh，传了一个参数class 然后进入spark-daemon.sh脚本里看看 发现里面有一个模式匹配，匹配我们传过来的值，如果参数是一个类，就调用第一...
实时计算框架：Spark集群搭建与入门案例.docx
04-26
启动后，Master和Worker进程会在相应节点上启动。 5. **验证集群状态**：访问Spark Web UI，默认端口为8080，可以查看集群状态。 入门案例展示了如何运行一个简单的Spark程序。通过`spark-submit`命令提交一个Spark...
Spark-master
05-24
在Spark源码中，`org.apache.spark.SparkMaster`是Master的主要实现类，包含了处理worker注册、driver注册、资源请求等核心功能。`org.apache.spark.deploy.master.Master`是Spark Master的主入口点，负责启动和监听...
23：Spark2.3.x分布式集群安装部署.zip
最新发布
03-08
然后，在每个Worker节点上启动Worker进程，执行`sbin/start-slave.sh <master-url>`，指定Master的URL。 5. **验证安装**：访问Master的Web UI（默认为http://master-ip:8080），查看集群状态，包括Master、Worker...
Spark实验：Standalone模式安装部署（带答案）1
08-03
7. **验证安装部署**：通过jps命令检查各节点的进程，确保Spark Master和Worker正常运行，同时可访问Web UI进行监控。 **五、注意事项** 1. 在配置过程中，务必确保环境变量设置正确，避免因路径错误导致的问题。 ...
Spark启动过程中遇到的错误 ./spark-shell –master spark://node001:7077
01-20
./spark-shell --master spark://node001:7077 --driver-memory 512M ``` 3. **验证配置**： - 重新启动Spark Shell后，确保错误不再出现。如果仍然出现问题，可能需要检查其他相关配置，如JVM堆大小、操作系统...
Spark中的Master和Worker
Queen0809的博客
04-21 2223
Master和Worker集群资源管理 1.Master是spark中资源调度系统的Leader，管理整个集群的资源信息，类似于yarn中的ResourceManager 2.Worker是spark中资源调度系统的slave，管理所在结点的资源信息，类似于yarn中的NodeManager 3.在standalone模式下，Master和Worker是必须启动的 ...
第35课Spark Master、Worker、Driver、Executor工作流程详解
zhumr的专栏
09-12 2万+
第35课Spark Master、Worker、Driver、Executor工作流程详解
Spark Master和Work启动过程
zhaomeng1123的专栏
11-17 1515
参考 Spark core篇一：Spark源码Master Worker启动消息通信
Spark分析之Master、Worker以及Application三者之间如何建立连接
weixin_34013044的博客
07-05 214
Master.preStart(){ 　　webUi.bind() 　　context.system.scheduler.schedule(0 millis, WORKER_TIMEOUT millis, self, CheckForWorkerTimeOut) //定时任务检测是否有DEAD WORKER需要移除 　　case CheckForWorkerTimeOut =&g...
com.alibaba.druid.pool.GetConnectionTimeoutException: wait millis 3000, active 16,maxActive 16
Less Is More
09-17 8955
Could not open JDBC Connection for transaction; nested exception is com.alibaba.druid.pool.GetConnectionTimeoutException: wait millis 3000, active 16, maxActive 16" 这个异常可能是因为druid连接池泄漏产生的异常。连接超时，active和maxActive相等，不能够创建新的连接，如果很长时间还获取不到，很有可能是连接池泄漏造成的，而且没有开
Spark中master与worker的进程通信实现
自由幻想的博客
01-27 2517
1.构建master的actor package SparkRPC import akka.actor.{Actor, ActorSystem, Props} import com.typesafe.config.ConfigFactory import scala.collection.mutable /** * Created by hqs on 2018/1/24. * 1.
递归（Scala）
weixin_44007155的博客
10-02 358
递归简单示例： def test1(n:Int){ if(n>2){ test1(n-1) } println("n="+n) } 调用结果： 底层机制： 如图所示： 在栈中开辟一个函数栈test(4) 运行到test(3)时，在栈中开辟一个新的函数栈test(3)， 运行到test(2)时，在栈中开辟一个新的函数栈test(2)， 当n=2时...
spark中master和worker之间的进程通讯（心跳机制）
liyang7916的博客
01-22 992
模拟spark源码的心跳机制 worker注册到Master, Master完成注册，并回复worker注册成功 worker定时发送心跳 Master接收到worker心跳后，要更新该worker的最近一次发送心跳的时间 给Master启动定时任务，定时检测注册的worker有哪些没有更新心跳,并将其从hashmap中删除 这个项目总体分三部分（三个模块） worker向master完成注册 worker定时向master发送心跳信息 master启动定时任务，定时监测worker.
spark 通信机制
chenguangchun1993的博客
12-06 2781
bute对于Network通信，不管传输的是序列化后的对象还是文件，在网络上表现的都是字节流。在传统IO中，字节流表示为Stream；在NIO中，字节流表示为ByteBuffer；在Netty中字节流表示为ByteBuff或FileRegion；在Spark中，针对Byte也做了一层包装，支持对Byte和文件流进行处理，即ManagedBuffer；ManagedBuffer是一个接口，包含了三个函
Spark架构解析：Master、Worker与Executor的协同
而Worker节点则运行Worker守护进程，这些进程与Master节点通信，并且负责管理Executor的生命周期。 Driver程序是应用程序的主入口点，即运行main()函数的部分，它创建SparkContext对象。在不同的运行模式下，Driver...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值