Behaviors
Factories for akka.actor.typed.Behavior.
- Source:
- Behaviors.scala
Type members
Classlikes
Behavior
that exposes additional fluent DSL methods to further change the message or
signal reception behavior. It's returned by for example Behaviors.receiveMessage.
Behavior
that exposes additional fluent DSL methods to further change the message or
signal reception behavior. It's returned by for example Behaviors.receiveMessage.
- Source:
- Behaviors.scala
Value members
Concrete methods
A behavior that treats every incoming message as unhandled.
A behavior that treats every incoming message as unhandled.
- Source:
- Behaviors.scala
A behavior that ignores every incoming message and returns “same”.
A behavior that ignores every incoming message and returns “same”.
- Source:
- Behaviors.scala
Intercept messages and signals for a behavior
by first passing them to a akka.actor.typed.BehaviorInterceptor
Intercept messages and signals for a behavior
by first passing them to a akka.actor.typed.BehaviorInterceptor
When a behavior returns a new behavior as a result of processing a signal or message and that behavior already contains
the same interceptor (defined by the isSame
method on the BehaviorInterceptor
) only the innermost interceptor
is kept. This is to protect against stack overflow when recursively defining behaviors.
The interceptor is created with a factory function in case it has state and should not be shared. If the interceptor has no state the same instance can be returned from the factory to avoid unnecessary object creation.
- Source:
- Behaviors.scala
Behavior decorator that logs all messages to the akka.actor.typed.Behavior using the provided
akka.actor.typed.LogOptions default configuration before invoking the wrapped behavior.
To include an MDC context then first wrap logMessages
with withMDC
.
Behavior decorator that logs all messages to the akka.actor.typed.Behavior using the provided
akka.actor.typed.LogOptions default configuration before invoking the wrapped behavior.
To include an MDC context then first wrap logMessages
with withMDC
.
- Source:
- Behaviors.scala
Behavior decorator that logs all messages to the akka.actor.typed.Behavior using the provided
akka.actor.typed.LogOptions configuration before invoking the wrapped behavior.
To include an MDC context then first wrap logMessages
with withMDC
.
Behavior decorator that logs all messages to the akka.actor.typed.Behavior using the provided
akka.actor.typed.LogOptions configuration before invoking the wrapped behavior.
To include an MDC context then first wrap logMessages
with withMDC
.
- Source:
- Behaviors.scala
Behavior decorator that copies all received message to the designated
monitor akka.actor.typed.ActorRef before invoking the wrapped behavior. The
wrapped behavior can evolve (i.e. return different behavior) without needing to be
wrapped in a monitor
call again.
Behavior decorator that copies all received message to the designated
monitor akka.actor.typed.ActorRef before invoking the wrapped behavior. The
wrapped behavior can evolve (i.e. return different behavior) without needing to be
wrapped in a monitor
call again.
The ClassTag
for T
ensures that the messages of this class or a subclass thereof will be
sent to the monitor
. Other message types (e.g. a private protocol) will bypass the interceptor
and be continue to the inner behavior.
- Value parameters:
- behavior
The inner behavior that is decorated
- monitor
The messages will also be sent to this
ActorRef
- Source:
- Behaviors.scala
Construct an actor behavior that can react to both incoming messages and lifecycle signals. After spawning this actor from another actor (or as the guardian of an akka.actor.typed.ActorSystem) it will be executed within an ActorContext that allows access to the system, spawning and watching other actors, etc.
Construct an actor behavior that can react to both incoming messages and lifecycle signals. After spawning this actor from another actor (or as the guardian of an akka.actor.typed.ActorSystem) it will be executed within an ActorContext that allows access to the system, spawning and watching other actors, etc.
Compared to using AbstractBehavior this factory is a more functional style
of defining the Behavior
. Processing the next message results in a new behavior
that can potentially be different from this one. State is maintained by returning
a new behavior that holds the new immutable state.
- Source:
- Behaviors.scala
Simplified version of Receive with only a single argument - the message to be handled. Useful for when the context is already accessible by other means, like being wrapped in an setup or similar.
Simplified version of Receive with only a single argument - the message to be handled. Useful for when the context is already accessible by other means, like being wrapped in an setup or similar.
Construct an actor behavior that can react to both incoming messages and lifecycle signals. After spawning this actor from another actor (or as the guardian of an akka.actor.typed.ActorSystem) it will be executed within an ActorContext that allows access to the system, spawning and watching other actors, etc.
Compared to using AbstractBehavior this factory is a more functional style
of defining the Behavior
. Processing the next message results in a new behavior
that can potentially be different from this one. State is maintained by returning
a new behavior that holds the new immutable state.
- Source:
- Behaviors.scala
Construct an actor Behavior
from a partial message handler which treats undefined messages as unhandled.
Construct an actor Behavior
from a partial message handler which treats undefined messages as unhandled.
- Source:
- Behaviors.scala
Construct an actor Behavior
from a partial message handler which treats undefined messages as unhandled.
Construct an actor Behavior
from a partial message handler which treats undefined messages as unhandled.
- Source:
- Behaviors.scala
Construct an actor Behavior
that can react to lifecycle signals only.
Construct an actor Behavior
that can react to lifecycle signals only.
- Source:
- Behaviors.scala
Return this behavior from message processing in order to advise the system to reuse the previous behavior. This is provided in order to avoid the allocation overhead of recreating the current behavior where that is not necessary.
Return this behavior from message processing in order to advise the system to reuse the previous behavior. This is provided in order to avoid the allocation overhead of recreating the current behavior where that is not necessary.
- Source:
- Behaviors.scala
setup
is a factory for a behavior. Creation of the behavior instance is deferred until
the actor is started, as opposed to Behaviors.receive that creates the behavior instance
immediately before the actor is running. The factory
function pass the ActorContext
as parameter and that can for example be used for spawning child actors.
setup
is a factory for a behavior. Creation of the behavior instance is deferred until
the actor is started, as opposed to Behaviors.receive that creates the behavior instance
immediately before the actor is running. The factory
function pass the ActorContext
as parameter and that can for example be used for spawning child actors.
setup
is typically used as the outer most behavior when spawning an actor, but it
can also be returned as the next behavior when processing a message or signal. In that
case it will be started immediately after it is returned, i.e. next message will be
processed by the started behavior.
- Source:
- Behaviors.scala
Return this behavior from message processing to signal that this actor shall terminate voluntarily. If this actor has created child actors then these will be stopped as part of the shutdown procedure.
Return this behavior from message processing to signal that this actor shall terminate voluntarily. If this actor has created child actors then these will be stopped as part of the shutdown procedure.
The PostStop
signal that results from stopping this actor will be passed to the
current behavior. All other messages and signals will effectively be
ignored.
- Source:
- Behaviors.scala
Return this behavior from message processing to signal that this actor shall terminate voluntarily. If this actor has created child actors then these will be stopped as part of the shutdown procedure.
Return this behavior from message processing to signal that this actor shall terminate voluntarily. If this actor has created child actors then these will be stopped as part of the shutdown procedure.
The PostStop
signal that results from stopping this actor will first be passed to the
current behavior and then the provided postStop
callback will be invoked.
All other messages and signals will effectively be ignored.
An example of when the callback can be useful compared to the PostStop
signal
if you want to send a reply to the message that initiated a graceful stop.
- Source:
- Behaviors.scala
Wrap the given behavior with the given SupervisorStrategy for
the given exception.
Exceptions that are not subtypes of Thr
will not be
caught and thus lead to the termination of the actor.
Wrap the given behavior with the given SupervisorStrategy for
the given exception.
Exceptions that are not subtypes of Thr
will not be
caught and thus lead to the termination of the actor.
It is possible to specify different supervisor strategies, such as restart, resume, backoff.
Note that only scala.util.control.NonFatal throwables will trigger the supervision strategy.
Example:
val dbConnector: Behavior[DbCommand] = ...
val dbRestarts =
Behaviors.supervise(dbConnector)
.onFailure(SupervisorStrategy.restart) // handle all NonFatal exceptions
val dbSpecificResumes =
Behaviors.supervise(dbConnector)
.onFailure[IndexOutOfBoundsException](SupervisorStrategy.resume) // resume for IndexOutOfBoundsException exceptions
- Source:
- Behaviors.scala
Return this behavior from message processing in order to advise the system to reuse the previous behavior, including the hint that the message has not been handled. This hint may be used by composite behaviors that delegate (partial) handling to other behaviors.
Return this behavior from message processing in order to advise the system to reuse the previous behavior, including the hint that the message has not been handled. This hint may be used by composite behaviors that delegate (partial) handling to other behaviors.
- Source:
- Behaviors.scala
Per message MDC (Mapped Diagnostic Context) logging.
Per message MDC (Mapped Diagnostic Context) logging.
The ClassTag
for T
ensures that only messages of this class or a subclass thereof will be
intercepted. Other message types (e.g. a private protocol) will bypass the interceptor and be
continue to the inner behavior untouched.
- Value parameters:
- behavior
The actual behavior handling the messages, the MDC is used for the log entries logged through
ActorContext.log
- mdcForMessage
Is invoked before each message is handled, allowing to setup MDC, MDC is cleared after each message processing by the inner behavior is done.
- Source:
- Behaviors.scala
Static MDC (Mapped Diagnostic Context)
Static MDC (Mapped Diagnostic Context)
The ClassTag
for T
ensures that only messages of this class or a subclass thereof will be
intercepted. Other message types (e.g. a private protocol) will bypass the interceptor and be
continue to the inner behavior untouched.
- Value parameters:
- behavior
The actual behavior handling the messages, the MDC is used for the log entries logged through
ActorContext.log
- staticMdc
This MDC is setup in the logging context for every message
- Source:
- Behaviors.scala
Combination of static and per message MDC (Mapped Diagnostic Context).
Combination of static and per message MDC (Mapped Diagnostic Context).
Each message will get the static MDC plus the MDC returned for the message. If the same key are in both the static and the per message MDC the per message one overwrites the static one in the resulting log entries.
The staticMdc
or mdcForMessage
may be empty.
The ClassTag
for T
ensures that only messages of this class or a subclass thereof will be
intercepted. Other message types (e.g. a private protocol) will bypass the interceptor and be
continue to the inner behavior untouched.
- Value parameters:
- behavior
The actual behavior handling the messages, the MDC is used for the log entries logged through
ActorContext.log
- mdcForMessage
Is invoked before each message is handled, allowing to setup MDC, MDC is cleared after each message processing by the inner behavior is done.
- staticMdc
A static MDC applied for each message
- Source:
- Behaviors.scala
Support for stashing messages to unstash at a later time.
Support for stashing messages to unstash at a later time.
- Source:
- Behaviors.scala
Support for scheduled self
messages in an actor.
It takes care of the lifecycle of the timers such as cancelling them when the actor
is restarted or stopped.
Support for scheduled self
messages in an actor.
It takes care of the lifecycle of the timers such as cancelling them when the actor
is restarted or stopped.
- See also:
- Source:
- Behaviors.scala