Akka学习笔记03--计算多个句子中每个单词出现的次数

***********

（暂时粗略写下，用空扩充。。）

用到的主要方法(可参考：Akka学习笔记06--Actor的消息)：

1.tell，！。

2.ask，？。

3.sender。

4.RoundRobinRouter，如代码段：

      val reduceActor=context.actorOf(Props[ReduceActor].withRouter(

   RoundRobinRouter(nrOfInstances = 5)), name = "reduce")

****

代码：

********************************************************************************************************************

1. package com.akka.mapreduce  
2.   
3. import akka.actor.{ActorSystem, Actor, Props}  
4. import akka.routing.RoundRobinRouter  
5. import scala.collection.mutable.HashMap  
6. import scala.concurrent.Await  
7. import scala.collection.immutable.Map  
8. import scala.collection.mutable.ArrayBuffer  
9. import akka.actor.actorRef2Scala  
10. import akka.pattern.ask  
11. import akka.util.Timeout  
12.   
13. /**  
14.  * Created by laiwenqiang on 15/2/2.  
15.  */  
16.   
17. sealed trait MapReduceMessage  
18. case class WordCount(word: String, index: Int) extends MapReduceMessage  
19. case class MapData(dataList: ArrayBuffer[WordCount]) extends MapReduceMessage  
20. case class ReduceData(reduceDataList: Map[String, Int]) extends MapReduceMessage  
21. case class Result() extends MapReduceMessage  
22.   
23. object MapReduceApplication extends App{  
24.   val _system = ActorSystem("MapReduceApp")  
25.   val master = _system.actorOf(Props[MasterActor], name = "master")  
26.   implicit val timeout = Timeout(5000)  
27.   
28.   master ! "The quick brown fox tried to jump over the lazy dog and fell on the dog"  
29.   master ! "Dog is man's best friend"  
30.   master ! "Dog and Fox belong to the same family"  
31.   
32.   Thread.sleep(500)  
33.   
34.   val future = (master ? Result).mapTo[String]  
35.   val result = Await.result(future, timeout.duration)  
36.   println(result)  
37.   _system.shutdown  
38.   
39. }  
40.   
41. class MasterActor extends Actor {  
42.   val mapActor = context.actorOf(Props[MapActor].withRouter(  
43.     RoundRobinRouter(nrOfInstances = 5)), name = "map")  
44.   val reduceActor = context.actorOf(Props[ReduceActor].withRouter(  
45.     RoundRobinRouter(nrOfInstances = 5)), name = "reduce")  
46.   val aggregateActor = context.actorOf(Props[AggregateActor],  
47.     name = "aggregate")  
48.   def receive: Receive = {  
49.     case line: String =>  
50.       mapActor ! line  
51.     case mapData: MapData =>  
52.       reduceActor ! mapData  
53.     case reduceData: ReduceData =>  
54.       aggregateActor ! reduceData  
55.     case Result =>  
56.       aggregateActor forward Result  
57.   }  
58. }  
59.   
60. class MapActor extends Actor {  
61.   val STOP_WORDS_LIST = List("a", "am", "an", "and", "are", "as",  
62.     "at", "be", "do", "go", "if", "in", "is", "it", "of", "on", "the",  
63.     "to")  
64.   val defaultCount: Int = 1  
65.   def receive: Receive = {  
66.     case message: String =>  
67.       sender ! evaluateExpression(message)  
68.   }  
69.   def evaluateExpression(line: String): MapData = MapData {  
70.     line.split("""\s+""").foldLeft(ArrayBuffer.empty[WordCount]) {  
71.       (index, word) =>  
72.       if(!STOP_WORDS_LIST.contains(word.toLowerCase))  
73.         index += WordCount(word.toLowerCase, 1)  
74.       else index  
75.     } }  
76. }  
77.   
78. class ReduceActor extends Actor {  
79.   def receive: Receive = {  
80.     case MapData(dataList) =>  
81.       sender ! reduce(dataList)  
82.   }  
83.   def reduce(words: IndexedSeq[WordCount]): ReduceData = ReduceData {  
84.     words.foldLeft(Map.empty[String, Int]) {  (index, words) =>  
85.       if (index contains words.word)  
86.         index + (words.word -> (index.get(words.word).get + 1))  
87.       else  
88.         index + (words.word -> 1)  
89.     }  
90.   } }  
91.   
92.   
93. class AggregateActor extends Actor {  
94.   val finalReducedMap = new HashMap[String, Int]  
95.   def receive: Receive = {  
96.     case ReduceData(reduceDataMap) =>  
97.       aggregateInMemoryReduce(reduceDataMap)  
98.     case Result =>  
99.       sender ! finalReducedMap.toString()  
100.   }  
101.   def aggregateInMemoryReduce(reducedList: Map[String, Int]): Unit = {  
102.     for ((key,value) <- reducedList) {  
103.       if (finalReducedMap contains key)  
104.         finalReducedMap(key) = (value + finalReducedMap.get(key).get)  
105.       else  
106.         finalReducedMap += (key -> value)  
107.     }  
108.   }  
109. }  

***************************************************************************************

输出结果：Map(dog -> 4, lazy -> 1, jump -> 1, fell -> 1, man's -> 1, family -> 1, belong -> 1, over -> 1, friend -> 1, fox -> 2, tried -> 1, quick -> 1, same -> 1, best -> 1, brown -> 1)

tips：参考于《Akka.Essentials》第二章。