20240626 追記
DIについて改めて調べてみました
そもそもDI(dependency injection)とは
とても簡潔に言うと、DI(dependency injection)とは、コードの一部が他のコードに依存している場合、その依存関係を外部から注入すること(仕組み)です。これにより、コードはより読みやすく、理解しやすく、テストしやすくなります。
→ っていわれてもわけわかめだと思うので実際にみていく
ポイントは2つ
- DI(dependency injection)は外部からコードの依存関係を渡してやる。
- DI(dependency injection)を実装するとテストしやすくなる。
DI(dependency injection)なしの場合
SampleController.ts
import SampleService from 'src/service/SampleService'
import { Controller, Res, Post, Body } from '@nestjs/common';
import { plainToClass } from 'class-transformer';
@Controller('v1/sample')
class SampleController {
// sampleService`のインスタンスを`new SampleService()`で作成
private readonly sampleService : SampleService = new SampleService();
@Post()
async getSamples(@Res() res: Response; @body body: sampleBodyParameter): Promise<SampleResponse> {
const vo: SampleOutVo = await this.sampleService.find(body.id);
return plainToClass(SampleResponse, vo);
}
}
export default SampleController
SampleService.ts
class SampleService {
async find(id: string): Promise<SampleOutVo> {
return { sample:'sample' };
}
}
export default SampleService
sampleServiceのインスタンスをnew SampleService()で作成している。
当たり前だが、SampleService.tsが存在しないとコードはエラーになる。
(import SampleService from 'src/service/SampleServiceでエラーになる。)
また、SampleService.tsにfindメソッドが実装されていないとエラーになる。
(this.sampleService.find(body.id)でエラーになる。)
つまり、SampleContollerの実装にはSampleServiceの先行実装が必要
=「SampleContollerはSampleServiceに依存している」
テスト時にmockデータを返したい場合
以下のようにSampleService.tsにテストのための実装を追加してやる。
テストのためのコードを本番の実装に書かなくてはならないので、処理が乱雑になる。
SampleService
import { Controller, Injectable, Res, Inject, Post, Body } from '@nestjs/common';
@Injectable()
class SampleService implements ISampleService {
async find(id: string): Promise<SampleOutVo> {
// テストのためのコードを SampleServiceに書かなくてはならない。
if (process.env.NODE_ENV == 'test') {
return { sample: 'testData' };
} else {
return { sample: 'sample' };
}
}
}
export default SampleService
DI(dependency injection)の場合
前提知識 : interfaceとは
interfaceは、クラスやオブジェクトが持つべきメソッド（関数）やプロパティ（値）の名前と型のみを定義します。実際の中身は定義しません
ISampleService .ts
export interface ISampleService {
// 実際のfindの中身は定義しない
find(id: string): Promise<SampleOutVo>
}
中身はinterfaceを継承したクラスで定義する。
SampleService .ts
@Injectable()
// ProjectServiceを継承(implements ISampleService )
class SampleService implements ISampleService {
// ISampleService で定義したfindの中身を定義
async find(id: string): Promise<SampleOutVo> {
return { sample:'sample' };
}
}
export default SampleService
DI(dependency injection)について
SampleController.ts
import SampleService from 'src/service/Interface/ISampleService'
import { Controller, Injectable, Res, Inject, Post, Body } from '@nestjs/common';
@Controller('v1/sample')
class SampleController {
constructor(
@Inject(constants.I_SAMPLE_SERVICE)
private readonly sampleService: ISampleService,
) {}
@Post()
async getSamples(@Res() res: Response; @body body: sampleBodyParameter): Promise<SampleResponse> {
const vo: SampleOutVo = await this.sampleService.find(body.id);
return plainToClass(SampleResponse, vo);
}
}
export default SampleController
sampleServiceのインスタンスはISampleService型のオブジェクトとして定義されている。
ISampleServiceはインターフェースとして定義されている。
ISampleService.ts
import SampleOutVo from '../vo/sample/SampleOutVo';
export default interface ISampleService {
find(): Promise<SampleOutVo>;
}
SampleContollerはISampleServiceに依存している状態。
前述の通り、ISampleServiceには実際に動く中身が必要ないため
中身を実装しなくてもSampleContollerが動かせる状態が作り出せる
(もちろん、実体がないのでSampleContollerを動かすとsampleService.findでエラーが起きるが)
では、どこでSampleServiceの中身を渡してやるか
@Inject(constants.I_SAMPLE_SERVICE)がよしなにやってくれる
class SampleController {
// ここ
constructor(
@Inject(constants.I_SAMPLE_SERVICE)
private readonly sampleService: ISampleService,
) {}
詳しい話は省くが、Module.tsにおいてI_SAMPLE_SERVICEという名前をSampleServiceと
紐づける処理を書いている。
SampleModule.ts
import { Module } from "@nestjs/common";
import SampleController from 'src/controller/SampleController'
import SampleService from 'src/service/SampleService'
import * as constants from './constants';
@Module({
controllers: [SampleController],
providers: [
// ここ
{
provide: SampleService,
useClass: constants.I_SAMPLE_SERVICE,
},
],
})
export class SampleModule {}
このような仕組みを
外部から
コードの依存性=Dependency(ここではSampleService)を
注入=Injection(sampleService: ISampleServiceに注入)
しているように見えるのでDependency Injectionと呼ぶ
テスト時にmockデータを返したい場合
Module.tsのProviersに、条件によってインスタンスを紐づけるを変更する処理を追加する。
下の例だと、NODE_ENVという環境変数が'test'の場合、SampleTestService 、それ以外の場合SampleServiceをI_SAMPLE_SERVICEと紐づけている。
SampleServiceProvider.ts
@Module({
controllers: [SampleController],
providers: [
{
provide: process.env.NODE_ENV === 'test' ? SampleTestService : SampleService,
useClass: constants.I_SAMPLE_SERVICE,
},
],
})
テストの際にNODE_ENVにtrueを渡してやると、コードを切り替えることなく、SampleServiceの代わりにSampleTestServiceを呼び出すことができる。
// SampleService
@Injectable()
export default class SampleService implements ISampleService {
async find(id: string): Promise<SampleOutVo> {
return { sample: 'testData' };
}
}
// SampleTestService
@Injectable()
export default class SampleTestService implements ISampleService {
async find(id: string): Promise<SampleOutVo> {
return { sample: 'sample' };
}
}
// SampleController
@Controller()
class SampleController {
constructor(
@Inject(constants.I_SAMPLE_SERVICE)
private readonly sampleService: ISampleService,
) {}
@Post()
async getSamples(@Res() res: Response, @Body() body: SampleBodyParameter): Promise<SampleResponse> {
// ここで呼び出されるメソッドはNODE_ENVの値によって変わる
// trueの場合、SampleTestServiceのgetProject
// falseの場合、SampleServiceのgetProject
const vo: SampleOutVo = await this.sampleService.getProject(body.id);
return plainToClass(SampleResponse, vo);
}
}
まとめ
- DI(dependency injection)は外部からコードの依存関係を渡してやる。
- DI(dependency injection)を実装するとテストしやすくなる。
参考