5.4 Estructura y Elementos de un Proyecto Laravel

5.4.1 Introducción al Patrón MVC en Laravel

Laravel sigue el patrón MVC (Modelo - Vista - Controlador), una forma de organizar el código para separar responsabilidades:

Modelos (M): Representan los datos y la lógica de negocio. Se encuentran en app/Models.
Vistas (V): Son las pantallas o interfaces que verá el usuario. Están en resources/views.
Controladores (C): Gestionan la lógica de la aplicación, recibiendo las peticiones y devolviendo respuestas. Están en app/Http/Controllers.
Rutas: Definen por dónde accede el usuario a cada funcionalidad. Se configuran en routes/web.php.

Esquema MVC en Laravel

graph TD
  Usuario -->|Solicita| Rutas
  Rutas -->|Delegan| Controladores
  Controladores -->|Consultan| Modelos
  Modelos -->|Datos| BaseDeDatos
  Controladores -->|Devuelven| Vistas

Esta separación facilita el mantenimiento, la escalabilidad y la organización del código.

5.4.2 Estructura del Proyecto Laravel

Dividimos la estructura en dos bloques: elementos MVC y otras carpetas importantes.

Elementos principales (MVC)

Carpeta/Archivo	Descripción
`app/Models/`	Modelos de la base de datos. Ej: `User.php`.
`resources/views/`	Plantillas Blade que generan el HTML.
`app/Http/Controllers/`	Lógica que maneja las peticiones HTTP.
`routes/web.php`	Archivo donde se definen las rutas para clientes web.

Otras carpetas y archivos importantes

Carpeta/Archivo	Descripción detallada
`app/`	Contiene la lógica de la aplicación: controladores, modelos, middleware.
`bootstrap/`	Carga inicial de la aplicación. Incluye `app.php`.
`config/`	Archivos de configuración de todo el sistema: base de datos, correo, sesiones, etc.
`database/`	Contiene migraciones, seeders y fábricas de datos para pruebas.
`public/`	Carpeta pública servida por Nginx. Contiene `index.php`, CSS, JS públicos.
`storage/`	Archivos generados automáticamente: logs, caché, ficheros temporales, subidas de usuarios.
`tests/`	Tests unitarios y funcionales para automatizar comprobaciones del proyecto.
`.env`	Archivo oculto que define las variables de entorno (configuraciones sensibles).
vendor/	Carpeta generada por Composer que contiene todas las dependencias del proyecto.
`artisan`	Comando CLI propio de Laravel para realizar tareas de desarrollo dentro del proyecto.
`composer.json`	Archivo que define todas las dependencias PHP del proyecto (gestor Composer).

Dentro de app/ podemos encontrar:

Carpeta/Archivo	Descripción
`Http/`	Contiene controladores y middleware.
`Models/`	Contiene los modelos de la base de datos.
`Console/`	Contiene comandos personalizados de Artisan.

Dentro de config/ podemos encontrar:

Carpeta/Archivo	Descripción
`app.php`	Configuración de la aplicación.
`database.php`	Configuración de la base de datos.
`mail.php`	Configuración del correo electrónico.
`session.php`	Configuración de sesiones.
`auth.php`	Configuración de autenticación.

Dentro de database/ podemos encontrar:

Carpeta/Archivo	Descripción
`migrations/`	Archivos que definen la estructura de las tablas de la base de datos.
`seeders/`	Archivos que permiten poblar la base de datos con datos iniciales.
`factories/`	Archivos que permiten crear datos de prueba para los modelos.

Dentro de storage/ podemos encontrar:

Carpeta/Archivo	Descripción
`app/`	Archivos subidos por los usuarios.
`framework/`	Archivos generados automáticamente por Laravel.
`logs/`	Archivos de registro de errores y eventos.

Dentro de tests/ podemos encontrar:

Carpeta/Archivo	Descripción
`Feature/`	Tests funcionales que comprueban el comportamiento de la aplicación.
`Unit/`	Tests unitarios que comprueban la lógica de los modelos y controladores.

Dentro de public/ podemos encontrar:

Carpeta/Archivo	Descripción
`css/`	Archivos CSS públicos.
`js/`	Archivos JavaScript públicos.
`index.php`	Punto de entrada a la aplicación.
`favicon.ico`	Icono de la página web.
`robots.txt`	Archivo que indica a los motores de búsqueda qué páginas indexar.
`htaccess`	Archivo de configuración de Apache (no usado en nuestro caso).

5.4.3 Instalación del Comando `laravel`

Laravel dispone de una interfaz de línea de comandos (CLI) para facilitar tareas de creación de proyectos y componentes.

Instalar el instalador de Laravel globalmente

Dentro del contenedor PHP, puedes instalar el instalador de Laravel si quieres crear proyectos más rápidamente:

Instalador de Laravel

Recuerda que en nuestro caso la instalación de laravel la tenemos que hacer dentro del contenedor PHP. docker exec -it php bash y luego ejecutar el siguiente comando.

composer global require laravel/installer

Esto instalará el comando laravel de forma global.

Diferencias entre `laravel` y `php artisan`

laravel:
- Se usa principalmente fuera de los proyectos.
- Sirve para crear nuevos proyectos:

