akka实例

一、akka简介

akka是用scala编写的actor模型框架。它在使用中不需要锁和多线程，每个actor在独立空间中进行数据操作，

各个actor间完全依赖消息进行信息交互，操作都是异步进行的。

它可以用于高并发、分布式场景，需要注意的是，akka消息的传递不保证绝对可靠投递，当然这带来了好处是

整个实现简单。

二、akka关键点

1、角色系统建立

在akka中，所有角色都需在角色系统中，可以通过ActorSystem.create方法建立，同时可以指定角色系统名称，这会在actor路径中体现出来；

2、角色类的定义

通过继承AbstractActor类，实现抽象方法createReceive,并在此方法定义消息处理模块(使用reciveBuilder.build进行构造),

接收消息（消息类型，其实也就是消息的class类型区分消息），并进行消息处理；

3、角色的创建

通知ActorSystem的actorOf方法创建actor，创建时可以通过new BalancingPool(3)指定该actor的工作worker数量，

以及actor的名称，这会在路径中体现出来。

4、角色路径及查找

akka内的各个actor采用类似于分布式文件系统（如hdfs）进行管理，actor类似于文件系统的各个文件。

akka主要根路径有三个：/（根路径），/system（系统相关的路径），/user(用户路径，通常定义的actor在此路径下)。

有了路径，可以通过getContext().actorSelect()方法基于路径,

获取到相关actor引用，进而发送消息。

三、akka实现步骤

1、建立角色系统，ActorSystem;

2、定义角色，actor;

3、注册角色，actorSystem.actorOf；

4、消息的传递，tell；

5、在actor内消息的处理（处理完后，也可通过actorSelect路径选择其它actor，并发送消息)

四、实例

1、添加maven依赖

    com.typesafe.akka
    akka-actor_2.11
    2.5.1

2、代码实例

public class ActorMain {

    public static void main(String[] args) {
        //生成角色系统
        ActorSystem system = ActorSystem.create("msgSystem");

        //生成角色 ProduceMsgActor
        ActorRef produceMsgActor = system.actorOf(new BalancingPool(3).props(Props.create(ProduceMsgActor.class)),"ProduceMsgActor");
        //生成角色 DisposeMsgActor
        ActorRef disposeMsgActor = system.actorOf(new BalancingPool(2).props(Props.create(DisposeMsgActor.class)),"DisposeMsgActor");

        //给produceMsgActor发消息请求
        produceMsgActor.tell("please produce msg1",ActorRef.noSender());

    }

    //定义角色 ProduceMsgActor  产生消息
    static class ProduceMsgActor extends AbstractActor {
        @Override
        public Receive createReceive() {
            return receiveBuilder().match(String.class,t->{
                //收到消息
                System.out.println(self()+"  receive msg  from "+sender()+": "+ t);

                //响应消息请求
                Msg msg = new Msg("haha");
                System.out.println(self()+"  produce msg : "+msg.getContent());

                //根据路径查找下一个处理者
                ActorSelection nextDisposeRefs = getContext().actorSelection("/user/DisposeMsgActor");

                //将消息发给下一个处理者DisposeMsgActor
                nextDisposeRefs.tell(msg,self());
            }).matchAny(t->{
                System.out.println("no disposer");
            }).build();
        }
    }

    //定义角色 DisposeMsgActor 消费消息
    static class DisposeMsgActor extends AbstractActor{
        @Override
        public Receive createReceive() {
            return receiveBuilder().match(Msg.class,t->{
                //收到消息
                System.out.println(self()+"  receive msg  from "+sender()+": "+ t.getContent());
                System.out.println(self()+" dispose msg : "+t.getContent());
            }).matchAny(t->{
                System.out.println("no disposer");
            }).build();
        }
    }

    //定义消息
    static class Msg {
        private String  content = "apple";

        public Msg(String content) {
            this.content = content;
        }

        public String getContent() {
            return content;
        }

        public void setContent(String content) {
            this.content = content;
        }
    }
}

运行结果：

Actor[akka://msgSystem/user/ProduceMsgActor/$b#-1551951661]  receive msg  from Actor[akka://msgSystem/deadLetters]: please produce msg1
Actor[akka://msgSystem/user/ProduceMsgActor/$b#-1551951661]  produce msg : haha
Actor[akka://msgSystem/user/DisposeMsgActor/$a#2115567017]  receive msg  from Actor[akka://msgSystem/user/ProduceMsgActor/$b#-1551951661]: haha
Actor[akka://msgSystem/user/DisposeMsgActor/$a#2115567017] dispose msg : haha