clean

Author: Roiocam

akka-actor-typed-tests/src/test/java/akka/actor/typed/eventstream/LoggingDocTest.java

@@ -15,8 +15,13 @@
 import akka.actor.typed.SpawnProtocol;
 import akka.actor.typed.SpawnProtocol.Spawn;
 import akka.actor.typed.eventstream.EventStream.Publish;
+import akka.actor.typed.eventstream.EventStream.Subscribe;
+import akka.actor.typed.javadsl.AbstractBehavior;
+import akka.actor.typed.javadsl.ActorContext;
 import akka.actor.typed.javadsl.Adapter;
 import akka.actor.typed.javadsl.AskPattern;
+import akka.actor.typed.javadsl.Behaviors;
+import akka.actor.typed.javadsl.Receive;
 import java.time.Duration;
 import java.util.concurrent.CompletionStage;
 import org.junit.Assert;
@@ -26,56 +31,47 @@
 import akka.actor.DeadLetter;
 import akka.actor.typed.ActorRef;
 import akka.actor.typed.ActorSystem;
-import akka.actor.typed.eventstream.EventStream.Subscribe;
-import akka.actor.typed.javadsl.AbstractBehavior;
-import akka.actor.typed.javadsl.ActorContext;
-import akka.actor.typed.javadsl.Behaviors;
-import akka.actor.typed.javadsl.Receive;
-import org.slf4j.Logger;
 // #imports-deadletter
 
 public class LoggingDocTest extends JUnitSuite {
 
     @Test
     public void subscribeToDeadLetters() {
-        ActorSystem<SpawnProtocol.Command> system = ActorSystem.create(SpawnProtocol.create(),
-            "DeadLettersSystem");
-        // #subscribe-deadletter
-        ActorSystem.create(Behaviors.setup(ctx -> {
-            ActorRef<DeadLetter> listener = ctx.spawn(DeadLetterActor.create(), "listener");
-            ctx.getSystem().eventStream().tell(new Subscribe<>(DeadLetter.class, listener));
-            return Behaviors.empty();
-        }), "DeadLettersSystem");
-        // #subscribe-deadletter
+        ActorSystem<SpawnProtocol.Command> system = ActorSystem.create(
+            Behaviors.setup(ctx -> {
+                Behavior<DeadLetter> deadLetterListener = Behaviors.empty();
+                // #subscribe-deadletter
+                ActorRef<DeadLetter> listener = ctx.spawn(deadLetterListener, "listener");
+                ctx.getSystem().eventStream().tell(new Subscribe<>(DeadLetter.class, listener));
+                // #subscribe-deadletter
+                return SpawnProtocol.create();
+            }), "DeadLettersSystem");
         ActorTestKit.shutdown(system);
     }
 
     public
     // #deadletter-actor
-    static class DeadLetterActor extends AbstractBehavior<DeadLetter> {
-
-        final Logger log = getContext().getLog();
+    static class DeadLetterActor extends AbstractBehavior<String> {
 
-        public static Behavior<DeadLetter> create() {
+        public static Behavior<String> create() {
             return Behaviors.setup(DeadLetterActor::new);
         }
 
-        public DeadLetterActor(ActorContext<DeadLetter> context) {
+        public DeadLetterActor(ActorContext<String> context) {
             super(context);
             ActorRef<DeadLetter> messageAdapter = context.messageAdapter(
                 DeadLetter.class,
-                d -> d
+                d -> d.message().toString()
             );
-            // subscribe DeadLetter at start up.
+            // subscribe DeadLetter at startup.
             context.getSystem().eventStream()
                 .tell(new Subscribe<>(DeadLetter.class, messageAdapter));
         }
 
         @Override
-        public Receive<DeadLetter> createReceive() {
-            return newReceiveBuilder().onMessage(DeadLetter.class, msg -> {
-                log.info("receive dead letter: {} from <{}> to <{}>", msg, msg.sender(),
-                    msg.recipient());
+        public Receive<String> createReceive() {
+            return newReceiveBuilder().onMessage(String.class, msg -> {
+                getContext().getLog().info("receive dead letter: {}", msg);
                 return Behaviors.same();
             }).build();
         }
@@ -107,8 +103,6 @@ public Electronic(String artist) {
 
     static class Listener extends AbstractBehavior<AllKindsOfMusic> {
 
-        final Logger log = getContext().getLog();
-
         public static Behavior<AllKindsOfMusic> create() {
             return Behaviors.setup(Listener::new);
         }
@@ -122,12 +116,12 @@ public Listener(ActorContext<AllKindsOfMusic> context) {
         public Receive<AllKindsOfMusic> createReceive() {
             return newReceiveBuilder()
                 .onMessage(Jazz.class, msg -> {
-                    log.info("{} is listening to Jazz: {}", getContext().getSelf().path().name(),
+                    getContext().getLog().info("{} is listening to Jazz: {}", getContext().getSelf().path().name(),
                         msg);
                     return Behaviors.same();
                 })
                 .onMessage(Electronic.class, msg -> {
-                    log.info("{} is listening to Electronic: {}",
+                    getContext().getLog().info("{} is listening to Electronic: {}",
                         getContext().getSelf().path().name(), msg);
                     return Behaviors.same();
                 }).build();

akka-actor-typed-tests/src/test/scala/akka/actor/typed/eventstream/LoggingDocSpec.scala

@@ -33,18 +33,14 @@ object LoggingDocSpec {
 
   object DeadLetterListener {
 
-    def apply(): Behavior[DeadLetter] = Behaviors.setup { context =>
-      // subscribe DeadLetter at start up.
-      val adapter = context.messageAdapter[DeadLetter](d => d)
+    def apply(): Behavior[String] = Behaviors.setup { context =>
+      // subscribe DeadLetter at startup.
+      val adapter = context.messageAdapter[DeadLetter](d => d.message.toString)
       context.system.eventStream ! Subscribe(adapter)
 
       Behaviors.receiveMessage {
-        case deadLetter: DeadLetter =>
-          context.log.info(
-            "receive dead letter: {} from <{}> to <{}>",
-            deadLetter.message,
-            deadLetter.sender,
-            deadLetter.recipient)
+        case msg: String =>
+          context.log.info("receive dead letter: {}", msg)
           Behaviors.same
       }
     }
@@ -78,7 +74,7 @@ class LoggingDocSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
   import LoggingDocSpec._
   import akka.actor.typed.scaladsl.AskPattern._
 
-  "allow registration to dead letters from start up" in {
+  "allow registration to dead letters" in {
     // #deadletters
     ActorSystem(Behaviors.setup[Void] { context =>
       context.spawn(DeadLetterListener(), "DeadLetterListener", Props.empty)
@@ -88,13 +84,15 @@ class LoggingDocSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with
   }
 
   "allow registration to dead letters" in {
-    // #subscribe-deadletter
     ActorSystem(Behaviors.setup[Void] { context =>
-      val deadLetterListener = context.spawn(DeadLetterListener(), "DeadLetterListener", Props.empty)
-      context.system.eventStream ! Subscribe[DeadLetter](deadLetterListener)
+      val deadLetterListener = Behaviors.empty[DeadLetter]
+      // #subscribe-deadletter
+      val listenerRef: ActorRef[DeadLetter] = context.spawn(DeadLetterListener(), "DeadLetterListener")
+      context.system.eventStream ! Subscribe[DeadLetter](listenerRef)
+      // #subscribe-deadletter
+
       Behaviors.empty
     }, "System")
-    // #subscribe-deadletter
   }
 
   "demonstrate superclass subscriptions on typed eventStream" in {

akka-docs/src/main/paradox/typed/event-stream.md

@@ -36,7 +36,7 @@ It uses @ref:[Subchannel Classification](#subchannel-classification) which enabl
 
 ## How to use
 
-The following example demonstrates how a subscription works. Given an actor will subscribe DeadLetter from start up:
+The following example demonstrates how a subscription works. Given an actor will subscribe DeadLetter from startup:
 
 Scala
 :  @@snip [LoggingDocSpec.scala](/akka-actor-typed-tests/src/test/scala/akka/actor/typed/eventstream/LoggingDocSpec.scala) { #deadletters }