O que é AKKA?
Akka é uma biblioteca de desenvolvimento e ambiente de tempo de execução que pode ser usada para construir aplicativos baseados em JVM altamente concorrentes, distribuídos, tolerantes a falhas e orientados a eventos. Facilite a construção de aplicativos distribuídos altamente concorrentes. Akka encapsula o modelo Actor Model. Pode ser entendido como uma entrega de mensagem assíncrona e sem bloqueio
O primeiro tipo: enviar uma string ou um único valor para AKKA
package day03
import scala.actors.Actor
/**
* Created by Administrator on 2017/9/18.
* 功能：演示AKK 1 继承Actor类 2 重写act方法
* 功能点：演示发送一个字符串
*/
// 1 继承actor类
class ActorDemo extends Actor{
// 2 重写act方法，一般有while true操作
override def act =
{
while(true)
{
// 3 在receive中写具体的操作，要用到case 判断
receive{
case name:String=>println("hello, "+name)
case money:Int=>println("how much "+money)
}
}
}
}
object ActorDemon01 {
def main(args: Array[String]): Unit = {
val helloActor=new ActorDemo // 1 创建一个继承actor的对象
helloActor.start() // 2 启动akka
helloActor ! "tom" // 3 依据具体的参数调用actor
helloActor ! 1000
}
}
Execute o programa em ideia e a captura de tela em execução será a seguinte:
Isso é relativamente simples, ou seja, os caracteres e valores são transmitidos separadamente, o que pode ser entendido
O segundo tipo: enviar aula de amostra para akka
package day03
import scala.actors.Actor
/**
* Created by Administrator on 2017/9/18.
* 功能：演示akka的发送样例类
*
*/
//几个样例类
case class Register(username:String,password:String)
case class Login(username:String,password:String)
// 1 继承Actor类
class ActorDemon02 extends Actor{
//2 重写act方法
override def act()
{
while(true)
{
//3 在receive中写相关的操作
receive{
case Login(username,password)=>println("Login "+username+" 密码 "+password)
case Register(username,password)=>println("Register "+username+" 密码 "+password)
}
}
}
}
object ActorDemon02 {
def main(args: Array[String]): Unit = {
val actorDemon02=new ActorDemon02 //4 创建akka对象
actorDemon02.start() // 4 启动akka
actorDemon02 ! Register("zhangsan","123") //调用akka
actorDemon02 ! Login("lisi","456")
}
}
Execute o programa em ideia, e a captura de tela do programa é a seguinte:
Explicação: Esta é uma classe de amostra transmitida para akka, semelhante ao primeiro cenário
总结点: 一 Akka的开发流程
1 继承actor类 : extends Actor
2 重写act方法: override def act 一般有while true操作
3 在receive中写具体的操作，receive{ ,要用到case 判断
总结点：二 Actor的调用流程：
1 创建一个继承actor的对象: val helloActor=new ActorDemo
2 启动akka: helloActor.start()
3 依据具体的参数调用actor: helloActor ! "tom"O terceiro tipo: ligação mútua entre Akka
package day03
import scala.actors.Actor
/**
* Created by Administrator on 2017/9/18.
* 功能：演示akka akka之间发送数据
*
*/
case class Message(content:String,sender:Actor)
class zxcActor extends Actor
{
override def act: Unit =
{
while(true)
{
receive{
case Message(content,sender)=>println("zxc received "+content)
sender ! "北京欢迎你"
sender ! 1000
}
}
}
}
class chongActor(val zxc:zxcActor) extends Actor
{
override def act: Unit =
{
//this 代表调用的对象 指的是 chongActor
zxc ! Message("hello i am chong",this)
while(true)
{
receive{
case response:String=>println("chong received "+response)
case response:Int=>println("how much "+response)
}
}
}
}
object ActorDemon03 {
def main(args: Array[String]): Unit = {
val zxc=new zxcActor
val chong=new chongActor(zxc)
zxc.start()
chong.start()
}
}
Execute o programa em ideia e a captura de tela da operação do programa é a seguinte:
Os pontos de resumo das chamadas entre Akka:
1 Os parâmetros do segundo ator devem ter uma referência ao primeiro ator
chongActor (val zxc: zxcActor)
2 Quando o próximo ator é chamado, ele é colocado na função act e fora da
substituição de recepção def act : Unit =
{// isso representa o objeto de chamada refere-se a chongActor
zxc! Message ("hello i am chong", this)
Descrição: 1 Ele é colocado fora de recebimento porque implementa sua própria operação em recebimento
2 Use isso para representar o chamador ao ligar, o que é mais conveniente