In NestJS, un provider è qualsiasi classe che può essere iniettata come dipendenza, e un servizio è il tipo più comune — una classe che contiene logica di business. Marcando una classe con @Injectable() la si rende un provider che il sistema DI di NestJS può creare e iniettare.
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; }
}
Il decoratore @Injectable() comunica a NestJS che questa classe partecipa nell'iniezione delle dipendenze — può essere iniettata in controller o altri provider.
@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
}
}
Dichiari la dipendenza come parametro del costruttore; NestJS crea e fornisce l'istanza — non scrivi mai 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 {}
I provider devono essere registrati nell'array providers di un modulo affinché il DI li conosca, e exports li condivide con altri moduli.
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.
I provider e i servizi sono fondamentali per l'architettura di NestJS e per il suo design basato sull'iniezione delle dipendenze.
I servizi contengono la logica di business dell'applicazione, mantenuti separati dai controller (che gestiscono solo i problemi HTTP) — questa separazione delle responsabilità rende la logica riutilizzabile tra controller, facilmente testabile in isolamento e ben organizzata.
Capire che @Injectable() segna una classe come provider iniettabile, che i provider sono registrati in moduli e iniettati tramite costruttori (il DI che crea le istanze per te), e che sono singleton per impostazione predefinita è conoscenza fondamentale quotidiana di NestJS.
Il pattern provider/servizio, combinato con controller e moduli, è la spina dorsale di ogni applicazione NestJS — padroneggiarlo è essenziale per costruire back-end ben strutturati e manutenibili ed è tra i primi concetti da imparare nel framework.