Web应用函数式架构的可选实现方案探讨

1. 纯函数拆分+依赖注入的分层架构 #

将每个组件的核心业务逻辑拆分为独立的纯函数，把IO操作、外部依赖等非纯逻辑作为参数注入到组件中，既保留分层职责，又保证核心逻辑可无mock测试。

示例（伪代码）：

// 纯函数模块，无任何依赖，仅处理数据转换
object ControllerLogic {
  def someWorkBefore(req): req1 = ???
  def someWorkAfter(res1): res = ???
}

object ServiceALogic {
  def someWorkBefore(req1): req2 = ???
  def someWorkAfter(res2): res1 = ???
}

object ServiceBLogic {
  def someWorkBefore(req2): req3 = ???
  def someWorkAfter(res3): res2 = ???
}

// 外层组件负责组合逻辑+注入依赖
class Controller(serviceACall: req1 => res1) {
  def call(req): res = {
    val req1 = ControllerLogic.someWorkBefore(req)
    val res1 = serviceACall(req1)
    ControllerLogic.someWorkAfter(res1)
  }
}

class ServiceA(serviceBCall: req2 => res2) {
  def call(req1): res1 = {
    val req2 = ServiceALogic.someWorkBefore(req1)
    val res2 = serviceBCall(req2)
    ServiceALogic.someWorkAfter(res2)
  }
}

class ServiceB(dbCall: req3 => res3) {
  def call(req2): res2 = {
    val req3 = ServiceBLogic.someWorkBefore(req2)
    val res3 = dbCall(req3)
    ServiceBLogic.someWorkAfter(res3)
  }
}

• 优势：纯函数可单独测试，无需mock；分层结构保留，职责清晰；依赖通过函数参数注入，测试时可直接传入测试用纯函数。

2. ADT+管道式流程组合 #

用**代数数据类型(ADT)**定义流程中各阶段的请求/响应模型，将整个业务流程拆分为一系列独立纯函数，通过函数组合形成线性管道，IO操作作为可替换的末端步骤。

示例（伪代码）：

// 定义流程各阶段的数据类型
case class RawRequest(...)
case class ControllerProcessedReq(...)
case class ServiceAProcessedReq(...)
case class ServiceBProcessedReq(...)
case class DBResp(...)
case class ServiceBProcessedResp(...)
case class ServiceAProcessedResp(...)
case class FinalResp(...)

// 独立纯函数步骤
val controllerPreProcess: RawRequest => ControllerProcessedReq = ???
val serviceAPreProcess: ControllerProcessedReq => ServiceAProcessedReq = ???
val serviceBPreProcess: ServiceAProcessedReq => ServiceBProcessedReq = ???
val dbAccess: ServiceBProcessedReq => DBResp = ??? // 实际场景可用IO包裹，注入不同实现
val serviceBPostProcess: DBResp => ServiceBProcessedResp = ???
val serviceAPostProcess: ServiceBProcessedResp => ServiceAProcessedResp = ???
val controllerPostProcess: ServiceAProcessedResp => FinalResp = ???

// 组合成完整流程管道
val requestPipeline: RawRequest => FinalResp = 
  controllerPreProcess
  .andThen(serviceAPreProcess)
  .andThen(serviceBPreProcess)
  .andThen(dbAccess)
  .andThen(serviceBPostProcess)
  .andThen(serviceAPostProcess)
  .andThen(controllerPostProcess)

// 外层Controller仅负责触发管道
class Controller(pipeline: RawRequest => FinalResp) {
  def call(req: RawRequest): FinalResp = pipeline(req)
}

• 优势：每个步骤独立可测，流程可视化强；修改流程只需调整管道组合，扩展性好；数据流转清晰，职责边界明确。

3. Reader Monad实现依赖上下文传递 #

利用Reader Monad将依赖封装在上下文中，核心业务逻辑专注于数据处理，依赖通过上下文隐式传递，既保持纯函数特性，又优雅处理依赖注入。

示例（伪代码）：

// 定义全局依赖环境
case class Env(
  serviceB: ServiceB,
  db: DBAccessor
)

// ServiceA的逻辑用Reader包裹，依赖从Env中获取
class ServiceA {
  def call(req1): Reader[Env, res1] = for {
    req2 <- Reader(_ => ServiceALogic.someWorkBefore(req1))
    res2 <- Reader(_.serviceB.call(req2))
    res1 <- Reader(_ => ServiceALogic.someWorkAfter(res2))
  } yield res1
}

// Controller同理
class Controller {
  def call(req): Reader[Env, res] = for {
    req1 <- Reader(_ => ControllerLogic.someWorkBefore(req))
    res1 <- Reader(env => new ServiceA().call(req1).run(env))
    res <- Reader(_ => ControllerLogic.someWorkAfter(res1))
  } yield res
}

• 优势：所有业务逻辑都是纯函数，依赖被隔离在上下文；测试时只需传入模拟环境，无需mock；保留分层结构，符合函数式依赖注入风格。

内容的提问来源于stack exchange，提问作者Егор Лебедев