Print und Evaluate aufgeteilt (Das war schmerzhaft). V1.0

src/main/java/com/example/Actor.java

@@ -1,8 +1,5 @@
 package com.example;
 
-/*
-Martrikelnummer der Gruppenmitglieder: Olha Grubryn (235122), Egor Rutkowski(225064), Nikola Kramaric (238498), Dennis Ruppel (238503)
-*/
 import akka.actor.typed.ActorRef;
 import akka.actor.typed.Behavior;
 import akka.actor.typed.javadsl.*;
@@ -159,15 +156,15 @@ public class Actor extends AbstractBehavior<Actor.Message> {
     private Behavior<Message> onLeftStringResponse(LeftStringResponse response){
         this.leftString = response.string;
         if(this.rightString != null){
-            if(this.initial != null){
+           if(this.initial != null){
-                initial.tell(new PrintAndEvaluate.StringResponse("(" + leftString + operationString + rightString +")"));
+               initial.tell(new PrintAndEvaluate.StringResponse("(" + leftString + operationString + rightString +")"));
-            }else {
+           }else {
-                if(side == true){
+               if(side == true){
-                    oberActor.tell(new Actor.LeftStringResponse("(" + leftString + operationString + rightString +")"));
+                   oberActor.tell(new Actor.LeftStringResponse("(" + leftString + operationString + rightString +")"));
-                }else {
+               }else {
-                    oberActor.tell(new Actor.RightStringResponse("(" + leftString + operationString + rightString +")"));
+                   oberActor.tell(new Actor.RightStringResponse("(" + leftString + operationString + rightString +")"));
-                }
+               }
-            }
+           }
         }
         return this;
     }
@@ -303,13 +300,13 @@ public class Actor extends AbstractBehavior<Actor.Message> {
                 }
             }
         } else {
-            if (operationString.equals("+")) {
+                if (operationString.equals("+")) {
-                initial.tell(new PrintAndEvaluate.IntResponse(leftInt + rightInt));
+                    initial.tell(new PrintAndEvaluate.IntResponse(leftInt + rightInt));
-            } else if (operationString.equals("-")) {
+                } else if (operationString.equals("-")) {
-                initial.tell(new PrintAndEvaluate.IntResponse(leftInt - rightInt));
+                    initial.tell(new PrintAndEvaluate.IntResponse(leftInt - rightInt));
-            } else {
+                } else {
-                initial.tell(new PrintAndEvaluate.IntResponse(leftInt * rightInt));
+                    initial.tell(new PrintAndEvaluate.IntResponse(leftInt * rightInt));
-            }
+                }
         }
         return this;
     }

src/main/java/com/example/AkkaMainSystem.java

@@ -1,9 +1,5 @@
 package com.example;
 
-/*
-Martrikelnummer der Gruppenmitglieder: Olha Grubryn (235122), Egor Rutkowski(225064), Nikola Kramaric (238498), Dennis Ruppel (238503)
-*/
-
 import akka.actor.typed.ActorRef;
 import akka.actor.typed.Behavior;
 import akka.actor.typed.javadsl.AbstractBehavior;

src/main/java/com/example/AkkaStart.java

@@ -3,9 +3,6 @@ package com.example;
 import akka.actor.typed.ActorSystem;
 
 import java.io.IOException;
