Comment gérer vos projets PHP avec Composer inclus dans ServBay

En tant qu’environnement de développement web local performant, ServBay fournit Composer en pré-installation, ce qui simplifie grandement la gestion des dépendances pour vos projets PHP. Composer est l’outil incontournable de gestion de dépendances pour le développement PHP moderne : il permet d’intégrer facilement des bibliothèques tierces, de gérer automatiquement les relations complexes entre dépendances et d’offrir un chargement automatique des classes. Grâce à ServBay, vous n’avez aucune installation ou configuration supplémentaire à effectuer : profitez de Composer pour accélérer votre développement PHP dès la prise en main.

Présentation de Composer

Composer est un gestionnaire de dépendances pour les projets PHP. Il permet aux développeurs de déclarer les bibliothèques externes (appelées paquets) nécessaires à leur projet, et de les installer ou mettre à jour automatiquement. Composer ne gère pas seulement des librairies, mais aussi des frameworks, composants, plugins et bien plus.

Points clés

1. Gestion des dépendances : Composer gère automatiquement toutes les dépendances de votre projet, garantit la compatibilité des versions et résout les éventuels conflits entre paquets.
2. Autoloading : Composer génère un script d’autoload unifié pour vous permettre d’utiliser facilement les classes installées via Composer, sans avoir à les inclure manuellement avec include ou require.
3. Gestion des versions : Vous pouvez spécifier les contraintes de version dans le fichier composer.json. Composer téléchargera alors les versions appropriées et verrouillera l’installation courante dans le fichier composer.lock pour garantir que tous les membres de l’équipe utilisent strictement les mêmes versions de dépendances quel que soit l’environnement.
4. Gestion des paquets : Composer utilise le dépôt central Packagist pour trouver et récupérer des paquets. Vous pouvez donc importer quasi toutes les bibliothèques PHP populaires en quelques secondes.
5. Communauté : Composer possède une large communauté active, ainsi qu’une documentation très riche.

Composer intégré à ServBay

ServBay intègre plusieurs versions de PHP et vous fournit Composer dès l’installation. Concrètement, il n’est pas nécessaire de télécharger ou configurer séparément Composer : il est prêt à être utilisé, toujours associé à la version de PHP actuellement active dans ServBay. Vous pouvez donc simplement utiliser la commande composer ou composer-2.2 dans le terminal de votre projet.

Astuce

Il existe deux versions principales de Composer : Composer 2.8.x (la plus récente), compatible avec PHP 7.2+, et Composer 2.2.x LTS, destiné aux anciennes versions de PHP (PHP 5.3 – PHP 7.1).

ServBay est fourni par défaut avec Composer 2.8.x pour PHP 7.2+.

Si vous travaillez avec PHP 5.3 – PHP 7.1, installez le paquet Composer 2.2.x LTS depuis la section “Paquets” de ServBay, puis utilisez la commande composer-2.2 pour l’exécuter. Les deux versions cohabitent sans conflit.

Gérer les dépendances avec Composer

Composer gère les dépendances d’un projet au travers du fichier composer.json placé à la racine du projet. Voici les étapes de base pour le créer et l’utiliser.

1. Créer le fichier composer.json

Dans le dossier racine de votre projet PHP, créez un fichier appelé composer.json. Par exemple, si vous travaillez dans /Applications/ServBay/www/mon_projet_php, créez le fichier dans ce dossier.

Le composer.json est un fichier JSON où la clé require permet de spécifier les dépendances. Les clés sont les noms des paquets (généralement sous la forme vendor/package) et les valeurs représentent les contraintes de version.

Par exemple, pour installer la librairie Monolog (un gestionnaire de logs PHP populaire) en version 2.0 minimum :

{
    "require": {
        "monolog/monolog": "^2.0"
    }
}

Ici, ^2.0 signifie : toute version compatible à partir de 2.0.0, jusqu’à — mais excluant — la version 3.0.0.

2. Installer les dépendances

En ligne de commande, placez-vous dans le dossier contenant le fichier composer.json puis exécutez :

composer install

Ce que fait cette commande :

• Composer lit le fichier composer.json.
• Il détermine toutes les dépendances nécessaires (y compris leurs propres dépendances).
• Il télécharge les bibliothèques dans le dossier vendor à la racine du projet.
• Un fichier composer.lock est généré, listant précisément les versions installées. Ce fichier est crucial et doit être versionné avec votre code (par exemple sur Git) pour garantir que tout le monde travaille avec les mêmes versions.
• Un fichier d’autoload est généré, généralement à vendor/autoload.php.

En cas de succès, le dossier vendor ainsi que composer.lock apparaissent à la racine de votre projet.

Bénéficier de l’autoloading de Composer

