GraphDSL Streams:如何从Akka接口获取物化Sink输出？

import akka.actor.ActorSystem
import akka.stream._
import akka.stream.scaladsl._
import akka.{ NotUsed, Done }
import scala.concurrent._
import scala.concurrent.duration._

object GraphDSLStreamsExample {
  def main(args: Array[String]): Unit = {
    implicit val system: ActorSystem = ActorSystem("GraphDSLStreamsExample")
    implicit val materializer: ActorMaterializer = ActorMaterializer()

    val source: Source[Int, NotUsed] = Source(1 to 10)
    val sink: Sink[Int, Future[Done]] = Sink.foreach(println)

    val graph: Graph[ClosedShape, Future[Done]] = GraphDSL.create(sink) { implicit builder =>
      sink =>
        import GraphDSL.Implicits._

        val broadcast = builder.add(Broadcast[Int](2))
        val merge = builder.add(Merge[Int](2))

        source ~> broadcast ~> merge ~> sink
                          broadcast ~> merge

        ClosedShape
    }

    val materializedSink: Future[Done] = RunnableGraph.fromGraph(graph).run()

    materializedSink.onComplete {
      case Success(_) =>
        println("Stream completed successfully.")
        system.terminate()
      case Failure(ex) =>
        println(s"Stream failed with: $ex")
        system.terminate()
    }

    Await.result(system.whenTerminated, Duration.Inf)
  }
}