Laravel

Aprende Laravel: Controllers

Autorangel cruz
Actualizado
Publicado
Lectura4 min de lectura
Aprende Laravel: Controllers

En los posts anteriores hemos visto cómo crear rutas y vistas. En este toca organizar la lógica de la aplicación con Controllers.

¿Qué es un Controller?

Un Controller es una clase PHP que agrupa la lógica relacionada con las solicitudes HTTP. En lugar de definir toda la lógica en las rutas (usando closures), puedes organizarla en clases Controller.

Con Controllers el código queda ordenado y es fácil de encontrar, puedes reutilizar métodos en diferentes rutas, y testear una clase es más fácil que testear un closure.

Controllers vs Route Closures

Cuando defines una ruta simple, puedes usar un closure:

Route::get('/posts', function () {
    $posts = Post::all();
    return view('posts.index', compact('posts'));
});

Pero a medida que tu aplicación crece, es mejor usar Controllers:

Route::get('/posts', [PostController::class, 'index']);

Una regla simple: si tu lógica tiene más de 2-3 líneas, usa un Controller.

Creando tu primer controller

Laravel incluye el comando Artisan make:controller para crear controllers rápidamente:

php artisan make:controller PostController

Esto creará un archivo app/Http/Controllers/PostController.php:

<?php
 
namespace App\Http\Controllers;
 
use Illuminate\Http\Request;
 
class PostController extends Controller
{
    // Tus métodos van aquí
}

Anatomía de un Controller

Un Controller típico tiene varios actions (métodos públicos) que manejan diferentes solicitudes:

<?php
 
namespace App\Http\Controllers;
 
use App\Models\Post;
use Illuminate\Http\Request;
 
class PostController extends Controller
{
    public function index()
    {
        $posts = Post::all();
        return view('posts.index', compact('posts'));
    }
 
    public function show(Post $post)
    {
        return view('posts.show', compact('post'));
    }
}

Convenciones de naming:

  • Controller names: PostController, UserController (singular o plural, tú decides)
  • Actions: index, create, store, show, edit, update, destroy

Resource Controllers

Laravel facilita la creación de controllers CRUD (Create, Read, Update, Delete) con el flag --resource:

php artisan make:controller PostController --resource

Esto genera un controller con 7 métodos estándar:

class PostController extends Controller
{
    public function index()     // GET /posts
    public function create()    // GET /posts/create
    public function store()     // POST /posts
    public function show($id)   // GET /posts/{id}
    public function edit($id)   // GET /posts/{id}/edit
    public function update($id) // PUT/PATCH /posts/{id}
    public function destroy($id)// DELETE /posts/{id}
}

Para conectar todas estas rutas automáticamente:

Route::resource('posts', PostController::class);

Con esa sola línea registras las 7 rutas. Route::resource() es perfecta para operaciones CRUD estándar.

Controller actions en detalle

Cada action del resource controller:

1. index - Lista todos los recursos:

public function index()
{
    $posts = Post::latest()->paginate(10);
    return view('posts.index', compact('posts'));
}

2. create - Muestra el formulario de creación:

public function create()
{
    return view('posts.create');
}

3. store - Guarda el nuevo recurso:

public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|max:255',
        'content' => 'required',
    ]);
 
    Post::create($validated);
 
    return redirect()->route('posts.index')
        ->with('success', 'Post creado exitosamente!');
}

4. show - Muestra un recurso específico:

public function show(Post $post)
{
    return view('posts.show', compact('post'));
}

5. edit - Muestra el formulario de edición:

public function edit(Post $post)
{
    return view('posts.edit', compact('post'));
}

6. update - Actualiza el recurso:

public function update(Request $request, Post $post)
{
    $validated = $request->validate([
        'title' => 'required|max:255',
        'content' => 'required',
    ]);
 
    $post->update($validated);
 
    return redirect()->route('posts.show', $post)
        ->with('success', 'Post actualizado!');
}

7. destroy - Elimina el recurso:

public function destroy(Post $post)
{
    $post->delete();
 
    return redirect()->route('posts.index')
        ->with('success', 'Post eliminado!');
}

Dependency Injection en Controllers

Laravel automáticamente inyecta dependencias en los métodos del controller. Por ejemplo, el objeto Request:

public function store(Request $request)
{
    // Laravel automáticamente inyecta Request
    $title = $request->input('title');
    // ...
}

También funciona con Models (Route Model Binding):

public function show(Post $post)
{
    // Laravel automáticamente busca el Post por ID
    return view('posts.show', compact('post'));
}

Single Action Controllers

Si un controller solo tiene una acción, puedes usar un Invokable Controller:

php artisan make:controller ShowDashboard --invokable

Esto crea un controller con un método mágico __invoke:

class ShowDashboard extends Controller
{
    public function __invoke()
    {
        $stats = // ... obtener estadísticas
        return view('dashboard', compact('stats'));
    }
}

