为什么使用 scala 的蛋糕模式而不是抽象字段？

Question

我一直在阅读有关通过 蛋糕图案。我想我明白了，但我一定错过了一些东西，因为我仍然看不到其中的意义！为什么最好通过自身类型声明依赖项，而不仅仅是抽象字段？

鉴于 Programming Scala TwitterClientComponent 声明中的示例像这样使用蛋糕模式的依赖关系：

//other trait declarations elided for clarity
...

trait TwitterClientComponent {

  self: TwitterClientUIComponent with
        TwitterLocalCacheComponent with
        TwitterServiceComponent =>

  val client: TwitterClient

  class TwitterClient(val user: TwitterUserProfile) extends Tweeter {
    def tweet(msg: String) = {
      val twt = new Tweet(user, msg, new Date)
      if (service.sendTweet(twt)) {
        localCache.saveTweet(twt)
        ui.showTweet(twt)
      }
    }
  }
}

这比将依赖关系声明为抽象字段（如下所示）更好吗？

trait TwitterClient(val user: TwitterUserProfile) extends Tweeter {
  //abstract fields instead of cake pattern self types
  val service: TwitterService
  val localCache: TwitterLocalCache
  val ui: TwitterClientUI

  def tweet(msg: String) = {
    val twt = new Tweet(user, msg, new Date)
    if (service.sendTweet(twt)) {
      localCache.saveTweet(twt)
      ui.showTweet(twt)
    }
  }
}

看看实例化时间，即 DI 实际发生的时间（据我所知），我很难看到 cake 的优点，特别是当您考虑到需要为 cake 声明（封闭特征）进行额外的键盘输入时，

    //Please note, I have stripped out some implementation details from the 
    //referenced example to clarify the injection of implemented dependencies

    //Cake dependencies injected:
    trait TextClient
        extends TwitterClientComponent
        with TwitterClientUIComponent
        with TwitterLocalCacheComponent
        with TwitterServiceComponent {


      // Dependency from TwitterClientComponent:
      val client = new TwitterClient

      // Dependency from TwitterClientUIComponent:
      val ui = new TwitterClientUI

      // Dependency from TwitterLocalCacheComponent:
      val localCache = new TwitterLocalCache 

      // Dependency from TwitterServiceComponent
      val service = new TwitterService
    }

现在再一次与抽象字段，或多或少相同！：

trait TextClient {
          //first of all no need to mixin the components

          // Dependency on TwitterClient:
          val client = new TwitterClient

          // Dependency on TwitterClientUI:
          val ui = new TwitterClientUI

          // Dependency on TwitterLocalCache:
          val localCache = new TwitterLocalCache 

          // Dependency on TwitterService
          val service = new TwitterService
        }

我确信我一定错过了蛋糕的优越性！但是，目前我看不到它比以任何其他方式（构造函数、抽象字段）声明依赖项提供的功能。

Answer 1

具有自类型注释的特征比具有字段注入的老式 bean 更具可组合性，您可能在第二个片段中想到了这一点。

让我们看看如何实例化这个特征：

val productionTwitter = new TwitterClientComponent with TwitterUI with FSTwitterCache with TwitterConnection

如果你需要测试这个特征，你可能会写：

val testTwitter = new TwitterClientComponent with TwitterUI with FSTwitterCache with MockConnection

嗯，有点 DRY 违规。让我们改进吧。

trait TwitterSetup extends TwitterClientComponent with TwitterUI with FSTwitterCache
val productionTwitter = new TwitterSetup with TwitterConnection
val testTwitter = new TwitterSetup with MockConnection

此外，如果组件中的服务之间存在依赖关系（例如 UI 依赖于 TwitterService），编译器将自动解决它们。

Answer 2

想想如果 TwitterService 使用 TwitterLocalCache 会发生什么。如果 TwitterService 自键入到 TwitterLocalCache 会容易得多，因为 TwitterService 无法访问 val localCache你已经声明了。 Cake 模式（和自键入）允许我们以更加通用和灵活的方式进行注入（当然还有其他方式）。

Answer 3

我不确定实际的接线如何工作，因此我使用您建议的抽象属性修改了您链接到的博客条目中的简单示例。

// =======================  
// service interfaces  
trait OnOffDevice {  
  def on: Unit  
  def off: Unit  
}  
trait SensorDevice {  
  def isCoffeePresent: Boolean  
}  

// =======================  
// service implementations  
class Heater extends OnOffDevice {  
  def on = println("heater.on")  
  def off = println("heater.off")  
}  
class PotSensor extends SensorDevice {  
  def isCoffeePresent = true  
}  

// =======================  
// service declaring two dependencies that it wants injected  
// via abstract fields
abstract class Warmer() {
  val sensor: SensorDevice   
  val onOff: OnOffDevice  

  def trigger = {  
    if (sensor.isCoffeePresent) onOff.on  
    else onOff.off  
  }  
}  

trait PotSensorMixin {
    val sensor = new PotSensor
}

trait HeaterMixin {
    val onOff = new Heater  
}

 val warmer = new Warmer with PotSensorMixin with HeaterMixin
 warmer.trigger 

在这个简单的情况下它确实有效（所以你建议的技术确实可用）。

然而，同一篇博客至少展示了其他三种方法来达到相同的结果；我认为选择主要取决于可读性和个人喜好。在您建议的技术的情况下，恕我直言，Warmer 类无法很好地传达其注入依赖项的意图。另外，为了连接依赖项，我还必须创建另外两个特征（PotSensorMixin 和 HeaterMixin），但也许您有更好的方法来做到这一点。

Answer 4

在这个例子中我认为没有什么大的区别。当特征声明多个抽象值时，自类型可能会带来更多的清晰度，例如

trait ThreadPool {
  val minThreads: Int
  val maxThreads: Int
}

然后，您只需声明对 ThreadPool 的依赖，而不是依赖于多个抽象值。
对我来说，自我类型（如 Cake 模式中使用的）只是一次声明多个抽象成员的一种方法，并为它们提供一个方便的名称。