java.lang.Object
- akka.actor.typed.scaladsl.Behaviors$

public class Behaviors$
extends java.lang.Object

Factories for Behavior.

Field Summary

Fields
Modifier and Type Field Description

static Behaviors$ MODULE$
Static reference to the singleton instance of this Scala object.

Constructor Summary

Constructors
Constructor Description

Behaviors$()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`<T> Behavior<T>`	`empty()`	A behavior that treats every incoming message as unhandled.
`<T> Behavior<T>`	`ignore()`	A behavior that ignores every incoming message and returns “same”.
`<O,I> Behavior<O>`	`intercept(scala.Function0<BehaviorInterceptor<O,I>> behaviorInterceptor, Behavior<I> behavior)`	Intercept messages and signals for a `behavior` by first passing them to a `BehaviorInterceptor`
`<T> Behavior<T>`	`logMessages(Behavior<T> behavior)`	Behavior decorator that logs all messages to the `Behavior` using the provided `LogOptions` default configuration before invoking the wrapped behavior.
`<T> Behavior<T>`	`logMessages(LogOptions logOptions, Behavior<T> behavior)`	Behavior decorator that logs all messages to the `Behavior` using the provided `LogOptions` configuration before invoking the wrapped behavior.
`<T> Behavior<T>`	`monitor(ActorRef<T> monitor, Behavior<T> behavior, scala.reflect.ClassTag<T> evidence$1)`	Behavior decorator that copies all received message to the designated monitor `ActorRef` before invoking the wrapped behavior.
`<T> Behaviors.Receive<T>`	`receive(scala.Function2<ActorContext<T>,T,Behavior<T>> onMessage)`	Construct an actor behavior that can react to both incoming messages and lifecycle signals.
`<T> Behaviors.Receive<T>`	`receiveMessage(scala.Function1<T,Behavior<T>> onMessage)`	Simplified version of `Receive` with only a single argument - the message to be handled.
`<T> Behaviors.Receive<T>`	`receiveMessagePartial(scala.PartialFunction<T,Behavior<T>> onMessage)`	Construct an actor `Behavior` from a partial message handler which treats undefined messages as unhandled.
`<T> Behaviors.Receive<T>`	`receivePartial(scala.PartialFunction<scala.Tuple2<ActorContext<T>,T>,Behavior<T>> onMessage)`	Construct an actor `Behavior` from a partial message handler which treats undefined messages as unhandled.
`<T> Behavior<T>`	`receiveSignal(scala.PartialFunction<scala.Tuple2<ActorContext<T>,Signal>,Behavior<T>> handler)`	Construct an actor `Behavior` that can react to lifecycle signals only.
`<T> Behavior<T>`	`same()`	Return this behavior from message processing in order to advise the system to reuse the previous behavior.
`<T> Behavior<T>`	`setup(scala.Function1<ActorContext<T>,Behavior<T>> factory)`	`setup` is a factory for a behavior.
`<T> Behavior<T>`	`stopped()`	Return this behavior from message processing to signal that this actor shall terminate voluntarily.
`<T> Behavior<T>`	`stopped(scala.Function0<scala.runtime.BoxedUnit> postStop)`	Return this behavior from message processing to signal that this actor shall terminate voluntarily.
`<T> Behaviors.Supervise<T>`	`supervise(Behavior<T> wrapped)`	Wrap the given behavior with the given `SupervisorStrategy` for the given exception.
`<T> Behavior<T>`	`unhandled()`	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.
`<T> Behavior<T>`	`withMdc(scala.collection.immutable.Map<java.lang.String,java.lang.String> staticMdc, Behavior<T> behavior, scala.reflect.ClassTag<T> evidence$3)`	Static MDC (Mapped Diagnostic Context)
`<T> Behavior<T>`	`withMdc(scala.collection.immutable.Map<java.lang.String,java.lang.String> staticMdc, scala.Function1<T,scala.collection.immutable.Map<java.lang.String,java.lang.String>> mdcForMessage, Behavior<T> behavior, scala.reflect.ClassTag<T> evidence$4)`	Combination of static and per message MDC (Mapped Diagnostic Context).
`<T> Behavior<T>`	`withMdc(scala.Function1<T,scala.collection.immutable.Map<java.lang.String,java.lang.String>> mdcForMessage, Behavior<T> behavior, scala.reflect.ClassTag<T> evidence$2)`	Per message MDC (Mapped Diagnostic Context) logging.
`<T> Behavior<T>`	`withStash(int capacity, scala.Function1<StashBuffer<T>,Behavior<T>> factory)`	Support for stashing messages to unstash at a later time.
`<T> Behavior<T>`	`withTimers(scala.Function1<TimerScheduler<T>,Behavior<T>> factory)`	Support for scheduled `self` messages in an actor.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MODULE$
```
public static final Behaviors$ MODULE$
```
    Static reference to the singleton instance of this Scala object.
- Constructor Detail
  - Behaviors$
```
public Behaviors$()
```
- Method Detail
  - setup
