PHP Composer: Pakete installieren und Klassen autoloaden

Composer ist der Paketmanager für PHP. Führe composer require vendor/package in deinem Projektordner aus: Composer lädt die Bibliothek nach vendor/, trägt sie in composer.json ein, und du lädst sie, zusammen mit allem anderen, was du installiert hast, mit einer Zeile, require __DIR__ . '/vendor/autoload.php';.

composer require monolog/monolog

<?php
require __DIR__ . '/vendor/autoload.php';

use Monolog\Logger;
use Monolog\Handler\StreamHandler;
use Monolog\Level;

$log = new Logger('app');
$log->pushHandler(new StreamHandler(__DIR__ . '/app.log', Level::Warning));
$log->warning('Disk almost full', ['free' => '2%']);

Kein include für jede Datei: Der Autoloader lädt Logger, StreamHandler und alles, was sie verwenden, beim ersten Bedarf der jeweiligen Klasse. Pakete kommen von Packagist, dem öffentlichen Verzeichnis, das Composer standardmäßig durchsucht.

Composer installieren

Composer braucht zuerst PHP auf deinem Rechner (siehe PHP installieren).

Windows: Lade Composer-Setup.exe von getcomposer.org herunter und führe es aus. Es findet deine php.exe und fügt composer zum PATH hinzu. Öffne danach ein neues Terminal.

macOS mit Homebrew:

brew install composer

Linux: Das Paket deiner Distribution (sudo apt install composer unter Debian und Ubuntu) funktioniert, ist aber oft ein älteres Release. Der offizielle Installer liefert das aktuelle:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"
sudo mv composer.phar /usr/local/bin/composer

Die Download-Seite auf getcomposer.org zeigt außerdem eine Zeile, die den Hash des Installers prüft, bevor er läuft; kopiere die Befehle von dort, um den aktuellen Hash zu bekommen. Prüfe dann, ob es funktioniert:

composer --version

composer.json und composer.lock

composer init stellt ein paar Fragen und schreibt composer.json, oder composer require legt sie beim ersten Paket an. Eine typische Datei:

{
    "name": "acme/shop",
    "require": {
        "php": ">=8.2",
        "monolog/monolog": "^3.0",
        "vlucas/phpdotenv": "^5.6"
    },
    "require-dev": {
        "phpunit/phpunit": "^11.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

• require listet auf, was das Projekt zum Laufen braucht, einschließlich der PHP-Version.
• require-dev listet Werkzeuge nur für die Entwicklung auf (Tests, statische Analyse). composer require --dev phpunit/phpunit fügt dort etwas hinzu, und composer install --no-dev überspringt es auf Produktionsservern.
• autoload sagt Composer, wo deine eigenen Klassen liegen (unten).

Daneben schreibt Composer composer.lock mit der genauen Version jedes installierten Pakets, einschließlich der Pakete, von denen deine Pakete abhängen. Committe beide Dateien. Committe vendor/ nicht: Trag es in .gitignore ein, denn composer install baut es aus der Lock-Datei neu auf.

composer install vs composer update

composer install          # install exactly what composer.lock says
composer update           # pick the newest allowed versions, rewrite composer.lock
composer update monolog/monolog   # update one package only
composer remove monolog/monolog   # uninstall and remove from composer.json
composer outdated         # list packages with newer versions available

Führe composer install nach dem Klonen eines Projekts und bei jedem Deployment aus: Alle bekommen dieselben Versionen, die getestet wurden. Führe composer update nur aus, wenn du aktualisieren willst, teste dann und committe die neue composer.lock. update auf einem Produktionsserver auszuführen installiert Versionen, die niemand getestet hat.

Versionsangaben: ^ und ~

composer require vendor/package ohne Version wählt das neueste stabile Release und schreibt dafür eine Angabe mit ^, und das ist meist das, was du willst.

Eigene Klassen mit PSR-4 autoloaden

PSR-4 ist die Konvention, die einen Namespace einem Ordner zuordnet: Mit "App\\": "src/" liegt die Klasse App\Text\Slug in src/Text/Slug.php. Nachdem du den Abschnitt autoload hinzugefügt hast, führst du aus:

composer dump-autoload

Der Autoloader von Composer ist eine mit spl_autoload_register() registrierte Funktion, die PHP aufruft, wann immer Code eine Klasse verwendet, die noch nicht geladen ist. Dieser Block schreibt zwei Klassendateien und registriert einen eigenen kleinen PSR-4-Autoloader, damit du die Zuordnung arbeiten siehst. Füge eine dritte Klassendatei hinzu und verwende sie.

<?php
// Two class files, laid out the PSR-4 way
is_dir('src/Text') || mkdir('src/Text', 0777, true);

file_put_contents('src/Greeter.php', <<<'PHP'
<?php
namespace App;

class Greeter
{
    public function hello(string $name): string
    {
        return "Hello, $name";
    }
}
PHP);

file_put_contents('src/Text/Slug.php', <<<'PHP'
<?php
namespace App\Text;

class Slug
{
    public static function from(string $title): string
    {
        return trim(preg_replace('/[^a-z0-9]+/', '-', strtolower($title)), '-');
    }
}
PHP);

// What vendor/autoload.php does for "App\\": "src/"
spl_autoload_register(function (string $class): void {
    $prefix = 'App\\';
    if (!str_starts_with($class, $prefix)) {
        return;
    }
    $file = __DIR__ . '/src/' . str_replace('\\', '/', substr($class, strlen($prefix))) . '.php';
    echo "autoload: $class => ", substr($file, strlen(__DIR__) + 1), "\n";
    if (is_file($file)) {
        require $file;
    }
});

echo (new App\Greeter())->hello('Ada'), "\n";
echo App\Text\Slug::from('Composer & PSR-4, Explained'), "\n";
echo App\Text\Slug::from('Loaded once, used twice'), "\n";

Der Autoloader läuft einmal pro Klasse: Der zweite Aufruf von Slug::from() gibt keine Zeile autoload: aus, weil die Klasse schon geladen ist. In einem echten Projekt schreibst du diese Funktion nie selbst; vendor/autoload.php registriert die Version von Composer, die auch die Pakete in vendor/ behandelt. Namespaces behandelt die Seite zu Namespaces.

Typische Fehler

• Class "Monolog\Logger" not found. Das Skript hat require 'vendor/autoload.php' nicht aufgerufen, oder der Pfad ist falsch. Verwende __DIR__ . '/vendor/autoload.php', damit der Pfad nicht vom aktuellen Verzeichnis abhängt.
• Deine eigene Klasse wird nach dem Eintrag in autoload nicht gefunden. Führe composer dump-autoload aus und prüfe, dass der Dateipfad genau zum Namespace passt, einschließlich Groß- und Kleinschreibung: App\Text\Slug muss src/Text/Slug.php sein, und Linux-Server behandeln src/text/slug.php als andere Datei.
• Your requirements could not be resolved to an installable set of packages. Zwei Pakete brauchen unvereinbare Versionen von etwas, oft von PHP selbst. Die Meldung listet den Konflikt auf; composer why-not vendor/package 2.0 erklärt, was eine Version blockiert.
• composer wird nicht erkannt. Das Terminal wurde vor der Installation geöffnet, oder der Ordner steht nicht im PATH. Öffne ein neues Terminal oder ruf php composer.phar direkt auf.