Midway 依赖注入(IoC)完全指南:从装饰器到容器的核心机制

原创2026-10-09 13:57:531,333 阅读
文章标签:后端微服务云原生

Midway 依赖注入(IoC)完全指南:从装饰器到容器的核心机制

依赖注入是 Midway 框架的基石能力,它通过 @Provide / @Inject 等轻量装饰器,让开发者用近乎原生 Class 的写法即可获得 Spring 级别的容器管理能力。本文以 Midway 2.0 官方文档为主体,结合 core 包源码 逐层拆解依赖注入标识符规则、三种作用域、异步初始化、动态函数注入与静态 API 等完整机制,读完即可在业务中正确设计服务、控制器与中间件的依赖关系,并能在中间件、SDK 封装等特殊场景下通过容器 API 动态获取服务。

快速理解:两个装饰器搞定对象管理

Midway 中大量使用了依赖注入特性,通过装饰器的轻量特性,让依赖注入变得优雅,从而让开发过程便捷有趣。以下面的函数目录结构为例:

.
├── package.json
├── src
│   ├── controller											# 控制器目录
│   │   └── userController.ts
│   └── service			  									# 服务目录
│   │     └── userService.ts
└── tsconfig.json

示例中提供了 userController.ts 和 userService.ts 两个文件,为了解释方便将其合并展示,内容大致如下:

import { Provide, Inject, Get } from '@midwayjs/decorator';

// userController.ts
@Provide()
@Controller('/')
export class UserController {
  @Inject()
  userService: UserService;

  @Get('/')
  async get() {
    const user = await this.userService.getUser();
    console.log(user); // world
  }
}

// userService.ts
@Provide()
export class UserService {
  async getUser() {
    return 'world';
  }
}

抛开所有装饰器,可以看到这是标准的 Class 写法,没有其他多余内容,这也是 Midway 体系的核心能力,依赖注入最迷人的地方。

  • @Provide 的作用是告诉依赖注入容器:我需要被容器加载;
  • @Inject 装饰器告诉容器:我需要将某个实例注入到属性上。

通过这两个装饰器的搭配,就可以方便地在任意类中拿到实例对象,就像上面的 this.userService。

在源码层面,@Provide 与 @Inject 分别定义于 packages/core/src/decorator/common/provide.ts 与 packages/core/src/decorator/common/inject.ts。Inject 同时是属性装饰器与参数装饰器,这意味着它既能注入属性,也能注入构造器参数。

依赖注入原理:容器、绑定与解析

我们以下面的伪代码举例:在 Midway 体系启动阶段,会创建一个依赖注入容器(MidwayContainer),扫描所有用户代码(src)中的文件,将拥有 @Provide 装饰器的 Class 保存到容器中。

/***** 下面为 Midway 内部代码 *****/

const container = new MidwayContainer();
container.bind(UserController);
container.bind(UserService);

这里的依赖注入容器类似于一个 Map:Map 的 key 是类名的驼峰形式,Value 则是类本身。从源码看,MidwayContainer 内部维护了 _registry(对象定义注册表)与 attrMap(属性缓存),其 bind 方法会根据元数据生成 IObjectDefinition,其中记录了作用域、构造器注入参数、属性注入元数据以及 @Init / @Destroy 方法(见 container.ts 的 bind 实现)。

在请求时,容器会动态实例化这些 Class,并处理属性的赋值,比如下面的伪代码:

/***** 下面为依赖注入容器伪代码 *****/
const userService = new UserService();
const userController = new UserController();

userController.userService = userService;

经过这样,就能拿到完整的 userController 对象了,实际的代码会稍微不一样。MidwayContainer 提供了 getAsync 方法,用于异步处理对象的初始化(很多依赖都有异步初始化的需求),并自动完成属性赋值、缓存、返回对象,将上面的流程合为同一个:

/***** 下面为依赖注入容器内部代码 *****/

// 自动 new UserService();
// 自动 new UserController();
// 自动赋值 userController.userService = await container.getAsync(UserService);

const userController = await container.getAsync(UserController);
await userController.handler(); // output 'world'

这就是依赖注入的核心过程——创建实例。源码中 getAsync 通过 getManagedResolverFactory().createAsync(identifier, args, this) 完成实例创建与依赖解析,见 container.ts 的 getAsync 实现。

