சேவை கொள்ளளவு (service container) மற்றும் சார்பு செலுத்தல் (dependency injection) என்றால் என்ன?

Question

Accepted Answer

**சேவை கொள்ளளவு** (IoC container) என்பது Laravel இன் இதயம் — இது **சார்பு செலுத்தல்** ஐ நிர்வகிக்கிறது, வகுப்பு சார்புகளை தானாக தீர்க்கிறது மற்றும் செலுத்துகிறது. நீங்கள் உங்களுக்குத் தேவையானものை type-hint செய்கிறீர்கள், மற்றும் கொள்ளளவு அதை உருவாக்கி வழங்குகிறது, இது느슨்டையாக-இணைக்கப்பட்ட, சோதனை செய்யக்கூடிய குறியீடை செயல்படுத்துகிறது.

## தானாக சார்பு செலுத்தல் (பொதுவான வழக்கு)

```php
class OrderController extends Controller {
    // type-hinted dependencies are AUTO-RESOLVED by the container — no manual `new`
    public function __construct(
        private OrderService $orders,
        private PaymentGateway $payments,
    ) {}

public function store(Request $request, Mailer $mailer) {
        // $request and $mailer also auto-injected into the method
    }
}
```

கொள்ளளவு constructor (மற்றும் method) type-hints ஐ படித்து **தானாக சார்புகளை உருவாக்கி செலுத்துகிறது** — அவற்றின் சார்புகளை recursively தீர்க்கிறது. நீங்கள் சேவைகளுக்கு `new` ஐ அரிதாகவே அழைக்கிறீர்கள்; கொள்ளளவு எல்லாவற்றையும் இணைக்கிறது.

## இணைப்புகளை இடைமுகங்களுக்கு பிணைத்தல்

```php
// in a service provider — tell the container which implementation to use for an interface
$this->app->bind(PaymentGateway::class, StripeGateway::class);

// now anything type-hinting PaymentGateway gets a StripeGateway
class OrderService {
    public function __construct(private PaymentGateway $gateway) {}   // gets StripeGateway
}
```

**இடைமுகத்தை செயல்படுத்தலுக்கு** பிணைப்பது உங்களை abstractions ஐ சார்ந்து இருக்க அनुమति देয் — மற்றும் செயல்படுத்தல் (e.g. சோதனைகளில் fake gateway) மாற்றவும் நுகரும் குறியீடை மாற்றாமல்.

## Singletons மற்றும் கைமுறையாக தீர்தல்

```php
$this->app->singleton(Cache::class, fn() => new RedisCache());   // ONE shared instance

// manual resolution (rarely needed — DI is preferred)
$service = app(OrderService::class);
$service = resolve(PaymentGateway::class);
```

`singleton` ஒரு ஒற்றை பகிரப்பட்ட instance ஐ பதிவு செய்கிறது; `app()`/`resolve()` கொள்ளளவிலிருந்து கைமுறையாக பெறுகிறது.

## இது ஏன் முக்கியமானது

சேவை கொள்ளளவு மற்றும் சார்பு செலுத்தல் Laravel க்கு அடிப்படையான — அவை application இன் கூறுகளை இணைப்பது எப்படி, எனவே அவற்றைப் புரிந்துகொள்வது Laravel உடன் திறம்பட வேலை செய்வதற்கு மற்றும் நன்கு-வடிவமைக்கப்பட்ட குறியீடு எழுதுவதற்கு முக்கியமானது.

கொள்ளளவின் **தானாக சார்பு செலுத்தல்** பரவலாக உள்ளது: controllers, jobs, மற்றும் பிற வகுப்புகளில் type-hinted சார்புகள் தானாக தீர்க்கப்பட்டு செலுத்தப்படுகின்றன (முழு சார்பு graph ஐ உருவாக்குகிறது), இதனால் நீங்கள் சேவைகளை அரிதாகவே கைமுறையாக உதாரணம் செய்கிறீர்கள் — இது clean,느슨்டையாக-இணைக்கப்பட்ட, சோதனை செய்யக்கூடிய குறியீடை செயல்படுத்துகிறது.

**இடைமுகங்களை செயல்படுத்தல்களுக்கு பிணைப்பதற்கான** திறன் குறிப்பாக முக்கியமானது: abstractions (இடைமுகங்கள்) ஐ சார்ந்து இருக்க, concrete வகுப்புகளை அல்ல, கொள்ளளவு செயல்படுத்தல் வழங்குவதுடன், குறியீடை flexible (configuration மூலம் செயல்படுத்தல்களை மாற்று) மற்றும் அதிக **சோதனை செய்யக்கூடிய** (சோதனைகளில் mocks/fakes செலுத்து — ஒரு முக்கிய பலன்) செய்கிறது.

கொள்ளளவைப் புரிந்துகொள்வது (தானாக தீர்ப்பு, இடைமுக பிணைப்பு, singletons), DI Laravel இடம் எப்படி வேலை செய்கிறது, மற்றும் சோதனை செய்யக்கூடிய தன்மை மற்றும் loose coupling ஐ எப்படி செயல்படுத்துகிறது என்பது பராமரிக்கக்கூடிய applications கட்டமைப்பதற்கு மற்றும் Laravel தானே எப்படி இயங்குகிறது என்பதைப் புரிந்துகொள்வதற்கு மதிப்பான அறிவு.

சேவை கொள்ளளவு Laravel இன் முழு architecture ஐ அடிப்படையாக கொண்டுள்ளது — மற்றும் DI ஆதிக்य செய்வது clean, சோதனை செய்யக்கூடிய, framework-idiomatic குறியீடு எழுதுவதற்கு முக்கியமாகும் — நன்கு-வடிப்பட கொள்ளளவு பணிபுரியும் கீழ் அவர்கள் அறியாமலேயே tightly-coupled குறியீடு எழுதுபவர்களிலிருந்து Laravel ஐ deeply புரிந்துகொள்ளும் மற்றும் நன்கு-வடிவமைக்கப்பட்ட applications கட்டமைக்கும் developers ஐ வேறுபடுத்தும் முக்கியமான அறிவு.