I NestJS er en provider enhver klasse, der kan injiceres som en afhængighed, og en service er den mest almindelige type — en klasse, der indeholder forretningslogik. Marking af en klasse med @Injectable() gør den til en provider, som NestJS DI-systemet kan oprette og injicere.
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; }
}
Dekoratoren @Injectable() fortæller NestJS, at denne klasse deltager i dependency injection — den kan injiceres i controllere eller andre providere.
@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 erklærer afhængigheden som en konstruktørparameter; NestJS opretter og leverer 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 {}
Providere skal registreres i et moduls providers-array, så DI er klar over dem, og exports deler dem med andre 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.
Providere og services er centrale for NestJS's arkitektur og dens dependency-injection-drevne design.
Services indeholder applikationens forretningslogik, adskilt fra controllere (som kun håndterer HTTP-problemer) — denne separation of concerns gør logikken genbrug mulig på tværs af controllere, let testbar isoleret og velorganiseret.
Forståelsen af, at @Injectable() markerer en klasse som en injicerbar provider, at providere registreres i moduler og injiceres via konstruktører (DI opretter instanserne for dig), og at de er singletons som standard, er fundamental daglig NestJS-viden.
Provider/service-mønsteret kombineret med controllere og moduler er ryggraden for ethvert NestJS-applikation — at mestre det er væsentlig for at bygge velstrukturerede, vedligeholdelige backends og er blandt de første begreber at lære i frameworket.