Неявная передача контекста запроса в системе акторов

На мой взгляд, самый простой способ - сделать ваш val неявным в классе case.

case class MessageA(req: RequestA)(implicit val ctx: RequestContext)

case class MessageB(req: RequestB)(implicit val ctx: RequestContext)

def businessLogic(req:RequestA):RequestB


def handle(ma: MessageA): Unit = {
  // import all the members of ma so that there is a legal implicit RequestContext in scope
  import ma._
  val intermediateResult = businessLogic(req)
  actorB ! MessageB(intermediateResult)
}

В вашем примере ваша обработка рассматриваемого сообщения уже учтена в методе, что делает это прямолинейным:

trait RequestContext

case class MessageA(req: RequestA, ctx: RequestContext)
object MessageA {
  def apply(req: RequestA)(implicit ctx: RequestContext) = MessageA(req, ctx)
}

case class MessageB(req: RequestB, ctx: RequestContext)
object MessageB {
  def apply(req: RequestB)(implicit ctx: RequestContext) = MessageB(req, ctx)
}

class Example extends Actor {

  def receive = {
    case MessageA(req, ctx) => handle(req)(ctx)
  }

  def handle(req: RequestA)(implicit ctx: RequestContext): Unit = {
    val intermediateResult = businessLogic(req) // could take implicit ctx as well
    actorB ! MessageB(intermediateResult)
  }
}

Но, как вы можете видеть, при объявлении типов сообщений все еще возникают некоторые накладные расходы, и сигнатуру метода handle также необходимо изменить. Стоит ли эта схема того, зависит от соотношения между потребителями и производителями этих неявных значений (т. е. если несколько вещей в handle используют контекст, это имеет больше смысла).

Вариантом вышеизложенного может быть:

case class MessageA(req: RequestA, ctx: RequestContext)
object MessageA {
  def apply(req: RequestA)(implicit ctx: RequestContext) = MessageA(req, ctx)
  implicit def toContext(implicit msg: MessageA) = msg.ctx
}

case class MessageB(req: RequestB, ctx: RequestContext)
object MessageB {
  def apply(req: RequestB)(implicit ctx: RequestContext) = MessageB(req, ctx)
  implicit def toContext(implicit msg: MessageB) = msg.ctx
}

...
def handle(implicit ma: MessageA): Unit = {
  val intermediateResult = businessLogic(req)
  actorB ! MessageB(intermediateResult)
}

Создайте универсальный класс конверта, содержащий как исходное сообщение, так и контекст. Создайте трейт, расширяющий Actor (вы должны поместить его в пакет akka._). Переопределить метод aroundReceive(), который распаковывает ваш конверт, инициализирует защищенную переменную актера для хранения текущего контекста, вызывает исходный метод получения с распакованным сообщением, деинициализирует переменную контекста. Довольно сомнительный подход, но именно так ведет себя Actor.sender().

Чтобы отправить сообщение такому контекстно-зависимому действующему лицу, вы должны вручную завернуть свое сообщение в упомянутый выше конверт, или вы также можете автоматизировать эту задачу, введя расширение над ActorRef, которое реализует операции Tell/Ask, поднимая сообщение до контекстно-зависимый.

Это не просто концепция, а краткое изложение подхода, который я недавно успешно опробовал. Более того, я еще больше обобщил его, введя еще одно абстрактное понятие — среды неявного контекста, такие как на основе акторов, на основе ThreadLocal, на основе Future и т. д., что позволило мне легко передавать данные контекста по всей цепочке синхронных/асинхронных операций неявным образом.