Akka编写一个RPC框架，模拟多个Worker连接Master的情况的案例

使用Akka编写一个RPC框架，实现Master与多个Worker之间的通信。流程图如下：

编写Pom文件，Pom文件的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.toto.akka</groupId>
    <artifactId>MyRPC</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <encoding>UTF-8</encoding>
        <scala.version>2.10.6</scala.version>
        <scala.compat.version>2.10</scala.compat.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>

        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor_2.10</artifactId>
            <version>2.3.14</version>
        </dependency>

        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-remote_2.10</artifactId>
            <version>2.3.14</version>
        </dependency>

    </dependencies>

    <build>
        <!-- 源码包放置的位置 -->
        <sourceDirectory>src/main/scala</sourceDirectory>
        <testSourceDirectory>src/test/scala</testSourceDirectory>
        <plugins>
            <!--专门用于编译scala的插件-->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                        <configuration>
                            <args>
                                <arg>-make:transitive</arg>
                                <arg>-dependencyfile</arg>
                                <arg>${project.build.directory}/.scala_dependencies</arg>
                            </args>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!--主要使用来的打包的插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <!--表示把下面的这些文件给删掉-->
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>reference.conf</resource>
                                </transformer>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>cn.toto.akka.Worker</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Message的代码如下：

package cn.toto.akka

/**
  * Created by toto on 2017/7/3.
  */
trait Message extends Serializable

//Worker -> Master worker向master发送相关信息
case class RegisterWorker(id: String, cores: Int, memory: Int) extends Message

//Master -> Worker  Master向worker发送相关信息
case class RegisteredWorker(masterUrl: String) extends Message

//Worker -> Master
case class Heartbeat(id: String) extends Message

//Worker internal message
case object SendHeartbeat

//Master internal message
case object CheckTimeOutWorker

WorkerInfo的代码如下：

package cn.toto.akka

/**
  * Created by toto on 2017/7/3.
  */
class WorkerInfo(val id: String, val cores: Int, val memory: Int) {
  //TODO
  var lastHeartbeatTime: Long = _
}

Master的代码如下：

package cn.toto.akka

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

import scala.collection.mutable

//如果想使用millis毫秒单位，需要引入下面这个包
import scala.concurrent.duration._

/**
  * Created by toto on 2017/7/3.
  */
class Master(val host: String, val port: Int) extends Actor{

  //保存WorkerID 到 WorkerInfo的映射
  val idToWorker = new mutable.HashMap[String, WorkerInfo]()
  //保存所的WorkerInfo信息
  val workers = new mutable.HashSet[WorkerInfo]()

  val CHECK_INTERVAL = 15000

  override def preStart(): Unit = {
    //导入隐式转换
    import context.dispatcher
    context.system.scheduler.schedule(0 millis, CHECK_INTERVAL millis, self, CheckTimeOutWorker)
  }

  override def receive: Receive = {
    //Worker发送个Mater的注册消息
    case RegisterWorker(workerId, cores, memory) => {
      if(!idToWorker.contains(workerId)) {
        //封装worker发送的信息
        val workerInfo = new WorkerInfo(workerId, cores, memory)
        //保存workerInfo
        idToWorker(workerId) = workerInfo
        workers += workerInfo
        //Master向Worker反馈注册成功的消息
        sender ! RegisteredWorker(s"akka.tcp://${Master.MASTER_SYSTEM}@$host:$port/user/${Master.MASTER_NAME}")
      }
    }

    //Worker发送给Master的心跳信息
    case Heartbeat(workerId) => {
      if(idToWorker.contains(workerId)) {
        val workerInfo = idToWorker(workerId)
        val currentTime = System.currentTimeMillis()
        //更新上一次心跳时间
        workerInfo.lastHeartbeatTime = currentTime
      }
    }

    //检测超时的Worker
    case CheckTimeOutWorker => {
      val currentTime = System.currentTimeMillis()
      val deadWorkers: mutable.HashSet[WorkerInfo] = workers.filter(w => currentTime - w.lastHeartbeatTime > CHECK_INTERVAL)
      //      for(w <- deadWorkers) {
      //        idToWorker -= w.id
      //        workers -= w
      //      }
      deadWorkers.foreach(w => {
        idToWorker -= w.id
        workers -= w
      })
      println("alive worker size : " + workers.size)
    }
  }
}

object Master {
  val MASTER_SYSTEM = "MaterActorSystem"
  val MASTER_NAME = "Master"

  def main(args: Array[String]): Unit = {
    val host = args(0)
    val port = args(1).toInt
    val confStr =
      s"""
         |akka.actor.provider = "akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname = "$host"
         |akka.remote.netty.tcp.port = "$port"
       """.stripMargin
    val conf = ConfigFactory.parseString(confStr)
    //ActorSystem是单例的，用于创建Acotor并监控actor
    val actorSystem = ActorSystem(MASTER_SYSTEM, conf)
    //通过ActorSystem创建Actor
    actorSystem.actorOf(Props(new Master(host, port)), MASTER_NAME)
    actorSystem.awaitTermination()
  }
}

worker的代码如下：

package cn.toto.akka

import java.util.UUID

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

import scala.concurrent.duration._

/**
  * Created by toto on 2017/7/3.
  */
class Worker(val cores: Int, val memory: Int, val masterHost: String, val masterPort: Int) extends Actor{

  //Master的引用
  var master: ActorSelection = _
  //Worker的ID
  val workerId = UUID.randomUUID().toString
  //masterUrl
  var masterUrl: String = _

  val HEARTBEAT_INTERVAL = 10000

  //preStart在构造器之后receive之前执行
  override def preStart(): Unit = {
    //首先跟Master建立连接
    master = context.actorSelection(s"akka.tcp://${Master.MASTER_SYSTEM}@$masterHost:$masterPort/user/${Master.MASTER_NAME}")
    //通过master的引用向Master发送注册消息
    master ! RegisterWorker(workerId, cores, memory)
  }

  override def receive: Receive = {
    //Master发送给Worker注册成功的消息
    case RegisteredWorker(masterUrl) => {
      this.masterUrl = masterUrl
      //启动定时任务，向Master发送心跳
      //导入隐式转换
      import context.dispatcher
      context.system.scheduler.schedule(0 millis, HEARTBEAT_INTERVAL millis, self, SendHeartbeat)
    }

    case SendHeartbeat => {
      //向Master发送心跳
      master ! Heartbeat(workerId)
    }
  }
}

object Worker {
  def main(args: Array[String]): Unit = {
    //Worker的地址和端口
    val host = args(0)
    val port = args(1).toInt
    val cores = args(2).toInt
    val memory = args(3).toInt
    //Master的地址和端口
    val masterHost = args(4)
    val masterPort = args(5).toInt

    val confStr =
      s"""
         |akka.actor.provider = "akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname = "$host"
         |akka.remote.netty.tcp.port = "$port"
       """.stripMargin
    val conf = ConfigFactory.parseString(confStr)
    //单例的ActorSystem
    val actorSystem = ActorSystem("WorkerActorSystem", conf)
    //通过actorSystem来创建Actor
    val worker = actorSystem.actorOf(Props(new Worker(cores, memory, masterHost, masterPort)), "Worker")
    actorSystem.awaitTermination()
  }
}

运行Master的代码：
准备工作：

接着模拟传入的参数：

接着右键Run Master，效果如下：

运行Woker程序
模拟传入的参数：

右键运行Worker的代码，效果如下：