Laravel లో controllers అంటే ఏమిటి?

Question

Accepted Answer

**Controllers** సంబంధిత request-handling logic ను క్లాసులలో సమూహపరుస్తాయి. అన్ని logic ను route closures లో ఉంచే బదులుగా, controllers అనువర్తనం యొక్క చర్యలను (ఉదా. అన్ని user-సంబంధిత కార్యకలాపాలు) పద్ధతులలో నిర్వహిస్తాయి — routes నిర్మలంగా మరియు code నిర్వహించబడుతుంది.

## ప్రాథమిక controller

```php
<?php
class UserController extends Controller {
    public function index() {
        return User::all();              // list users
    }
    public function show(User $user) {   // route model binding — auto-fetch by id
        return $user;
    }
    public function store(Request $request) {
        $validated = $request->validate(['name' => 'required', 'email' => 'required|email']);
        return User::create($validated);  // create
    }
}
```

Artisan ద్వారా ఒకటి రూపొందించండి: `php artisan make:controller UserController`. ప్రతి method ఒక చర్యను నిర్వహిస్తుంది, మరియు routes వాటిని సూచిస్తాయి.

## Resource controllers (RESTful CRUD)

```php
// generate a controller with all 7 RESTful methods stubbed
// php artisan make:controller PostController --resource

Route::resource('posts', PostController::class);   // maps routes to the methods:
// index() create() store() show() edit() update() destroy()
```

A **resource controller** ప్రామాణిక CRUD methods ను కలిగి ఉంది, `Route::resource` తో జత చేయబడింది సాంప్రదాయిక RESTful routing కోసం — విలక్షణమైన CRUD resources కోసం minimal boilerplate.

## Controllers లో Dependency injection

```php
class OrderController extends Controller {
    // type-hinted dependencies are AUTO-INJECTED by Laravel's service container
    public function __construct(private OrderService $orders) {}

public function store(Request $request, Mailer $mailer) {   // method injection too
        // $request and $mailer are resolved & injected automatically
    }
}
```

Laravel యొక్క service container **స్వయంచాలకంగా injects** type-hinted dependencies ని controller constructors మరియు methods లో (`Request` సహా) — clean, testable code.

## Controllers ను thin ఉంచండి

```text
✓ Controllers should handle HTTP concerns (validate input, call services, return responses)
✗ Business logic belongs in SERVICES/models, not bloated controllers ("thin controllers")
```

## ఇది ఎందుకు ముఖ్యమైనది

Controllers ఒక core Laravel building block — వారు request-handling logic ను cohesive classes లోకి నిర్వహిస్తారు, ఇది trivial routes కంటే ఎక్కువ ఏదైనా అనువర్తనం కోసం అవసరం.

Controllers ను ఎలా సృష్టించాలి, routes ను వాటి methods కు ఎలా నిర్దేశిస్తాయో, మరియు ముఖ్యంగా `Route::resource` తో **resource controllers** ఉపయోగించాలో (సాంప్రదాయిక RESTful CRUD కోసం minimal boilerplate తో) అర్థం చేసుకోవడం Laravel apps నిర్మించడానికి రోజువారీ జ్ఞానం.

ఒక key Laravel feature **automatic dependency injection** service container ద్వారా controllers లోకి — type-hinted dependencies (services, request, mailers) స్వయంచాలకంగా resolved మరియు injected చేయబడతాయి, clean, testable, loosely-coupled code ను సక్షమ చేస్తుంది.

సమానంగా ముఖ్యమైనది controllers **thin** ఉంచే best practice — HTTP concerns (validation, services ను కాల్ చేయడం, responses రిటర్న చేయడం) మాత్రమే నిర్వహించడం మరియు business logic ను services/models కు delegate చేయడం, ఇది code ని maintainable మరియు testable ఉంచుతుంది.

Controllers, routing మరియు models కలిసి, Laravel యొక్క request handling యొక్క backbone ను ఏర్పరుస్తాయి, వాటిని well-organized, professional Laravel applications నిర్మించడానికి సంబంధమైన చేస్తాయి.