Akka oder Reaktor [geschlossen]

Ich bin gerade dabei, ein neues Projekt zu starten (Java-basiert). Ich muss es als modulare, verteilte und belastbare Architektur erstellen.

Daher möchte ich, dass die Geschäftsprozesse untereinander kommunizieren, interoperabel, aber auch unabhängig sind.

Ich betrachte gerade zwei Frameworks, die neben ihrem Altersunterschied zwei unterschiedliche Ansichten zum Ausdruck bringen:

• Akka ( http://akka.io )
• Reaktor ( https://github.com/reactor/reactor )

Was sollte ich bei der Auswahl eines der oben genannten Frameworks beachten?

Soweit ich bis jetzt verstehe, ist Akka immer noch irgendwie gekoppelt (auf eine Weise, dass ich den Schauspieler 'auswählen' muss, an den ich die Nachrichten senden möchte), aber sehr belastbar. Während Reactor lose ist (wie basierend auf Event-Posting).

Kann mir jemand helfen zu verstehen, wie man eine richtige Entscheidung trifft?

AKTUALISIEREN

Nachdem ich den Event Bus von Akka besser durchgesehen habe, glaube ich, dass die von Reactor ausgedrückten Funktionen bereits in Akka enthalten sind.

Zum Beispiel kann das Abonnement- und Event-Publishing, das unter https://github.com/reactor/reactor#events-selectors-and-consumers dokumentiert ist, in Akka wie folgt ausgedrückt werden:

final ActorSystem system = ActorSystem.create("system");
final ActorRef actor = system.actorOf(new Props(
    new UntypedActorFactory() {

        @Override
        public Actor create() throws Exception {

            return new UntypedActor() {
                final LoggingAdapter log = Logging.getLogger(
                        getContext().system(), this);

                @Override
                public void onReceive(Object message)
                        throws Exception {
                    if (message instanceof String)
                        log.info("Received String message: {}",
                                message);
                    else
                        unhandled(message);
                }
            };
        }
    }), "actor");

system.eventStream().subscribe(actor, String.class);
system.eventStream().publish("testing 1 2 3");

Daher scheint es mir jetzt, dass die Hauptunterschiede zwischen den beiden sind:

• Akka, reifer, an Typesafe gebunden
• Reaktor, frühes Stadium, an den Frühling gebunden

Ist meine Interpretation korrekt? Aber was ist konzeptionell der Unterschied zwischen dem Schauspieler in Akka und dem Verbraucher in Reactor ?

Es ist an dieser Stelle schwer zu sagen, da Reactor immer noch eine Skizze ist und ich (technischer Leiter von Akka) keinen Einblick habe, wohin es gehen wird. Es wird interessant sein zu sehen, ob Reactor ein Konkurrent von Akka wird, wir freuen uns darauf.

Soweit ich sehen kann, fehlt Reactor in Ihrer Anforderungsliste die Ausfallsicherheit (dh die Überwachung in Akka) und die Standorttransparenz (dh die Bezugnahme auf aktive Entitäten auf eine Weise, mit der Sie über lokale oder Remote-Nachrichten abstrahieren können implizieren durch "verteilt"). Für "modular" weiß ich nicht genug über Reactor, insbesondere darüber, wie Sie aktive Komponenten nachschlagen und verwalten können.

Wenn Sie jetzt ein echtes Projekt starten und etwas brauchen, das Ihren ersten Satz erfüllt, dann wäre es meiner Meinung nach nicht umstritten, Akka an dieser Stelle zu empfehlen (wie Jon ebenfalls bemerkte). Fühlen Sie sich frei, konkretere Fragen zu SO oder zur Akka-User-Mailingliste zu stellen .

Der Reaktor ist nicht an Spring gebunden, sondern ein optionales Modul. Wir möchten, dass Reactor tragbar ist, eine Grundlage, wie Jon dargelegt hat.

Ich werde nicht sicher sein, die Produktion voranzutreiben, da wir nicht einmal Milestone (1.0.0.SNAPSHOT) sind. In dieser Hinsicht würde ich mir Akka genauer ansehen, das ein fantastisches asynchrones Framework IMO ist. Berücksichtigen Sie auch Vert.x und Finagle, die möglicherweise angepasst werden, wenn Sie entweder nach einer Plattform (erstere) oder nach zusammensetzbaren Futures (letztere) suchen. Wenn Sie sich um eine Vielzahl von asynchronen Mustern kümmern , bieten Ihnen GPars möglicherweise eine umfassendere Lösung.

Am Ende könnten sich sicherlich Überschneidungen ergeben. Tatsächlich tendieren wir zu einem gemischten Ansatz (flexibles zusammensetzbares Eventing, verteilt und nicht an eine Versandstrategie gebunden), bei dem Sie leicht Bits von RxJava , Vert.x , Akka usw. Finden können Wir sind nicht einmal von der Wahl der Sprache überzeugt, auch wenn wir uns stark für Groovy engagieren, haben die Leute bereits Clojure- und Kotlin- Häfen eröffnet. Fügen Sie dieser Mischung die Tatsache hinzu, dass einige Anforderungen von Spring XD und Grails bestimmt werden .

Vielen Dank für Ihr Interesse, hoffentlich haben Sie in ein paar Monaten mehr Vergleichspunkte :)

Dies ist eine ausgezeichnete Frage, und die Antwort wird sich in den kommenden Wochen ändern. Wir können nicht versprechen, wie die Kommunikation zwischen Knoten im Moment aussehen wird, nur weil es zu früh ist. Wir müssen noch einige Teile zusammenstellen, bevor wir das Clustering in Reactor demonstrieren können.

Nur weil Reactor keine Kommunikation zwischen Knoten ausführt, heißt das nicht, dass OOTB dies nicht kann . :) Man würde nur eine ziemlich dünne Netzwerkschicht benötigen, um zwischen Reaktoren mit etwas wie Redis oder AMQP zu koordinieren, um ihm einige Cluster-Smarts zu geben.

Wir sprechen definitiv über verteilte Szenarien in Reactor und planen diese. Es ist einfach zu früh, um genau zu sagen, wie es funktionieren wird.

Wenn Sie etwas benötigen, das gerade Clustering ausführt, ist die Wahl von Akka sicherer.