此外,官方还发布过一篇名为《这一次,教你从零开始写一个 IoC 容器》的公众号文章,可作为扩展阅读。

依赖注入标识符:驼峰命名与匹配规则

默认情况下,Midway 会将类名变为驼峰形式作为依赖注入标识符,一般情况下用户无需改变它,直接使用 @Provide 和 @Inject 装饰器即可。这两个装饰器都有可选参数,并且是成对出现的。

默认规则:

  1. @Provide 取类名的驼峰字符串作为依赖注入标识符;
  2. @Inject 根据规则获取 key。

@Inject 的取 key 规则如下:

  1. 如果装饰器包含参数,则以参数字符串作为 key;
  2. 如果没有参数,标注的 TS 类型为 Class,则将类 @Provide 的 key 作为 key;
  3. 如果没有参数,标注的 TS 类型为非 Class(如 Interface),则将属性名作为 key。

两者相互一致即可关联。对应到源码,Inject 在写入元数据时会记录 injectMode(标识符模式),InjectModeEnum 定义了 Identifier、Class、SelfName 三种匹配方式,见 packages/core/src/interface.ts。

export interface IService {}

// service
@Provide() // <------ 这里暴露的 key 是 userService
export class UserService implements IService {
  //...
}

// controller
@Provide()
@Controller('/api/user')
export class APIController {
  @Inject('userService') // <------ 这里注入的 key 是 userService
  userService1: UserService;

  @Inject()
  userService2: UserService; // <------ 这里的类型是 Class,注入的 key 是 userService

  @Inject()
  userService: IService; // <------ 这里的类型是 Interface,注入的 key 是 userService

  //...
}

也可以修改暴露给依赖注入容器的 key,同时注入的地方也要相应修改:

// service
@Provide('bbbService') // <------ 这里暴露的 标识符 是 bbbService
export class UserService {
  //...
}

// controller
@Provide()
export class UserController {
  @Inject('bbbService') // <------ 这里注入的 标识符 是 bbbService
  userService: UserService;

  //...
}

除了字符串,还可以使用 Class 本身作为注入标识符:

@Provide() // <------ 这里暴露的 标识符 是 userService
export class UserService {
  //...
}

@Provide()
export class UserController {
  @Inject()
  userService: UserService; // <------ 这里注入的标识符是 UserService 类 (userService)

  //...
}

关于驼峰命名的注意事项

Midway 使用的驼峰库为 camelcase,在一些情况下可能和你预想的不同。比如,碰到两个大写字母相连时,后一个字母会变成小写:

(ABCD) => abcd;
(UserMQController) => userMqController;

如果不确定,可以在项目下的命令行中临时测试:

➜  midway_v2_demo git:(master) ✗ node

> require('camelCase')('UserMQController')
'userMqController'
>

源码中,容器默认标识符正是通过 camelCase(target.name) 生成的,见 packages/core/src/decorator/decoratorManager.ts 与 packages/core/src/util/camelCase.ts。

作用域:Singleton、Request 与 Prototype

默认的未指定或未声明的情况下,所有 @Provide 出来的 Class 的作用域都为请求作用域(Request)。这意味着这些 Class 会在每一次请求第一次调用时被实例化(new),请求结束后实例销毁。默认情况下的控制器(Controller)和服务(Service)都是这种作用域。

在 Midway 的依赖注入体系中,有三种作用域:

作用域 说明
Singleton 单例 全局唯一(进程级别)
Request 请求作用域(默认) 生命周期绑定请求链路,实例在请求链路上唯一,请求结束立即销毁。例如 http 请求进来时会创建一个请求作用域 ctx,可通过 @Inject() ctx 拿到;定时器触发也相当于创建了请求作用域 ctx,同样可以注入
Prototype 原型作用域 每次调用都会重复创建一个新的对象

源码中 ScopeEnum 定义于 packages/core/src/interface.ts,而容器在 bind 时对未声明作用域的 Class 默认赋予 ScopeEnum.Request(见 container.ts bind 实现)。

不同作用域有不同的用途:单例可以用来做进程级别的数据缓存,或者数据库连接等只需要执行一次的工作;由于全局唯一、只初始化一次,调用速度也比较快。请求作用域则是大部分需要获取请求参数和数据的服务的首选;原型作用域使用较少,但在一些特殊场景下也有它独特的作用。

