Scala之Akka编写一个简单的RPC框架（模拟多个Worker连接Master）

最新推荐文章于 2021-02-20 15:37:35 发布

Therefore丶

最新推荐文章于 2021-02-20 15:37:35 发布

阅读量197

点赞数

分类专栏：大数据框架文章标签： Scala RPC 通信

本文链接：https://blog.csdn.net/u010051036/article/details/89479521

版权

大数据框架专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1，需求概述：（使用Akka模型，实现一个简单的RPC通信框架）

1）workder启动时，向master发送注册信息

2）mater将workder的注册信息保存（此处用可变的map），并向worker发送注册成功信息

3）worker定期向master发送心跳信息，证明自身还活着

4）master定期检测worker，如果workder已经挂掉了，将保存的workder信息给移除

2，Master

package com.it.scala.spark

import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import com.typesafe.config.ConfigFactory

import scala.collection.mutable
import scala.collection.mutable.ListBuffer
import scala.concurrent.duration._


//todo:利用akka实现简易版的spark通信框架-----Master端

class SparkMaster extends Actor {
  //构造代码块先被执行
  println("master constructor invoked")

  //定义一个map集合，用于存放worker信息
  private val workerMap = new mutable.HashMap[String, WorkerInfo]()

  //定义一个list集合，用于存放WorkerInfo信息，方便后期按照worker上的资源进行排序
  private val workerList = new ListBuffer[WorkerInfo]

  //master定时检查的时间间隔
  val CHECK_OUT_TIME_INTERVAL = 5000 //5秒

  //prestart方法会在构造代码块执行后被调用，并且只被调用一次（初始化方法）
  override def preStart(): Unit = {
    println("preStart method invoked")

    //master定时检查超时的worker
    //需要手动导入隐式转换
//    import context.dispatcher
    //用context.system.scheduler.schedule设置定时任务，第一个参数是延迟时间，第二个参数是频率时间，
    // 第三个参数self表示指向actor自己的引用，第四个参数才是真正发送的消息
    context.system.scheduler.schedule(0 millis, CHECK_OUT_TIME_INTERVAL millis, self, CheckOutTime)
  }

  //receive方法会在prestart方法执行后被调用，该方法会不断的被调用，以接收消息
  override def receive: Receive = {
    //master接受worker的注册信息，消息类型是RegisterMessage，注意这里需要带上参数才能进行正确的匹配
    case RegisterMessage(workerId, memory, cores) => {
      //判断当前worker是否已经注册
      if (!workerMap.contains(workerId)) {
        //保存信息到map集合中
        val workerInfo = new WorkerInfo(workerId, memory, cores)
        workerMap.put(workerId, workerInfo)
        //保存workerinfo到list集合中
        workerList += workerInfo

        //master反馈注册成功给worker
        sender ! RegisteredMessage(s"workerId:$workerId 注册成功")
      }
    }

    //master接受worker的心跳信息
    case SendHeartBeat(workerId) => {
      //判断worker是否已经注册，master只接受已经注册过的worker的心跳信息
      if (workerMap.contains(workerId)) {
        //获取workerinfo信息
        val workerInfo: WorkerInfo = workerMap(workerId)
        //获取当前系统时间
        val lastTime: Long = System.currentTimeMillis()

        workerInfo.lastHeartBeatTime = lastTime
      }
    }

    //判断是否已经worker是否已经超时
    case CheckOutTime => {
      //过滤出超时的worker 判断逻辑： 获取当前系统时间 - worker上一次心跳时间 >master定时检查的时间间隔
      val outTimeWorkers: ListBuffer[WorkerInfo] = workerList.filter(x => System.currentTimeMillis() - x.lastHeartBeatTime > CHECK_OUT_TIME_INTERVAL)
      //遍历超时的worker信息，然后移除掉超时的worker
      for (workerInfo <- outTimeWorkers) {
        //获取workerid
        val workerId: String = workerInfo.workerId
        //从map集合中移除掉超时的worker信息
        workerMap.remove(workerId)
        //从list集合中移除掉超时的workerInfo信息
        workerList -= workerInfo

        println("超时的workerId:" + workerId)
      }

      println("活着的worker总数：" + workerList.size)

      //master按照worker内存大小进行降序排列
      println(workerList.sortBy(x => x.memory).reverse.toList)
    }
  }
}

object SparkMaster {
  def main(args: Array[String]): Unit = {
    //master的ip地址
    val host = "127.0.0.1"
    //master的port端口
    val port = 8888

    //准备配置文件信息
    val configStr =
      s"""
         |akka.actor.provider = "akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname = "$host"
         |akka.remote.netty.tcp.port = "$port"
      """.stripMargin

    //配置config对象 利用ConfigFactory解析配置文件，获取配置信息
    val config = ConfigFactory.parseString(configStr)

    // 1、创建ActorSystem,它是整个进程中老大，它负责创建和监督actor，它是单例对象
    val masterActorSystem = ActorSystem("masterActorSystem", config)
    // 2、通过ActorSystem来创建master actor
    val masterActor: ActorRef = masterActorSystem.actorOf(Props(new SparkMaster), "masterActor")
    // 3、向master actor发送消息
    //masterActor ! "connect"
  }
}

