Nest.js의 Modules, Controllers, Providers 알아보기

NestJS의 기본적인 구성 요소

- main.ts
  - 프로그램 엔트리 파일
  - NestFactory를 통해 Nest Application 인스턴스 생성

- app.module.ts
  - Nest Application의 root 모듈
  - main.ts에서 인스턴스 생성에 사용한다

- app.controller.ts
  - 최초에 생성해주는 컨트롤러
  - Request를 받아주는 역할

- app.service.ts
  - 최초에 생성해주는 서비스 (Provider로 분류된다)
  - 비즈니스 로직을 컴포넌트화 하여 분리하는 역할

- app.controller.spec.ts
  - 유닛 테스트를 위한 파일

프로바이더

의존성을 주입할 수 있다.

• 계층형 구조 ( Layered Architecture )

• 제어 역전 ( IoC, Inversion of Control )

• 의존성 주입 ( Dependency Injection )

계층형 구조 ( Layered Architecture )

복잡한 작업을 나누고, 각 작업마다 역량을 집중하여 해결하는 방식 ( 관심사 분리 )

3-Tier Architecture

• Presentation Tier: 사용자 인터페이스 혹은 외부와의 통신을 담당 ⇒ Controller

• Application Tier: Logic Tier라고 하기도 하고 Middle Tier라고 하기도 한다. 주로 비즈니스 로직을 여기서 구현을 하며, Presentation Tier와 Data Tier사이를 연결 ⇒ Service

• Data Tier: 데이터베이스에 데이터를 읽고 쓰는 역할을 담당

제어 역전 ( IoC, Inversion of Control )

나 대신 프레임워크가 제어한다.

const person = new Person();

interface Thing {
  think(): void;
}

interface Livable {
  sleep(): void;
}

class Home implements Livable {
  private Thing thing;

  constructor Home(private readonly Thing _thing) {
    thing = _thing;
  }

  public void think() {
    thing.think();
  }
}

class Human implements Thing {
  public void think() {
    console.log('haman think!');
  }
}

Home home = new Home(new Thing());

import "reflect-metadata";
import { Container, Service } from "typedi";

@Service()
class Human implements Thing {
  public void think() {
    console.log('human think!');
  }
}

@Service()
class Home implements Livable {
  constructor(private readonly thing: Thing) {}

  public void sleep() {
    this.thing.think();
  }
}


const homeInstance = Container.get<Home>(Home);
homeInstance.think();  // "human think!"

의존성 주입 ( DI, Dependency Injection )

프레임워크가 주체가 되어 나에게 필요한 클래스 등을 대신 관리해준다

IoC: 프레임워크가 제어 할게 ( 추상적 )

DI: 프레임워크가 주체가 되어 내가 필요한 것들을 대신 관리해줄 게 ( IoC의 구현체 )

자, 다시 Provider를 보도록 하자.

서비스

import { Injectable } from '@nestjs/common';
import { Cat } from './interfaces/cat.interface';

@Injectable()
export class CatsService {
  private readonly cats: Cat[] = [];

  create(cat: Cat) {
    this.cats.push(cat);
  }

  findAll(): Cat[] {
    return this.cats;
  }
}

// interfaces/cat.interface.ts

export interface Cat {
  name: string;
  age: number;
  breed: string;
}

// cats.controller.ts
import { Controller, Get, Post, Body } from '@nestjs/common';
import { CreateCatDto } from './dto/create-cat.dto';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';

@Controller('cats')
export class CatsController {
  constructor(private catsService: CatsService) {}

  @Post()
  async create(@Body() createCatDto: CreateCatDto) {
    this.catsService.create(createCatDto);
  }

  @Get()
  async findAll(): Promise<Cat[]> {
    return this.catsService.findAll();
  }
}

생성자를 이용한 의존성 주입(Constructor Injection) 권장

수정자를 이용한 의존성 주입(Setter Injection)

필드를 이용한 의존성 주입(Field Injection)

선택적 프로바이더 ( Optional providers )

import { Injectable, Optional, Inject } from '@nestjs/common';

@Injectable()
export class HttpService<T> {
  constructor(@Optional() @Inject('HTTP_OPTIONS') private httpClient: T) {}
}

속성 기반 주입 ( Property-based injection )

필드를 이용한 의존성 주입이다.

import { Injectable, Inject } from '@nestjs/common';

@Injectable()
export class HttpService<T> {
  @Inject('HTTP_OPTIONS')
  private readonly httpClient: T;
}

클래스가 다른 프로바이더를 확장(extend)하지 않는 이상 반드시 생성자를 이용한 의존성 주입을 사용하자.

모듈

@Module 데코레이터가 가지는 속성

• providers: Nest 인젝터 (Injector: 의존성을 주입하는 Nest 내부 모듈) 가 인스턴스화 시키고 적어도 이 모듈 안에서 공유하는 프로바이더.

• controllers: 이 모듈안에서 정의된, 인스턴스화 되어야하는 컨트롤러의 집합

• imports: 해당 모듈에서 필요한 모듈의 집합. 여기에 들어가는 모듈은 프로바이더를 노출하는 모듈

• exports: 해당 모듈에서 제공하는 프로바이더의 부분집합이며, 이 모듈을 가져오는 다른 모듈에서 사용할 수 있도록 노출할 프로바이더

// cats/cats.module.ts

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}

// app.module.ts

import { Module } from '@nestjs/common';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule {}

//cats.module.ts

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
  exports: [CatsService],
})
export class CatsModule {}

의존성 주입

// cats.module.ts

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {
  constructor(private catsService: CatsService) {}
}

전역 모듈 ( Global modules )

Refrences