Saltar al contenido
Portada » Lenguajes » 12. Introducción a Frameworks PHP

12. Introducción a Frameworks PHP

Introducción a Frameworks PHP. A medida que desarrollamos aplicaciones más completas con PHP es común que el código comience a crecer en extensión y complejidad. Esto puede generar dificultades para organizar los archivos, estructurar la lógica de la aplicación, reutilizar funciones, es por este motivo por el que tienen gran importancia lo frameworks de PHP.

En este capítulo haremos una pequeña introdución para que conozcas lo que son los framework y por qué deberías utilizarlos en tus proyectos. Veremos cómo estas herramientas ayudan a aplicar principios como el MVC (Modelo-Vista-Controlador), el enrutamiento, la gestión de dependencias, etc..

Nos enfocaremos en dos de los frameworks más populares y utilizados en la actualidad:

  • Laravel, conocido por su elegancia, sintaxis expresiva y enorme ecosistema de herramientas.
  • CodeIgniter, porpular por su ligereza y facilidad de uso.

También aprenderás cómo iniciar un proyecto básico con Laravel, configurarlo paso a paso y comprender la estructura de carpetas y archivos que utiliza este framework moderno.

12.1 ¿Qué es un framework y por qué usarlo?

¿Qué es un framework?

Un framework es un conjunto de herramientas, librerías y convenciones predefinidas que nos ayuda a construir aplicaciones de forma más rápida, ordenada y segura. Nos permite trabajar sobre una arquitectura estructurada, facilita la separación de responsabilidades, y nos ofrece soluciones integradas para tareas comunes como el manejo de rutas, el acceso a bases de datos, la validación de formularios o la autenticación de usuarios.

En lugar de construir una aplicación desde cero, un framework proporciona una serie de componentes ya preparados que nos ayudan a resolver tareas comunes como:

  • Gestión de rutas y URLs
  • Conexión y consulta a bases de datos
  • Manejo de sesiones y cookies
  • Validación y saneamiento de datos
  • Autenticación de usuarios
  • Generación de vistas (plantillas HTML)
  • Seguridad contra ataques (como inyección SQL o CSRF)
  • etc.

El uso de un framework nos obliga (en el buen sentido) a seguir ciertas reglas y estructuras que facilitan la colaboración entre desarrolladores, el mantenimiento del código a largo plazo y la escalabilidad de nuestros proyectos.

¿Por qué usar un framework?

Aunque es totalmente posible desarrollar aplicaciones únicamente con PHP «puro» (sin ningún framework), conforme un proyecto crece, surgen varios desafíos:

  • Desorganización del código: cuando se mezclan funciones, lógica y diseño sin una estructura clara.
  • Duplicación de código: funciones similares se escriben una y otra vez.
  • Dificultad para mantener o escalar la aplicación: añadir nuevas funcionalidades se vuelve complejo.
  • Problemas de seguridad: al no aplicar buenas prácticas de forma sistemática.

Un framework ayuda a resolver todos estos problemas gracias a sus características:

Ventaja del uso de un frameworkDescripción
Estructura clara y organizadaEl código se divide en carpetas según su responsabilidad: modelos, vistas, controladores, etc.
Seguridad incorporadaMuchos frameworks ya traen protección contra ataques comunes como inyección SQL o XSS.
Mayor velocidad de desarrolloTareas comunes ya están resueltas, como la autenticación, formularios, validación, etc.
Reutilización de códigoAl tener clases reutilizables y configuraciones centralizadas, se reduce la duplicación.
Pruebas y mantenimientoLa estructura facilita escribir pruebas automatizadas y mantener el código ordenado.
Trabajo en equipo más efectivoAl usar convenciones comunes, varios desarrolladores pueden colaborar fácilmente.

Frameworks vs. Librerías

Es importante distinguir entre frameworks y librerías:

  • Una librería es un conjunto de funciones que tú decides cuándo y cómo usar dentro de tu aplicación.
  • Un framework, en cambio, marca las reglas: tú trabajas dentro de su estructura definida por el framework, siguiendo su flujo y sus convenciones.

