从源创建两个接收器-Akka Streams

Question

I'm studying Akka. I created a source of Integer numbers (1 to 100) and applied some flows, after that I want to divide the stream into two sinks: one for even number and another for odd ones but I don't know how to do that. Can anybody help me? Thank you much! See my code bellow:

public class App 
{
    final ActorSystem system = ActorSystem.create("example");
    final Materializer materializer = ActorMaterializer.create(system); 

    final Source<Integer, NotUsed> source = Source.range(1, 100);

    final Flow<Integer, Integer, NotUsed> addFlow = Flow.fromFunction(n -> addFlow(n)); 
    final Flow<Integer, Integer, NotUsed> multipleFlow= Flow.fromFunction(n -> multipleFlow(n)); 
    final Flow<Integer, Integer, NotUsed> mathFlow = addFlow.via(multipleFlow);

    final Flow<Integer, Integer, NotUsed> evenFlow = Flow.of(Integer.class).filter(n -> n%2==0);

    final Sink<Integer, CompletionStage<Done>> evenSink =  Sink.foreach(n -> System.out.println("sink even : " + n)); 
    final Sink<Integer, CompletionStage<Done>> oddSink =  Sink.foreach(n -> System.out.println("sink odd : " + n)); 

    public static void main( String[] args )
    {
        App app = new App();
        app.runAkka();
    }

    private void runAkka() {
        RunnableGraph<NotUsed> runnable = source.via(mathFlow).via(evenFlow).to(evenSink);
        runnable.run(materializer);
    }

    private int addFlow(int n) {
        return ++n;
    }

    private int multipleFlow(int n) {
        return n * n;
    }
}

Answer 1

This isn't a Java solution, but a Scala snippet using the GraphDSL approach. Thought it might serve as a reference for your Java version:

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.stream.scaladsl._
import akka.stream.ClosedShape
import akka.NotUsed

implicit val system = ActorSystem("Sys")
implicit val materializer = ActorMaterializer()

val source: Source[Int, NotUsed] = Source(1 to 20)

def evenFlow: Flow[Int, Int, NotUsed] =  Flow[Int].filter(_ % 2 == 0)
def oddFlow: Flow[Int, Int, NotUsed] = Flow[Int].filter(_ % 2 == 1)

val evenSink = Sink.foreach[Int](x => print(x + "e "))
val oddSink = Sink.foreach[Int](x => print(x + "o "))

val graph = GraphDSL.create() { implicit builder =>
  import GraphDSL.Implicits._

  val bcast = builder.add(Broadcast[Int](2))

  source ~> bcast.in
  bcast.out(0) ~> evenFlow ~> evenSink
  bcast.out(1) ~> oddFlow ~> oddSink

  ClosedShape
}

RunnableGraph.fromGraph(graph).run
// res1: akka.NotUsed = NotUsed
// 1o 2e 3o 4e 5o 6e 7o 8e 9o 10e 11o 12e 13o 14e 15o 16e 17o 18e 19o 20e