BlackBox DI

Rust的依赖注入

安装

在您的项目目录中运行以下Cargo命令

cargo add blackbox_di

或添加以下行到您的Cargo.toml

blackbox_di = "0.1"

使用方法

提供者创建

使用 #[interface] 注释接口

#[interface]
trait IService {
  fn call(&self);
}

使用 #[injectable] 注释服务结构

#[injectable]
struct Service {}

使用 #[implements] 注释实现块

#[implements]
impl IService for Service {
  fn call() {
    println!("Service calling");
  }
}

模块创建

使用 #[module] 注释模块结构，并指定 Service 结构作为 provider

#[module]
struct RootModule {
  #[provider]
  service: Service
}

容器创建

#[launch]
async fn launch() {
    let app = build::<RootModule>(BuildParams::default()).await;

    let service = app
      .get_by_token::<Service>(&get_token::<Service>)
      .unwrap();

    // short (equivalent to above)
    let service = app.get::<Service>().unwrap();
    service.call();
}

注入引用

按类型注入

为可注入依赖指定 #[inject]

#[injectable]
struct Repo {}

#[injectable]
struct Service {
  #[inject]
  repo: Ref<Repo>
}

别忘了在 RootModule 模块中指定 Repo

#[module]
struct RootModule {
  #[provider]
  repo: Repo

  #[provider]
  service: Service
}

按令牌注入

您可以使用令牌代替类型

#[injectable]
struct Repo {}

#[injectable]
struct Service {
  #[inject("REPO_TOKEN")]
  repo: Ref<Repo>
}

然后

#[module]
struct RootModule {
  #[provider("REPO_TOKEN")]
  repo: Repo

  #[provider]
  service: Service
}

或使用常量作为令牌

const REPO_TOKEN: &str = "REPO_TOKEN";

#[injectable]
struct Repo {}

#[injectable]
struct Service {
  #[inject(REPO_TOKEN)]
  repo: Ref<Repo>
}

#[module]
struct RootModule {
  #[provider(REPO_TOKEN)]
  repo: Repo

  #[provider]
  service: Service
}

使用接口

您还可以使用接口注入可注入依赖

const REPO_TOKEN: &str = "REPO_TOKEN";

#[interface]
trait IRepo {}

#[injectable]
struct Repo {}

#[implements]
impl IRepo for Repo {}

#[injectable]
struct Service {
  #[inject(REPO_TOKEN)]
  repo: Ref<dyn IRepo>
}

#[module]
struct RootModule {
  #[provider(REPO_TOKEN)]
  repo: Repo

  #[provider]
  service: Service
}

或直接使用接口的现有实现

#[interface]
trait IRepo {}

#[injectable]
struct Repo {}

#[implements]
impl IRepo for Repo {}

#[injectable]
struct Service {
  #[inject(use Repo)]
  repo: Ref<dyn IRepo>
}

#[module]
struct RootModule {
  #[provider]
  repo: Repo

  #[provider]
  service: Service
}

工厂

如果一个服务有非注入依赖

#[injectable]
struct Service {
  #[inject]
  repo: Ref<Repo>

  greeting: String
}

您应该指定一个工厂函数

#[implements]
impl Service {
  #[factory]
  fn new(repo: Ref<Repo>) -> Service {
    Service {
      repo, 
      greeting: String::from("Hello")
    } 
  }
}

或对于接口

#[injectable]
struct Service {
  #[inject(use Repo)]
  repo: Ref<dyn IRepo>

  greeting: String
}

#[implements]
impl Service {
  #[factory]
  fn new(repo: Ref<dyn IRepo>) -> Service {
    Service {
      repo, 
      greeting: String::from("Hello")
    } 
  }
}

具有 非注入 依赖的可注入服务必须具有 factory 函数。

为了有可变非注入依赖，您需要使用 RefMut<...>

#[injectable]
struct Service {
  #[inject(use Repo)]
  repo: Ref<dyn IRepo>

  greeting: RefMut<String>
}

#[implements]
impl Service {
  #[factory]
  fn new(repo: Ref<dyn Repo>) -> Service {
    Service {
      repo, 
      greeting: RefMut::new(String::from("Hello"))
    } 
  }

  fn set_greeting(&self, msg: String) {
    *self.greeting.as_mut() = msg;
  }

  fn print_greeting(&self) {
    println!("{}", self.greeting.as_ref());
  }
}

模块

您可以指定多个模块并将它们导入

#[module]
struct UserModule {
  #[provider]
  user_service: UserService,
}

#[module]
struct RootModule {
  #[import]
  user_module: UserModule
}

要使用导入模块中的提供者，您应该将这些提供者指定为exported

#[module]
struct UserModule {
  #[provider]
  #[export]
  user_service: UserService,
}

此外，您可以将您的模块指定为global，这样您就不必直接导入它们。只需在root模块中指定它们即可

#[module]
#[global]
struct UserModule {
  #[provider]
  #[export]
  user_service: UserService,
}

#[module]
struct AccountModule {
  #[provider]
  #[export]
  account_service: AccountService,
}


#[module]
struct RootModule {
  #[import]
  user_module: UserModule

  #[import]
  account_module: AccountModule
}

依赖循环

在模块导入时使用Lazy来解析依赖循环

#[module]
struct UserModule {
  #[import]
  account_module: Lazy<AccountService>,

  #[provider]
  #[export]
  user_service: UserService,
}

#[module]
struct AccountModule {
  #[import]
  user_module: Lazy<UserModule>,
  
  #[provider]
  #[export]
  account_service: AccountService,
}


#[module]
struct RootModule {
  #[import]
  user_module: UserModule

  #[import]
  account_module: AccountModule
}

生命周期事件

当容器完全初始化后，系统触发事件on_module_init

#[implements]
impl OnModuleInit for Service {
  async fn on_module_init(&self) {
    ...
  }
}

和on_module_destroy

#[implements]
impl OnModuleDestroy for Service {
  async fn on_module_destroy(&self) {
    ...
  }
}

记录器

记录器用于显示有关应用构建的信息。要使用自定义记录器，实现ILogger特性

pub trait ILogger {
    fn log<'a>(&self, level: LogLevel, msg: &'a str);
    fn log_with_ctx<'a>(&self, level: LogLevel, msg: &'a str, ctx: &'a str);
    fn set_context<'a>(&self, ctx: &'a str);
    fn get_context(&self) -> String;
}

然后更改构建参数

let app = build::<RootModule>(
  BuildParams::default().buffer_logs()
).await;

let custom_logger = app.get::<CustomLogger>().unwrap();

app.use_logger(custom_logger.cast::<dyn ILogger>().unwrap());

许可证

BlackBox DI许可在

• MIT许可证（LICENSE-MIT 或 https://opensource.org/licenses/MIT）