Diferencia entre revisiones de «Usuario:ManuelRomero/ProgramacionWeb/Composer»

De WikiEducator
Saltar a: navegación, buscar
(Carga automática de clases)
 
(9 revisiones intermedias por el mismo usuario no mostrado)
Línea 1: Línea 1:
 
<!--https://es.wikieducator.org/Usuario:ManuelRomero/PHP/autoload-->
 
<!--https://es.wikieducator.org/Usuario:ManuelRomero/PHP/autoload-->
 
<div id=seccion>
 
<div id=seccion>
https://medium.com/tech-tajawal/php-composer-the-autoloader-d676a2f103aa
+
 
<div class=parrafo>
+
 
==Composer==
 
==Composer==
MRM_Definicion|Title=qué es composer|
+
 
;Lo mismo que un director de orquesta, organiza y dirige todos los instrumentos para que la música suene de forma armoniosa, composer va a ser un orquestador que gestionará todos los paquetes y librerías necesarias para que mi proyecto pueda funcionar correctamente como una unidad
+
<div class=parrafo>
 +
 
 +
https://medium.com/tech-tajawal/php-composer-the-autoloader-d676a2f103aa
 +
 
 +
{{MRM_Definicion|Title=¿Qué es Composer?|
 +
Del mismo modo que un '''''director de orquesta''''' coordina a todos los instrumentos para que la música suene de forma armoniosa, '''''Composer''''' actúa como un '''''orquestador del proyecto PHP'''''. 
 +
Su función principal es gestionar de forma unificada todos los '''''paquetes, librerías y dependencias''''' que una aplicación necesita para funcionar correctamente.
 
}}
 
}}
  
 +
{{MRM_Definicion|Title=¿Qué hace Composer?|
 +
Entre sus funciones principales, '''Composer me permite''':
  
 +
* Gestionar automáticamente la '''''autocarga (autoload) de las clases''''', evitando tener que hacer ''includes'' o ''requires'' manuales.
 +
* Instalar '''''librerías y paquetes de terceros''''' dentro de mi proyecto de forma rápida, segura y organizada.
 +
}}
  
