Qué es MVC en Laravel y qué son los controladores MVC

El MVC (Modelo-Vista-Controlador) es un patrón de arquitectura de software que separa una aplicación en tres componentes interrelacionados. En Laravel, este patrón es fundamental para organizar el código de manera eficiente y facilitar el mantenimiento y escalabilidad de las aplicaciones web.

• El Modelo representa la capa de datos y lógica de negocio de la aplicación. Gestiona la interacción con la base de datos y define las reglas de negocio. En Laravel, los modelos suelen ubicarse en el directorio app/Models y suelen extender de la clase Illuminate\Database\Eloquent\Model.
• La Vista es la capa de presentación que se encarga de mostrar la información al usuario. En Laravel, las vistas suelen ser archivos Blade ubicados en el directorio resources/views. Utilizan el motor de plantillas Blade para generar contenido HTML dinámico.
• El Controlador actúa como intermediario entre el modelo y la vista. Gestiona las solicitudes HTTP del usuario, interactúa con los modelos para procesar datos y devuelve las respuestas apropiadas mediante las vistas. En Laravel, los controladores se ubican en el directorio app/Http/Controllers.

Los controladores MVC en Laravel son clases que agrupan la lógica relacionada con las solicitudes y respuestas de la aplicación. Facilitan la organización del código al separar la lógica de negocio de la presentación y permiten manejar las rutas de manera más sencilla.

Para crear un controlador en Laravel, se puede utilizar el comando artisan:

php artisan make:controller NombreDelControlador

Por ejemplo, para crear un controlador llamado ProductoController:

php artisan make:controller ProductoController

Este comando genera una clase de controlador básica en app/Http/Controllers/ProductoController.php. Dentro de este controlador, se pueden definir métodos que correspondan a diferentes acciones, como mostrar una lista de productos o crear uno nuevo.

Ejemplo de un controlador básico:

<?php

namespace App\Http\Controllers;

use App\Models\Producto;
use Illuminate\Http\Request;

class ProductoController extends Controller
{
    public function index()
    {
        $productos = Producto::all();
        return view('productos.index', ['productos' => $productos]);
    }
}

En este ejemplo, el método index recupera todos los registros de productos utilizando el modelo Producto y retorna la vista productos.index pasando los datos necesarios.

Al definir rutas en el archivo routes/web.php, se puede asociar una ruta al método del controlador:

use App\Http\Controllers\ProductoController;

Route::get('/productos', [ProductoController::class, 'index']);

De esta manera, cuando un usuario accede a la ruta /productos, Laravel invoca el método index del ProductoController.

Los controladores en Laravel también pueden aprovechar middleware, inyección de dependencias y otras características avanzadas del framework para construir aplicaciones robustas y seguras.

En resumen, el patrón MVC en Laravel proporciona una estructura clara y organizada para el desarrollo de aplicaciones web. Los controladores MVC son esenciales para gestionar la lógica de las solicitudes y mantener el código modular y mantenible.

Métodos GET sin y con parámetros y variables en MVC

En la arquitectura MVC de Laravel, los métodos GET se utilizan para manejar solicitudes HTTP que suelen recuperar y mostrar datos sin modificar el estado del servidor. Para responder a estas solicitudes, se definen rutas y se implementan métodos en los controladores correspondientes.

Para definir una ruta que responda a un método GET sin parámetros, se utiliza el método Route::get en el archivo routes/web.php:

use App\Http\Controllers\PaginaController;

Route::get('/inicio', [PaginaController::class, 'inicio']);

En este ejemplo, cuando un usuario accede a la URL /inicio, se invoca el método inicio del PaginaController. El controlador podría ser:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class PaginaController extends Controller
{
    public function inicio()
    {
        return view('inicio');
    }
}

Aquí, el método inicio simplemente retorna una vista llamada inicio, sin procesar datos adicionales.