Una frase común para explicarlo es:

Con una librería tú llamas al código. Con un framework, es el framework quien llama al tuyo.

Ejemplo simple

Imaginemos que queremos crear una página que muestre una lista de usuarios desde una base de datos.

Con PHP puro:

  • Tendrías que crear la conexión a la base de datos manualmente.
  • Escribir tú mismo las sentencias SQL.
  • Manejar errores y sanitizar entradas.
  • Crear tu estructura de carpetas, plantillas y rutas.

Con un framework (como Laravel o CodeIgniter):

  • Usas una clase ya preparada para la conexión.
  • La estructura de carpetas ya está definida.
  • El framework valida automáticamente la entrada del usuario.
  • Puedes usar una interfaz ORM (Object Relational Mapping o Mapeo Objeto-Relacional) para escribir consultas de forma más limpia.

Algunos frameworks populares en PHP

FrameworkDescripción breve
LaravelUno de los frameworks más populares. Muy completo, moderno, y con una curva de aprendizaje amigable.
SymfonyMuy robusto y flexible, ideal para aplicaciones complejas y grandes.
CodeIgniterLigero y sencillo, recomendado para quienes inician en frameworks.
YiiPotente y de alto rendimiento, especialmente útil para aplicaciones rápidas.
SlimMicroframework para crear APIs y aplicaciones pequeñas con rapidez.

12.2 Introducción a Laravel y CodeIgniter

En el ecosistema de frameworks PHP, Laravel y CodeIgniter destacan como dos de los más utilizados y valorados por la comunidad. Cada uno tiene sus fortalezas y características particulares que los hacen adecuados para diferentes tipos de proyectos. A continuación, exploraremos cada uno por separado.

¿Qué es Laravel?

Laravel es un framework de desarrollo web en PHP de código abierto, creado por Taylor Otwell en 2011. Está diseñado para ayudar a los desarrolladores a construir aplicaciones web de manera eficiente, limpia y elegante, siguiendo el patrón arquitectónico MVC (Modelo-Vista-Controlador).

Laravel ha crecido hasta convertirse en el framework PHP más popular del mundo gracias a su:

  • Sintaxis clara y expresiva.
  • Herramientas integradas para tareas comunes.
  • Excelente documentación.
  • Gran comunidad de soporte.

Filosofía de Laravel

Laravel se enfoca en proporcionar una experiencia de desarrollo sencilla y productiva. Su lema es:

“The PHP Framework For Web Artisans”

Esto significa que Laravel está diseñado para los artesanos del código, aquellos que quieren escribir código limpio, legible y mantenible.

Algunas de sus metas clave:

  • Fomentar el uso de buenas prácticas (DRY, SOLID, etc.).
  • Facilitar el desarrollo rápido con herramientas integradas.
  • Promover una arquitectura limpia y desacoplada.

Arquitectura MVC en Laravel

Laravel está estructurado siguiendo el patrón MVC, lo cual permite separar claramente las responsabilidades de la aplicación:

ComponenteDescripciónArchivos típicos
Modelo (Model)Representa los datos y la lógica del negocio.app/Models/Producto.php
Vista (View)Se encarga de la presentación (HTML/Blade).resources/views/productos/index.blade.php
Controlador (Controller)Procesa las peticiones, maneja la lógica y devuelve respuestas.app/Http/Controllers/ProductoController.php

Herramientas y Componentes Clave de Laravel

Laravel incluye una gran variedad de módulos integrados que facilitan el desarrollo. A continuación, te explico los principales:

– Routing (Sistema de rutas)

Laravel tiene un sistema de rutas muy potente. Puedes definir una URL y asociarla a una función o controlador.

// routes/web.php
Route::get('/saludo', function () {
    return 'Hola Mundo desde Laravel';
});

O bien usar un controlador:

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

– Controladores

Los controladores organizan la lógica del sistema. Puedes generarlos con Artisan:

