package concurrent
- Alphabetic
- Public
- Protected
Type Members
- trait ActorModule extends AbstractModule
Facilitates runtime dependency injection of "functional programming"-style actor behaviors.
Facilitates runtime dependency injection of "functional programming"-style actor behaviors.
1. Mix this trait into the
object
defining the actor message(s) and behavior(s); 2. Define theMessage
type with actor message class; 3. Annotate with Provides the "create" method that returns the (possibly just initial) Behavior of the actor; 4. Use thebindTypedActor
in PekkoGuiceSupport, passing theobject
as the actor module.For example:
object ConfiguredActor extends ActorModule { type Message = GetConfig final case class GetConfig(replyTo: ActorRef[String]) @Provides def apply(configuration: Configuration): Behavior[GetConfig] = { // TODO: Define ConfiguredActor's behavior using the injected configuration. Behaviors.empty } } final class AppModule extends AbstractModule with PekkoGuiceSupport { override def configure() = { bindTypedActor(classOf[ConfiguredActor], "configured-actor") } }
Message
is a type member rather than a type parameter is because you can't define, using the example above,GetConfig
inside the object and also have the object extendActorModule[ConfiguredActor.GetConfig]
.- Annotations
- @ApiMayChange()
- See also
https://pekko.apache.org/docs/pekko/1.0/typed/style-guide.html#functional-versus-object-oriented-style
- class ActorRefProvider[T <: Actor] extends Provider[ActorRef]
Provider for creating actor refs
- class ActorSystemProvider extends Provider[ActorSystem]
Provider for the actor system
Provider for the actor system
- Annotations
- @Singleton()
- class ClassicActorSystemProviderProvider extends Provider[ClassicActorSystemProvider]
Provider for a classic actor system provide
Provider for a classic actor system provide
- Annotations
- @Singleton()
- class CoordinatedShutdownProvider extends Provider[CoordinatedShutdown]
Provider for the coordinated shutdown
Provider for the coordinated shutdown
- Annotations
- @Singleton()
- abstract class CustomExecutionContext extends ExecutionContextExecutor
This class defines a custom execution context that delegates to an pekko.actor.ActorSystem.
This class defines a custom execution context that delegates to an pekko.actor.ActorSystem.
It is very useful for situations in which the default execution context should not be used, for example if a database or blocking I/O is being used.
To define a custom context, subclass CustomExecutionContext with the dispatcher name:
@Singleton class DatabaseExecutionContext @Inject()(system: ActorSystem) extends CustomExecutionContext(system, "database-dispatcher")
and then bind it in dependency injection:
bind[DatabaseExecutionContext].to(classOf[DatabaseExecutionContext]).asEagerSingleton()
Then have the execution context passed in as an implicit parameter:
class DatabaseService @Inject()(implicit executionContext: DatabaseExecutionContext) { ... }
- See also
- class DefaultFutures extends Futures
ActorSystem based timeout.
- class ExecutionContextProvider extends Provider[ExecutionContextExecutor]
Provider for the default execution context
Provider for the default execution context
- Annotations
- @Singleton()
- trait Futures extends AnyRef
This trait is used to provide non-blocking timeouts and delays on an operation that returns a Future.
This trait is used to provide non-blocking timeouts and delays on an operation that returns a Future.
You can dependency inject the Futures as follows to create a Future that will timeout after a certain period of time:
class MyService @Inject()(futures: Futures, piCalculator: PiCalculator) extends Timeout { def calculateWithTimeout(timeoutDuration: FiniteDuration): Future[Int] = { futures.timeout(timeoutDuration)(piCalculator.rawCalculation()) } }
And you can also use a delay to return data after a given period of time.
class PiCalculator @Inject()(futures: Futures) { def rawCalculation(): Future[Int] = { futures.delay(300 millis) { Future.successful(42) } } }
You should check for timeout by using
scala.concurrent.Future.recover
orscala.concurrent.Future.recoverWith
and checking for scala.concurrent.TimeoutException:val future = myService.calculateWithTimeout(100 millis).recover { case _: TimeoutException => -1 }
- See also
- trait InjectedActorSupport extends AnyRef
Support for creating injected child actors.
- trait LowPriorityFuturesImplicits extends AnyRef
Low priority implicits to add
withTimeout
methods to scala.concurrent.Future.Low priority implicits to add
withTimeout
methods to scala.concurrent.Future.You can dependency inject the ActorSystem as follows to create a Future that will timeout after a certain period of time:
class MyService @Inject()(piCalculator: PiCalculator)(implicit futures: Futures) { def calculateWithTimeout(timeoutDuration: FiniteDuration): Future[Int] = { piCalculator.rawCalculation().withTimeout(timeoutDuration) } }
You should check for timeout by using
scala.concurrent.Future.recover
orscala.concurrent.Future.recoverWith
and checking for scala.concurrent.TimeoutException:val future = myService.calculateWithTimeout(100 millis).recover { case _: TimeoutException => -1 }
- class MaterializerProvider extends Provider[Materializer]
Provider for the default flow materializer
Provider for the default flow materializer
- Annotations
- @Singleton()
- trait PekkoComponents extends AnyRef
Components for configuring Pekko.
- trait PekkoGuiceSupport extends AnyRef
Support for binding actors with Guice.
Support for binding actors with Guice.
Mix this trait in with a Guice AbstractModule to get convenient support for binding actors. For example:
class MyModule extends AbstractModule with PekkoGuiceSupport { def configure = { bindActor[MyActor]("myActor") bindTypedActor(HelloActor(), "hello-actor") } }
Then to use the above actor in your application, add a qualified injected dependency, like so:
class MyController @Inject() ( @Named("myActor") myActor: ActorRef, helloActor: ActorRef[HelloActor.SayHello], val controllerComponents: ControllerComponents, ) extends BaseController { ... }
- class PekkoSchedulerProvider extends Provider[Scheduler]
Provider for an Pekko Typed Scheduler.
Provider for an Pekko Typed Scheduler.
- Annotations
- @Singleton()
- trait PekkoTypedComponents extends AnyRef
Pekko Typed components.
- final class TypedActorRefProvider[T] extends Provider[ActorRef[T]]
A singleton Provider of the typed
ActorRef[T]
resulting from spawning an actor with theBehavior[T]
in dependency scope and the given name, in the ActorSystem in dependency scope.A singleton Provider of the typed
ActorRef[T]
resulting from spawning an actor with theBehavior[T]
in dependency scope and the given name, in the ActorSystem in dependency scope.- T
The class of the messages the typed actor can handle.
- Annotations
- @Singleton() @ApiMayChange()
Value Members
- object ActorModule
The companion object to hold ActorModule's ActorModule.Aux type alias.
The companion object to hold ActorModule's ActorModule.Aux type alias.
- Annotations
- @ApiMayChange()
- object ActorSystemProvider
- object Futures extends LowPriorityFuturesImplicits
- object Pekko
Helper to access the application defined Pekko Actor system.