object Behaviors
Factories for akka.actor.typed.Behavior.
- Annotations
- @ApiMayChange()
- Source
- Behaviors.scala
- Alphabetic
- By Inheritance
- Behaviors
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
Receive[T] extends Behavior[T]
Behavior
that exposes additional fluent DSL methods to further change the message or signal reception behavior.Behavior
that exposes additional fluent DSL methods to further change the message or signal reception behavior. It's returned by for example Behaviors.receiveMessage.- Annotations
- @DoNotInherit()
- final class Supervise[T] extends AnyVal
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate() @throws( ... )
-
def
empty[T]: Behavior[T]
A behavior that treats every incoming message as unhandled.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
ignore[T]: Behavior[T]
A behavior that ignores every incoming message and returns “same”.
-
def
intercept[O, I](behaviorInterceptor: BehaviorInterceptor[O, I])(behavior: Behavior[I]): Behavior[O]
Intercept messages and signals for a
behavior
by first passing them to a akka.actor.typed.BehaviorInterceptorIntercept messages and signals for a
behavior
by first passing them to a akka.actor.typed.BehaviorInterceptorWhen 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 theBehaviorInterceptor
) only the innermost interceptor is kept. This is to protect against stack overflow when recursively defining behaviors.If the interceptor does keep mutable state care must be taken to create the instance in a
setup
block so that a new instance is created per spawned actor rather than shared among actor instance. -
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
logMessages[T](logOptions: LogOptions, behavior: Behavior[T]): Behavior[T]
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.
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
withwithMDC
. -
def
logMessages[T](behavior: Behavior[T]): Behavior[T]
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.
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
withwithMDC
. -
def
monitor[T](monitor: ActorRef[T], behavior: Behavior[T]): Behavior[T]
Behavior decorator that copies all received message to the designated monitor akka.actor.typed.ActorRef before invoking the wrapped behavior.
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. -
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
receive[T](onMessage: (ActorContext[T], T) ⇒ Behavior[T]): Receive[T]
Construct an actor behavior that can react to both incoming messages and lifecycle signals.
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. -
def
receiveMessage[T](onMessage: (T) ⇒ Behavior[T]): Receive[T]
Simplified version of Receive with only a single argument - the message to be handled.
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. -
def
receiveMessagePartial[T](onMessage: PartialFunction[T, Behavior[T]]): Receive[T]
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.Behaviors can also be composed with Behavior#orElse.
-
def
receivePartial[T](onMessage: PartialFunction[(ActorContext[T], T), Behavior[T]]): Receive[T]
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.Behaviors can also be composed with Behavior#orElse.
-
def
receiveSignal[T](handler: PartialFunction[(ActorContext[T], Signal), Behavior[T]]): Behavior[T]
Construct an actor
Behavior
that can react to lifecycle signals only. -
def
same[T]: Behavior[T]
Return this behavior from message processing in order to advise the system to reuse the previous behavior.
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.
-
def
setup[T](factory: (ActorContext[T]) ⇒ Behavior[T]): Behavior[T]
setup
is a factory for a behavior.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. Thefactory
function pass theActorContext
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. -
def
stopped[T](postStop: () ⇒ Unit): Behavior[T]
Return this behavior from message processing to signal that this actor shall terminate voluntarily.
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 providedpostStop
callback will be invoked. All other messages and signals will effectively be ignored. -
def
stopped[T]: Behavior[T]
Return this behavior from message processing to signal that this actor shall terminate voluntarily.
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. -
def
supervise[T](wrapped: Behavior[T]): Supervise[T]
Wrap the given behavior with the given SupervisorStrategy for the given exception.
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
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unhandled[T]: Behavior[T]
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.
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.
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
withMdc[T](staticMdc: Map[String, Any], mdcForMessage: (T) ⇒ Map[String, Any])(behavior: Behavior[T]): Behavior[T]
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
ormdcForMessage
may be empty.- staticMdc
A static MDC applied for each message
- 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.
- behavior
The actual behavior handling the messages, the MDC is used for the log entries logged through
ActorContext.log
See also akka.actor.typed.Logger.withMdc
-
def
withMdc[T](staticMdc: Map[String, Any])(behavior: Behavior[T]): Behavior[T]
Static MDC (Mapped Diagnostic Context)
Static MDC (Mapped Diagnostic Context)
- staticMdc
This MDC is setup in the logging context for every message
- behavior
The actual behavior handling the messages, the MDC is used for the log entries logged through
ActorContext.log
See also akka.actor.typed.Logger.withMdc
-
def
withMdc[T](mdcForMessage: (T) ⇒ Map[String, Any])(behavior: Behavior[T]): Behavior[T]
Per message MDC (Mapped Diagnostic Context) logging.
Per message MDC (Mapped Diagnostic Context) logging.
- 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.
- behavior
The actual behavior handling the messages, the MDC is used for the log entries logged through
ActorContext.log
See also akka.actor.typed.Logger.withMdc
-
def
withTimers[T](factory: (TimerScheduler[T]) ⇒ Behavior[T]): Behavior[T]
Support for scheduled
self
messages in an actor.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