artisan make:controller ProductoController
// ProductoController.php
public function index() {
    $productos = Producto::all();
    return view('productos.index', compact('productos'));
}

– Blade: Motor de plantillas

Laravel incluye Blade, su propio motor de plantillas, que te permite usar estructuras de control en vistas sin mezclar PHP puro con HTML.

<!-- resources/views/productos/index.blade.php -->
@foreach ($productos as $producto)
    <p>{{ $producto->nombre }} - ${{ $producto->precio }}</p>
@endforeach

Blade también soporta layouts, componentes reutilizables y slots.

– ORM Eloquent

Laravel incluye un ORM llamado Eloquent, que te permite trabajar con la base de datos usando modelos orientados a objetos.

// app/Models/Producto.php
class Producto extends Model {
    protected $fillable = ['nombre', 'precio'];
}

// Uso en controlador
$productos = Producto::where('categoria', 'Electrónica')->get();

– Migrations (Migraciones)

Las migraciones permiten definir la estructura de la base de datos en código PHP.

artisan make:migration create_productos_table
Schema::create('productos', function (Blueprint $table) {
    $table->id();
    $table->string('nombre');
    $table->decimal('precio', 8, 2);
    $table->timestamps();
});

Con php artisan migrate aplicas la estructura a tu base de datos.

– Artisan: Consola de comandos

Artisan es la línea de comandos integrada de Laravel, útil para generar código y administrar el proyecto.

artisan make:model Producto
php artisan migrate
php artisan serve

– Middleware

Laravel permite usar middleware para filtrar solicitudes HTTP (como autenticación o protección CSRF).

// web.php
Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', function () {
        return view('dashboard');
    });
});

– Validación

Laravel permite validar formularios fácilmente:

$request->validate([
    'nombre' => 'required|max:255',
    'precio' => 'required|numeric',
]);

– Autenticación y autorización

Laravel incluye sistemas completos de login, registro, recuperación de contraseña, y roles/permiso mediante paquetes como Laravel Breeze, Jetstream o Laravel UI.

Estructura de un Proyecto Laravel

Un proyecto Laravel contiene carpetas organizadas con funciones específicas:

CarpetaDescripción
app/ModelsModelos Eloquent
app/Http/ControllersControladores
resources/viewsVistas Blade
routes/web.phpDefinición de rutas web
database/migrationsMigraciones
public/Carpeta pública para archivos accesibles por el navegador
config/Archivos de configuración
.envVariables de entorno (configuración del entorno, DB, mail, etc.)

Ventajas de Usar Laravel

VentajaDescripción
Productividad altaArtisan, Blade, Eloquent y otras herramientas permiten desarrollar más rápido.
Buenas prácticas integradasFacilita el uso de MVC, inyección de dependencias, separación de capas.
SeguridadIncluye protección contra CSRF, XSS, SQL Injection.
Comunidad activaMiles de tutoriales, paquetes, foros y ayuda disponible.
Pruebas integradasHerramientas para testing automático con PHPUnit.
APIs modernasIdeal para crear APIs RESTful fácilmente.
Ecosistema LaravelPuedes añadir paquetes como Laravel Nova (admin), Horizon (colas), Sanctum (API tokens), etc.

Ejemplo Práctico: CRUD básico con Laravel

Modelo:

artisan make:model Producto -m

Migración:

Schema::create('productos', function (Blueprint $table) {
    $table->id();
    $table->string('nombre');
    $table->decimal('precio', 8, 2);
    $table->timestamps();
});

Controlador:

artisan make:controller ProductoController --resource

Ruta:

Route::resource('productos', ProductoController::class);

Vista (Blade):

@foreach ($productos as $producto)
    <p>{{ $producto->nombre }} - ${{ $producto->precio }}</p>
@endforeach

Con estas líneas, puedes tener un CRUD funcional con Laravel.🧠 Conclusión

Como has podido ver, Laravel no es solo un framework, es un ecosistema completo para construir aplicaciones PHP. Proporciona una estructura robusta con una gran cantidad de herramientas integradas. Es ideal tanto para desarrolladores novatos como para profesionales que necesitan construir aplicaciones escalables, seguras y limpias.

