Akka Streams GraphStage

Question

在Akka Streams中推荐使用GraphStage，但我找不到任何关于在Java语言中使用getStageActor()方法的文档(我找到的所有文档都使用Scala)。

如何将以下代码转换为Java？

lazy val self: StageActor = getStageActor(onMessage)

和

private def onMessage(x: (ActorRef, Any)): Unit =
{
  x match {
    case (_, msg: String) =>
      log.info("received msg, queueing: {} ", msg)
      messages = messages.enqueue(msg)
      pump()
  }
}

Answer 1

根据getStageActor method documentation，它接受类型为

scala.Function1<scala.Tuple2<ActorRef,java.lang.Object>, scala.runtime.BoxedUnit>

在Scala中，它看起来像

((ActorRef, AnyRef)) => Unit

在Java语言中，这个类型在语义上等同于(使用Function接口)

Function<Tuple<ActorRef, Object>, Void>

其中Tuple<A, B>是包含A和B类型的两个值的类。

因此，要调用getStageActor方法，需要创建上述类型的值。您可以通过构造扩展AbstractFunction1的类的实例直接完成此操作

import scala.Function1;
import scala.Tuple2;
import scala.runtime.AbstractFunction1;
import scala.runtime.BoxedUnit;

getStateActor(new AbstractFunction1<Tuple2<ActorRef, Object>, BoxedUnit>() {
    @Override
    public BoxedUnit apply(Tuple2<ActorRef, Object> args) {
        return BoxedUnit.UNIT;
    }
});

如果您使用Java8，那么使用lambda表达式有更好的语法方法。

如果您使用Scala，那么scala.Function1是一个函数式接口，您可以直接使用2.12+表达式：

getStateActor((args: Tuple2<ActorRef, Object>) -> BoxedUnit.UNIT);

如果您使用的是旧版本的Scala，那么由于特征的编译方式，Function1不是一个函数接口，您将需要使用scala-java8-compat库。有了它，代码看起来就像

import static scala.compat.java8.JFunction.*;

getStateActor(func((args: Tuple2<ActorRef, Object>) -> BoxedUnit.UNIT));

然后，要实现函数的逻辑，可以使用_1()和_2()方法访问元组的元素：

(args: Tuple2<ActorRef, Object>) -> {
    Object msg = args._2();
    if (msg instanceof String) {
        log.info("received msg, queueing: {} ", msg);
        messages = messages.enqueue((String) msg);
        pump();
    }
    return BoxedUnit.UNIT;
}

这是您想要转换的逻辑的直接转换。

Answer 2

我以前没有使用过getStageActor()，因此在这方面我不能提供太多帮助。至于从Scala到Java的代码转换，如果要求允许，请打包一个包含Scala版本的类的jar供Java应用程序使用；否则，请考虑使用Java反编译器(例如cfr、procyon)来反编译Scala编译的类，并根据需要改进反编译的Java代码。

例如，反编译下面的虚拟Scala代码将有助于揭示lazy val和pattern matching的框架Java方式

class Foo {
  lazy val self = dummy(bar(_: String))
  def dummy(u: Unit) = 1
  private def bar(x: String): Unit = {
    x match {
      case "blah" => println(s"x = $x")
    }
  }
}

如下面的反编译代码所示，lazy val是在Java语言中完成的，其中的值包装在一个带有bitmap$0布尔标志的synchronized块中，pattern matching被转换为if和MatchError exception：

$ java -jar /path/to/decompiler/cfr_0_125.jar Foo.class

private int self;
private volatile boolean bitmap$0;

private int self$lzycompute() {
    Foo foo = this;
    synchronized (foo) {
        if (!this.bitmap$0) {
            new Serializable(this){
                public static final long serialVersionUID = 0L;
                private final /* synthetic */ Foo $outer;

                public final void apply(String x$1) {
                    this.$outer.Foo$$bar(x$1);
                }
                {
                    if ($outer == null) {
                        throw null;
                    }
                    this.$outer = $outer;
                }
            };
            this.self = this.dummy(BoxedUnit.UNIT);
            this.bitmap$0 = true;
        }
        return this.self;
    }
}

public int self() {
    return this.bitmap$0 ? this.self : this.self$lzycompute();
}

public int dummy(BoxedUnit u) {
    return 1;
}

public void Foo$$bar(String x) {
    String string = x;
    if ("blah".equals(string)) {
        Predef$.MODULE$.println((Object)new StringContext(
                (Seq)Predef$.MODULE$.wrapRefArray((Object[])new String[]{"x = ", ""})
            ).s((Seq)Predef$.MODULE$.genericWrapArray((Object)new Object[]{x}))
        );
        BoxedUnit boxedUnit = BoxedUnit.UNIT;
        return;
    }
    throw new MatchError((Object)string);
}