本文介绍akka的基本使用方法，由于属于基础功能，想不出一个很高大上的名称，此处就以基础模式命名。下文会介绍actor的使用方法，及其优劣点。
class SimpleActor(name:String) extends Actor {
private def doWork(message:SayHello):Unit = {
println(s"$name 收到 ${message.from.path.name} 的消息 [$message] ，工作进行中... 当前线程号 ${Thread.currentThread().getId}")
}
override def receive: Receive = {
case msg @ SayHello(from,message) =>
doWork(msg)
val returnMsg = HelloSaid(s"嗨 ${from.path.name} ,${self.path.name} 收到了 $message 消息")
println(s"$name 工作结束，准备返回消息[${returnMsg.message}]")
}
}
object SimpleBasicPattern {
def main(args: Array[String]): Unit = {
val system = ActorSystem("BasicPattern",ConfigFactory.load())
val person1 = system.actorOf(Props(new SimpleActor("person1")),"personActor1")
println(s"Main thread Id ${Thread.currentThread().getId}")
person1 ! SayHello(person1,"Hello World 1")
person1 ! SayHello(person1,"Hello World 2")
}
}
输出： Main thread Id 1 person1 收到 personActor1 的消息 [SayHello(Actor[akka://BasicPattern/user/personActor1#1662593548],Hello World 1)] ，工作进行中... 当前线程号 13 person1 工作结束，准备返回消息[嗨 personActor1 ,personActor1 收到了 Hello World 1 消息] person1 收到 personActor1 的消息 [SayHello(Actor[akka://BasicPattern/user/personActor1#1662593548],Hello World 2)] ，工作进行中... 当前线程号 13 person1 工作结束，准备返回消息[嗨 personActor1 ,personActor1 收到了 Hello World 2 消息]
如上图，我设计了一个简单的actor：HelloWroldActor。它有两个方法，其中receive是收到消息之后处理消息的入口函数，定义了对消息的处理方式。收到SayHello之后，调用doWork同步处理消息
我们可以跟上一篇博客进行对比，此处给person1发送了一条SayHello消息，在OOP中是直接调用函数，此处使用 ！ 函数发送消息；person1收到消息后，同步调用doWork处理消息。这是最基本的actor使用方式：通过 ！ 发消息给actor。从输出中可以看到，主线程和doWork所在线程是不同的线程。
这是基础模式的最基本形式，给actor发送消息，actor对消息进行响应，发送和响应是异步的，同一个actor对所有的消息都是按照邮箱队列的顺序，串行调用的。下面是基础模式的另外一种高级形式。
class HelloWorldActor(other:ActorRef,name:String) extends Actor {
private def doWork(message:String):HelloSaid = {
println(s"$name 收到 ${other.path.name} 的消息 [$message] ，工作进行中...")
HelloSaid("这是处理后返回的消息")
}
override def receive: Receive = {
case DoWork(message) =>
println(s"嗨 ${other.path.name} ，我正在为你工作")
val returnMsg = doWork(message)
other ! WorkDone(returnMsg.message)
case WorkDone(message) =>
println(s"$name 收到了 ${sender().path.name} 的回复消息：[$message]")
}
}
object BasicPattern {
def main(args: Array[String]): Unit = {
val system = ActorSystem("BasicPattern",ConfigFactory.load())
val person1 = system.actorOf(Props(new HelloWorldActor(null,"person1")),"personActor1")
val person2 = system.actorOf(Props(new HelloWorldActor(person1,"person2")),"personActor2")
person2 ! DoWork("Hello World")
}
}
输出： 嗨 personActor1 ，我正在为你工作 person2 收到 personActor1 的消息 [Hello World] ，工作进行中... person1 收到了 personActor2 的回复消息：[嗨 personActor1 工作已完成，这是返回消息 HelloSaid(这是处理后返回的消息)]
在上面的模式中，我们首先给person2发送了开始工作的消息，person2收到消息后，开始为person1工作：调用doWork进行计算。计算结束后把消息发送给了person1，person1收到workDone的消息后，将结果打印了出来。这个例子稍微复杂点，涉及到了两个actor的通信。但这仍然是一种简单的形式，因为person1的actorRef引用是通过构造函数传递给person2的，这样person2就只能为person1工作。这非常不方便，因为actor创建的时候不一定能知道另外一个actor的地址。那么下面又是一种高级形式：
class HelloActor(name:String) extends Actor {
private def doWork(message:String,forActor:ActorRef):HelloSaid = {
println(s"$name 收到 ${forActor.path.name} 的消息 [$message] ，工作进行中...")
HelloSaid("这是处理后返回的消息")
}
override def receive: Receive = {
case DoWorkFor(message,forActor) =>
println(s"嗨 ${forActor.path.name} ，我正在为你工作")
val returnMsg = doWork(message,forActor)
forActor ! WorkDone(returnMsg.message)
case WorkDone(message) =>
println(s"$name 收到了 ${sender().path.name} 的回复消息：[$message]")
}
}
object BasicPattern3 {
def main(args: Array[String]): Unit = {
val system = ActorSystem("BasicPattern2",ConfigFactory.load())
val person1 = system.actorOf(Props(new HelloActor("person1")),"personActor1")
val person2 = system.actorOf(Props(new HelloActor("person2")),"personActor2")
person2 ! DoWorkFor("Hello World",person1)
}
}
输出： 嗨 personActor1 ，我正在为你工作 person2 收到 personActor1 的消息 [Hello World] ，工作进行中... person1 收到了 personActor2 的回复消息：[这是处理后返回的消息]
在上面的图中，我们把person1的actorRef通过消息的形式发送给了person2，这样person2就能为不同的person工作了，因为工作的对象是通过消息传递的。
通过上面3个例子，我们可以看到，只能通过给actor发送消息与actor通信，调用其对应的函数，函数的返回结果也只能异步的发送给调用方。而在OOP中调用另一个对象的函数，看起来比这个简单多了，获取函数处理结果也非常简单。但读者要仔细思考这两者的区别，actor的通信全都是异步的。意味着person2给person1发送消息之后，可以立即进行其他的处理，而不需要等待person1的应答，即person1和person2功能做到了完全解耦。
BasicPattern2和BasicPattern3的区别是调用方获取方式的不同，其实还有另外一种形式：
class Master(workerPath:String) extends Actor{
override def receive: Receive = {
case DoWork(message) =>
println(s"master 收到 doWork消息:$message")
val worker = context.actorSelection( s"/user/$workerPath")
worker ! DoWorkFor(message,self)
case WorkDone(message) =>
println(s"master 收到 ${sender().path.name} 的返回消息 $message")
}
}
class Worker extends Actor{
private def doWork(message:String):String = {
println(s"worker 收到了消息 $message")
"这里是worker返回消息"
}
override def receive: Receive = {
case DoWorkFor(message,forActor) =>
val result = doWork(message)
forActor ! WorkDone(result)
}
}
object BasicPattern4 {
def main(args: Array[String]): Unit = {
val system = ActorSystem("BasicPattern2",ConfigFactory.load())
system.actorOf(Props(new Worker()),"workerActor")
val master = system.actorOf(Props(new Master("workerActor")),"masterWorker")
master ! DoWork("Hello World")
}
}
输出 master 收到 doWork消息:Hello World worker 收到了消息 Hello World master 收到 workerActor 的返回消息 这里是worker返回消息
在这个形式中，master通过worker的actorPath，用actorSelection查询了worker的地址，然后发送消息给它。与BasicPattern3不同的是，master不需要知道worker的邮箱地址，它只需要知道worker的actorPath就可以发消息了。然后master和worker就可以按照前面的pattern互通消息了。
请注意DoWork、WorkDone、DoWork这三个消息的处理完全是异步的，没有任何直接的关系。
上面的4个例子我都将其认定为基础模式，因为这都是Akka的基础功能，没有涉及太高深的技术，也是在学习Akka的初期最容易理解的模式。虽然简单，还是有很多值得学习的地方的。在下一篇博客中，我们会针对BasicPattern4进行优化，讲解另外MasterWorkerBackend模式，这种模式比较复杂，希望读者深刻理解本博文的4个例子，再阅读后续文章。
