Scalaz（16）－ Monad：依赖注入－Dependency Injection By Reader Monad

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了Scalaz（16）－ Monad：依赖注入－Dependency Injection By Reader Monad，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

在上一篇讨论里我们简单的介绍了一下Cake Pattern和Reader Monad是如何实现依赖注入的。主要还是从方法上示范了如何用Cake Pattern和Reader在编程过程中解析依赖和注入依赖。考虑到依赖注入模式在编程中的重要性和普遍性，觉着还需要再讨论的深入一些，使依赖注入模式在FP领域里能从理论走向实际。既然我们正在scalaz的介绍系列里，所以这篇我们就着重示范Reader Monad的依赖注入方法。

再说明一下依赖注入：我们说过在团队协作开发里能够实现软件模块的各自独立开发，原理首先是实现软件模块之间的松散耦合（decoupling）。对依赖注入的学术定义如下：Dependency Inversion Principle

1、上层模块不应该依赖下层模块，反之亦然。它们之间不应该有直接的代码引用。它们应该都依赖一个抽象的中间层，也就是共享接口（interface）。

2、抽象层不应该依赖实现细节，而细节实现则必须依赖抽象层。大家都按照共享的抽象层进行实现细节编程。

这两条足够解释何为软件模块松散耦合以及具体编码的要求了。这样来说不仅在团队协同开发，即使在个人独立开发环境下依赖注入模式也能发挥良好的作用。一是可以按需要把软件切分成功能模块独立编程。通过依赖注入模式，当下层模块进行了调整后是不会影响上层模块的；上层模块可以随时连接不同的下层功能模块实现不同的功能，比如连接一些测试环境实现上层模块的独立测试。

下面我们还是取用上期的示范例子，由简入深，逐步说明Reader依赖注入的原理、组合、结构设计：

还说那个咖啡机例子：包括了一个开关设备、咖啡感应器；如果感应到壶里有咖啡的话，按下开关咖啡机可以开启加热。

下面是功能抽象描述，它们是按照开发条件和环境需要进行具体细分的。细分程度要确保每项功能都可以独立完成编程。

  trait OnOffDevice {
    def on: Unit
    def off: Unit
  }
  trait SensorDevice {
    def isCoffeePresent: Boolean
  }

这就是一个抽象层。所有开发人员都必须按照这层的功能描述来编程，所谓编程细节依赖与抽象层要求。

我们现在就可以不用理会以上功能是否已经实现，立即进入上层模块的功能组合了。我们只需要申明依赖项目，先从最简单的开始，假如我现在只需要引用OnOffDevice一项依赖的话，可以在伴生对象（companion object）这样申明操作Reader（primitive reader）：

object OnOffDevice {
  def on: Reader[OnOffDevice,String] = Reader(_.on)
  def off:  Reader[OnOffDevice,String] = Reader(_.off)
}

由于只有一个依赖，我们可以直接申明功能Reader,把on,off两个函数变成Primitive Reader。假如我们需要函数运算结果的话，只要注入OnOffDevice实例。由于Reader是个Monad，我们可以用map这样写：

object OnOffDevice {
  def onOffDevice: Reader[OnOffDevice,OnOffDevice] = Reader(identity)
  def on: Reader[OnOffDevice,String] = onOffDevice map { _.on }
  def off: Reader[OnOffDevice,String] = onOffDevice map { _.off }
}


我们用identity构建了一个基础（primitive）Reader，然后以这个基础Reader用map组合成我们需要的功能函数Reader。现在的on,off函数款式（signature）和前面的定义是一样的。现在我们可以实现这些Reader功能：

object OnOffService {
	def on = for {
		ison <- OnOffDevice.on
	} yield ison
	def off = for {
		isoff <- OnOffDevice.off
	} yield isoff
}


我们抽象化了OnOffDevice，不需要实现依赖项目就可以直接使用这些Reader功能函数：

def trigger = OnOffService.on      //> trigger: => scalaz.Kleisli[scalaz.Id.Id,OnOffDevice,String］


假如现在实现了OnOffDevice实例： 

class OnOffDeviceImpl extends OnOffDevice {
	def on = "MockDevice.On"
	def off = "MockDevice.Off"
}


我们可以在最终运行中注入实现的依赖实例来获取最终结果： 
object MockOnOffDevice extends OnOffDeviceImpl
def trigger = OnOffService.on                     //> trigger: => scalaz.Kleisli[scalaz.Id.Id,Exercises.reader1.OnOffDevice,String
                                                  //| ]
