Skip to content

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.