如果希望将对象定义为其他两种作用域,需要额外配置。Midway 提供了 @Scope 装饰器来定义类的作用域,下面的代码将 user 服务变成了一个全局唯一的实例:

// service
import { Scope, ScopeEnum } from '@midwayjs/decorator';

@Provide()
@Scope(ScopeEnum.Singleton)
export class UserService {
  //...
}

默认为请求作用域的目的是为了和请求上下文关联,可以更好地追踪问题。

@Inject 装饰器是在当前类的作用域下去寻找对象来注入的。比如,在 Singleton 作用域下,由于和请求不关联,默认没有 ctx 对象,所以注入 ctx 是不对的:

@Provide()
@Scope(ScopeEnum.Singleton)
export class UserService {
  @Inject()
  ctx; // undefined
  //...
}

单例的限制:注入链路被冻结

当作用域被设置为单例(Singleton)之后,整个 Class 注入的对象在第一次实例化之后就已经被固定了,这意味着单例中注入的内容不能是其他作用域。

看一个例子:

// 这个类是默认的请求作用域(Request)
@Provide()
export class HomeController {
  @Inject()
  userService: UserService;
}

// 设置了单例,进程级别唯一
@Provide()
@Scope(ScopeEnum.Singleton)
export class UserService {
  async getUser() {
    // ...
  }
}

这种情况下,不论调用 HomeController 多少次,每次请求的 HomeController 实例是不同的,而 UserService 永远是固定的那一个。

再演示单例中注入的服务是否还会保留原有作用域(这里的 DBManager 特意设置成请求作用域,来演示特殊场景):

// 这个类是默认的请求作用域(Request)
@Provide()
export class HomeController {
  @Inject()
  userService: UserService;
}

// 设置了单例,进程级别唯一
@Provide()
@Scope(ScopeEnum.Singleton)
export class UserService {
  @Inject()
  dbManager: DBManager;

  async getUser() {
    // ...
  }
}

// 未设置作用域,默认是请求作用域(这里用来验证单例链路下,后续的实例都被缓存的场景)
@Provide()
export class DBManager {}

这种情况下,不论调用 HomeController 多少次,每次请求的 HomeController 实例是不同的,而 UserService 和 DBManager 都会是固定的那一个。

可以简单地理解为:单例就像一个缓存,其中依赖的所有对象都将被冻结,不再变化。 从容器实现上看,单例对象在第一次创建后即被缓存复用,后续请求不再重建,这正是 ManagedResolverFactory 内部按作用域缓存实例的结果。

异步初始化:@Init 装饰器

在某些情况下,一个实例在被其他依赖调用前需要初始化。如果初始化只是读取某个文件,可以写成同步方式;而如果初始化是从远端拿取数据或者连接某个服务,普通同步代码就非常难写。

Midway 提供了异步初始化的能力,通过 @Init 标签来管理初始化方法。@Init 方法目前只能是一个:

@Provide()
export class BaseService {
  @Config('hello')
  config;

  @Plugin('plugin2')
  plugin2;

  @Init()
  async init() {
    await new Promise((resolve) => {
      setTimeout(() => {
        this.config.c = 10;
        resolve();
      }, 100);
    });
  }
}

等价于:

const service = new BaseService();
await service.init();

@Init 装饰器标记的方法,一定会以异步方式来调用。一般来说,异步初始化的服务较慢,请尽可能标注为单例(@Scope(ScopeEnum.Singleton))。

在源码中,@Init 方法的信息会在 bind 阶段写入对象定义(definition.initMethod),容器在实例创建后、对外返回前会先执行该初始化方法,见 container.ts 的 initMethod 注册逻辑。

获取依赖注入容器

一般情况下,用户无需关心依赖注入容器,但在一些特殊场景下需要主动获取,例如:

  • 需要动态调用服务的场景,比如 Web 的中间件场景、启动阶段需要调用服务的场景;
  • 封装框架或其他三方 SDK 时需要动态获取服务的场景。

简单来说,任意需要通过 API 动态获取服务的场景,都需要先拿到依赖注入容器。

Midway 将依赖注入容器挂载在两个地方:框架的 app 以及每次请求的上下文 Context。由于不同上层框架的情况不同,这里列举常见的示例。

对于不同的上层框架,Midway 统一提供了 IMidwayApplication 定义,所有上层框架 app 都会实现这个接口:

