Scalaz（15）－ Monad：依赖注入－Reader besides Cake

我们可以用Monad Reader来实现依赖注入（dependency injection DI or IOC）功能。Scala界中比较常用的不附加任何Framework的依赖注入方式可以说是Cake Pattern了。现在通过Monad Reader可以实现同样功能，两者对比优点各有千秋。所谓依赖注入是指在编程时使用了某个未知实现细节的对象，但依赖注入确保这个对象在这段程序运行时已经实例化。这种需求通常是在大型软件开发时对项目进行模块化分割后虽然模块之间互有依赖，但又可以同步开发。特别是在多人协作开发时，各人开发进度不受他人影响。这主要是通过各人分享事先规划好的软件抽象描述如interface,trait等加上依赖注入实现的。我们下面通过一个实际例子来示范Cake Pattern和Monad Reader是如何实现依赖注入的：

我们来模拟一个咖啡机开关场景：有一个电炉，可开（on）可关（off）。还有一个感应器能感应罐里是否还有咖啡。按下开关时当罐里有咖啡时才开启（on）电炉，开始工作。

下面是大家共享的trait：

 // 可开关电炉
 trait OnOffDeviceComponent {
   val onOff: OnOffDevice
   trait OnOffDevice {
     def on: Unit
     def off: Unit
   }
 }
 //咖啡感应设备
 trait SensorDeviceComponent {
   val sensor: SensorDevice
   trait SensorDevice {
     def isCoffeePresent: Boolean
   }
 }

在整体设计时把功能要求用trait表述并分享给所有开发人员。这里的设计目标有“可开关电炉”和“咖啡机感应设备”

假设由我负责这个咖啡机开关编程。不过我并不知道如何开启电炉，也不知道如何确定咖啡有否，因为这些功能可能还没开发出来呢。但这两项的功能都可以通过依赖注入提供给我。让我能使用它们：

 // 咖啡机开关实现，这里是不需要电炉和咖啡感应功能实现
 trait WarmerComponentImpl {
   this: SensorDeviceComponent with OnOffDeviceComponent =>
   //注入了SensorDeviceComponent和OnOffDeviceComponent
   //解析了 sensor.isCoffeePresent, onOff.on, onOff.off
   class Warmer {
     def trigger = {
       if (sensor.isCoffeePresent) onOff.on
       else onOff.off
     }
   }
 }

假设后来团队其它人完成了对那两项依赖的开发并提供了bytecode子库：

 // 电炉开关实现
 trait OnOffDeviceComponentImpl extends OnOffDeviceComponent {
   class Heater extends OnOffDevice {
     def on = println("heater.on")
     def off = println("heater.off")
   }
 }
 // 感应器状态实现
 trait SensorDeviceComponentImpl extends SensorDeviceComponent {
   class PotSensor extends SensorDevice {
     def isCoffeePresent = true
   }
 }

最终我把所有子库统一引用集成后就可以从中选择需要的实例进行组合了：

 // 把所有实例集成组合起来
 object ComponentRegistry extends
   OnOffDeviceComponentImpl with
   SensorDeviceComponentImpl with
   WarmerComponentImpl {

   val onOff = new Heater
   val sensor = new PotSensor
   val warmer = new Warmer
 }
 //运行
 ComponentRegistry.warmer.trigger                  //> heater.on

输出结果heater.on是因为感应器的实现代码里def isCoffeePresent = true。不由我控制。这恰恰彰显了依赖注入的作用。

当然，如果其它人提供了另一个感应器状态实现：

 // 感应器状态实现
 trait SensorNoCoffee extends SensorDeviceComponent {
   class PotSensor extends SensorDevice {
     def isCoffeePresent = false
   }
 }

我用SensorNoCoffee来组合：

 // 把所有实例集成起来
 object ComponentRegistry extends
   OnOffDeviceComponentImpl with
   SensorNoCoffee with
   WarmerComponentImpl {

   val onOff = new Heater
   val sensor = new PotSensor
   val warmer = new Warmer
 }

 /运行
 ComponentRegistry.warmer.trigger                  //> heater.off

现在结果变成了heater.off。如果我们有许多版本的实现程序，我们可以通过灵活配置来实现不同的功能。

我看Cake Pattern特别适合大型软件开发团队协同开发。

那么用Monad Reader可以实现同样的依赖注入功能吗？

下面是功能需求trait：

 //事先统一设计的功能抽象描述，这个直接点，没有外套trait
   trait OnOffDevice {
     def on: Unit
     def off: Unit
   }
   trait SensorDevice {
     def isCoffeePresent: Boolean
   }

虽然现在只有抽象trait，但我现在就可以对Warmer的功能进行编程了：

 //用Reader注入依赖OnOffDevice,SensorDevice. 只是共享的trait
   trait WarmerFunctions {
       def on: Reader[OnOffDevice,Unit] = Reader(OnOffDevice => OnOffDevice.on)
       def off: Reader[OnOffDevice,Unit] = Reader(OnOffDevice => OnOffDevice.off)
       def isCoffeePresent: Reader[SensorDevice,Boolean] = Reader(SensorDevice => SensorDevice.isCoffeePresent)
   }
 //功能实现。这时还没用到OnOffDevice,SensorDevice实例
   object WarmerFuncImpl extends WarmerFunctions {
     def thereIsCoffee = for {
       hasCoffee <- isCoffeePresent
     } yield hasCoffee
     def warmerOn = for {
      ison <- on
     } yield ison
     def warmerOff = for {
         isoff <- off
     } yield isoff
   }

假设这时有人完成并提交了功能实现程序：

  trait Heater extends OnOffDevice {
     def on = println("heater.on")
     def off = println("heater.off")
   }
   trait PotSensor extends SensorDevice {
     def isCoffeePresent = false
   }

有了功能实现的bytecode后就可以把它们组合起来了：

   object allDevices extends Heater with PotSensor

现在可以实现集成后的trigger函数。这里需要使用具体的功能实现程序：

  def trigger = {
       if ( WarmerFuncImpl.thereIsCoffee(allDevices) )
         WarmerFuncImpl.warmerOn(allDevices)
       else
         WarmerFuncImpl.warmerOff(allDevices)
   }                                               //> trigger: => scalaz.Id.Id[Unit]
   //测试运行
   trigger                                         //> heater.off

现在trigger的结果是heater.off，这是由感应器具体实现来确定的。当然，如果还有另一个版本的实现程序：

   trait PotHasCoffee extends SensorDevice {
     def isCoffeePresent = true
   }

用PotHasCoffee来组合：

   object allDevices extends Heater with PotHasCoffee

再测试：

 //测试运行
   trigger                                         //> heater.on

现在输入变成heater.on了。

似乎Monad Reader的依赖注入方式简单直接些。但Cake Pattern应该更适合团队协同开发，所以我们可以选择在局部功能开发中使用Reader，然后在大型软件集成时用Cake Pattern。