CodeIgniter.

¿Qué es CodeIgniter?

CodeIgniter es un framework de desarrollo web para PHP, rápido, ligero y con una estructura sencilla, basado tambiénen el patrón MVC (Modelo-Vista-Controlador). Fue creado originalmente por EllisLab y actualmente está mantenido por el equipo de British Columbia Institute of Technology (BCIT).

Su objetivo principal es permitir el desarrollo de aplicaciones PHP con el mínimo de configuración, ofreciendo alto rendimiento y una curva de aprendizaje baja, ideal para quienes comienzan con frameworks o vienen de escribir PHP puro.

Filosofía de CodeIgniter

A diferencia de otros frameworks más pesados o complejos, CodeIgniter busca ser minimalista y flexible, sin imponer demasiadas reglas. Se basa en los siguientes principios:

  • Simplicidad sobre complejidad
  • Ligereza sobre extensividad
  • Alto rendimiento
  • Configuración mínima
  • Documentación clara y completa

No requiere usar Composer, líneas de comandos o configuración compleja. Es posible descargarlo, descomprimirlo y empezar a usarlo en pocos minutos.

Características Clave

CaracterísticaDescripción
MVC estructuradoFacilita la organización del código en capas: modelo, vista, controlador
Rápido y ligeroUno de los frameworks más veloces y livianos de PHP
Configuración mínimaNo necesita un entorno complejo ni uso obligatorio de línea de comandos
ModularPosibilidad de cargar solo las librerías necesarias
Seguridad integradaSoporte para XSS, CSRF y filtrado de datos
Excelente documentaciónDocumentación clara, concisa y bien organizada

Estructura MVC en CodeIgniter

Como ya hemos comentado, CodeIgniter sigue el patrón Modelo-Vista-Controlador, con una estructura muy clara:

  • Modelos → Interactúan con la base de datos.
  • Vistas → Se encargan del diseño y la presentación.
  • Controladores → Coordinan lógica y flujo entre modelos y vistas.
// Modelo: app/Models/ProductoModel.php
class ProductoModel extends \CodeIgniter\Model {
    protected $table = 'productos';
    protected $allowedFields = ['nombre', 'precio'];
}

// Controlador: app/Controllers/Producto.php
class Producto extends \CodeIgniter\Controller {
    public function index() {
        $model = new \App\Models\ProductoModel();
        $data['productos'] = $model->findAll();
        return view('productos', $data);
    }
}

// Vista: app/Views/productos.php
<?php foreach($productos as $p): ?>
    <p><?= $p['nombre']; ?> - $<?= $p['precio']; ?></p>
<?php endforeach; ?>

Estructura de Carpetas

La estructura típica de un proyecto CodeIgniter 4 es:

/app
    /Controllers
    /Models
    /Views
/public
/system
/writable
.env
  • app/ → Código de la aplicación.
  • public/ → Document root del servidor (similar a public_html).
  • system/ → Núcleo del framework.
  • writable/ → Carpeta para logs, caché, etc.
  • .env → Variables de entorno.

Routing en CodeIgniter

Las rutas pueden definirse en el archivo app/Config/Routes.php:

$routes->get('/', 'Home::index');
$routes->get('/productos', 'Producto::index');

También puede usarse el enrutamiento automático (por convención controlador/metodo).

Carga de modelos y librerías

En CodeIgniter puedes cargar modelos directamente dentro de los controladores:

$model = new \App\Models\ProductoModel();

También puedes usar servicios y helpers con funciones como:

helper('form');
$session = \Config\Services::session();

Modelo y acceso a base de datos con CodeIgniter

CodeIgniter tiene su propio ORM ligero (aunque no tan avanzado como Eloquent). Permite hacer operaciones fácilmente:

$model = new ProductoModel();

// Obtener todos los productos
$productos = $model->findAll();

// Insertar nuevo
$model->save(['nombre' => 'Ratón', 'precio' => 25.99]);

// Actualizar
$model->update(1, ['precio' => 27.50]);

// Eliminar
$model->delete(1);

Seguridad en CodeIgniter

CodeIgniter ofrece herramientas integradas para proteger tu aplicación:

SeguridadSoporte
CSRFActivado por defecto
XSSMediante funciones de escape
ValidaciónIncorporada en formularios
Filtrado de entradaInput sanitization y filtros integrados

Ejemplo de protección CSRF en formularios:

<?= csrf_field() ?>
<input type="text" name="nombre">

Validación de formularios

CodeIgniter tiene validación incorporada muy fácil de usar:

$validation = \Config\Services::validation();

$rules = [
    'nombre' => 'required|min_length[3]',
    'precio' => 'required|decimal'
];

if (! $this->validate($rules)) {
    echo $validation->listErrors();
} else {
    $model->save($this->request->getPost());
}

CLI (Interfaz de línea de comandos)

CodeIgniter 4 incluye una herramienta CLI opcional similar a Artisan de Laravel:

php spark serve
php spark make:controller Producto
php spark make:model ProductoModel

Esto facilita tareas de desarrollo, migraciones, y pruebas.

Migraciones

CodeIgniter 4 permite usar migraciones para gestionar la estructura de la base de datos:

php spark make:migration CreateProductosTable

Archivo de migración:

public function up() {
    $this->forge->addField([
        'id' => ['type' => 'INT', 'auto_increment' => true],
        'nombre' => ['type' => 'VARCHAR', 'constraint' => 100],
        'precio' => ['type' => 'DECIMAL', 'constraint' => '8,2'],
    ]);
    $this->forge->addKey('id', true);
    $this->forge->createTable('productos');
}

Ventajas de CodeIgniter

VentajaDescripción
Muy rápidoDe los frameworks más ligeros y rápidos en ejecución
Instalación sencillaNo requiere Composer ni CLI obligatorio
Curva de aprendizaje bajaIdeal para quienes migran de PHP puro
FlexibleNo impone estructuras rígidas
ModularSolo cargas lo que necesitas
Documentación claraFácil de entender, bien explicada

Diferencias clave con Laravel

ComparativaLaravelCodeIgniter
Filosofía«Código elegante y expresivo»«Ligero, sencillo y rápido»
ComplejidadAlta (más funciones)Baja (más directo)
ORMEloquent (avanzado)ORM básico
Motor de plantillasBladePHP puro
CLIArtisanSpark (opcional)
Curva de aprendizajeMedia/AltaBaja
EcosistemaMuy amplioMás limitado

Resumiendo, CodeIgniter es un framework excelente si:

  • Buscas rendimiento y sencillez.
  • Eres principiante y quieres una entrada suave al desarrollo moderno.
  • Tienes aplicaciones pequeñas o medianas que no necesitan toda la complejidad de Laravel.

Su enfoque minimalista, curva de aprendizaje baja y buena documentación lo hacen ideal para desarrolladores que buscan velocidad y control.

12.3 Proyecto Básico con Laravel

Objetivo

Vamos a crear una pequeña aplicación Laravel llamada “Gestor de Productos”, que permitirá:

  • Mostrar un listado de productos.
  • Crear nuevos productos.
  • Eliminar productos.

Usaremos Laravel 10 o superior, Eloquent ORM, el motor de plantillas Blade, migraciones, rutas, controladores y formularios.

Requisitos Previos

Asegúrate de tener instalado:

  • PHP 8.x
  • Composer
  • Laravel (opcionalmente el instalador global: composer global require laravel/installer)
  • MySQL o MariaDB
  • Un entorno como XAMPP, Laragon o Laravel Sail

1º Crear un nuevo proyecto

composer create-project laravel/laravel gestor_productos
cd gestor_productos

Si usas Laravel Sail (Docker), puedes inicializarlo con:

php artisan sail:install
./vendor/bin/sail up

2º Configurar la base de datos