export interface IMidwayApplication {
  getApplicationContext(): IMidwayContainer;
  //...
}

即通过 app.getApplicationContext() 方法,都能获取到依赖注入容器:

const container = app.getApplicationContext();

配合 @App 装饰器,可以方便地在任意地方拿到当前运行的 app 实例:

import { App } from '@midwayjs/decorator';
import { IMidwayApplication } from '@midwayjs/core';

@Provide()
export class BootApp {
  @App()
  app: IMidwayApplication; // 这里也可以换成实际的框架的 app 定义

  async ready() {
    // 获取依赖注入容器
    const container = this.app.getApplicationContext();
  }
}

请求链路的依赖注入容器

除了普通的依赖注入容器之外,Midway 还提供了一个请求链路的依赖注入容器。这个请求链路的容器与全局的依赖注入容器关联,共享一个对象池,但两者有所区别。

请求链路容器是为了获取特有的请求作用域对象,从中获取的对象都和请求绑定、关联了当前上下文。这意味着:如果 Class 代码和请求关联,必须从这个请求链路的依赖注入容器中获取。

请求链路的依赖注入容器必须从请求上下文对象中获取,最常见的场景为 Web 中间件:

@Provide()
export class ReportMiddleware {
  resolve() {
    return async (ctx, next) => {
      // ctx.requestContext  请求链路的依赖注入容器
      await next();
    };
  }
}

Express 的请求链路依赖注入容器挂载在 req 对象上:

@Provide()
export class ReportMiddleware {
  resolve() {
    return (req, res, next) => {
      // req.requestContext  请求链路的依赖注入容器
      next();
    };
  }
}

动态获取服务等实例

拿到依赖注入容器或者请求链路的依赖注入容器之后,才可以通过容器的 API 获取对象:

import { UserService } from './service/user';

@Provide()
export class ReportMiddleware {
  @App()
  app: IMidwayApplication;

  resolve() {
    return async (ctx, next) => {
      const container = app.getApplicationContext();

      // 下面的方法等价,获取的对象和请求不关联,没有 ctx 上下文
      const userService1 = await container.getAsync<UserService>('userService');
      const userService2 = await container.getAsync<UserService>(UserService);
      // 如果传入 class,这么写也能推导出正确的类型
      const userService2 = await container.getAsync(UserService);

      // 下面的方法获取的服务和请求关联,可以注入上下文
      const userService = await ctx.requestContext.getAsync<UserService>(UserService);
      await next();
    };
  }
}

Express 的写法:

import { UserService } from './service/user';

@Provide()
export class ReportMiddleware {
  @App()
  app: IMidwayApplication;

  resolve() {
    return (req, res, next) => {
      req.requestContext.getAsync<UserService>(UserService).then((userService) => {
        // do something
        next();
      });
    };
  }
}

值得注意的是,getAsync 的入参既可以是标识符字符串,也可以是 Class 本身,容器会根据 Class 推导出正确的类型与标识符(见 container.ts),这对类型安全非常友好。

注入已有对象:registerObject

有时候,应用已经有现成的实例而不是类,比如引入了一个第三方库,这时如果希望这个对象能够被其他 IoC 容器中的实例引用,可以通过增加对象的方式处理。拿常见的 http 请求库 urllib 举例:假如希望在多个类中使用它、且不通过 require 的方式,就需要在业务调用前(一般在启动的生命周期中)通过 registerObject 方法添加这个对象,添加时需要给出一个标识符,方便其他类注入:

// in global file
import * as urllib from 'urllib';
import { Configuration } from '@midwayjs/decorator';

@Configuration()
export class AutoConfiguration {
  @App()
  app: IMidwayApplication;

  async onReady() {
    // 注入一些全局对象
    this.app.getApplicationContext().registerObject('httpclient', urllib);
  }
}

这个时候就可以在任意的类中通过 @Inject 使用了:

@Provide()
export class BaseService {
  @Inject()
  httpclient;

  async getUser() {
    return await this.httpclient.request('/api/getuser');
  }
}

源码层面,registerObject 将对象注册到容器的对象注册表中(见 container.ts 的 registerObject 实现),之后容器在解析注入时若命中该标识符,会直接返回这个已有实例。

动态函数注入:providerWrapper 与工厂方法

