1 按照akka官网地址学习akka

版本 2.6.19

按照akka官网学习akka,文档地址

2 代码地址

3 学习actor介绍说明部分

scala 代码

package com.scala.study.akka.instruction.scala

import akka.actor.typed.scaladsl.Behaviors
import akka.actor.typed.{ActorRef, ActorSystem, Behavior}

object HelloWorld{
  final case class Greet(whom:String,replyTo : ActorRef[Greeted])
  final case class Greeted(whom:String,from : ActorRef[Greet])

  def apply() : Behavior[Greet] = Behaviors.receive {
    (context,message) =>
      context.log.info("hello {} !",message.whom)
      message.replyTo ! Greeted(message.whom,context.self)
      Behaviors.same
  }
}


object HelloWorldBot {
  def apply(max : Int) : Behavior[HelloWorld.Greeted] = {
    bot(0,max)
  }

  private def bot(greetingCounter: Int,max : Int) : Behavior[HelloWorld.Greeted] = {
    Behaviors.receive{
      (context,message) =>
        val n = greetingCounter + 1;
        context.log.info("Greeting {} for {}",n,message.whom)
        if(n == max){
          Behaviors.stopped
        }else{
          message.from ! HelloWorld.Greet(message.whom,context.self)
          bot(n,max)
        }
    }
  }
}

object HelloWorldMain{
  final case class SayHello(name:String)
  def apply():Behavior[SayHello] = {
    Behaviors.setup{
      context =>
        val greeter = context.spawn(HelloWorld(),"greeter")
        Behaviors.receiveMessage{
          message =>
            context.log.info("HelloWorldMain message is  {}",message)
            val replyTo = context.spawn(HelloWorldBot(max = 3),message.name)
            greeter ! HelloWorld.Greet(message.name,replyTo)
            Behaviors.same
        }
    }
  }
}


object ActorSystemMain {
  def main(args: Array[String]): Unit = {
    val system : ActorSystem[HelloWorldMain.SayHello] = ActorSystem(HelloWorldMain(),"hello")
    system ! HelloWorldMain.SayHello("world")
  }
}

java 代码


package com.scala.study.akka.instruction.java;

import akka.actor.typed.ActorRef;
import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;

public class HelloWorld extends AbstractBehavior<HelloWorld.Greet> {

    public HelloWorld(ActorContext<Greet> context) {
        super(context);
    }

    public static Behavior<Greet> create() {
        return Behaviors.setup(HelloWorld::new);
    }

    @Override
    public Receive<Greet> createReceive() {
        return newReceiveBuilder()
                .onMessage(
                        Greet.class,
                        this::onGreet
                )
                .build();
    }

    public Behavior<Greet> onGreet(Greet command){
        getContext().getLog().info("Hello {}!",command.whom);
        command.replyTo.tell(
                new Greeted(command.whom,getContext().getSelf())
        );
        return this;
    }

    public static final class Greet {
        public final String whom;
        public final ActorRef<Greeted> replyTo;

        public Greet(String whom, ActorRef<Greeted> replyTo) {
            this.whom = whom;
            this.replyTo = replyTo;
        }
    }


    public static final class Greeted {
        public final String whom;
        public final ActorRef<Greet> from;

        public Greeted(String whom, ActorRef<Greet> from) {
            this.whom = whom;
            this.from = from;
        }
    }
}


package com.scala.study.akka.instruction.java;

import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;

public class HelloWorldBot extends AbstractBehavior<HelloWorld.Greeted> {
    private final int max;
    private int greetingCounter;

    public HelloWorldBot(ActorContext<HelloWorld.Greeted> context, int max) {
        super(context);
        this.max = max;
    }

    public static Behavior<HelloWorld.Greeted> create(int max) {
        return Behaviors.setup(context -> new HelloWorldBot(context, max));
    }


    @Override
    public Receive<HelloWorld.Greeted> createReceive() {
        return newReceiveBuilder()
                .onMessage(
                        HelloWorld.Greeted.class,
                        this::onGreeted
                )
                .build();
    }

    private Behavior<HelloWorld.Greeted> onGreeted(HelloWorld.Greeted message) {
        ++greetingCounter;
        getContext().getLog().info("Greeting {} for {} ", greetingCounter, message.whom);
        if (greetingCounter == max) {
            return Behaviors.stopped();
        } else {
            message.from.tell(new HelloWorld.Greet(message.whom, getContext().getSelf()));
            return this;
        }
    }
}





package com.scala.study.akka.instruction.java;

import akka.actor.typed.ActorRef;
import akka.actor.typed.ActorSystem;
import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;

public class HelloWorldMain extends AbstractBehavior<HelloWorldMain.SayHello> {

    private final ActorRef<HelloWorld.Greet> greeter;

    public HelloWorldMain(ActorContext<SayHello> context) {
        super(context);
        greeter = context.spawn(HelloWorld.create(), "greeter");
    }

    public static Behavior<SayHello> create() {
        return Behaviors.setup(HelloWorldMain::new);
    }

    @Override
    public Receive<SayHello> createReceive() {
        return newReceiveBuilder()
                .onMessage(
                        SayHello.class,
                        this::onStart
                )
                .build();
    }

    private Behavior<SayHello> onStart(SayHello command) {
        ActorRef<HelloWorld.Greeted> replyTo = getContext().spawn(HelloWorldBot.create(3), command.name);
        greeter.tell(new HelloWorld.Greet(command.name, replyTo));
        return this;
    }


    public static class SayHello {
        public final String name;

        public SayHello(String name) {
            this.name = name;
        }
    }

    public static void main(String[] args) {
        final ActorSystem<SayHello> system = ActorSystem.create(HelloWorldMain.create(), "hello");
        system.tell(new HelloWorldMain.SayHello("World"));

    }
}

4 案例说明

HelloWorldMain作为actorSystem
HelloWorldMain启动，创建HelloWorld的ActorRef(greeter)
HelloWorldMain接收SayHello消息，生成HelloWorldBot的ActorRef,并向geeter发送一笔Greet消息，消息replyTo为elloWorldBot的ActorRef
geeter接收消息，向replyTo发送Greeted消息
HelloWorldBot的ActorRef接收Greeted，计数器+1，计数器小于3时，发送一笔Greet消息给geeter，否则销毁

akka学习--1

1 按照akka官网地址学习akka

2 代码地址

3 学习actor介绍说明部分

4 案例说明