Para manejar métodos GET con parámetros, se puede definir una ruta que incluya variables dinámicas. Por ejemplo:

Route::get('/usuarios/{id}', [UsuarioController::class, 'mostrar']);

En este caso, {id} es un parámetro de ruta que captura información de la URL. El controlador recibiría este parámetro de la siguiente manera:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Usuario;

class UsuarioController extends Controller
{
    public function mostrar($id)
    {
        $usuario = Usuario::findOrFail($id);
        return view('usuarios.mostrar', ['usuario' => $usuario]);
    }
}

El parámetro $id recibido en el método mostrar permite buscar un usuario específico en la base de datos utilizando el modelo Usuario. Si el usuario existe, se pasa a la vista para su visualización.

También es posible definir parámetros opcionales en las rutas utilizando el signo de interrogación ? y asignando un valor por defecto en el controlador:

Route::get('/productos/{categoria?}', [ProductoController::class, 'listar']);

En el controlador:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Producto;

class ProductoController extends Controller
{
    public function listar($categoria = null)
    {
        if ($categoria) {
            $productos = Producto::where('categoria', $categoria)->get();
        } else {
            $productos = Producto::all();
        }
        return view('productos.listar', ['productos' => $productos]);
    }
}

En este ejemplo, si se proporciona una categoría en la URL, se filtran los productos por esa categoría; de lo contrario, se muestran todos.

Para manejar variables de consulta (query strings), se utiliza el objeto Request, que permite acceder a los parámetros enviados a través de la URL después del signo de interrogación ?. Por ejemplo, para la ruta:

Route::get('/buscar', [BusquedaController::class, 'buscar']);

Y el controlador:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Articulo;

class BusquedaController extends Controller
{
    public function buscar(Request $request)
    {
        $termino = $request->input('q');
        $resultados = Articulo::where('titulo', 'like', "%{$termino}%")->get();
        return view('busqueda.resultados', ['resultados' => $resultados]);
    }
}

Aquí, mediante $request->input('q'), se obtiene el valor del parámetro de consulta q, que el usuario pudo haber ingresado en un formulario de búsqueda.

Es importante considerar las restricciones de parámetros para garantizar que los datos recibidos sean válidos. Laravel permite restringir los parámetros directamente en las rutas utilizando expresiones regulares:

Route::get('/orden/{numero}', [OrdenController::class, 'ver'])
     ->where('numero', '[0-9]+');

De este modo, el parámetro {numero} solo aceptará valores numéricos, mejorando la validación desde el nivel de las rutas.

Al utilizar métodos GET con parámetros, es esencial manejar correctamente las variables en los controladores para evitar errores y asegurar que la aplicación responde adecuadamente a diferentes tipos de solicitudes.

Para iniciar el servidor y probar estas rutas, se utiliza el servidor de artisan:

php artisan serve

Esto inicia el servidor en localhost en el puerto 8000, sirviendo la aplicación Laravel desde el directorio public.

En resumen, los métodos GET en controladores MVC permiten gestionar solicitudes tanto con como sin parámetros, ofreciendo flexibilidad para construir aplicaciones web dinámicas en Laravel. Los desarrolladores pueden definir rutas y controladores que respondan a diferentes necesidades, aprovechando las características del framework para mantener un código limpio y eficiente.

Métodos POST

En Laravel, los métodos POST se utilizan para manejar solicitudes HTTP que envían datos al servidor, como formularios de registro o actualización de información. Estos métodos permiten crear y modificar recursos de manera segura dentro de la aplicación.

Para definir una ruta que responda a una solicitud POST, se utiliza el método Route::post en el archivo routes/web.php:

use App\Http\Controllers\UsuarioController;

Route::post('/usuarios', [UsuarioController::class, 'almacenar']);

En este ejemplo, cuando un usuario envía datos a la URL /usuarios mediante una solicitud POST, se invoca el método almacenar del UsuarioController.

El controlador correspondiente podría ser:

<?php