===Carga automática de clases===
+
{{MRM_Definicion|Title=Otras funcionalidades importantes de Composer|
*Para cargar de forma automática las clases ya hemos visto como realizar un autoload de cada clase que necesitemos.
+
Además del autoload y la instalación de dependencias, Composer también:
*Para ello escribimos el código en  la función anónima que recibe en callback como argumento la función
+
'''''spl_autload_register'''''.
+
*Suponiendo que las clases las tenemos en el directorio '''''Classes''''' del proyecto
+
<source lang=php>
+
spl_autoload_register(function ($clase)){
+
  require("Clases/$clase.php");
+
}
+
</source>
+
*Esto también lo podríamos poner escrbiendo la función nominada
+
<source lang=php>
+
function autocarga($clase){
+
  require("Clases/$clase.php");
+
}
+
  
spl_autoload_register(autocarga);
+
* Mantiene un fichero de ''metainformación'' del proyecto en '''composer.json''', donde se define:
</source>
+
*O como lo venimos haciendo en las diferentes sesiones
+
 
<source lang=php>
 
<source lang=php>
$carga=fn($clase)=> require("Clases/$clase.php");
+
get_included_files()
spl_autoload_register(function ($carga));
+
 
</source>
 
</source>
  
 +
*Sería ideal tener un sistema que nos permitiera indicar dónde se encuentran las clases, generar automáticamente la autocarga y mantenerlo todo organizado.* 
 +
Para eso existe '''Composer''', que incorpora diferentes estrategias para el ''autoload'': '''classmap''' y '''PSR-4'''.
  
 +
{{MRM_Puntos_clave|
 +
*Cada clase en su propio fichero* 
 +
*El fichero debe llamarse igual que la clase*
 +
}}
  
 +
===Usando Composer con ''classmap''===
  
+
*Creamos una estructura de directorios, por ejemplo:*
 
+
[[Archivo:directorios_autoload.png]]
*Esto está bien, y hace que sólo estén cargados los ficheros que necesitemos en un momento dado
+
Puedes comprobar los ficheros cargados en un momento dado invocando a la función '''''get_included_files()''''' que te devuelve un array con todos los ficheros cargados.
+
Este método presenta el inconveniente que o bien tienes todas las clases implementadas en un mismo directorio, o bien en la función de autocarga busca en directorios según el nombre de la clase, lo cual puede ser muy incómodo y poco productivo.
+
  
 
+
*Ejemplo de clase:*
*Estaría bien un software que le podamos decir en un fichero dónde se ubican cada clase de nuestro proyecto, y que luego se pueda cargar automáticamente el fichero cuando sea necesario disponer de él
+
*Para este comentidoo podemos usar ello vamos a usar '''''composer''''' que tiene diferentes opciones que pueden satisfacer esta necesidad. Analizaremos dos de ellas '''''classmap''''' y PSR-4.
+
Por supuesto, siguiendo las buenas prácricas de programación, seguimos escribiendo cada clase en un fichero con el mismo nombre de la clase que implementa.
+
 
+
{{MRM_Puntos_clave|Cada clase está en un fichero que contiene el mismo nombre que la clase
+
Sólo una clase por fichero
+
}}
+
Composer es lo que se conoce como un orquestador, es decir un software que va a permitir que mi aplicación (la orquesta) funcione bien usando diferentes ficheros y diferentes librerías (los instrumentos de la orquesta). Composer se va a encargar de buscar los ficheros y librerías necesarias con la versión correspondiente para que todo funcione correctamente. Por supuesto, todo lo que necesitamos lo tendremos que especificar en un fichero. Este fichero se llama '''''composer.json''''
+
*Vemos como '''''composer'''' realiza todo lo que necesitamos
+
*Veamos el ejemplo.
+
;Creamos una estructura de directorios
+
[[Archivo:directorios_autoload.png]]
+
;En cada directorio creamos clases, para el ejemplo solo muestran un texto
+
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
/**
+
class B {
* Created by PhpStorm.
+
     public function __toString() {
* User: manuel
+
* Date: 25/01/19
+
* Time: 17:54
+
*/
+
 
+
class B
+
{
+
     public function __toString()
+
    {
+
        // TODO: Implement __toString() method.
+
 
         return "Hola desde la clase B";
 
         return "Hola desde la clase B";
 
     }
 
     }
 
}
 
}
 
</source>
 
</source>
*Esto para cada una de las clases.
+
 
ahora escribimos un fichero composer
+
*Creamos el fichero '''composer.json''' indicando que Composer debe escanear el directorio ''Clases/'':*
 +
 
 
<source lang=php>
 
<source lang=php>
 
{
 
{
 
   "autoload": {
 
   "autoload": {
 
     "classmap": [
 
     "classmap": [
       "Classes"
+
       "Clases"
 
     ]
 
     ]
 
   }
 
   }
 
}
 
}
 
</source>
 
</source>
*a continuación actulizamos composer
+
 
 +
*Actualizamos Composer para generar la carga automática:*
 +
 
 
<source lang=bash>
 
<source lang=bash>
 
composer update
 
composer update
 
</source>
 
</source>
*Podemos ver cómo composer ha creado una estructura de carpetas donde ya tiene localizadas todas las clases del proyecto
+
 
[[Archivo:autoload_composer.png]]<br />
+
*Composer crea automáticamente la carpeta '''vendor/''' y genera el fichero de autocarga.*
*Y debemos incluir en nuestro proyecto el fichero autoload de composer
+
[[Archivo:autoload_composer.png]]
 +
 
 +
*Ahora sólo tenemos que incluir el autoload en nuestro proyecto:*
 +
 
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
 
require "vendor/autoload.php";
 
require "vendor/autoload.php";
 +
</source>
  
 +
*Si añadimos nuevos ficheros, recuerda regenerar el autoload:*
  
 
+
<source lang=bash>
?>
+
composer dumpautoload
 