Ejemplos de uso del comando laravel:

Crear un nuevo proyecto Laravel

laravel new nombre-del-proyecto

Comprobar la versión de Laravel instalada

laravel --version

php artisan: Se usa dentro de un proyecto Laravel ya creado.

Comando php artisan

Recuerda que en nuestro caso la instalación de laravel la tenemos que hacer dentro del contenedor PHP. docker exec -it php bash y luego ejecutar el siguiente comando.

Algunos ejemplos de uso del comando php artisan (los veremos más adelante):

Crear un nuevo controlador

php artisan make:controller NombreControlador

Crear un nuevo modelo

php artisan make:model NombreModelo

Crear un nuevo recurso (controlador + rutas)

php artisan make:controller NombreControlador --resource

Crear un nuevo middleware

php artisan make:middleware NombreMiddleware

Crear un nuevo comando de consola

php artisan make:controller NombreControlador

Crear una nueva migración

php artisan make:migration crear_tabla_usuarios

Crear un nuevo seeder

php artisan route:list

Importante

En este curso nos centraremos principalmente en php artisan, ya que nuestro proyecto ya está creado.

5.4.4 Clase `Route` en Laravel

La clase Route permite definir cómo responde nuestra aplicación a las diferentes URLs.

Hay dos grandes tipos de rutas:

Rutas web: Se definen en routes/web.php y manejan peticiones de navegadores tradicionales.
Rutas API: Se definen en routes/api.php y están pensadas para ser usadas por clientes REST (apps móviles, servicios externos).

Rutas API

A partir de la versión 12 de laravel el fichero routes/api.php no se instala en el proyecto por defecto. En el tema 10 trataremos las rutas API y veremos cómo crearlas.

Algunos métodos estáticos principales de Route:

`Route::get()`

Responde a peticiones HTTP GET (páginas web).

Route::get('/home', function () {
    return view('home');
});

`Route::post()`

Responde a peticiones HTTP POST (envíos de formularios).

Route::post('/submit', function () {
    return 'Formulario enviado';
});

`Route::put()`

Actualiza recursos existentes, utilizado en APIs REST.

Route::put('/profile', function () {
    return 'Perfil actualizado';
});

`Route::delete()`

Elimina recursos, utilizado en APIs REST.

Route::delete('/post', function () {
    return 'Publicación eliminada';
});

`Route::view()`

Devuelve una vista simple sin necesidad de un controlador. Se utiliza para páginas estáticas, páginas que no requieren lógica adicional o acceso a la base de datos.

Route::view('/', 'welcome');

Uso frecuente

Route::view() es muy útil para páginas estáticas como "Sobre nosotros", "Contacto", "FAQ", etc.

5.4.5 Crear dos vistas usando `Route::view()`

Vamos a crear dos páginas simples utilizando Route::view().

1. Crear las vistas

Dentro de resources/views/, crea una carpeta landing:

resources/views/landing/

Dentro de landing/, crea dos archivos:

resources/views/landing/index.blade.php

<h1>Bienvenido a nuestra página principal</h1>

resources/views/landing/about.blade.php

<h1>Sobre nosotros</h1>

Es importante que las extensiones de los archivos sean .blade.php, ya que Laravel utiliza el motor de plantillas Blade para procesar estas vistas. Aunque luego en el enrutador no se vean las extensiones, Laravel las procesa como plantillas. Por ejemplo si tenemos el archivo:

index.blade.php, en el enrutador lo llamaremos index y no index.blade.php.
/user/index.blade.php, en el enrutador lo llamaremos user.index y no user/index.blade.php.

En el último caso resaltar el uso de un . para separar la carpeta de la vista. Esto es importante porque Laravel utiliza el punto como separador de carpetas al buscar las vistas.

2. Definir las rutas

Edita el archivo routes/web.php y añade:

Route::view('/', 'landing.index')-> name('index');
Route::view('/about', 'landing.about')-> name('about');

A las rutas les hemos dado un nombre para poder referenciarlas más fácilmente en el futuro. Esto nos será de mucha utilidad más adelate.

3. Probar las rutas

Accede a http://localhost:8080/ para ver la página principal.
Accede a http://localhost:8080/about para ver la página "Sobre nosotros".

Felicitaciones

¡Ya has creado tu primera pequeña web usando Laravel, rutas y vistas Blade!

Nota sobre `php artisan serve`

¿Usar php artisan serve?

En nuestro entorno con Docker NO usamos php artisan serve.

Ya tenemos configurado Nginx como servidor web. php artisan serve solo se utiliza en entornos locales simples (sin Docker, sin Nginx).

Todo el acceso debe ser a través de http://localhost:8080 utilizando Nginx.

5.4 Estructura y Elementos de un Proyecto Laravel

5.4.1 Introducción al Patrón MVC en Laravel

5.4.2 Estructura del Proyecto Laravel

Elementos principales (MVC)

Otras carpetas y archivos importantes

5.4.3 Instalación del Comando laravel

Instalar el instalador de Laravel globalmente

Diferencias entre laravel y php artisan

5.4.4 Clase Route en Laravel

Route::get()

Route::post()

Route::put()

Route::delete()

Route::view()

5.4.5 Crear dos vistas usando Route::view()