package concurrent
- Alphabetic
- Public
- All
Type Members
-
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()
-
trait
AkkaComponents extends AnyRef
Components for configuring Akka.
-
trait
AkkaGuiceSupport 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 AkkaGuiceSupport { def configure = { bindActor[MyActor]("myActor") } }
Then to use the above actor in your application, add a qualified injected dependency, like so:
class MyController @Inject() (@Named("myActor") myActor: ActorRef, val controllerComponents: ControllerComponents) extends BaseController { ... }
-
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 akka.actor.ActorSystem.
This class defines a custom execution context that delegates to an akka.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()
Value Members
- object ActorSystemProvider
-
object
Akka
Helper to access the application defined Akka Actor system.
- object Futures extends LowPriorityFuturesImplicits