Y lo usas en rutas así:

Route::get('/dashboard', ShowDashboard::class);

Los Invokable Controllers sirven para acciones únicas que no encajan en un CRUD estándar (ej: exportar PDF, procesar webhook, generar reporte).

Evita "Fat Controllers"

Un error común es poner toda la lógica de negocio en los controllers:

// MAL - Controller muy pesado
public function store(Request $request)
{
    $validated = $request->validate([...]);
 
    // Mucha lógica de negocio aquí
    $user = User::create($validated);
    Mail::to($user)->send(new WelcomeEmail());
    $user->assignRole('subscriber');
    event(new UserRegistered($user));
    // ... 50 líneas más
 
    return redirect()->route('home');
}

Es mejor delegar la lógica compleja a Services o Actions:

// MEJOR - Controller delgado
public function store(Request $request, RegisterUserService $service)
{
    $validated = $request->validate([...]);
 
    $user = $service->register($validated);
 
    return redirect()->route('home')
        ->with('success', 'Bienvenido!');
}

El controller solo debe:

  1. Validar input
  2. Llamar a services/models
  3. Retornar una respuesta (view, redirect, json)

Personalizando resource routes

Puedes limitar qué rutas generar con only o except:

// Solo index y show
Route::resource('posts', PostController::class)
    ->only(['index', 'show']);
 
// Todas excepto delete
Route::resource('posts', PostController::class)
    ->except(['destroy']);

También puedes cambiar los nombres de las rutas:

Route::resource('posts', PostController::class)
    ->names([
        'index' => 'posts.all',
        'show' => 'posts.detail',
    ]);

PHP Attributes en Laravel 13

Laravel 13 introduce soporte nativo para PHP Attributes en controllers. En lugar de implementar la interfaz HasMiddleware con su método estático middleware(), puedes declarar el middleware directamente sobre la clase o el método:

use Illuminate\Routing\Attributes\Controllers\Middleware;
 
#[Middleware('auth')]
class PostController extends Controller
{
    #[Middleware('subscribed')]
    public function create()
    {
        return view('posts.create');
    }
}

También puedes usar #[Authorize] para políticas:

use App\Models\Post;
use Illuminate\Routing\Attributes\Controllers\Authorize;
use Illuminate\Routing\Attributes\Controllers\Middleware;
 
#[Middleware('auth')]
class PostController extends Controller
{
    #[Authorize('update', 'post')]
    public function edit(Post $post)
    {
        return view('posts.edit', compact('post'));
    }
}

El segundo argumento de #[Authorize] es el nombre del parámetro de ruta ('post'), así la policy recibe el modelo ya resuelto; con una clase, como Post::class, sirve para acciones sin instancia como create.

Ambas formas son válidas en Laravel 13. Los attributes son opcionales y no reemplazan a la interfaz HasMiddleware.

Siguiente paso

En el próximo post vemos cómo trabajar con la base de datos usando Models y Eloquent ORM: crear, leer, actualizar y eliminar datos.

¿Necesitas ayuda con tu proyecto Laravel? Ofrezco servicios de desarrollo Laravel con arquitectura SOLID, APIs RESTful escalables y código mantenible a largo plazo.

Preguntas frecuentes

¿Por qué usar Controllers en lugar de closures en rutas?

Porque separan la lógica de las rutas, un mismo método puede usarse en varias rutas y testear clases es más fácil que testear closures. En un proyecto que crece, eso hace que el código sea más fácil de mantener.

¿Cómo creo un Controller en Laravel?

Usa el comando Artisan php artisan make:controller PostController. Para crear un resource controller con los 7 métodos CRUD automáticos, usa php artisan make:controller PostController --resource.

¿Qué son los Resource Controllers?

Son controllers con 7 métodos estándar para operaciones CRUD: index (lista), create (formulario crear), store (guardar), show (ver uno), edit (formulario editar), update (actualizar), destroy (eliminar). Una línea Route::resource('posts', PostController::class) genera las 7 rutas automáticamente.

¿Qué es Dependency Injection en Controllers?

Laravel automáticamente inyecta dependencias en los métodos del controller. Por ejemplo, en public function store(Request $request), Laravel inyecta el objeto Request automáticamente. También funciona con Models vía Route Model Binding.

¿Qué es un Invokable Controller?

Es un controller con un único método __invoke() para una sola acción. Perfecto para acciones que no encajan en CRUD estándar (exportar PDF, procesar webhook, generar reporte). Se crea con php artisan make:controller ShowDashboard --invokable y se usa como Route::get('/dashboard', ShowDashboard::class).

Fuentes

¿Tienes un proyecto en mente?

Trabajo con Laravel, WordPress, SEO técnico y servidores MCP. El primer paso es una llamada de descubrimiento, sin costo ni compromiso, donde me cuentas qué necesitas y te digo con honestidad si puedo ayudarte.

Hablemos