在某些场景下,我们需要函数作为某个逻辑动态执行,而依赖注入容器中的对象属性都是已经创建好的,无法满足动态逻辑需求。比如需要工厂函数根据不同的场景返回不同的实例,或者一个三方包本身是函数、想在业务中直接调用,这些场景下就需要直接注入一个工厂方法,并在函数中拿到上下文,动态生成实例。

下面是标准的工厂方法注入样例。一般工厂方法用于返回相同接口的实现,比如有两个 ICacheService 接口的实现:

export interface ICacheService {
  getData(): any;
}

@Provide()
export class LocalCacheService implements ICacheService {
  async getData {}
}

@Provide()
export class RemoteCacheService implements ICacheService {
  async getData {}
}

然后定义一个动态服务(工厂),根据当前用户配置返回不同的实现:

// src/service/dynamicCacheService.ts

import { providerWrapper, IMidwayContainer } from '@midwayjs/core';

export async function dynamicCacheServiceHandler(container: IMidwayContainer) {
  // 从容器 API 获取全局配置
  const config = container.getConfigService().getConfiguration();
  if (config['redis']['mode'] === 'local') {
    return await container.getAsync('localCacheService');
  } else {
    return await container.getAsync('remoteCacheService');
  }
}

providerWrapper([
  {
    id: 'dynamicCacheService',
    provider: dynamicCacheServiceHandler,
    scope: ScopeEnum.Request, // 设置为请求作用域,那么上面传入的容器就为请求作用域容器
    // scope: ScopeEnum.Singleton,	// 也可以设置为全局作用域,那么里面的调用的逻辑将被缓存
  },
]);

这样在业务中就可以直接使用了。注意:在注入的时候,方法会被调用后再注入:

@Provide()
@Controller('/')
export class HomeController {
  @Inject()
  ctx: Context;

  @Inject('dynamicCacheServiceHandler')
  cacheService: ICacheService;

  @Get('/')
  async home() {
    const data = await this.cacheService.getData();
    // ...
  }
}

通过 providerWrapper 将一个原本的函数写法进行了包裹,与现有的依赖注入体系融合到一起,让容器能够统一管理。从源码看,providerWrapper 的实现就是给 provider 函数挂上 FUNCTION_INJECT_KEY 元数据(见 packages/core/src/context/providerWrapper.ts),容器在扫描到带该标记的函数时,会将其作为函数定义(FunctionDefinition)注册进容器。

注意:动态方法必须 export,才会被依赖注入扫描到,默认为请求作用域(获取的 Container 是请求作用域容器)。

由于能把动态方法绑定到依赖注入容器,那么也能将一个回调方法绑定进去,这样获取的方法是可以被执行的,可以根据业务的传参来决定返回的结果:

import { providerWrapper, IMidwayContainer } from '@midwayjs/core';

export function cacheServiceHandler(container: IMidwayContainer) {
  return async (mode: string) => {
    if (mode === 'local') {
      return await container.getAsync('localCacheService');
    } else {
      return await container.getAsync('remoteCacheService');
    }
  };
}

providerWrapper([
  {
    id: 'cacheServiceHandler',
    provider: cacheServiceHandler,
    scope: ScopeEnum.Singleton,
  },
]);

@Provide()
@Controller('/')
export class HomeController {
  @Inject()
  ctx: Context;

  @Inject('cacheServiceHandler')
  getCacheService;

  @Get('/')
  async home() {
    const data = await this.getCacheService('local');
    // ...
  }
}

依赖注入容器的默认对象

Midway 会默认注入一些值,方便业务直接使用:

标识符 值类型 作用域 描述
baseDir string 全局 本地使用 ts-node 开发时为 src 目录,否则为 dist 目录
appDir string 全局 应用的根路径,一般为 process.cwd()
ctx object 请求链路 对应框架的上下文类型,比如 EggJS 和 Koa 的 Context,Express 的 req
logger object 请求链路 在 EggJS 下等价于 ctx.logger
req object 请求链路 Express 特有
res object 请求链路 Express 特有
socket object 请求链路 WebSocket 场景特有

使用示例:

@Provide()
export class BaseService {
  @Inject()
  baseDir;

  @Inject()
  appDir;

  async getUser() {
    console.log(this.baseDir);
    console.log(this.appDir);
  }
}

从源码看,容器构造时就会注册 ctx 相关的请求上下文键(见 container.ts 构造函数),baseDir 与 appDir 则在框架启动阶段被注册为全局对象。

类名冲突检查

在项目比较大的时候,比较容易出现类名重复。Midway 提供同名类重复检查的功能,只需要在入口 configuration.ts 文件的 @Configuration 装饰器中加入 conflictCheck 属性即可:

@Configuration({
  conflictCheck: true, // 开启命名冲突检查
})
export class AutoConfiguration {}

开启后,容器在启动扫描阶段会检测注册的同名标识符,帮助开发者尽早发现因类名重复导致的注入错乱问题。

静态 API:无需实例获取容器与框架

在有些工具类中,可以不需要创建 class 实例就能获取到全局的依赖注入容器(在使用 bootstrap.js 启动之后):

import { getCurrentApplicationContext } from '@midwayjs/core';

export const getService = async (serviceName) => {
  return getCurrentApplicationContext().getAsync(serviceName);
};

获取主框架(在使用 bootstrap.js 启动之后):

import { getCurrentMainFramework } from '@midwayjs/core';

export const framework = () => {
  return getCurrentMainFramework();
};

获取主框架的 app 对象(在使用 bootstrap.js 启动之后):

import { getCurrentMainApp } from '@midwayjs/core';

export const getGlobalConfig = () => {
  return getCurrentMainApp().getConfig();
};

这些静态 API 的实现位于 packages/core/src/util/contextUtil.ts:getCurrentApplicationContext 直接读取全局挂载的 MIDWAY_APPLICATION_CONTEXT,getCurrentMainFramework 读取全局的 MIDWAY_MAIN_FRAMEWORK,而 getCurrentMainApp 则通过主框架的 getApplication() 获取 app 实例。它们都要求应用已经通过 bootstrap.js 完成启动,否则全局对象尚未挂载。

面向接口编程

Midway 也支持基于接口进行注入,但由于 TypeScript 编译后会移除接口类型,不如使用类作为定义好用。

比如定义一个接口及其实现类:

export interface IPay {
  payMoney();
}

@Provide('WeChatPay')
export class WeChatPay implements IPay {
  async payMoney() {
    // ...
  }
}

@Provide('AlipayPay')
export class AlipayPay implements IPay {
  async payMoney() {
    // ...
  }
}

如果有个服务需要注入,可以使用下面显式声明的方式:

@Provide()
export class PaymentService {
  @Inject('AlipayPay')
  payService: IPay; // 注意,这里的类型是接口,编译后类型信息会被移除

  async orderGood {
    await this.payService.payMonety();
  }
}

由于接口类型会被移除,Midway 只能通过 @Inject 装饰器的参数或者属性名来匹配注入的对象信息,类似 Java Spring 中的 Autowire by name。

以上就是静态的面向接口注入方式。如果需要动态方式,和前面动态函数注入描述的一致,注入方法使用即可。

常见的使用错误:构造器中获取注入属性

请不要在构造器中获取注入的属性,这会使得拿到的结果为 undefined。原因是装饰器注入的属性,都在实例创建后(new)才会赋值。这种情况下,请使用 @Init 装饰器:

@Provide()
export class UserService {
  @Config('userManager')
  userManager;

  constructor() {
    console.log(this.userManager); // undefined
  }

  @Init()
  async initMethod() {
    console.log(this.userManager); // has value
  }
}

这一现象与容器实例化的先后顺序直接相关:new 构造在容器完成属性赋值之前执行,而 @Init 标记的方法在容器完成属性注入后、对象对外可用前执行,因此初始化逻辑应放在 @Init 方法中而不是构造函数里。

关于继承

为了避免属性错乱,请不要在基类上使用 @Provide 装饰器。现阶段,Midway 支持属性装饰器的继承,但不支持类装饰器和方法装饰器的继承(会有歧义)。

小结

Midway 的依赖注入体系可以概括为一条清晰的主线:@Provide 注册(类/函数 → 标识符)、@Inject 消费(按标识符、Class 或属性名匹配)、容器按作用域(Singleton / Request / Prototype)实例化与缓存对象、@Init 负责异步初始化、providerWrapper 将动态函数纳入统一管理。结合 core 包源码 阅读本文,可以更深刻地理解容器 bind → getAsync 的完整调用链,进而在实际项目中设计出职责清晰、作用域合理、可测试的服务依赖关系。

登录后查看全文
midway