La fonctionnalité phare de Composer est le chargement automatique des classes (“autoloading”), qui respecte les standards tels que PSR-0 ou PSR-4 pour faire correspondre les espaces de noms aux chemins de fichiers. Voici comment exploiter la fonctionnalité :

1. Configurer le champ autoload

Ajoutez ou modifiez la section autoload de votre fichier composer.json. Par exemple, pour faire correspondre le namespace App\ au dossier src/ :

{
    "require": {
        "monolog/monolog": "^2.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Cela indique à Composer que toute classe débutant par App\ doit être recherchée dans le dossier src/ (ex : App\MyClass ⇒ src/MyClass.php).

2. Générer les fichiers d’autoload

Après avoir modifié la configuration autoload, exécutez :

composer dump-autoload

Cette commande régénère le fichier vendor/autoload.php. Si vous installez ou mettez à jour des dépendances mais n’avez pas touché à autoload, l’exécution de composer install ou composer update suffit également.

3. Inclure le fichier d’autoload dans votre code

Débutez vos scripts PHP en incluant le fichier d’autoload généré par Composer :

<?php

// Inclusion du fichier d’autoload généré par Composer
require __DIR__ . '/vendor/autoload.php';

// Vous pouvez maintenant utiliser toutes les bibliothèques installées par Composer ou vos propres classes autoloadées
use Monolog\Logger;
use Monolog\Handler\StreamHandler;
use App\MyClass; // Si vous avez configuré le namespace App\ dans autoload

// Utilisation de la librairie Monolog
$log = new Logger('name');
$log->pushHandler(new StreamHandler('your.log', Logger::WARNING));
$log->warning('Ceci est un avertissement !');

// Utilisation de vos propres classes (si configuré dans autoload)
// $myObject = new MyClass();
// $myObject->doSomething();

?>

Grâce à la ligne require __DIR__ . '/vendor/autoload.php';, toutes les classes gérées par Composer sont accessibles partout dans le projet, sans multiplier manuellement les require ou include — un vrai gain de temps et de robustesse.

Mettre à jour les dépendances

Quand un projet évolue, vous avez souvent besoin de mettre à jour vos librairies.

Dans le dossier racine du projet, exécutez :

composer update

• composer update vérifie si de nouvelles versions satisfaisant les contraintes de composer.json sont disponibles (y compris les dépendances internes).
• Installe les nouvelles versions si elles existent.
• Met à jour le fichier composer.lock afin de refléter précisément les nouvelles versions installées.

À noter :

• composer install vs composer update : Utilisez composer install en priorité pour installer un projet à partir du fichier composer.lock (cohérence garantie de l’environnement). composer update sert principalement à mettre à jour explicitement les dépendances (et modifie le fichier composer.lock). En équipe, on n’exécute composer update qu'en cas de besoin, puis on versionne ensuite le nouveau duo composer.json + composer.lock.

Conseils pour utiliser Composer dans ServBay

ServBay facilite le développement local, mais voici quelques recommandations :

1. Environnement terminal : Assurez-vous d’exécuter Composer dans un terminal où ServBay a correctement configuré les variables d’environnement : choisissez toujours un nouveau terminal après avoir lancé ServBay pour être certain que les commandes php et composer sont disponibles. En cas de message command not found, redémarrez le terminal ou vérifiez que ServBay fonctionne.
2. Version PHP : ServBay permet de changer de version PHP à la volée. Composer s’exécutera toujours avec celle qui est active dans l’interface ServBay. Pour utiliser une version PHP spécifique (par exemple si vous devez installer une bibliothèque qui ne supporte qu’une ancienne version), sélectionnez d’abord la bonne version dans ServBay, puis lancez Composer.
3. Chemin projet : Par souci de simplicité, placez toujours vos projets web dans un sous-dossier de /Applications/ServBay/www et configurez-les via le panneau ServBay pour un accès immédiat par le navigateur. Exécutez les commandes Composer directement dans le sous-dossier du projet.

Exercice pratique : installer GuzzleHttp avec Composer

Exemple d’utilisation de Composer dans un projet ServBay avec la librairie GuzzleHttp (un client HTTP populaire pour PHP).

1. Créez le dossier projet et placez-vous dedans : Dans le répertoire racine de ServBay, créez un nouveau dossier et placez-vous à l’intérieur :

   cd /Applications/ServBay/www
   mkdir guzzle_demo.servbay.demo
   cd guzzle_demo.servbay.demo

   Ici, le répertoire suit la convention de nommage “démonstration” de ServBay.

2. Créez le fichier composer.json : Ajoutez le fichier suivant dans guzzle_demo.servbay.demo :

   {
       "require": {
           "guzzlehttp/guzzle": "^7.0"
       },
       "autoload": {
            "psr-4": {
                "App\\": "src/"
            }
        }
   }

   On ajoute la configuration PSR-4 pour de bonnes pratiques, même si elle n’est pas utilisée dans cet exemple simple.

3. Installez les dépendances : Dans guzzle_demo.servbay.demo :

   composer install

   GuzzleHttp et ses dépendances s’installent automatiquement, ainsi que le répertoire vendor et le fichier composer.lock.

4. Créez un fichier PHP pour utiliser la dépendance : Créez le fichier index.php :

   <?php
   // Inclusion du fichier d’autoload généré par Composer
   require __DIR__ . '/vendor/autoload.php';
   
   use GuzzleHttp\Client;
   use GuzzleHttp\Exception\RequestException;
   
   echo "<h1>Démo GuzzleHttp</h1>";
   echo "<pre>";
   
   try {
       // Création d’une instance Guzzle
       $client = new Client();
   
       // Envoi d’une requête GET
       $response = $client->request('GET', 'https://httpbin.org/get', [
           'query' => ['param1' => 'value1', 'param2' => 'value2']
       ]);
   
       // Récupération du corps de la réponse
       $body = $response->getBody()->getContents();
       echo "Contenu de la réponse :\n";
       echo $body;
   
       // Code de statut HTTP
       $statusCode = $response->getStatusCode();
       echo "\n\nCode HTTP : " . $statusCode;
   
   } catch (RequestException $e) {
       // Gestion des erreurs de requête
       echo "Exception lors de la requête :\n";
       echo $e->getMessage();
       if ($e->hasResponse()) {
           echo "\nStatut HTTP : " . $e->getResponse()->getStatusCode();
           echo "\nContenu de la réponse : " . $e->getResponse()->getBody()->getContents();
       }
   } catch (\Exception $e) {
       // Gestion des autres erreurs
       echo "Une erreur est survenue :\n";
       echo $e->getMessage();
   }
   
   echo "</pre>";
   ?>

   Ce script inclut l’autoload, utilise Guzzle pour envoyer une requête à une API de test, puis affiche la réponse.

5. Configurez le site dans ServBay : Ouvrez le panneau ServBay, onglet “Sites” (ou “Hôtes”), cliquez sur “Ajouter”, puis ciblez le dossier /Applications/ServBay/www/guzzle_demo.servbay.demo et donnez-lui le domaine guzzle_demo.servbay.demo. Sauvegardez et redémarrez le serveur web (Caddy ou Nginx).

6. Testez dans le navigateur : Visitez l’URL http://guzzle_demo.servbay.demo/. Vous verrez alors la sortie PHP affichant le résultat reçu depuis https://httpbin.org/get.

Foire Aux Questions (FAQ)

Q : J’utilise PHP 5.6 et Composer ne fonctionne pas, que faire ?

R : ServBay propose deux versions de Composer : la version principale 2.8.x, et la version LTS 2.2.x conçue pour les anciens PHP. Pour PHP 5.6, installez Composer 2.2 LTS et utilisez la commande composer-2.2.

Q : Dans mon terminal, la commande composer n’est pas reconnue (“command not found”). Que faire ?

R :

1. Vérifiez que ServBay fonctionne.
2. Fermez puis rouvrez votre terminal pour recharger les variables d’environnement.
3. Assurez-vous d’avoir au moins une version de PHP activée dans le panneau ServBay.
4. Si le problème persiste, essayez d’utiliser le chemin absolu du PHP de ServBay pour lancer Composer, par exemple /Applications/ServBay/php/8.2/bin/php /usr/local/bin/composer install (ajustez le chemin selon votre configuration). L’objectif de ServBay reste cependant de pouvoir utiliser la commande composer directement.

Q : Comment forcer Composer à utiliser une version précise de PHP dans ServBay ?

R : Composer utilisera toujours la version de PHP activée via l’onglet “PHP” du panneau ServBay. Pour changer la version de PHP utilisée par Composer, sélectionnez-la dans ServBay, ouvrez un nouveau terminal, puis relancez vos commandes Composer.

Q : À quoi sert composer.lock ? Dois-je le versionner dans Git ?

R : Le fichier composer.lock enregistre exactement les versions des dépendances installées après chaque exécution de composer install ou composer update. Il est vivement recommandé de le committer dans votre gestionnaire de version (Git, etc.) afin de garantir une cohérence parfaite des versions sur toutes les machines et tous les environnements de déploiement, et éviter le fameux “ça marche chez moi”. Quand un collaborateur clone votre projet, composer install s’appuie sur composer.lock en priorité.

Conclusion

L’intégration en natif de Composer dans ServBay offre aux développeurs PHP un environnement de développement local puissant et ergonomique. Il devient ainsi extrêmement simple de gérer les dépendances de vos projets, d’exploiter l’autoloading, et de travailler sur différents environnements PHP. Cette synergie ServBay + Composer est aujourd’hui un incontournable pour accélérer le développement, fiabiliser les workflows, et garantir la maintenabilité de vos projets PHP modernes.