-/*
-Martrikelnummer der Gruppenmitglieder: Olha Grubryn (235122), Egor Rutkowski(225064), Nikola Kramaric (238498), Dennis Ruppel (238503)
-*/
 public class AkkaStart {
   public static void main(String[] args) {
     final ActorSystem<AkkaMainSystem.Create> messageMain = ActorSystem.create(AkkaMainSystem.create(), "akkaMainSystem");

src/main/java/com/example/ExampleActor.java

@@ -0,0 +1,35 @@
+package com.example;
+
+import akka.actor.typed.ActorRef;
+import akka.actor.typed.Behavior;
+import akka.actor.typed.javadsl.*;
+
+public class ExampleActor extends AbstractBehavior<ExampleActor.Message>{
+
+    public interface Message {};
+
+    public record ExampleMessage(ActorRef<AkkaMainSystem.Create> someReference, String someString) implements Message {  }
+
+    public static Behavior<Message> create(String name) {
+        return Behaviors.setup(context -> new ExampleActor(context, name));
+    }
+
+    private final String name;
+
+    private ExampleActor(ActorContext<Message> context, String name) {
+        super(context);
+        this.name = "test";
+    }
+
+    @Override
+    public Receive<Message> createReceive() {
+        return newReceiveBuilder()
+                .onMessage(ExampleMessage.class, this::onExampleMessage)
+                .build();
+    }
+
+    private Behavior<Message> onExampleMessage(ExampleMessage msg) {
+        getContext().getLog().info("I ({}) got a message: ExampleMessage({},{})", this.name, msg.someReference, msg.someString);
+        return this;
+    }
+}

src/main/java/com/example/ExampleTimerActor.java

@@ -0,0 +1,45 @@
+package com.example;
+
+import akka.actor.typed.javadsl.TimerScheduler;
+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;
+
+import java.time.Duration;
+
+
+public class ExampleTimerActor extends AbstractBehavior<ExampleTimerActor.Message> {
+
+    public interface Message {};
+
+
+    public record ExampleMessage(String someString) implements Message {  }
+
+    public static Behavior<Message> create() {
+        return Behaviors.setup(context -> Behaviors.withTimers(timers -> new ExampleTimerActor(context, timers)));
+    }
+
+    private final TimerScheduler<ExampleTimerActor.Message> timers;
+
+    private ExampleTimerActor(ActorContext<Message> context, TimerScheduler<ExampleTimerActor.Message> timers) {
+        super(context);
+        this.timers = timers;
+
+        Message msg = new ExampleMessage("test123");
+        this.timers.startSingleTimer(msg, msg, Duration.ofSeconds(10));
+    }
+
+    @Override
+    public Receive<Message> createReceive() {
+        return newReceiveBuilder()
+                .onMessage(ExampleMessage.class, this::onExampleMessage)
+                .build();
+    }
+
+    private Behavior<Message> onExampleMessage(ExampleMessage msg) {
+        getContext().getLog().info("I have send myself this message after 10 Seconds: {}", msg.someString);
+        return this;
+    }
+}

src/main/java/com/example/PrintAndEvaluate.java

@@ -1,9 +1,5 @@
 package com.example;
 
-/*
-Martrikelnummer der Gruppenmitglieder: Olha Grubryn (235122), Egor Rutkowski(225064), Nikola Kramaric (238498), Dennis Ruppel (238503)
-*/
-
 import akka.actor.typed.ActorRef;
 import akka.actor.typed.Behavior;
 import akka.actor.typed.javadsl.AbstractBehavior;
@@ -11,14 +7,9 @@ import akka.actor.typed.javadsl.ActorContext;
 import akka.actor.typed.javadsl.Behaviors;
 import akka.actor.typed.javadsl.Receive;
 
-import java.time.Duration;
-import java.time.Instant;
-
 public class PrintAndEvaluate extends AbstractBehavior<PrintAndEvaluate.Message> {
 
     String name;
-    Instant startTime; // Startzeit für die Zeitmessung der Berechnung
-
     public interface Message{}
 
     public record StringResponse(String string) implements Message{}
@@ -45,35 +36,29 @@ public class PrintAndEvaluate extends AbstractBehavior<PrintAndEvaluate.Message>
                 .build();
     }
 
-    // Mit dieser Message wird der PrintAndEvaluate Aktor in Gang gesetzt
+    //Mit dieser Message wird der PrintAndEvaluate Aktor in Gang gesetzt
     private Behavior<Message> onStartMessage(StartMessage message){
-        // Startzeit für die Zeitmessung setzen
+        //Starten des Formatierungsvorganges
-        this.startTime = Instant.now();
-
-        // Starten des Formatierungsvorganges
         this.getContext().getLog().info("\n Beginn der Ausdrucksformatierung");
-
         ActorRef<Actor.Message> printActor = getContext().spawnAnonymous(Actor.create());
-        printActor.tell(new Actor.PrintMessage(getContext().getSelf(), message.expression));
+        printActor.tell(new Actor.PrintMessage(getContext().getSelf(),message.expression));
 
-        // Starten des Berechnungsvorganges
+        //Starten des Berechnungsvorganges
         this.getContext().getLog().info("\n Beginn der Berechnung");
         ActorRef<Actor.Message> computeActor = getContext().spawnAnonymous(Actor.create());
         computeActor.tell(new Actor.EvaluateMessage(getContext().getSelf(), message.expression));
         return this;
     }
 
-    // Ausgeben des Ausdruckes als String
+    //Ausgeben des Ausdruckes als String
     private Behavior<Message> onStringResponse(StringResponse response){
         this.getContext().getLog().info("\n Formatierter Ausdruck: " + response.string);
         return this;
     }
 
-    // Ausgeben des berechneten Wertes von dem Ausdruck und der Berechnungsdauer
+    //Ausgeben des berechneten Wertes von dem Ausdruck
     private Behavior<Message> onIntResponse(IntResponse response){
-        Duration duration = Duration.between(startTime, Instant.now());
         this.getContext().getLog().info("\n Ausgerechneter Wert: " + response.wert);
-        this.getContext().getLog().info("\n Berechnungsdauer: " + duration.toSeconds() + " Sekunden");
         return this;
     }
 }