</source>
 
</source>
*Podemos ver el resultado
 
[[Archivo:ejercicios_autoload.png]]
 
Si añadimos nuevos ficheros necesitamos hacer
 
adding new files requires '''''composer dumpautoload''''' to regenerate the mapping.
 
</div>
 
  
==Usando PSR4==
+
---
*https://styde.net/curso-de-laravel-5-que-es-psr-4-y-uso-de-los-namespaces/
+
 
 +
==Usando PSR-4==
 +
 
 +
*PSR-4 es el método moderno y recomendado de autocarga. Usa los '''namespaces''' para localizar las clases automáticamente sin necesidad de regenerar el autoload cada vez.*
 +
 
 +
*Referencias recomendadas:* 
 +
https://styde.net/curso-de-laravel-5-que-es-psr-4-y-uso-de-los-namespaces/
 +
https://diego.com.es/namespaces-en-php 
 +
https://www.php.net/manual/es/language.namespaces.php
  
 
;Espacio de nombres
 
;Espacio de nombres
* https://diego.com.es/namespaces-en-php
+
*Un '''namespace''' es una forma de organizar clases, funciones e interfaces evitando conflictos entre nombres.*
* https://www.php.net/manual/es/language.namespaces.php
+
*Es equivalente a la organización en directorios del sistema de ficheros.*
*El espacio de nombres o <span style=color:#A04000>namespace </span> es una forma de organizar las clases evitando conflictos (permitir dos clases diferentes con el mismo nombre) y mejorar la estructura del proyecto
+
 
*Es una forma de agrupar clases lo mismo que un directorio agrupa todo su contenido y los permite localizarlo
+
Ejemplo equivalente en archivos reales:
  
*De hecho es el mismo concepto, de esta forma no tendremos ningún problema en tener dos ficheros con el mismo nombre (en diferente directorio)
 
 
<source lang=php>
 
<source lang=php>
/home/profesor/dwes/notas.ods
+
/home/profesor/dwes/notas.ods
/home/profesor/bd/notas.ods
+
/home/profesor/bd/notas.ods
 
</source>
 
</source>
 +
 +
Puedes tener dos clases con el mismo nombre si pertenecen a distintos namespaces.
 +
 
{{MRM_Resumen|
 
{{MRM_Resumen|
;Los espacios de nombres de PHP permiten agrupar  
+
Los namespaces de PHP permiten agrupar clases, funciones, interfaces y constantes relacionadas.
clases, funciones, interfaces y constantes relacionadas.
+
 
}}
 
}}
;Declarar un namespace
+
 
*Debe de ser la primera instrucción del fichero (Cuidado incluso con espacios en blanco)
+
===Declarar un namespace===
 +
 
 +
*El namespace debe ser la primera línea del fichero (sin espacios previos).*
 +
 
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
 
namespace MiProyecto;
 
namespace MiProyecto;
..
 
 
</source>
 
</source>
*El namespace puede tener varios niveles de jerarquía cuidado con la barra  de separación '''''\'''''
+
 
 +