```
public <T> Behavior<T> setup(scala.Function1<ActorContext<T>,Behavior<T>> factory)
```
    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.
  - withStash
```
public <T> Behavior<T> withStash(int capacity,
                                 scala.Function1<StashBuffer<T>,Behavior<T>> factory)
```
    Support for stashing messages to unstash at a later time.
  - same
```
public <T> Behavior<T> same()
```
    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.
  - unhandled
```
public <T> Behavior<T> unhandled()
```
    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.
  - stopped
```
public <T> Behavior<T> stopped()
```
    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.
  - stopped
```
public <T> Behavior<T> stopped(scala.Function0<scala.runtime.BoxedUnit> postStop)
```
    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.
  - empty
```
public <T> Behavior<T> empty()
```
    A behavior that treats every incoming message as unhandled.
  - ignore
```
public <T> Behavior<T> ignore()
```
    A behavior that ignores every incoming message and returns “same”.
  - receive
```
public <T> Behaviors.Receive<T> receive(scala.Function2<ActorContext<T>,T,Behavior<T>> onMessage)
```
    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 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.
  - receiveMessage
```
public <T> Behaviors.Receive<T> receiveMessage(scala.Function1<T,Behavior<T>> onMessage)
```
    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 <T>setup(scala.Function1<akka.actor.typed.scaladsl.ActorContext<T>,akka.actor.typed.Behavior<T>>) 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 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.
  - receivePartial
```
public <T> Behaviors.Receive<T> receivePartial(scala.PartialFunction<scala.Tuple2<ActorContext<T>,T>,Behavior<T>> onMessage)
```
    Construct an actor Behavior from a partial message handler which treats undefined messages as unhandled.
  - receiveMessagePartial
```
public <T> Behaviors.Receive<T> receiveMessagePartial(scala.PartialFunction<T,Behavior<T>> onMessage)
```
    Construct an actor Behavior from a partial message handler which treats undefined messages as unhandled.
  - receiveSignal
```
public <T> Behavior<T> receiveSignal(scala.PartialFunction<scala.Tuple2<ActorContext<T>,Signal>,Behavior<T>> handler)
```
    Construct an actor Behavior that can react to lifecycle signals only.
  - intercept
```
public <O,I> Behavior<O> intercept(scala.Function0<BehaviorInterceptor<O,I>> behaviorInterceptor,
                                         Behavior<I> behavior)
```
    Intercept messages and signals for a behavior by first passing them to a 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.
  - monitor
```
public <T> Behavior<T> monitor(ActorRef<T> monitor,
                               Behavior<T> behavior,
                               scala.reflect.ClassTag<T> evidence$1)
```
    Behavior decorator that copies all received message to the designated monitor 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.
    
    Parameters:
    
    monitor - The messages will also be sent to this ActorRef
    
    behavior - The inner behavior that is decorated
  - logMessages
```
public <T> Behavior<T> logMessages(Behavior<T> behavior)
```
    Behavior decorator that logs all messages to the Behavior using the provided LogOptions default configuration before invoking the wrapped behavior. To include an MDC context then first wrap logMessages with withMDC.
  - logMessages
```
public <T> Behavior<T> logMessages(LogOptions logOptions,
                                   Behavior<T> behavior)
```
    Behavior decorator that logs all messages to the Behavior using the provided LogOptions configuration before invoking the wrapped behavior. To include an MDC context then first wrap logMessages with withMDC.
  - supervise
```
public <T> Behaviors.Supervise<T> supervise(Behavior<T> wrapped)
```
    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 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
  - withTimers
```
public <T> Behavior<T> withTimers(scala.Function1<TimerScheduler<T>,Behavior<T>> factory)
```
    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:
    
    TimerScheduler
  - withMdc
```
public <T> Behavior<T> withMdc(scala.Function1<T,scala.collection.immutable.Map<java.lang.String,java.lang.String>> mdcForMessage,
                               Behavior<T> behavior,
                               scala.reflect.ClassTag<T> evidence$2)
```
    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.
    
    Parameters:
    
    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
  - withMdc
```
public <T> Behavior<T> withMdc(scala.collection.immutable.Map<java.lang.String,java.lang.String> staticMdc,
                               Behavior<T> behavior,
                               scala.reflect.ClassTag<T> evidence$3)
```
    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.
    
    Parameters:
    
    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
  - withMdc
```
public <T> Behavior<T> withMdc(scala.collection.immutable.Map<java.lang.String,java.lang.String> staticMdc,
                               scala.Function1<T,scala.collection.immutable.Map<java.lang.String,java.lang.String>> mdcForMessage,
                               Behavior<T> behavior,
                               scala.reflect.ClassTag<T> evidence$4)
```
    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.
    
    Parameters:
    
    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

Class Behaviors$

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MODULE$

Constructor Detail

Behaviors$

Method Detail

setup

withStash

same

unhandled

stopped

stopped

empty

ignore

receive

receiveMessage

receivePartial

receiveMessagePartial

receiveSignal

intercept

monitor

logMessages

logMessages

supervise

withTimers

withMdc

withMdc

withMdc