Great question! Let’s walk through how to handle this correctly—you don’t need to manually create an ActorSystem or ExecutionContext inside your Actor, because Akka provides these for you out of the box, and using the built-in references is safer and more aligned with Akka’s design.

1. Use the Actor’s Built-in Context References #

Every Akka Actor has access to two critical references via its context object:

• context.system: The ActorSystem that the Actor belongs to. This is the same system you used to spawn the Actor in the first place—no need to create a new one (doing so would waste resources and cause inconsistencies).
• context.dispatcher: The ExecutionContext tied to the Actor’s thread pool. This is preferred over global execution contexts because it aligns with the Actor’s scheduling model, reducing thread-switching overhead.

2. Inject These References into Your Service #

The cleanest approach is to pass these built-in references to your service via its constructor. Here’s a concrete example:

First, Define Your Service

Let’s say your data-fetching service looks like this (using Akka HTTP’s singleRequest):

import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model.HttpRequest
import akka.http.scaladsl.unmarshalling.Unmarshal
import scala.concurrent.ExecutionContext
import scala.concurrent.Future

// Sample data type
case class Data(id: Int, content: String)

class DataFetchService(system: ActorSystem, ec: ExecutionContext) {
  def fetchLocalData(): Future[Data] = {
    // Use the provided ActorSystem to create an HTTP client
    Http(system).singleRequest(HttpRequest(uri = "http://local-network-service/data"))
      // Unmarshal the response using the provided ExecutionContext
      .flatMap(response => Unmarshal(response.entity).to[Data])(ec)
  }
}

Then, Use the Service in Your Actor

In your Actor, initialize the service using context.system and context.dispatcher, then call its methods safely:

import akka.actor.{Actor, ActorLogging, ActorRef}
import scala.util.{Success, Failure}

// Protocol messages
case object FetchData
case class DataFetched(data: Data)
case class FetchFailed(errorMsg: String)

class MyDataActor extends Actor with ActorLogging {
  // Initialize the service with the Actor's built-in context references
  private val dataService = new DataFetchService(context.system, context.dispatcher)

  override def receive: Receive = {
    case FetchData =>
      val requester: ActorRef = sender()
      // Call the service's method
      dataService.fetchLocalData().onComplete {
        case Success(data) => requester ! DataFetched(data)
        case Failure(ex) =>
          log.error(ex, "Failed to retrieve local data")
          requester ! FetchFailed(ex.getMessage)
      }(context.dispatcher) // Explicitly use the Actor's dispatcher for the callback
  }
}

3. Better Alternative: Use pipeTo for Future Results #

Instead of using onComplete to handle the Future’s result directly, Akka recommends using the pipeTo pattern. This sends the Future’s result (success or failure) as a message to another Actor (like the sender), which is more idiomatic and avoids potential thread-safety issues:

import akka.pattern.pipe

// Inside your Actor's receive method:
case FetchData =>
  dataService.fetchLocalData()
    .pipeTo(sender())(context.dispatcher)

With this approach, the sender will receive either the Data instance (on success) or a Failure object (on failure)—you can adjust your Actor’s receive logic to handle these cases accordingly.

Key Best Practices #

• Never manually create an ActorSystem inside an Actor: Each Actor is part of an existing system; creating a new one leads to resource leaks and misaligned lifecycle management.
• Prefer context.dispatcher over global ExecutionContext.global: The Actor’s dispatcher is optimized for Akka’s message-driven model, ensuring better performance and consistency.
• Keep service dependencies explicit: Injecting ActorSystem and ExecutionContext via the service’s constructor makes your code testable and clear about its dependencies.

内容的提问来源于stack exchange，提问作者handris