Nest.js的依赖注入

鱼雪

前言

在 NestJS 中，依赖注入是一个核心概念，用于管理应用程序的组件和服务之间的依赖关系。这种模式通过提供一个容器（NestContainer）来解决类之间的依赖关系，使得代码更加模块化、可测试且易于维护。

The Dependency Injection(DI) pattern
- is frequently used today by the bigest framework.
It is a way
- to keep code clean and easier to use.
By using this pattern
- you end up with fewer coupled components
- and more reusable ones
- which helps accelerate the development process time
Nest.js is based on Angular in terms of architecture
- is used to create
  - testable
  - scalable
  - lossely-coupled
  - easily maintainable application
As is the case with Angular
- Nest.js has ite own dependency injection system
  - which is part of the core of the framework
  - meaning that Nest.js is less dependent on a third-party library.

依赖注入模式
- 目前最大的框架都京城使用这种模式
- 这是一种保持代码简洁、更易于使用的方法
- 使用这种模式可以减少耦合组件的数量，增加可重用组件的数量，从而加快开发进程
Nest.js在架构上基于Angular
- 用于创建：可测试、可扩展、松耦合和易维护的应用程序
- 与Angular一样，Nest.js也有自己的依赖注入系统
  - 这是架构核心的一部分
  - 这意味着Nest.js对第三方库的依赖性较低

dependency injection pattern
- 依赖注入
frequently used today
- 现今经常被使用
keep code clean
- 保持代码整洁
easier to use
- 更易于使用
fewer coupled components
- 较少的耦合组件
more reusable components
- 更多可重用组件
accelerate the development process time
- 加速开发过程
based on Angular
- 基于...
in terms of architecture
- 在架构方面
create testable, scalable, loosely-coupled and easily maintainable application
- 创建可测试、可扩展、松耦合且易于维护的应用程序
has its own dependency injection system
- 拥有自己的依赖注入系统
part of the core of the framework
- ...的核心部分
less dependent on a third-party library
- 较少依赖第三方库

Since TypeScript 1.5
- introduces the notion of the decorator
you can do meta-programming
- using the added metadata provided by using a decorator on different objects or properties
  - such as
    - class
    - function
    - function parameters
    - class property
meta-programming
- is the ability
  - to write some code or program
    - using the metadata describing on object
The type of program
- allows you to modify the functioning of a program
  - using its own metadata
    - this metadata is of interest to us
    - because it helps inject some object into another object
    - whose name is Dependency Injection
By using the decorator
- you can add metadata on any object or property linked to those decorators
- To get or define metadata on any object
  - you can also use the reflect-metadata library in order to manipulate them

The real interest in using Dependency Injection
- is that the object will be less coupled between the dependent and its dependencies
With the framework
- that provides the injector system
  - you can manage your objects without thinking about the instanciation fo them
    - because that is managed by the injector
    - which is there to resolve the dependencies of every dependent object.
This means it is easier
- to write test and mock dependencies
- which are much cleaner and more readable