val result = trigger(MockOnOffDevice)             //> result  : scalaz.Id.Id[String] = SomeDevice.On
result === "SomeDevice.On"                        //> res0: Boolean = true

我们看到，对运算结果注入依赖实例后就能得出具体的运算值。

那如果我们需要两项依赖呢？

trait OnOffDevice {
	def on: String
	def off: String
}
trait SensorDevice {
	def isCoffeePresent: Boolean
}



我们可以把两个依赖组成一个更大的功能，一个更高一层的依赖： 

trait Device { //高层组合依赖
  def onOffDevice: OnOffDevice     //具体依赖
  def sensorDevice: SensorDevice   //具体依赖
}
object Device {
  val device = Reader[Device,Device](identity)
  val onOffDevice = device map {_.onOffDevice}
  val sensorDevice = device map {_.sensorDevice}
}


所有Reader的注入依赖现在变成Device类型了。依赖的功能Reader变成这样：

object OnOffDevice {
import Device.onOffDevice
	def on: Reader[Device,String] = onOffDevice map { _.on }
	def off: Reader[Device,String] = onOffDevice map { _.off }
}
object SensorDevice {
import Device.sensorDevice
  def isCoffeePresent: Reader[Device,Boolean] = sensorDevice map { _.isCoffeePresent }
}


从Device引入依赖onOffDevice,sensorDevice后所有函数Reader都要求注入Device类型实例。下面我们可以分开实现依赖的功能函数Reader: 

object OnOffService {
	def on = for {
		ison <- OnOffDevice.on
	} yield ison
	def off = for {
		isoff <- OnOffDevice.off
	} yield isoff
}
object SensorService {
	def isCoffeePresent = for {
		hasCoffee <- SensorDevice.isCoffeePresent
	} yield hasCoffee
}


我们看到原来的Reader实现细节编码是不需要改变的，如OnOffService。
假设我们获得了下面的功能实现程序： 

class OnOffDeviceImpl extends OnOffDevice {
	def on = "SomeDevice.On"
	def off = "SomeDevice.Off"
}
class SensorDeviceImpl extends SensorDevice {
	def isCoffeePresent = true
}

由于这次的依赖注入是Device类型的，所以我们需要获取Device实例用来注入到结果Reader：

object MockOnOffDevice extends OnOffDeviceImpl
object MockSensorDevice extends SensorDeviceImpl
trait DeviceImpl extends Device {
	def onOffDevice = new OnOffDevice {
		def on = MockOnOffDevice.on
		def off = MockOnOffDevice.off
	}
	def sensorDevice = new SensorDevice {
		def isCoffeePresent = MockSensorDevice.isCoffeePresent
	}
}

现在这个DeviceImpl是一个Device实例，我们可以把它注入到Reader得出运算结果，还是先运行上面的例子：

object MockDevice extends Device with DeviceImpl
def trigger = OnOffService.on                     //> trigger: => scalaz.Kleisli[scalaz.Id.Id,Exercises.reader2.Device,String]
val result = trigger(MockDevice)                  //> result  : scalaz.Id.Id[String] = SomeDevice.On

这次是用Device实例注入得出结果的。

我们还可以把依赖项目独立分别定义，这样可以更灵活的组合Device：

trait OnOffComponent {
	def onOffDevice: OnOffDevice
}
trait SensorComponent {
	def sensorDevice: SensorDevice
}
trait Device extends OnOffComponent with SensorComponent

这样我们可以把两个依赖分开来格式化后组合成Device实例，因为我们的注入依赖现在是Device类型的了：

object MockOnOffDevice extends OnOffDeviceImpl
object MockSensorDevice extends SensorDeviceImpl
trait OnOffFunctions extends OnOffComponent {
	def onOffDevice = MockOnOffDevice
}
trait SensorFunctions extends SensorComponent {
  def sensorDevice = MockSensorDevice
}


完成了Device实例的组合后可以通过注入Device实例来得取运算结果：

object MockDevice extends Device with OnOffFunctions with SensorFunctions
def trigger =
  if (SensorService.isCoffeePresent(MockDevice))
     OnOffService.on(MockDevice)
  else
     OnOffService.off(MockDevice)                 //> trigger: => scalaz.Id.Id[String]
