I NestJS är en provider vilken klass som helst som kan injiceras som ett beroende, och en service är den vanligaste typen — en klass som innehåller affärslogik. Om du markerar en klass med @Injectable() gör det den till en provider som NestJS:s DI-system kan skapa och injicera.
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; }
}
Dekoratören @Injectable() talar om för NestJS att denna klass deltar i dependency injection — den kan injiceras i controllers eller andra providers.
@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
}
}
Du deklarerar beroendet som en konstruktorparameter; NestJS skapar och tillhandahåller instansen — du skriver aldrig 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 {}
Providers måste registreras i en moduls providers-array för att DI ska veta om dem, och exports delar dem med andra moduler.
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.
Providers och services är kärnan i NestJS:s arkitektur och dess dependency-injection-drivna design.
Services innehåller programmets affärslogik, åtskild från controllers (som hanterar endast HTTP-frågor) — denna separation of concerns gör logiken återanvändbar över controllers, lätt testbar isolerat och väl organiserad.
Att förstå att @Injectable() markerar en klass som en injicerbar provider, att providers registreras i moduler och injiceras via konstruktorer (DI skapar instanserna åt dig), och att de är singletons som standard är grundläggande daglig NestJS-kunskap.
Provider/service-mönstret, kombinerat med controllers och moduler, är ryggraden i varje NestJS-applikation — att behärska det är essentiellt för att bygga väl strukturerade, underhållbara back-ändar och är bland de första koncept man bör lära sig i ramverket.