J'utilise Akka de Java. Selon la documentation, Quelle est la bonne façon d'utiliser devenir () de Java?
ps
J'utilise AKKA 2.0.3
mise à jour:
On dirait qu'il y a deux méthodes: contexte () et getcontext (). Le premier retourne ActorContext et le second retourne untypedactorContext. UnttypedactorContext a context.fr () prend procédure partialfunction devenir (procédure
3 Réponses :
Vous êtes confondre Akka Java et Scala API. Techniquement, vous pouvez utiliser des bibliothèques scala comme Akka à partir du code Java, mais assez souvent, c'est verbeux et encombrant. Donc, l'équipe d'Akka a décidé de se développer pour séparer les API - Native à Scala et Java Adapter.
in Scala API Vous étendez D'autre part en API Java, vous étendez < code> akka.actor.untypedactor ayant (java-like) Pour couper la longue histoire courte - si vous utilisez Java API, tenez-y. Il existe une distinction claire entre Scala et Java Documentation. akka. acteur.actor qui a un contexte de type akka.actor.actorcontext . Ce actorcontext.become () accepte < Code> Partialfunction , qui est une classe Scala spécifique.
getcontext () , retourner akka.actor.untypedactorContext . Celui-ci accepte akka.japi.procedure .
Je comprends, en général. Mais existe-t-il une méthode formelle pour identifier ce qui appartient à Java et à quoi pour Scala API? Les deux contextes () et GetContext () sont techniquement disponibles auprès de Java, il est donc difficile de deviner ce qui devrait être utilisé.
@aav: Convention de nommage SCALADOC + pour démarreurs. Context () est le nom de type SCALA, tandis que getcontext () est typique de Java. Il est également documenté bien.
Il y a beaucoup de bons exemples sur la façon de faire cela dans Java aussi bien. Cet échantillon aide: }
}
En bref, lorsque vous utilisez Checkout Ceci (Java) P> Java API code>, assurez-vous que vous appelez getContext () code> méthode au lieu de context () code> qui est destiné à Soyez utilisé avec Scala API CODE>. 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()
}
Je ne comprends pas pourquoi les gens aviennent sans mentionner pourquoi.
@Marounmaroun Peut-être, ils sont contrariés de voir que la documentation ne correspond pas à la réalité? :)
Pourquoi ne pas coller un lien vers la documentation où vous voyez cela? Et aussi indiquer quel classe "contexte" est
Je parle d'ActorContext. Voici la place de la documentation: doc.akka .io / Docs / Akka / 2.0.3 / Java / UNTTYPED-acteurs.html # Mettez à niveau
Dans la documentation de l'API générée, deviennent () a une signature différente: doc.akka.io/api/akka/2.0.3/#akka.actor.actorContext