trigger                                           //> res0: scalaz.Id.Id[String] = SomeDevice.On

如果换另一个版本的SensorDevice实现：

class SensorDeviceImpl extends SensorDevice {
	def isCoffeePresent = false
}

重新运行： 

object MockDevice extends Device with OnOffFunctions with SensorFunctions
def trigger =
  if (SensorService.isCoffeePresent(MockDevice))
     OnOffService.on(MockDevice)
  else
     OnOffService.off(MockDevice)                 //> trigger: => scalaz.Id.Id[String]
trigger                                           //> res0: scalaz.Id.Id[String] = SomeDevice.Off

正确反应了新的运算结果。

从以上的示范中我们看到了依赖的层次结构以及Reader搭配。我们可以用多层结构来精简基础Reader。但多层式的依赖结构统一了注入依赖类型，最后注入时就无法拆分依赖类型，又会弱化依赖的组合灵活性。所以在组织依赖时应该注意确定在自己的程序中将会使用到所有依赖。这样调用统一的一种注入类型就足够了。

下面再增添多一个依赖：增加一个电源制式检测功能，只有US制式的电源才能启动咖啡机。现在全部功能的抽象描述如下：

trait OnOffDevice {
	def on: String
	def off: String
}
trait SensorDevice {
	def isCoffeePresent: Boolean
}
trait PowerConfig {
  def getPowerVolts(country: String): Int
  def isUSStandard(volt: Int): Boolean
}


我们再试试增加多一层结构：

trait Device extends OnOffComponent with SensorComponent
trait DeviceComponent {
	def onOffDevice: OnOffDevice
	def sensorDevice: SensorDevice
}
trait PowerComponent {
	def powerConfig: PowerConfig
}
trait Appliance extends DeviceComponent with PowerComponent
object Appliance {
  val appliance = Reader[Appliance,Appliance](identity)
  val onOffDevice = appliance map {_.onOffDevice}
  val sensorDevice = appliance map {_.sensorDevice}
  val powerConfig = appliance map {_.powerConfig}
}

Appliance是更高层依赖。

下面还是保留了原来的Reader实现编码不变，除了import：

object OnOffDevice {
import Appliance.onOffDevice
	def on: Reader[Appliance,String] = onOffDevice map { _.on }
	def off: Reader[Appliance,String] = onOffDevice map { _.off }
}
object SensorDevice {
import Appliance.sensorDevice
  def isCoffeePresent: Reader[Appliance,Boolean] = sensorDevice map { _.isCoffeePresent }
}
object PowerConfig {
import Appliance.powerConfig
	def getPowerVolts(country: String) = powerConfig map {_.getPowerVolts(country)}
	def isUSStandard(volts: Int) = powerConfig map {_.isUSStandard(volts)}
}


现在注入依赖的类型变成了Appliance。原来Reader功能实现代码还是不用改变：

object OnOffService {
	def on = for {
		ison <- OnOffDevice.on
	} yield ison
	def off = for {
		isoff <- OnOffDevice.off
	} yield isoff
}
object SensorService {
	def isCoffeePresent = for {
		hasCoffee <- SensorDevice.isCoffeePresent
	} yield hasCoffee
}
object PowerService {
	def isUSStandard(country: String) = for {
		is110v <- PowerConfig.getPowerVolts(country)
		isUSS <- PowerConfig.isUSStandard(is110v)
	} yield isUSS
}


假如增加了新功能实现程序：

class OnOffDeviceImpl extends OnOffDevice {
	def on = "SomeDevice.On"
	def off = "SomeDevice.Off"
}
class SensorDeviceImpl extends SensorDevice {
	def isCoffeePresent = true
}
class PowerConfigImpl extends PowerConfig {
	def getPowerVolts(country: String) = country match {
		case "USA" => 110
		case "UK" => 220
		case "HK" => 220
		case "CHN" => 110
		case _  => 0
	}
	def isUSStandard(volts: Int) = volts === 110
}


同样，需要把这些实例转成Appliance类型：

object MockOnOffDevice extends OnOffDeviceImpl
object MockSensorDevice extends SensorDeviceImpl
object MockPowerConfig extends PowerConfigImpl
trait OnOffFunctions extends OnOffComponent {
	def onOffDevice = MockOnOffDevice
}
trait SensorFunctions extends SensorComponent {
  def sensorDevice = MockSensorDevice
}
trait DeviceFunctions extends DeviceComponent  {
	def onOffDevice = MockOnOffDevice
  def sensorDevice = MockSensorDevice
}
trait PowerFunctions extends PowerComponent {
	def powerConfig = MockPowerConfig
}