Edita el archivo .env:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=gestor
DB_USERNAME=root
DB_PASSWORD=tu_clave

Crea la base de datos vacía gestor desde MySQL.

3º Crear la migración y el modelo

Generamos el modelo Producto junto con su migración:

php artisan make:model Producto -m

Edita el archivo de migración en database/migrations/xxxx_create_productos_table.php:

public function up()
{
    Schema::create('productos', function (Blueprint $table) {
        $table->id();
        $table->string('nombre');
        $table->decimal('precio', 8, 2);
        $table->timestamps();
    });
}

Aplica la migración:

php artisan migrate

4º Crear el controlador

php artisan make:controller ProductoController

Editamos app/Http/Controllers/ProductoController.php:

namespace App\Http\Controllers;

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

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

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

    public function store(Request $request)
    {
        $request->validate([
            'nombre' => 'required|min:3',
            'precio' => 'required|numeric',
        ]);

        Producto::create($request->all());

        return redirect()->route('productos.index')->with('success', 'Producto añadido.');
    }

    public function destroy(Producto $producto)
    {
        $producto->delete();
        return redirect()->route('productos.index')->with('success', 'Producto eliminado.');
    }
}

5º Definir rutas

Editamos routes/web.php:

use App\Http\Controllers\ProductoController;

Route::get('/', [ProductoController::class, 'index'])->name('productos.index');
Route::get('/productos/crear', [ProductoController::class, 'create'])->name('productos.create');
Route::post('/productos', [ProductoController::class, 'store'])->name('productos.store');
Route::delete('/productos/{producto}', [ProductoController::class, 'destroy'])->name('productos.destroy');

6º Habilitar asignación masiva en el modelo

En app/Models/Producto.php:

protected $fillable = ['nombre', 'precio'];

7º Crear las vistas Blade

resources/views/productos/index.blade.php

<!DOCTYPE html>
<html>
<head>
    <title>Productos</title>
</head>
<body>
    <h1>Listado de productos</h1>

    @if(session('success'))
        <p>{{ session('success') }}</p>
    @endif

    <a href="{{ route('productos.create') }}">Añadir nuevo producto</a>

    <ul>
        @foreach ($productos as $producto)
            <li>
                {{ $producto->nombre }} - ${{ $producto->precio }}
                <form action="{{ route('productos.destroy', $producto) }}" method="POST" style="display:inline;">
                    @csrf
                    @method('DELETE')
                    <button type="submit">Eliminar</button>
                </form>
            </li>
        @endforeach
    </ul>
</body>
</html>

resources/views/productos/create.blade.php

<!DOCTYPE html>
<html>
<head>
    <title>Nuevo Producto</title>
</head>
<body>
    <h1>Añadir nuevo producto</h1>

    @if ($errors->any())
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    @endif

    <form method="POST" action="{{ route('productos.store') }}">
        @csrf
        <label>Nombre:</label>
        <input type="text" name="nombre"><br>
        <label>Precio:</label>
        <input type="text" name="precio"><br>
        <button type="submit">Guardar</button>
    </form>

    <a href="{{ route('productos.index') }}">Volver</a>
</body>
</html>

Prueba la aplicación

  1. Inicia el servidor de Laravel:
php artisan serve
  1. Ve a http://localhost:8000 en tu navegador.

Podrás añadir productos, verlos listados y eliminarlos. Esta pequeña aplicación básica demuestra cómo Laravel gestiona MVC, formularios, validación, Eloquent, vistas Blade, y rutas.

Resumiendo.

Con este proyecto:

  • Hemos visto cómo se estructura una aplicación Laravel.
  • Hemos creado el conjunto de operaciones CRUD básico de productos.
  • Hemos usado migraciones, controladores, vistas Blade, validación y rutas.

Este ejemplo puede ampliarse fácilmente con autenticación, edición, filtros, paginación, carga de imágenes, etc.

Anterior

Índice

Siguiente

Bibliografía de programación en PHP.

LOGO PHP ntroducción a Frameworks PHP.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *