Automatiza la creación de tus proyectos con Composer
Tags: php, composer, dependencias, librerías
Published: 2020-01-29 15:38:52

---
title: Automatiza la creación de tus proyectos con Composer
published: true
tags: PHP, Composer, Dependencias, Librerías
canonical_url: http://galatar.com/automatiza-la-creacion-de-tus-proyectos-con-composer/
---

## Qué es Composer y en qué puede ayudarme

Cuando creas un nuevo proyecto de desarrollo de código, sea en el lenguaje que sea, no creo que empieces desde cero y teclees todo el código desde principio a fin. Normalmente vas a utilizar partes de algún proyecto ya desarrollado, por ti u otra persona, como eje del proyecto y luego irás añadiendo librerías por aquí y por allá para empezar con alguna base. Me arriesgaría a decir que todo este código “importado” puede llegar a suponer el 75% del proyecto.

Normalmente lo que hacemos para esta tarea es copiar una carpeta de una librería que usamos en un proyecto del año pasado, otra que encontramos hace poco en la web, código que hemos desarrollado para un proyecto anterior y que poco a poco vamos adaptando a este, etc.

El problema es que vamos mezclando versiones de librería que muchos veces son incompatibles entre si (no las librerías, sino las versiones) o que son incompatibles con nuestra versión actual de PHP. Además suele ser una locura casarlas entre si, llamar a unas desde otra y, no digamos ya, actualizarlas cuando salgan nuevas versiones o parches de seguridad.

Para este tipo de escenarios, propios de una peli de terror, se inventaron los gestores de dependencias, que no son otra cosa que utilidades que te ayudan a instalar los paquetes que necesites y a ir comprobando e instalado las dependencias que, a su vez, tienen esos paquetes para funcionar.  
  
A nivel de sistema operativo un ejemplo serían **apt** y **yum** en Linux; para Javascript existen **npm** o **bower** y Java tiene **Maven**. Para PHP tenemos la fortuna de contar con **Composer**