再直接进行Appliance实例组合：

object MockAppliance extends Appliance with DeviceFunctions with PowerFunctions

运行后注入Appliance实例得出结果：

def trigger =
  if ((PowerService.isUSStandard("CHN")(MockAppliance))
      && (SensorService.isCoffeePresent(MockAppliance)))
       OnOffService.on(MockAppliance)
   else
     OnOffService.off(MockAppliance)              //> trigger: => scalaz.Id.Id[String]
trigger                                           //> res0: scalaz.Id.Id[String] = SomeDevice.On

下面是这段程序的源代码，提供给大家作为参考：

package Exercises
import scalaz._
import Scalaz._
object reader3 {
trait OnOffDevice {
	def on: String
	def off: String
}
trait SensorDevice {
	def isCoffeePresent: Boolean
}
trait PowerConfig {
  def getPowerVolts(country: String): Int
  def isUSStandard(volt: Int): Boolean
}

trait OnOffComponent {
	def onOffDevice: OnOffDevice
}
trait SensorComponent {
	def sensorDevice: SensorDevice
}
trait Device extends OnOffComponent with SensorComponent
trait DeviceComponent {
	def onOffDevice: OnOffDevice
	def sensorDevice: SensorDevice
}
trait PowerComponent {
	def powerConfig: PowerConfig
}
trait Appliance extends DeviceComponent with PowerComponent
object Appliance {
  val appliance = Reader[Appliance,Appliance](identity)
  val onOffDevice = appliance map {_.onOffDevice}
  val sensorDevice = appliance map {_.sensorDevice}
  val powerConfig = appliance map {_.powerConfig}
}
object OnOffDevice {
import Appliance.onOffDevice
	def on: Reader[Appliance,Boolean] = sensorDevice map { _.isCoffeePresent }
}
object PowerConfig {
import Appliance.powerConfig
	def getPowerVolts(country: String) = powerConfig map {_.getPowerVolts(country)}
	def isUSStandard(volts: Int) = powerConfig map {_.isUSStandard(volts)}
}
object OnOffService {
	def on = for {
		ison <- OnOffDevice.on
	} yield ison
	def off = for {
		isoff <- OnOffDevice.off
	} yield isoff
}
object SensorService {
	def isCoffeePresent = for {
		hasCoffee <- SensorDevice.isCoffeePresent
	} yield hasCoffee
}
object PowerService {
	def isUSStandard(country: String) = for {
		is110v <- PowerConfig.getPowerVolts(country)
		isUSS <- PowerConfig.isUSStandard(is110v)
	} yield isUSS
}
class OnOffDeviceImpl extends OnOffDevice {
	def on = "SomeDevice.On"
	def off = "SomeDevice.Off"
}
class SensorDeviceImpl extends SensorDevice {
	def isCoffeePresent = true
}
class PowerConfigImpl extends PowerConfig {
	def getPowerVolts(country: String) = country match {
		case "USA" => 110
		case "UK" => 220
		case "HK" => 220
		case "CHN" => 110
		case _  => 0
	}
	def isUSStandard(volts: Int) = volts === 110
}
object MockOnOffDevice extends OnOffDeviceImpl
object MockSensorDevice extends SensorDeviceImpl
object MockPowerConfig extends PowerConfigImpl
trait OnOffFunctions extends OnOffComponent {
	def onOffDevice = MockOnOffDevice
}
trait SensorFunctions extends SensorComponent {
  def sensorDevice = MockSensorDevice
}
trait DeviceFunctions extends DeviceComponent  {
	def onOffDevice = MockOnOffDevice
  def sensorDevice = MockSensorDevice
}
trait PowerFunctions extends PowerComponent {
	def powerConfig = MockPowerConfig
}
object MockAppliance extends Appliance with DeviceFunctions with PowerFunctions
def trigger =
  if ((PowerService.isUSStandard("CHN")(MockAppliance))
      && (SensorService.isCoffeePresent(MockAppliance)))
       OnOffService.on(MockAppliance)
   else
     OnOffService.off(MockAppliance)              //> trigger: => scalaz.Id.Id[String]
trigger                                           //> res0: scalaz.Id.Id[String] = SomeDevice.On
}

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript