Cad iad soláthróirí saincheaptha agus comhéigeantaí insteallta?

Question

Accepted Answer

Ar bhraistint ar dhá dhóighleabhar simplí ar `@Injectable()` , tacaíonn NestJS le **soláthróirí saincheaptha** — bealaí solúbtha chun a shainiú cad a bheidh insteallta — ag baint úsáide as **comhéigeantaí insteallta**. Ligeann sé seo duit luachanna a insteallta, a chumrú conas a bheidh daingnithe i gcruthaithe, feidhmeanna a athrú, agus cleachtais neamhdhoshartha a insteallta.

## An ceithre chineál soláthróra saincheaptha

```ts
@Module({
  providers: [
    // 1. useClass — standard (or swap the implementation behind a token)
    { provide: PaymentService, useClass: StripePaymentService },

// 2. useValue — inject a constant/object/mock (great for config and testing)
    { provide: "CONFIG", useValue: { apiKey: "abc", timeout: 5000 } },

// 3. useFactory — compute the provider dynamically (can use other deps)
    {
      provide: "DATABASE_CONNECTION",
      useFactory: async (config: ConfigService) => {
        return await createConnection(config.get("DB_URL"));   // async setup
      },
      inject: [ConfigService],        // dependencies for the factory
    },

// 4. useExisting — create an alias for an existing provider
    { provide: "ALIAS", useExisting: PaymentService },
  ],
})
export class AppModule {}
```

## Comhéigeantaí insteallta — le haghaidh cleachtais neamhdhoshartha

```ts
// classes can be tokens directly (by type). For values/interfaces, use a string/Symbol token:
@Injectable()
export class PaymentProcessor {
  constructor(@Inject("CONFIG") private config: AppConfig) {}   // inject by token
}
```

De bharr go bhféadfá dochar a dhéanamh ar dhúil nó ar luach simplí a insteallta de réir cineáil (níl siad ann ag an am runtime), úsáideann tú **comhéigeantas** (teanga nó `Symbol`) le `@Inject(token)` a insteallta. Seo an chaoi ina instealltar tú réada cumraithe, cliant tríú páirtí, nó cleachtais a chur i gcomhéigeantas.

## useFactory — an ceann is cumhachtach (dhinimiciúil, socrú asynchronous)

```ts
// create a provider whose value depends on runtime config / async initialization
{
  provide: "REDIS_CLIENT",
  useFactory: (config: ConfigService) => new Redis(config.get("REDIS_URL")),
  inject: [ConfigService],
}
```

Ritheonn `useFactory` feidhm (le cleachtais insteallta) chun an soláthróir a thabhairt — riachtanach do cheangail, do chliant, nó aon rud a bhfuil gá dó do chumrú runtime nó socrú asynchronous.

## Feidhmeanna a athrú (useClass) — solúbthacht & tástáil

```ts
// inject a different implementation based on environment
{
  provide: PaymentService,
  useClass: process.env.NODE_ENV === "test" ? MockPaymentService : StripePaymentService,
}
```

De bharr go bhraitheanns ar an comhéigeantas (`PaymentService`), is féidir leat an rang nó an t-inneall docht a athrú — seirbhís fhíor Stripe i dtáirgeadh, brég i dtástáil — gan aon chód ionfhurtaiste a athrú.

## Cén fáth a bhíonn sé tábhachtach

Leathnaíonn soláthróirí saincheaptha agus comhéigeantaí insteallta DI NestJS ar bhraistint ar dhá dhóighleabhar simplí ar dhoshartha, agus tabhairt solúbthachta ar fhíor-thairbhí.

Tá sé tábhachtach a thuiscint iad do roinnt rudaí i gcoitianta: **luachanna neamhdhoshartha a insteallta** (réada cumraithe, taisc) trí `useValue` agus comhéigeantaí teanga/Symbol (de bharr go bhféadfá dochar a dhéanamh ar dhúib nó ar luachanna simplí a insteallta de réir cineáil); **cruthú dinimiciúil/asynchronous soláthróra** trí `useFactory` (an fhoirm is cumhachtach — ceangail dhátabhaísí, cliant Redis, nó daingnithe de sheirbhísí SDK tríú páirtí cumraithe ó luachanna runtime, le cleachtais insteallta féin); agus **feidhmeanna a athrú** trí `useClass` i ndiaidh comhéigeantas (a chumhachtú oideachasúil-bhunaithe agus, go tábhachtach, **brég simplí i dtástáil** — soláthróir brég a sholáthar ar comhéigeantas gan ionfhurtaiste a bhualadh).

Is é an solúbthacht seo atá fhágáil ar NestJS's DI cumhachtach d'ailtireacht táirgthe agus d'inmharthanacht an-bhreá.

A bheith ar an eolas ar an ceithre chineál soláthróra (`useClass`, `useValue`, `useFactory`, `useExisting`), ar conas a oibríonn comhéigeantaí insteallta le haghaidh cleachtais neamhdhoshartha, agus cén uair a bhá bhreá agus gach ceann a bhaint amach, is céim thábhachtach ar bhraistint ar DI bunúsach — is é seo an chaoi ina bhfuil tú ag socrú dátabhaísí, seirbhísí seachtracha, cumraitheachta, agus cleachtais sofhéachta/brégtha ar bhealach idiomasúil NestJS, agus é a dhéanamh ábhar riachtanach go fíor, ábhar architectúrtha suntasach i bhfíor-thairbhí.