namespace App\Http\Controllers;

use App\Models\Usuario;
use Illuminate\Http\Request;

class UsuarioController extends Controller
{
    public function almacenar(Request $request)
    {
        // Validar los datos del formulario
        $datosValidados = $request->validate([
            'nombre' => 'required|string|max:255',
            'correo' => 'required|email|unique:usuarios,correo',
            'contraseña' => 'required|string|min:8|confirmed',
        ]);

        // Crear un nuevo usuario
        $usuario = Usuario::create([
            'nombre' => $datosValidados['nombre'],
            'correo' => $datosValidados['correo'],
            'contraseña' => bcrypt($datosValidados['contraseña']),
        ]);

        // Redirigir con un mensaje de éxito
        return redirect('/usuarios')->with('status', 'Usuario creado exitosamente');
    }
}

En este código, el método almacenar utiliza el objeto Request para acceder a los datos enviados y realizar la validación correspondiente. La función validate aplica reglas para asegurar que los datos cumplen ciertos criterios antes de crear el nuevo recurso.

Al crear formularios en las vistas, es esencial especificar el método POST y utilizar la directiva @csrf para incluir el token CSRF, que protege contra ataques de Cross-Site Request Forgery:

<form action="/usuarios" method="POST">
    @csrf
    <label for="nombre">Nombre:</label>
    <input type="text" name="nombre" id="nombre" required>

    <label for="correo">Correo electrónico:</label>
    <input type="email" name="correo" id="correo" required>

    <label for="contraseña">Contraseña:</label>
    <input type="password" name="contraseña" id="contraseña" required>

    <label for="contraseña_confirmation">Confirmar Contraseña:</label>
    <input type="password" name="contraseña_confirmation" id="contraseña_confirmation" required>

    <button type="submit">Registrar</button>
</form>

La inclusión de name="contraseña_confirmation" y la regla confirmed en la validación garantizan que el usuario confirme su contraseña correctamente.

Para manejar archivos enviados mediante formularios, como imágenes o documentos, se utilizan las funcionalidades de Laravel para subir y almacenar archivos:

public function subirAvatar(Request $request)
{
    $request->validate([
        'avatar' => 'required|image|mimes:jpeg,png,jpg,gif|max:2048',
    ]);

    $nombreArchivo = time().'.'.$request->avatar->extension();

    $request->avatar->move(public_path('avatars'), $nombreArchivo);

    // Actualizar el perfil del usuario con el nombre del archivo
    // ...

    return back()->with('status', 'Avatar subido correctamente');
}

La ruta para este método se define en routes/web.php:

Route::post('/perfil/avatar', [PerfilController::class, 'subirAvatar']);

Al trabajar con métodos POST, es crucial gestionar correctamente los datos sensibles y aplicar prácticas de seguridad como la validación y el uso de tokens CSRF. Laravel facilita estas tareas proporcionando herramientas integradas que simplifican el proceso.

Además, es posible utilizar middleware para proteger rutas específicas y asegurarse de que solo usuarios autenticados puedan acceder a ciertos métodos:

Route::post('/comentarios', [ComentarioController::class, 'guardar'])->middleware('auth');

En este caso, el middleware auth verifica que el usuario esté autenticado antes de permitir el acceso al método guardar.

Para probar las rutas y métodos POST, se puede iniciar el servidor web integrado de PHP desde la raíz del proyecto Laravel:

php -S localhost:8000 -t public

Esto levanta la aplicación en http://localhost:8000, donde se pueden realizar pruebas de envío de formularios y ver cómo los datos son procesados por los controladores.

En resumen, los métodos POST desempeñan un papel fundamental en la manipulación de datos dentro de una aplicación Laravel. Al definir rutas adecuadas y utilizar las herramientas que el framework ofrece, se pueden manejar solicitudes POST de manera eficaz, manteniendo siempre un enfoque en la seguridad y la integridad de los datos.