3，Worker

package com.it.scala.spark


import java.util.UUID

import akka.actor.{Actor, ActorRef, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import scala.concurrent.duration._


//todo:利用akka实现简易版的spark通信框架-----Worker端
class SparkWorker(val memory: Int, val cores: Int, val masterHost: String, val masterPort: String) extends Actor {
  println("Worker constructor invoked")

  //定义workerId
  private val workerId: String = UUID.randomUUID().toString

  //定义发送心跳的时间间隔
  val SEND_HEART_HEAT_INTERVAL = 10000 //10秒

  //定义全局变量
  var master: ActorSelection = _

  //prestart方法会在构造代码块之后被调用，并且只会被调用一次
  override def preStart(): Unit = {
    println("preStart method invoked")
    //获取master actor的引用
    //ActorContext全局变量，可以通过在已经存在的actor中，寻找目标actor
    //调用对应actorSelection方法，
    // 方法需要一个path路径：1、通信协议、2、master的IP地址、3、master的端口 4、创建master actor老大 5、actor层级
    master = context.actorSelection(s"akka.tcp://masterActorSystem@$masterHost:$masterPort/user/masterActor")

    //向master发送注册信息，将信息封装在样例类中，主要包含：workerId,memory,cores
    master ! RegisterMessage(workerId, memory, cores)

  }

  //receive方法会在prestart方法执行后被调用，不断的接受消息
  override def receive: Receive = {
    //worker接受master的反馈信息
    case RegisteredMessage(message) => {
      println(message)

      //向master定期的发送心跳
      //worker先自己给自己发送心跳
      //需要手动导入隐式转换
      import context.dispatcher
      context.system.scheduler.schedule(0 millis, SEND_HEART_HEAT_INTERVAL millis, self, HeartBeat)
    }
    //worker接受心跳
    case HeartBeat => {
      //这个时候才是真正向master发送心跳
      master ! SendHeartBeat(workerId)
    }
  }
}

object SparkWorker {
  def main(args: Array[String]): Unit = {
    //定义worker的IP地址
    val host = "127.0.0.1"
    //定义worker的端口
    val port = 8887

    //定义worker的内存
    val memory = 128
    //定义worker的核数
    val cores = 8
    //定义master的ip地址
    val masterHost = "127.0.0.1"
    //定义master的端口
    val masterPort = "8888"

    //准备配置文件
    val configStr =
      s"""
         |akka.actor.provider = "akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname = "$host"
         |akka.remote.netty.tcp.port = "$port"
      """.stripMargin

    //通过configFactory来解析配置信息
    val config = ConfigFactory.parseString(configStr)
    // 1、创建ActorSystem，它是整个进程中的老大，它负责创建和监督actor
    val workerActorSystem = ActorSystem("workerActorSystem", config)
    // 2、通过actorSystem来创建 worker actor
    val workerActor: ActorRef = workerActorSystem.actorOf(Props(new SparkWorker(memory, cores, masterHost, masterPort)), "workerActor")

    //向worker actor发送消息
    workerActor ! "connect"
  }
}

4，RemoteMessage

package com.it.scala.spark


//定义发送消息的特质，该特质主要用于封装消息的样例类
trait RemoteMessage extends Serializable {

}

//worker向master发送注册信息，由于不在同一进程中，需要实现序列化
case class RegisterMessage(val workerId: String, val memory: Int, val cores: Int) extends RemoteMessage

//master反馈注册成功信息给worker,由于不在同一进程中，也需要实现序列化
case class RegisteredMessage(message: String) extends RemoteMessage

//worker向worker发送心跳 由于在同一进程中，不需要实现序列化
case object HeartBeat

//worker向master发送心跳，由于不在同一进程中，需要实现序列化
case class SendHeartBeat(val workerId: String) extends RemoteMessage

//master自己向自己发送消息，由于在同一进程中，不需要实现序列化
case object CheckOutTime

5，WorkerInfo

package com.it.scala.spark

//封装worker信息
class WorkerInfo(val workerId: String, val memory: Int, val cores: Int) {
  //定义一个变量用于存放worker上一次心跳时间
  var lastHeartBeatTime: Long = _

  override def toString: String = {
    s"workerId:$workerId , memory:$memory , cores:$cores"
  }
}

6，测试

先启动Master，再启动Worker

Master端输出：

Worker端输出：

Therefore丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Scala之Akka编写一个简单的RPC框架（模拟多个Worker连接Master）

1，需求概述：（使用Akka模型，实现一个简单的RPC通信框架）1）workder启动时，向master发送注册信息2）mater将workder的注册信息保存（此处用可变的map），并向worker发送注册成功信息3）worker定期向master发送心跳信息，证明自身还活着4）master定期检测worker，如果workder已经挂掉了，将保存的workder信息给移除...
复制链接

扫一扫

专栏目录