Modules (组件)

• 定义

  Kodein-DI允许将绑定导出到module中，这种方式能够将功能分开到各个Modules中，实现业务分离。创建一个简单的module：

  val apiModule = DI.Module(name = "API") {
      bind<API>() with singleton { APIImpl() }
      /* other bindings */
  }
  

  然后在di中绑定：

  val di = DI {
      import(apiModule)
      /* other bindings */
  }
  

  module将在每个DI实例中重新声明并绑定。如果创建定义单例的module并将该模块导入两个不同的DI实例，则单例对象将创建两次。

• 名称唯一性

  每一个模块名称只能在同一个DI实例中导入一次，如果导入第二次，Kodein-DI将报错。

  但是有时候可能并不能确保每个模块的名称都是唯一的，可能需要导入第三方定义的模块，Kodein-DI提供了两种解决方案：

  1. 重命名模块

     val di = DI {
         import(apiModule.copy(name = "otherAPI"))
     }
     

  2. 为导入的模块添加前缀

     val di = DI {
         import(apiModule.copy(prefix = "otherAPI-"))
     }
     

• 仅导入一次

  一个模块在定义的时候可能依赖于另一个模块，因此将该依赖导入到具有该依赖的模块中。但是，每个模块只能导入一次，因此，如果依赖与另一个模块的每个模块都导入它，则Kodein-DI将在第二次导入该模块的时候失败。

  为了解决这个问题，Kodein-DI引入了importOnce：如果以前未导入任何具有该名称的模块，将导入该模块，反之则不。

  val appModule = DI.Module {
      importOnce(apiModule)
  }
  

继承

Kodein-DI允许通过extend来创建新的DI实例，这将保留之前的绑定，这表明父DI中的单例将继续仅存在一次，父级和子级DI都将给出相同的实例：

val subDI = DI {
    extend(appDI)
    /* other bindings */
}

覆盖

默认情况下，Kodein-DI中不允许覆盖绑定。因为这很可能将相同的类、tag使用不同的instance、prividers、factories等，这会给调试带来麻烦。

但是在某些情况，特别是测试环境下，覆盖绑定来代替原有绑定是有意义的：

val di = DI {
    bind<API>() with singleton { APIImpl() }
    //第二次，需要显式地指定覆盖
    bind<API>(overrides = true) with singleton { OtherAPIImpl() }
}

默认情况下，module也是不允许覆盖地，除非显式声明：

val di = DI {
    import(testEnvModule,allowOverride = true)
}

有时，你在定义绑定地时候不知道实际是覆盖先前地绑定还是定义新的绑定，你可以在定义模块的时候使用allowSilentOverride表明 其中的绑定可以覆盖也可以不覆盖：

val testModule = DI.Module(name = "test",allowSilentOverride = true){
    //可能添加一个新的绑定，可能覆盖一个绑定
    bind<EmailClient>() with singleton { MockEmailClient() }
}

如果要访问通过覆盖之前的实例，可以使用overriddenInstance()，这对装饰者模式（增强绑定）来说很有用。

val testModule = DI.Module(name = "test"){
    bind<Logger>(overrides = true) with singleton {
        //overriddeninstance()将返回覆盖之前的实例
        FileLoggerWrapper("path/to/file",overriddeninstance())
    }
}

来自父级的覆盖访问

val parent = DI {
    bind<Foo>() with provider { Foo1() }
    bind<Bar>() with singleton { Bar(foo = instance<Foo>()) }
}

val child = DI {
    extend(parent)
    bind<Foo>(overrides = true) with provider { Foo2() }
}

val foo = child.instance<Bar>().foo

在上面的例子中，foo变量的绑定类型为Foo1。由于Bar绑定时单例的，并且是在parent DI中声明，因此它无权访问child中声明的绑定。在此例中，parent.instance<Foo>和child.instance<Foo>都将生成Foo1对象。

默认情况下，所有的绑定都会复制到新容器，singleton和multiton除外，因此可以在新容器访问父级绑定或覆盖。

如果想要Bar的单例也复制到child容器，需要使用copy关键字复制到子容器中：

val child = DI {
    //由于复制，child容器将生成Foo2实例
    extend(parent,copy = Copy {
        copy the binding<Bar>()
    })
    bind<Foo>(overrides = true) with provider { Foo2() }
}

复制后的单例将不再是唯一的，因此，Bar具有两个实例，原始绑定的实例与复制生成的实例。

如果需要复制的绑定是由上下文绑定（作用域）的，则同样需要指定它：

val parent = DI {
    bind<Session>(tag = "req") with scoped(requestScope).singleton { 
        context.session() 
    }
}

val child = DI {
    extend(parent,copy = Copy {
        copy the binding<Session>() with scoped(requestScope) and tag("req")
    })
}

你还可以复制与特定定义相匹配的所有绑定：

val child = DI {
    extend(parent,copy = Copy {
        copy all binding<String>()
        copy all scope(requestScope)
    })
}

最后，你可以简单地复制所有绑定：

val child = DI {
    //Copy.ALL 复制所有绑定;Copy.NONE 不复制任何内容
    extend(parent,copy = Copy.ALL)
}