使用Java中的been（）

我使用的是来自Java的Akka。根据文档，

context.been（）

将

Procedure

作为参数。事实上，它需要的是

PartialFunction

，它似乎是由许多具有奇怪名称的方法自动生成的

使用Java中的been（）的正确方法是什么

PS 我用的是Akka 2.0.3

更新：

---

看起来有两个方法：context（）和getContext（）。第一个返回ActorContext，第二个返回UntypedActorContext。UntypedActorContext已成为（过程）

您混淆了Akka Java和Scala API。从技术上讲，您可以从Java代码中使用类似Akka的Scala库，但这通常是冗长和繁琐的。因此Akka团队决定开发分离的API——Scala中的本机API和Java适配器

在Scala API中，您可以扩展该API，它具有类型为的

上下文
字段。这个
ActorContext.been（）
接受，它是一个特定于Scala的类

另一方面，在Java API中，您扩展了（类Java）方法
getContext（）
，返回。这个接受

长话短说——如果您使用的是JavaAPI，请坚持使用它。Scala和Java文档之间有着明显的区别。
关于如何在Java中实现这一点，也有很多很好的示例。希望此示例能够帮助：

Procedure<Object> angry = new Procedure<Object>() {
@Override
public void apply(Object message) {
  if (message.equals("bar")) {
    getSender().tell("I am already angry?", getSelf());
  } else if (message.equals("foo")) {
    getContext().become(happy);
  }
}
};

Procedure<Object> happy = new Procedure<Object>() {
@Override
public void apply(Object message) {
  if (message.equals("bar")) {
    getSender().tell("I am already happy :-)", getSelf());
  } else if (message.equals("foo")) {
    getContext().become(angry);
  }
 }
};

public void onReceive(Object message) {
if (message.equals("bar")) {
  getContext().become(angry);
} else if (message.equals("foo")) {
  getContext().become(happy);
} else {
  unhandled(message);
}

Procedure=newprocedure（）{
@凌驾
公共无效应用（对象消息）{
if（message.equals（“bar”））{
getSender（）。告诉（“我已经生气了？”，getSelf（））；
}else if（message.equals（“foo”））{
getContext（）.变得（快乐）；
}
}
};
过程=新过程（）{
@凌驾
公共无效应用（对象消息）{
if（message.equals（“bar”））{
getSender（）.tell（“我已经很快乐了：-）”，getSelf（））；
}else if（message.equals（“foo”））{
getContext（）。变得（愤怒）；
}
}
};
接收时公共无效（对象消息）{
if（message.equals（“bar”））{
getContext（）。变得（愤怒）；
}else if（message.equals（“foo”））{
getContext（）.变得（快乐）；
}否则{
未处理（消息）；
}

}
}
简而言之，在使用
JavaAPI
时，请确保调用的是
getContext（）
方法，而不是
context（）
，后者将与
Scala API
一起使用

结帐

或

一切都可以用同样的想法来完成，就像在Scala中一样
我不明白为什么人们不提原因就投了反对票。@Marounnaroun也许，他们看到文档与现实不符而感到不安？：）为什么不粘贴一个链接到您看到的文档？并说明我所说的ActorContext是什么类别的“上下文”。这里是文档中的位置：在生成的API文档中，been（）有不同的签名：一般来说，我理解它。但是，是否有一种正式的方法来确定哪些属于Java，哪些属于ScalaAPI？context（）和getContext（）在技术上都可以从Java获得，所以很难猜测应该使用什么。@aav:ScalaDoc+初学者命名约定
context（）
是类似Scala的名称，而
getContext（）
是Java的典型名称。它也有很好的记录。
@Slf4j
@RequiredArgsConstructor
public class Greeter extends AbstractActor {

    private final ActorRef printer;

    public static Props props(ActorRef printer) {
        return Props.create(Greeter.class, printer);
    }

    @Override
    public Receive createReceive() {
        return withWhomToGreet(""); // initial state
    }

    private Receive withWhomToGreet(String name) {
        return receiveBuilder()
                .match(WhoToGreet.class, // changing actor state context
                       whoToGreet -> getContext().become(withWhomToGreet(whoToGreet.getWho())))
                .match(Greet.class, greet -> {
                    String msg = format("Hola, %s", name);
                    log.info("sending {} to {}", msg, printer);
                    printer.tell(Greeting.of(msg), self());
                })
                .matchAny(o -> {
                    log.error("unexpected: {}", o);
                    unhandled(o);
                })
                .build();
    }
}

class CounterActor : AbstractActor() {

    companion object Factory {
        sealed class Commands {
            override fun toString(): String = javaClass.simpleName

            object Increment : Commands()
            object Decrement : Commands()
            object GetState : Commands()
        }

        private val type = CounterActor::class.java
        val props: Props = Props.create(type) { CounterActor() }
        val name: String = type.simpleName
    }

    override fun createReceive(): Receive = withCounter(0) // init state

    private fun withCounter(counter: Int): Receive =
        receiveBuilder()
            .matchAny { cmd ->
                context.system.log().info("current: $counter, received: $cmd")
                when (cmd) {
                    is GetState -> sender.tell("counter value: $counter", self)
                    is Increment -> {
                        // switch context with new updated actor state,
                        // actor is still stateless, similarly like we
                        // doing in scala for context.become 
                        // Make sure with Java API you are calling
                        // getContext() method, not context()!
                        context.become(withCounter(counter + 1))
                    }
                    is Decrement -> // another change of actor state
                        context.become(withCounter(counter - 1))
                    else -> unhandled(cmd)
                }
            }
            .build()
}