*También puede tener varios niveles separados por barras invertidas ''\''':*
 +
 
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
namespace MiProyecto\nivel1\subnivel2;
+
namespace MiProyecto\Nivel1\Subnivel2;
...
+
 
</source>
 
</source>
{MRM_Resumen|Title=Algunos comentarios|
 
*Cada namespace referencia a una ubicación en un directorio
 
*No tiene por qué coincidir el namespace con el nombre de directorio, pero suele ser una buena práctica
 
  
}
+
{{MRM_Resumen|Title=Comentarios sobre namespaces|
* Una alternativa más interesante que classmap va a ser psr4.
+
*Cada namespace suele corresponder a un directorio.
*Con ella conseguimos no tener que volver a invocar a composer, cada vez que añadamos nuevas clases
+
*No es obligatorio que coincidan exactamente, pero es buena práctica.*
*Hace la ejecución mucho más rápida, aunque al principio da la impresión de mas engorroso y menos sencillez.
+
}}
*psr-4, está basado en el nombre de espacios o '''''namespace'''''
+
====namespace====
+
*Es una forma de organizar nuestras clases. para que podamos usar incluso clases con el mismo nombre (cada una de ellas que tenga un nombre de espacio diferente
+
*para ello ponemos en una clase un nombre al principio de la clase
+
*Todas las clases de ese directorio pertenecerán la mismo namespace
+
  
 +
---
  
 +
===PSR-4 en Composer===
 +
 +
*PSR-4 es más potente y elegante que ''classmap'', y no requiere regenerar el autoload cuando se añaden nuevas clases.*
 +
 +
*Se basa completamente en los '''namespaces'''.*
 +
 +
Ejemplo de configuración en '''composer.json''':
  
*Con  ella no vamos a tener que regenerar el composer cada vez que añadamos una clase
 
*Añadimos en composer.json
 
 
<source lang=php>
 
<source lang=php>
 
{
 
{
"autoload":{
+
  "autoload": {
     "psr-4":{
+
     "psr-4": {
        "Nombre_Espacio\\":"Dir_donde_están_las_clases"
+
      "MiProyecto\\": "src/"
      }
+
 
     }
 
     }
 +
  }
 
}
 
}
 +
</source>
  
"psr-4"
+
Esto significa:
 +
 
 +
* Las clases con namespace **MiProyecto** se cargarán desde la carpeta **src/**
 +
* La clase:
 +
<source lang=php>
 +
namespace MiProyecto\Modelos;
 +
</source>
 +
 
 +
se ubica en
 +
<source lang=php>
 +
src/Modelos/Usuario.php
 +
</source>
 +
 
 +
*Tras crear o modificar el composer.json, sólo debes ejecutar:*
 +
 
 +
<source lang=bash>
 +
composer dumpautoload
 +
</source>
 +
 
 +
PSR-4 permite:
 +
 
 +
* Organizar clases por módulos y carpetas
 +
* Crear proyectos escalables
 +
* Evitar conflictos de nombres
 +
* Mejorar la legibilidad y mantenibilidad del código
 +
 
 +
y es el estándar moderno utilizado por:
 +
 
 +
* Laravel 
 +
* Symfony 
 +
* CodeIgniter 4 
 +
* Doctrine 
 +
* La mayoría del ecosistema PHP actual 
 +
 
 +
 
 +
 
 +
 
 +
===Comparativa: ''classmap'' vs ''PSR-4''===
 +
 
 +
A la hora de configurar la carga automática de clases con Composer, existen dos métodos principales: '''classmap''' y '''PSR-4'''. 
 +
Ambos funcionan, pero sirven para necesidades diferentes.
 +
 
 +
{| class="wikitable"
 +
! Método
 +
! Cómo funciona
 +
! Ventajas
 +
! Inconvenientes
 +
|-
 +
|'''classmap'''
 +
|Composer escanea directorios y genera una lista interna (mapa) con todas las clases y su fichero correspondiente.
 +
|
 +
* Muy sencillo de configurar 
 +
* Funciona sin namespaces 
 +
* Útil para proyectos heredados
 +
|
 +
* No escala bien 
 +
* Requiere ejecutar <code>composer dumpautoload</code> o <code>composer update</code> al añadir nuevas clases 
 +
* No organiza la estructura del proyecto
 +
|-
 +
|'''PSR-4'''
 +
|La autocarga se basa en los namespaces: cada namespace corresponde a una carpeta. 
 +
Composer encuentra automáticamente las clases según su ruta.
 +
|
 +
* Estándar moderno y recomendado 
 +
* No requiere regenerar el autoload al añadir nuevas clases 
 +
* Organización clara y modular 
 +
* Muy usado en Laravel y frameworks modernos 
 +
* Facilita evitar conflictos de nombres
 +
|
 +
* Requiere usar namespaces 
 +
* Necesita estructura organizada desde el principio
 +
|}
 +
 
 +
===Ejemplo visual: cómo piensan los dos sistemas===
 +
 
 +
;Classmap (método antiguo o heredado)
 +
Composer crea un “mapa” con las rutas exactas.
 +
 
 +
<source lang=php>
 +
{
 +
  "autoload": {
 +
    "classmap": ["Clases/"]
 +
  }
 
}
 
}
 +
</source>
  
 +
Resultado interno:
 +
<source lang=bash>
 +
 +
B => Clases/B.php
 +
C => Clases/C.php
 +
MiClaseEspecial => Clases/OtraCarpeta/MiClaseEspecial.php
 
</source>
 
</source>
 +
Cada vez que añades una clase nueva → 
 +
'''composer dumpautoload'''
 +
 +
---
 +
;PSR-4 (método moderno)
 +
Mapea namespaces a carpetas:
 +
 +
<source lang=php>
 +
{
 +
  "autoload": {
 +
    "psr-4": {
 +
      "MiProyecto\\": "src/"
 +
    }
 +
  }
 +
}
 +
</source>
 +
 +
Reglas:
 +
 +
<source lang=php>
 +
namespace MiProyecto\Modelos;
 +
 +
src/Modelos/Usuario.php
 +
</source>
 +
 +
Añades una clase → no hace falta hacer nada 
 +
(Composer la encontrará automáticamente).
 +
</div>
 
</div>
 
</div>

Última revisión de 20:38 16 nov 2025

Composer

https://medium.com/tech-tajawal/php-composer-the-autoloader-d676a2f103aa



Icon define.gif
¿Qué es Composer?

Del mismo modo que un director de orquesta coordina a todos los instrumentos para que la música suene de forma armoniosa, Composer actúa como un orquestador del proyecto PHP. Su función principal es gestionar de forma unificada todos los paquetes, librerías y dependencias que una aplicación necesita para funcionar correctamente.




Icon define.gif
¿Qué hace Composer?

Entre sus funciones principales, Composer me permite:

  • Gestionar automáticamente la autocarga (autoload) de las clases, evitando tener que hacer includes o requires manuales.
  • Instalar librerías y paquetes de terceros dentro de mi proyecto de forma rápida, segura y organizada.


{{MRM_Definicion|Title=Otras funcionalidades importantes de Composer| Además del autoload y la instalación de dependencias, Composer también:

  • Mantiene un fichero de metainformación del proyecto en composer.json, donde se define:
get_included_files()
  • Sería ideal tener un sistema que nos permitiera indicar dónde se encuentran las clases, generar automáticamente la autocarga y mantenerlo todo organizado.*

Para eso existe Composer, que incorpora diferentes estrategias para el autoload: classmap y PSR-4.



Icon key points.gif

Puntos clave

  • Cada clase en su propio fichero*
  • El fichero debe llamarse igual que la clase*



Usando Composer con classmap

  • Creamos una estructura de directorios, por ejemplo:*

Directorios autoload.png

  • Ejemplo de clase:*
<?php
class B {
    public function __toString() {
        return "Hola desde la clase B";
    }
}
  • Creamos el fichero composer.json indicando que Composer debe escanear el directorio Clases/:*
{
  "autoload": {
    "classmap": [
      "Clases"
    ]
  }
}
  • Actualizamos Composer para generar la carga automática:*
composer update
  • Composer crea automáticamente la carpeta vendor/ y genera el fichero de autocarga.*

Autoload composer.png

  • Ahora sólo tenemos que incluir el autoload en nuestro proyecto:*
<?php
require "vendor/autoload.php";
  • Si añadimos nuevos ficheros, recuerda regenerar el autoload:*
composer dumpautoload

---

Usando PSR-4

  • PSR-4 es el método moderno y recomendado de autocarga. Usa los namespaces para localizar las clases automáticamente sin necesidad de regenerar el autoload cada vez.*
  • Referencias recomendadas:*

https://styde.net/curso-de-laravel-5-que-es-psr-4-y-uso-de-los-namespaces/ https://diego.com.es/namespaces-en-php https://www.php.net/manual/es/language.namespaces.php

Espacio de nombres
  • Un namespace es una forma de organizar clases, funciones e interfaces evitando conflictos entre nombres.*
  • Es equivalente a la organización en directorios del sistema de ficheros.*

Ejemplo equivalente en archivos reales:

/home/profesor/dwes/notas.ods
/home/profesor/bd/notas.ods

Puedes tener dos clases con el mismo nombre si pertenecen a distintos namespaces.


Icon summary.gif
Objetivo

Los namespaces de PHP permiten agrupar clases, funciones, interfaces y constantes relacionadas.


Declarar un namespace

  • El namespace debe ser la primera línea del fichero (sin espacios previos).*
<?php
namespace MiProyecto;
  • También puede tener varios niveles separados por barras invertidas \':*
<?php
namespace MiProyecto\Nivel1\Subnivel2;


Icon summary.gif
Comentarios sobre namespaces
  • Cada namespace suele corresponder a un directorio.
  • No es obligatorio que coincidan exactamente, pero es buena práctica.*


---

PSR-4 en Composer

  • PSR-4 es más potente y elegante que classmap, y no requiere regenerar el autoload cuando se añaden nuevas clases.*
  • Se basa completamente en los namespaces.*

Ejemplo de configuración en composer.json:

{
  "autoload": {
    "psr-4": {
      "MiProyecto\\": "src/"
    }
  }
}

Esto significa:

  • Las clases con namespace **MiProyecto** se cargarán desde la carpeta **src/**
  • La clase:
namespace MiProyecto\Modelos;

se ubica en

src/Modelos/Usuario.php
  • Tras crear o modificar el composer.json, sólo debes ejecutar:*
composer dumpautoload

PSR-4 permite:

  • Organizar clases por módulos y carpetas
  • Crear proyectos escalables
  • Evitar conflictos de nombres
  • Mejorar la legibilidad y mantenibilidad del código

y es el estándar moderno utilizado por:

  • Laravel
  • Symfony
  • CodeIgniter 4
  • Doctrine
  • La mayoría del ecosistema PHP actual



Comparativa: classmap vs PSR-4

A la hora de configurar la carga automática de clases con Composer, existen dos métodos principales: classmap y PSR-4. Ambos funcionan, pero sirven para necesidades diferentes.

Método Cómo funciona Ventajas Inconvenientes
classmap Composer escanea directorios y genera una lista interna (mapa) con todas las clases y su fichero correspondiente.
  • Muy sencillo de configurar
  • Funciona sin namespaces
  • Útil para proyectos heredados
  • No escala bien
  • Requiere ejecutar composer dumpautoload o composer update al añadir nuevas clases
  • No organiza la estructura del proyecto
PSR-4 La autocarga se basa en los namespaces: cada namespace corresponde a una carpeta.

Composer encuentra automáticamente las clases según su ruta.

  • Estándar moderno y recomendado
  • No requiere regenerar el autoload al añadir nuevas clases
  • Organización clara y modular
  • Muy usado en Laravel y frameworks modernos
  • Facilita evitar conflictos de nombres
  • Requiere usar namespaces
  • Necesita estructura organizada desde el principio

Ejemplo visual: cómo piensan los dos sistemas

Classmap (método antiguo o heredado)

Composer crea un “mapa” con las rutas exactas.

{
  "autoload": {
    "classmap": ["Clases/"]
  }
}

Resultado interno:

B => Clases/B.php
C => Clases/C.php
MiClaseEspecial => Clases/OtraCarpeta/MiClaseEspecial.php

Cada vez que añades una clase nueva → composer dumpautoload

---

PSR-4 (método moderno)

Mapea namespaces a carpetas:

{
  "autoload": {
    "psr-4": {
      "MiProyecto\\": "src/"
    }
  }
}

Reglas:

namespace MiProyecto\Modelos;
 
src/Modelos/Usuario.php

Añades una clase → no hace falta hacer nada (Composer la encontrará automáticamente).