src/main/java/com/example/AddressBook.java

@@ -8,12 +8,10 @@ import akka.actor.typed.javadsl.Behaviors;
 import akka.actor.typed.javadsl.Receive;
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 import java.util.Random;
 
 public class AddressBook extends AbstractBehavior<AddressBook.Message> {
-    private final ArrayList<ActorRef<Customer.Message>> customers;
+    ArrayList<ActorRef<Customer.Message>> customers = new ArrayList<>();
 
     public interface Message {}
 
@@ -30,32 +28,24 @@ public class AddressBook extends AbstractBehavior<AddressBook.Message> {
         }
     }
 
-    // Nachricht, um die Liste der Kunden abzurufen
-    public static final class GetCustomers implements Message {
-        public final ActorRef<List<ActorRef<Customer.Message>>> replyTo;
-
-        public GetCustomers(ActorRef<List<ActorRef<Customer.Message>>> replyTo) {
-            this.replyTo = replyTo;
-        }
-    }
-
-    private AddressBook(ActorContext<Message> context, ArrayList<ActorRef<Customer.Message>> customers) {
+    private AddressBook(ActorContext<Message> context, ArrayList<ActorRef<Customer.Message>> custo) {
         super(context);
-        this.customers = new ArrayList<>(customers);
+        if (!custo.isEmpty()) {
+            this.customers.addAll(custo);
             for (ActorRef<Customer.Message> cst : this.customers) {
                 cst.tell(new Customer.AddressHello(getContext().getSelf()));
             }
         }
+    }
 
-    public static Behavior<Message> create(ArrayList<ActorRef<Customer.Message>> customers) {
-        return Behaviors.setup(context -> new AddressBook(context, customers));
+    public static Behavior<Message> create(ArrayList<ActorRef<Customer.Message>> custo) {
+        return Behaviors.setup(context -> new AddressBook(context, custo));
     }
 
     @Override
     public Receive<Message> createReceive() {
         return newReceiveBuilder()
                 .onMessage(CustomerMessage.class, this::onCustomerMessage)
-                .onMessage(GetCustomers.class, this::onGetCustomers)
                 .build();
     }
 
@@ -68,10 +58,4 @@ public class AddressBook extends AbstractBehavior<AddressBook.Message> {
         msg.fragender.tell(new Customer.AddressMessage(addressOf, msg.truckReference));
         return this;
     }
-
-    // Methode, um die Liste der Kunden zu senden
-    private Behavior<Message> onGetCustomers(GetCustomers msg) {
-        msg.replyTo.tell(Collections.unmodifiableList(customers));
-        return this;
-    }
 }

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

@@ -26,32 +26,35 @@ public class AkkaMainSystem extends AbstractBehavior<AkkaMainSystem.Create> {
         return newReceiveBuilder().onMessage(Create.class, this::onCreate).build();
     }
 
+
     private Behavior<Create> onCreate(Create command) {
 
         // Erstellen des Adressbuchs
         ArrayList<ActorRef<Customer.Message>> customers = new ArrayList<>();
+        ActorRef<AddressBook.Message> addressBook = getContext().spawn(AddressBook.create(customers), "addressBook");
+
         // Erstellen von vier Empfänger*innen
         for (int i = 0; i < 4; i++) {
             customers.add(getContext().spawn(Customer.create("Customer" + (i + 1)), "customer" + (i + 1)));
         }
-        ActorRef<AddressBook.Message> addressBook = getContext().spawn(AddressBook.create(customers), "addressBook");
-
-        // Nachricht GetCustomers senden, um Kundenreferenzen abzurufen
 
         // Erstellen des Verteilzentrums
-        ActorRef<DistributionCenter.Message> distributionCenter = getContext().spawn(DistributionCenter.create(addressBook), "distributionCenter");
-/*
+        ActorRef<DistributionCenter.Message> distributionCenter = getContext().spawn(DistributionCenter.create(), "distributionCenter");
+
         // Erstellen von vier Wagen mit zufälligen Routen
         for (int i = 0; i < 4; i++) {
-            List<String> route = new ArrayList<>(); // Hier sollte die Liste der Orte sein, nicht der Kundenreferenzen
+            List<ActorRef<Customer.Message>> route = new ArrayList<>(customers);
             Collections.shuffle(route);
             ActorRef<DeliveryCar.Message> truck = getContext().spawn(DeliveryCar.create(route), "truck" + (i + 1));
             // Erstellen einer leeren Paketliste
             List<Paket> paketeList = new ArrayList<>();
+            paketeList.add(new Paket("Inhalt 1"));
+            paketeList.add(new Paket("Inhalt 2"));
             // Beispiel für den Aufruf der ArriveMessage-Nachricht mit korrekten Parametern
             distributionCenter.tell(new DistributionCenter.ArriveMessage(paketeList, truck));
+
         }
-*/
+
         return this;
     }
 }

src/main/java/com/example/DistributionCenter.java

@@ -8,41 +8,10 @@ import akka.actor.typed.javadsl.Behaviors;
 import akka.actor.typed.javadsl.Receive;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 public class DistributionCenter extends AbstractBehavior<DistributionCenter.Message> {
 
-    private final ActorRef<AddressBook.Message> addressBook;
-    private final List<Paket> lagerraum = new ArrayList<>();
-
-    private DistributionCenter(ActorContext<Message> context, ActorRef<AddressBook.Message> addressBook) {
-        super(context);
-        this.addressBook = addressBook;
-
-        // Erhalten Sie die replyTo-Referenz aus dem Kontext
-        ActorRef<List<ActorRef<Customer.Message>>> replyTo = context.spawnAnonymous(Behaviors.<List<ActorRef<Customer.Message>>>receive((ctx, message) -> {
-            if (message instanceof List) {
-                @SuppressWarnings("unchecked")
-                List<ActorRef<Customer.Message>> customers = (List<ActorRef<Customer.Message>>) message;
-                ctx.getLog().info("Kundenliste erhalten: {}", customers);
-                // Nachricht senden, um Routen zu generieren
-                context.getSelf().tell(new GenerateRoutes(customers));
-                return Behaviors.same();
-            }
-            return Behaviors.unhandled();
-        }));
-
-        // Anfrage an das AddressBook senden, um die Kundenliste abzurufen
-        addressBook.tell(new AddressBook.GetCustomers(replyTo));
-    }
-
-    public static Behavior<Message> create(ActorRef<AddressBook.Message> addressBook) {
-        return Behaviors.setup(context -> new DistributionCenter(context, addressBook));
-    }
-
-    interface Message {}
-
     public static class ArriveMessage implements Message {
         private final List<Paket> pakete;
         private final ActorRef<DeliveryCar.Message> truck;
@@ -61,91 +30,33 @@ public class DistributionCenter extends AbstractBehavior<DistributionCenter.Mess
         }
     }
 
-    public static class LoadMessage implements Message {
-        private final List<Paket> pakete;
-
-        public LoadMessage(List<Paket> pakete) {
-            this.pakete = pakete;
+    private DistributionCenter(ActorContext<Message> context) {
+        super(context);
     }
 
-        public List<Paket> getPakete() {
-            return pakete;
-        }
-    }
+    interface Message {}
 
-    public static class GenerateRoutes implements Message {
-        private final List<ActorRef<Customer.Message>> customers;
-
-        public GenerateRoutes(List<ActorRef<Customer.Message>> customers) {
-            this.customers = customers;
-        }
-
-        public List<ActorRef<Customer.Message>> getCustomers() {
-            return customers;
-        }
+    public static Behavior<Message> create() {
+        return Behaviors.setup(DistributionCenter::new);
     }
 
     @Override
     public Receive<Message> createReceive() {
         return newReceiveBuilder()
                 .onMessage(ArriveMessage.class, this::onArriveMessage)
-                .onMessage(LoadMessage.class, this::onLoadMessage)
-                .onMessage(GenerateRoutes.class, this::onGenerateRoutes)
                 .build();
     }
 
     private Behavior<Message> onArriveMessage(ArriveMessage msg) {
         // Füge alle Pakete aus der Ankunftsnachricht dem Lagerraum hinzu
-        List<Paket> arrivedPackages = msg.getPakete();
-        lagerraum.addAll(arrivedPackages);
-        getContext().getLog().info("Angekommene Pakete: {}", arrivedPackages);
+        List<Paket> pakete = msg.getPakete();
+        getContext().getLog().info("Angekommene Pakete: {}", pakete);
 
-        // Entferne zufällig 3 Pakete aus dem Lagerraum und sende sie dem angekommenen Wagen
-        int numPackagesToSend = Math.min(3, lagerraum.size());
-        List<Paket> packagesToSend = new ArrayList<>();
-        for (int i = 0; i < numPackagesToSend; i++) {
-            packagesToSend.add(lagerraum.remove(0));
-        }
-        msg.getTruck().tell(new DeliveryCar.LoadMessage(packagesToSend));
+        // Hier kann die weitere Logik für die Behandlung der Pakete implementiert werden
 
-        // Ausgabe, wie viele Pakete nun im Verteilzentrum vorhanden sind
-        getContext().getLog().info("Pakete im Verteilzentrum nach Laden: {}", lagerraum.size());
+        // Beispiel: Senden der Pakete an einen internen Akteur zur weiteren Verarbeitung
+        // ...
 
         return this;
     }
-
-    private Behavior<Message> onLoadMessage(LoadMessage msg) {
-        // Ausgabe, wie viele Pakete nun im Verteilzentrum vorhanden sind
-        getContext().getLog().info("Pakete im Verteilzentrum nach Laden: {}", lagerraum.size());
-
-        return this;
-    }
-
-    private Behavior<Message> onGenerateRoutes(GenerateRoutes msg) {
-        List<ActorRef<Customer.Message>> customers = msg.getCustomers();
-        generateRoutes(customers);
-        return this;
-    }
-
-    private void generateRoutes(List<ActorRef<Customer.Message>> customers) {
-        // Überprüfen, ob die Kundenliste null oder leer ist
-        if (customers == null || customers.isEmpty()) {
-            getContext().getLog().info("Kundenliste ist leer oder null. Keine Routen generiert.");
-            return;
-        }
-
-        // Erstelle vier Lastwagen mit zufälligen Routen
-        for (int i = 0; i < 4; i++) {
-            List<ActorRef<Customer.Message>> route = generateRandomRoute(customers);
-            getContext().spawn(DeliveryCar.create(route), "deliveryCar" + i);
-            getContext().getLog().info("Lieferwagen {} erstellt mit Route: {}", i, route);
-        }
-    }
-
-    // Dummy-Methode zum Generieren einer zufälligen Route
-    private List<ActorRef<Customer.Message>> generateRandomRoute(List<ActorRef<Customer.Message>> customers) {
-        List<ActorRef<Customer.Message>> route = new ArrayList<>(customers);
-        Collections.shuffle(route);
-        return route;
-    }
 }