În NestJS, un furnizor este orice clasă care poate fi injectată ca o dependență, iar un serviciu este cel mai comun tip — o clasă care conține logica de afaceri. Marcarea unei clase cu @Injectable() o face un furnizor pe care sistemul DI al NestJS îl poate crea și injecta.
import { Injectable } from "@nestjs/common";
@Injectable() // marks the class as a provider (injectable)
export class UsersService {
private users = [];
findAll() { return this.users; } // business logic
findOne(id: string) { return this.users.find(u => u.id === id); }
create(data) { this.users.push(data); return data; }
}
Decoratorul @Injectable() spune NestJS că această clasă participă la injecția de dependențe — poate fi injectată în controllere sau alți furnizori.
@Controller("users")
export class UsersController {
// NestJS sees this parameter and INJECTS a UsersService instance automatically
constructor(private usersService: UsersService) {}
@Get()
findAll() {
return this.usersService.findAll(); // use the injected service
}
}
Declarați dependența ca parametru al constructorului; NestJS creează și furnizează instanța — nu scrieți niciodată new UsersService().
@Module({
controllers: [UsersController],
providers: [UsersService], // register the provider so DI can resolve it
exports: [UsersService], // make it available to OTHER modules that import this one
})
export class UsersModule {}
Furnizurii trebuie înregistrați în matricea providers a unui modul pentru ca DI să-i cunoască, iar exports le partajează cu alte module.
By default, NestJS creates ONE shared instance of each provider (singleton scope)
for the whole application → efficient, shared state.
(Other scopes exist: REQUEST-scoped, TRANSIENT — but singleton is the default.)
Controller → handles HTTP (routing, request/response)
Service → handles business logic (rules, data access, computations)
→ Separation makes logic REUSABLE (multiple controllers can use one service),
TESTABLE (test the service in isolation), and ORGANIZED.
Furnizurii și serviciile sunt esențiali pentru arhitectura NestJS și designul său condus de injecția de dependențe.
Serviceurile dețin logica de afaceri a aplicației, separată de controllere (care se ocupă doar de problemele HTTP) — această separare a preocupărilor face logica reutilizabilă pe mai mulți controllere, ușor de testat în izolare și bine organizată.
Înțelegerea că @Injectable() marchează o clasă ca furnizor injectabil, că furnizorii sunt înregistrați în module și injectați prin constructori (DI creând instanțele pentru voi), și că sunt singletoni în mod implicit, este cunoaștere fundamentală a NestJS pe care o folosiți zilnic.
Modelul furnizor/serviciu, combinat cu controllere și module, este coloana vertebrală a fiecărei aplicații NestJS — stăpânirea acestuia este esențială pentru construirea back-endurilor bine structurate și ușor de întreținut și este printre primele concepte de învățat în framework.