Package akka.actor.typed.javadsl

Class AbstractOnMessageBehavior<T>

java.lang.Object

akka.actor.typed.Behavior<T>

akka.actor.typed.ExtensibleBehavior<T>

akka.actor.typed.javadsl.AbstractOnMessageBehavior<T>

public abstract class AbstractOnMessageBehavior<T>
extends ExtensibleBehavior<T>

An actor Behavior can be implemented by extending this class and implementing the abstract method onMessage(T). Mutable state can be defined as instance variables of the class.

This is an object-oriented style of defining a Behavior. A more functional style alternative is provided by the factory methods in Behaviors, for example Behaviors.receiveMessage.

An alternative object-oriented style is found in AbstractBehavior, which uses builders to define the Behavior. In contrast to extending AbstractBehavior, extending this class should have reduced overhead, though depending on the complexity of the protocol handled by this actor and on the Java version in use, the onMessage and onSignal methods may be overly complex.

Instances of this behavior should be created via Behaviors.setup and the ActorContext should be passed as a constructor parameter from the factory function. This is important because a new instance should be created when restart supervision is used.

When switching behavior to another behavior which requires a context, the original ActorContext can be used or a Behaviors.setup can be used: either will end up using the same ActorContext instance.

It must not be created with an ActorContext of another actor (e.g. the parent actor). Doing so will be detected at runtime and throw an IllegalStateException when the first message is received.

See Also:

Behaviors.setup

Nested Class Summary

Nested classes/interfaces inherited from class akka.actor.typed.Behavior

Behavior.BehaviorDecorators<Inner>, Behavior.BehaviorDecorators$

Constructor Summary

Constructors

Constructor	Description
AbstractOnMessageBehavior(ActorContext<T> context)

Method Summary

Modifier and Type	Method	Description
protected ActorContext<T>	getContext()
abstract Behavior<T>	onMessage(T message)	Implement this to define how messages are processed.
Behavior<T>	onSignal(Signal signal)	Override this to handle a signal.
Behavior<T>	receive(TypedActorContext<T> ctx, T msg)	Process an incoming message and return the next behavior.
Behavior<T>	receiveSignal(TypedActorContext<T> ctx, Signal signal)	Process an incoming Signal and return the next behavior.

Methods inherited from class akka.actor.typed.Behavior

BehaviorDecorators, canonicalize, existsInStack, interpretMessage, interpretSignal, isAlive, isDeferred, isUnhandled, narrow, start, validateAsInitial

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AbstractOnMessageBehavior

public AbstractOnMessageBehavior(ActorContext<T> context)

Method Detail

getContext

protected final ActorContext<T> getContext()

onMessage

public abstract Behavior<T> onMessage(T message)
                               throws java.lang.Exception

Implement this to define how messages are processed. To indicate no change in behavior beyond changes due to updating instance variables of this class, one may return either this or Behaviors.same.

Throws:

java.lang.Exception

onSignal

public Behavior<T> onSignal(Signal signal)
                     throws java.lang.Exception

Override this to handle a signal. The default implementation handles only MessageAdaptionFailure and otherwise ignores the signal.

Throws:

java.lang.Exception

receive

public final Behavior<T> receive(TypedActorContext<T> ctx,
                                 T msg)
                          throws java.lang.Exception

Description copied from class: ExtensibleBehavior

Process an incoming message and return the next behavior.

The returned behavior can in addition to normal behaviors be one of the canned special objects:

* returning stopped will terminate this Behavior * returning same designates to reuse the current Behavior * returning unhandled keeps the same Behavior and signals that the message was not yet handled

Code calling this method should use Behavior$ canonicalize to replace the special objects with real Behaviors.

Specified by:

receive in class ExtensibleBehavior<T>

Throws:

java.lang.Exception

receiveSignal

public final Behavior<T> receiveSignal(TypedActorContext<T> ctx,
                                       Signal signal)
                                throws java.lang.Exception

Description copied from class: ExtensibleBehavior

Process an incoming Signal and return the next behavior. This means that all lifecycle hooks, ReceiveTimeout, Terminated and Failed messages can initiate a behavior change.

The returned behavior can in addition to normal behaviors be one of the canned special objects:

* returning stopped will terminate this Behavior * returning same designates to reuse the current Behavior * returning unhandled keeps the same Behavior and signals that the message was not yet handled

Code calling this method should use Behavior$ canonicalize to replace the special objects with real Behaviors.

Specified by:

receiveSignal in class ExtensibleBehavior<T>

Throws:

java.lang.Exception