![](http://galatar.com/wp-content/uploads/2018/01/logo-composer.png)

### Instalación desde Windows

Descarga el ejecutable para hacer una instalación automatizada desde la web de Composer [https://getcomposer.org/doc/00-intro.md#installation-windows](https://getcomposer.org/doc/00-intro.md#installation-windows)

Tras la instalación podrás utilizar Composer desde cualquier directorio utilizando la línea de comandos y tecleando **php composer.phar**

### Instalación desde Linux y Mac

Accede a la página de instalación de Composer y sigue las instrucciones [https://getcomposer.org/download/](https://getcomposer.org/download/) (el proceso de instalación cambia con cada versión así que es mejor que lo mires allí). Desde estos sistemas se puede utilizar Composer directamente desde línea de comando como si fuera un ejecutable sin necesidad de invocar a php. Así que, una vez instalado abre un terminal y teclea **composer**

## Comenzar a utilizar Composer

Composer no funciona a nivel global, sino a nivel de proyecto. Una vez instalado accede desde una terminal o línea de comandos al directorio raíz de tu proyecto y teclea **composer init** ó **php composer.phar init** si desarrollas con Windows.

Esto arranca el generador de configuración de Composer, que, de manera interactiva te irá pidiendo datos para generar el fichero de configuración de dependencias para tu proyecto, el fichero **composer.json**.

Te recomiendo irlo haciendo en paralelo a medida que vas siguiendo este tutorial.

![Cuadro de diálogo de composer init](http://galatar.com/wp-content/uploads/2018/01/composer_init-1024x531.png)

Primero te pide el nombre del proyecto que vas a generar, en realidad el lo llama “package” porque para Composer todo son paquetes y el formato que suele usarse es: **nombre\_desarrollador/nombre\_paquete** , si eres un pistolero solitario, o **nombre\_empresa/nombre\_paquete** si desarrollas para una empresa u organización. Luego te pide una descripción del proyecto, un número de versión para reflejar el estado de madurez del mismo (puedes dejarlo en blanco de momento), el tipo de paquete que vas a crear: librería, proyecto, metapaquete, plugin de Composer y por último el [tipo de licencia](https://es.wikipedia.org/wiki/Licencia_de_software) que vas a usar para tu proyecto (propietaria, GPL, BSD, MIT, etc. ).

Con esto ya tienes los parámetros básicos de tu proyecto, a continuación puedes empezar a declarar las dependencias que vas a utilizar. Para ello, continúa con la configuración (dile **Yes** cuando te pregunte si vas a definir dependencias).

Para cada dependencia que quieras definir primero pones el nombre aproximado del paquete para que Composer lo busque en su base de datos de paquetes ([https://packagist.org/](https://packagist.org/)), luego eliges uno de entre los resultados y a continuación pones la versión que quieres (déjalo en blanco si quieres la última). A modo de ejemplo instala el gestor de plantillas **twig/twig**. Tardará un poquito y de nuevo te preguntará si quieres seguir agregando dependencias.

Si quieres puedes seguir definiendo dependencias, cuando quieras parar pulsa la tecla **enter** la próxima vez que te pregunte **Search for a package:**

Cuidado no pulses **CTRL-C** ni cierres el terminal antes de terminar porque abortarías todo el proceso.

A continuación te pregunta si quieres definir dependencias en fase de desarrollo, si tienes alguna clara, adelante, si no teclea **No** para salir. Entonces te preguntará si quieres crear el fichero de configuración con los datos que has ido proporcionando, teclea **Yes** o pulsa **enter** para terminar.

Con esto se genera un fichero que se graba en la carpeta de tu proyecto como **composer.json** Abre el fichero para darle un vistazo y verás que contiene las opciones que has ido indicando.

```json
{  
    "name": "galatar/tuto_composer",  
    "description": "Tutorial sobre composer",  
    "type": "project",  
    "require": {  
        "twig/twig": "^2.4"  
    },  
    "authors": [  
        {  
            "name": "Juanan Ruiz",  
            "email": "juanan@us.es"  
        }  
    ]  
}
```

De momento no se ha descargado nada, ni se ha creado ningún otro fichero, para que Composer ejecute el fichero de configuración que acabas de definir escribe **composer install** en tu terminal.

Una vez que termine el proceso de descarga, a veces tarda un rato, puedes echar un vistazo a las carpetas y ficheros que se han creado en tu proyecto, en principio tendrás un nuevo fichero **composer.lock** y una carpeta **vendor**

```text
.  
├── composer.json  
├── composer.lock  
└── vendor  
    ├── autoload.php  
    ├── composer  
    ├── symfony  
    └── twig
```

El fichero **composer.lock** almacena los datos de los paquetes que Composer ha descargado, si le das un vistazo verás que contiene bastante información porque cada paquete que descargas tiene su propio fichero de dependencias (su propio composer.json) que queda reflejado en este fichero. Ten cuidado porque nunca debes tocar este fichero a mano, los cambios que necesites realizar los haces en tu fichero **composer.json** y luego los haces efectivos con la orden **composer update**. Por último, pero no menos importante, Composer crea la carpeta **vendor** donde se guardan los ficheros de los paquetes que has instalado y los ficheros que el propio Composer necesita para funcionar.

## Instalar paquetes para el entorno de desarrollo

Composer también te permite especificar paquetes que en principio estarán disponibles sólo en modo “desarrollo”, o sea, que solo deberían descargarse y utilizarse en los equipos de desarrollo y testeo de tu aplicación.

Habrás visto que una de las opciones que aparece al final del asistente de **composer init** dice algo así:

```text
Would you like to define your dev dependencies (require-dev) interactively [yes]?
```

Pues los paquetes que instales en ese momento se instalarán en una rama especial del fichero **composer.json** llamada **require-dev**.

Si no lo haces en ese momento también podrás añadir paquetes a esa rama en cualquier momento desde la línea de comandos usando algo como: **composer require monolog/monolog –dev**

Que instala **Monolog** un paquete de gestión de información super completo para hacer el seguimiento de logs de tu proyecto en modo desarrollo. Dentro de tu archivo composer.json se añadirá algo así:

```json
...  
"require-dev": {  
    "monolog/monolog": "^1.23",  
},  
...
```

En cualquier caso ten en cuenta que Composer no puede averiguar por arte de magia cuando está en un equipo de desarrollo y cuando en uno de producción, por lo que cuando estés desplegando tu proyecto en este último utiliza siempre **composer install –no-dev** o **composer update –no-dev**

## Trabajar con un proyecto existente que utiliza Composer

Si trabajas en equipo puede que otra persona haya creado y compartido contigo el proyecto. O puede que lo hayas creado tú siguiendo este tutorial y ahora quieras compartirlo con alguien más.

En este caso ya partes de un fichero **composer.json** que has debido recibir o compartir con el resto del proyecto. Lo que no has debido recibir ni compartir, si estás haciendo las cosas bien, es la carpeta **vendor** y su contenido.

Esa carpeta con sus ficheros y sus carpetas se van a crear en el nuevo entorno ejecutando **composer install** desde la raíz del proyecto.

Si utilizas un gestor de dependencias como **git** para programar en equipo (o simplemente para guardarte las espaldas) debes incluir en tu repositorio los archivos **composer.json** y **composer.lock** , pero debes excluir el directorio **vendor**. Este se creará solito en nuevas instancias de tu proyectos cuando ejecutes el comando **composer install** como has visto arriba.

## Autocarga de paquetes

La mayoría de los paquetes que descargues incluirán su propia información de autoload, para poder instanciar las clases que contienen. Otro de las ventajas de Composer es que el se encarga de organizar todo la autocarga directamente desde un fichero centralizado, este fichero se llama **autoload.php** y lo encontrarás en la carpeta **vendor** de tu proyecto.

Para poder acceder a cualquier clase sólo tendrás que incluir el fichero **autoload.php** desde tu script.

```php
<?php  
require_once '../vendor/autoload.php';  
$twig_loader = new Twig_Loader_Filesystem('../templates');  
$twig = new Twig_Environment($twig_loader, array('cache' => '../cache/twig',));
```

También puedes cargar tus propias clases utilizando Composer, sigue leyendo.

## Carga tus clases automáticamente con Composer

Si ya sabes de que van los espacios de nombre en PHP (espero que si) ahora es el momento de declarar el espacio de nombre raíz para tu proyecto y la carpeta donde el interprete de php debe buscar tus clases. Para ello añade algo parecido a lo siguiente en el fichero **composer.json**

```json
"autoload": {  
    "psr-4": {  
    "Galatar\\TutoComposer\": "src"  
    }  
}
```

Con lo que tendrás algo así:

```json
{  
  "name": "galatar/tuto_composer",  
  "description": "Tutorial sobre composer",  
  "type": "project",  
  "require": {  
      "twig/twig": "^2.4"  
  },  
  "require-dev": {  
      "monolog/monolog": "^1.23",  
  },  
  "autoload": {  
      "psr-4": {  
          "Galatar\\TutoComposer\": "src"  
      }  
  },  
  "authors": [  
      {  
          "name": "Juanan Ruiz",  
          "email": "juanan@us.es"  
      }  
  ]  
}
```

Ahora por fin podrás empezar a escribir tus primeras clases dejando en manos de Composer la carga automática de las mismas (autoload).

Crea una carpeta **src** en la raíz del proyecto y crea dentro de ella un fichero **Persona.php** con el siguiente contenido:

```php
<?php  
// src/Persona.php  
namespace Galatar\TutoComposer;  
class Persona  
{  
    public function saluda()  
    {  
        print("Hola soy una persona");  
    }  
}
```

Crea también en la raíz del proyecto una carpeta **public** y escribe en ella un fichero **index.php** con el siguiente contenido:

```php
<?php  
// tuto_galatar/public/index.php  
require_once '../vendor/autoload.php';  
use Galatar\TutoComposer\Persona;  
$persona = new Persona();  
$persona->saluda();
```

Ahora tu estructura de directorios debería parecerse a esto, si te fijas ya tienes un pequeño framework:

```
.  
├── composer.json  
├── composer.lock  
├── public  
│   └── index.php  
├── src  
│   └── Persona.php  
└── vendor  
    ├── autoload.php  
    ├── composer  
    ├── symfony  
    └── twig
```

Activa desde consola el servidor web que viene integrado con php utilizando la orden: **php -S localhost:8000**  

Ahora ve a tu navegador web y teclea: **http://localhost:8000**

Debería aparecer una página con la frase: **Hola soy una persona**

Gracias por haber llegado hasta aquí y espero que este tutorial te haya sido de utilidad.

Si algo no ha ido bien repasa de nuevo las instrucciones anteriores. Si tienes alguna duda o te gustaría que hablara del algún tema relacionado déjame un comentario e intentaré atenderte en cuanto pueda.

### Para más información

- [Libros Web: Composer, el manual oficial](http://librosweb.es/libro/composer/capitulo_2/cargando_clases_de_forma_automatica.html)