1、Akka介绍
来自学习资料
Akka用Scala语言开发，基于Actor并发模型实现，Akka具有高可靠、高性能、可扩展等特点，使用Akka可以轻松实现分布式RPC功能。
Actor模型：在计算机科学领域，Actor模型是一个并行计算（Concurrent Computation）模型，它把actor作为并行计算的基本元素来对待：为响应一个接收到的消息，一个actor能够自己做出一些决策，如创建更多的actor，或发送更多的消息，或者确定如何去响应接收到的下一个消息。
Actor是Akka中最核心的概念，它是一个封装了状态和行为的对象，Actor之间可以通过交换消息的方式进行通信，每个Actor都有自己的收件箱（Mailbox）。通过Actor能够简化锁及线程管理，可以非常容易地开发出正确地并发程序和并行系统，Actor具有如下特性：
1.提供了一种高级抽象，能够简化在并发（Concurrency）/并行（Parallelism）应用场景下的编程开发
2.提供了异步非阻塞的、高性能的事件驱动编程模型
3.超级轻量级事件处理（每GB堆内存几百万Actor）
2、重要类介绍
1、ActorSystem
在Akka中，ActorSystem是一个重量级的结构，他需要分配多个线程，所以在实际应用中，ActorSystem通常是一个单例对象，我们可以使用这个ActorSystem创建很多
2、Actor
在Akka中，Actor负责通信，在Actor中有一些重要的生命周期方法。
1.preStart()方法：该方法在Actor对象构造方法执行后执行，整个Actor生命周期中仅执行一次。
receive()方法：该方法在Actor的preStart方法执行完成后执行，用于接收消息，会被反复执行。
2、使用akka实现一个简单啊rpc通讯框架（一）
这里先简单写个demo来感受使用akka进行通信
有个Master，一个Worker（或者多个，多个实例就行），创建Worker的时候会向Master发送一个消息，而Master接收到消息后又向Worker发送消息，Worker接收到消息后打印一句话。
创建maven项目，使用maven导包
<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>
<plugin>
<!--scala编译插件-->
<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></mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>Master类
class Master extends Actor{
println("创建Master对象...")
//初始化方法
override def preStart(): Unit = {
println("Master初始化...")
}
//不停地接收消息
override def receive: Receive = {
case "connect" => {
println("一个Worker连接了.....")
//向发送者返回消息
sender ! "reply"
}
}
}
object Master {
def main(args: Array[String]): Unit = {
//连接地址和端口号
val host = args(0)
val port = args(1).toInt
val configStr =
s"""
|akka.actor.provider = "akka.remote.RemoteActorRefProvider"
|akka.remote.netty.tcp.hostname = "$host"
|akka.remote.netty.tcp.port = "$port"
""".stripMargin
//传入配置参数获取配置
val config = ConfigFactory.parseString(configStr)
//获取ActorSystem，指定名称和配置
val masterSystem = ActorSystem("MasterSystem",config)
//创建Actor
val master = masterSystem.actorOf(Props(new Master),"master")
//自己给自己发送给消息
// master ! "connect"
masterSystem.awaitTermination()
}
}Worker类
class Worker(val masterHost : String,val masterPort : Int) extends Actor{
var master : ActorSelection =_
println("创建Worker对象...")
override def preStart(): Unit = {
//与Master建立连接，拿到master引用
master = context.actorSelection(s"akka.tcp://MasterSystem@$masterHost:$masterPort/user/master")
//向Master发送消息
master ! "connect"
}
override def receive: Receive = {
case "reply" => {
println("收到Master消息")
}
}
}
object Worker {
def main(args: Array[String]): Unit = {
val host = args(0)
val port = args(1).toInt
val masterHost = args(2)
val masterPort = args(3).toInt
val configStr =
s"""
|akka.actor.provider = "akka.remote.RemoteActorRefProvider"
|akka.remote.netty.tcp.hostname = "$host"
|akka.remote.netty.tcp.port = "$port"
""".stripMargin
//传入配置参数获取配置
val config = ConfigFactory.parseString(configStr)
//获取ActorSystem，指定名称和配置
val workerSystem = ActorSystem("WorkerSystem",config)
//创建Actor
val actor = workerSystem.actorOf(Props(new Worker(masterHost,masterPort)),"worker")
workerSystem.awaitTermination()
}
}可以在本机直接运行，指定参数即可，不做演示了。
下面放到两台机器上运行
将项目打成jar包
pom.xml中指定主类,然后打包
<mainClass>cn.itcast.rpc.Master</mainClass>
将打成的jar包传到linux上（192.168.25.127），运行
[root@mini1 ~]# java -jar my-akka-2.0.jar 192.168.25.127 8888
[INFO] [11/29/2017 05:18:56.444] [main] [Remoting] Starting remoting
[INFO] [11/29/2017 05:18:56.600] [main] [Remoting] Remoting started; listening on addresses :[akka.tcp://MasterSystem@192.168.25.127:8888]
[INFO] [11/29/2017 05:18:56.600] [main] [Remoting] Remoting now listens on addresses: [akka.tcp://MasterSystem@192.168.25.127:8888]
创建Master对象...
Master初始化...重新指定主类(Worker),打包（完全同上），打成的jar包就放到windows的D盘下
命令行输入
D:\>java -jar my-akka-2.0.jar 192.168.191.3 9999 192.168.25.127 8888
[INFO] [11/28/2017 21:23:36.483] [main] [Remoting] Starting remoting
[INFO] [11/28/2017 21:23:36.866] [main] [Remoting] Remoting started; listening on addresses :[akka.tcp://[email protected]:9999]
[INFO] [11/28/2017 21:23:36.870] [main] [Remoting] Remoting now listens on addresses: [akka.tcp://[email protected]:9999]
创建Worker对象...
收到Master消息发现worker收到了master的消息
再看master，收到了worker的消息
...
[INFO] [11/28/2017 21:23:36.870] [main] [Remoting] Remoting now listens on addresses: [akka.tcp://WorkerSystem@192.168.191.3:9999]
创建Worker对象...
收到Master消息
一个Worker连接了.....