NestJS-இல், ஒரு provider என்பது dependency ஆக inject செய்யக்கூடிய எந்த class-ஆகும், மற்றும் ஒரு service என்பது மிகவும் பொதுவான வகை — business logic-ஐ வைத்திருக்கும் ஒரு class. ஒரு class-ஐ @Injectable() என குறிப்பது அதை NestJS-இன் DI system உருவாக்கி inject செய்யக்கூடிய provider ஆக மாற்றுகிறது.
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; }
}
@Injectable() decorator இந்த class dependency injection-இல் பங்கேற்கிறது என்று NestJS-க்கு கூறுகிறது — இதை controllers-இலோ அல்லது மற்ற providers-இலோ inject செய்யலாம்.
@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
}
}
நீங்கள் dependency-ஐ ஒரு constructor parameter ஆக அறிவிக்கிறீர்கள்; NestJS instance-ஐ உருவாக்கி வழங்குகிறது — நீங்கள் ஒருபோதும் 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-ஐ DI அறிந்துகொள்ள ஒரு module-இன் providers array-இல் பதிவு செய்ய வேண்டும், மற்றும் exports அவற்றை மற்ற modules-உடன் பகிர்கிறது.
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 மற்றும் services என்பது NestJS-இன் architecture மற்றும் அதன் dependency-injection-driven வடிவமைப்பின் மையமாகும்.
Services applicationஇன் business logic-ஐ வைத்திருக்கின்றன, controllers-இலிருந்து தனியாக வைக்கப்படுகின்றன (அவை HTTP தொடர்பான விஷயங்களை மட்டும் கையாளுகின்றன) — இந்த separation of concerns logic-ஐ பல controllers-இல் மறுபயன்படுத்தக்கூடியதாகவும், தனிமையில் எளிதாக testable ஆகவும், நன்கு ஒழுங்கமைக்கப்பட்டதாகவும் ஆக்குகிறது.
@Injectable() ஒரு class-ஐ injectable provider ஆக குறிக்கிறது என்பதையும், providers modules-இல் பதிவு செய்யப்பட்டு constructors மூலம் inject செய்யப்படுகின்றன என்பதையும் (DI உங்களுக்காக instances-ஐ உருவாக்குகிறது), அவை default ஆக singletons என்பதையும் புரிந்துகொள்வது அடிப்படையான தினசரி NestJS அறிவு.
Provider/service pattern, controllers மற்றும் modules-உடன் இணைந்து, ஒவ்வொரு NestJS application-இன் முதுகெலும்பாகும் — அதை தேர்ச்சி பெறுவது நன்கு கட்டமைக்கப்பட்ட, maintainable back-ends-ஐ உருவாக்க அத்தியாவசியம் மற்றும் framework-இல் கற்க வேண்டிய முதல் கருத்துக்களில் ஒன்று.