Illuminate\Support\Manager — anatomie van het driversysteem

Wat is Manager?

Illuminate\Support\Manager is een abstracte klasse die al sinds Laravel 4.0 bestaat. Ze biedt de basis om eenvoudig systemen te bouwen waarin je tussen meerdere “drivers” kunt wisselen, zoals cache, sessies en mail. Een “driver” is een backend met dezelfde interface maar een andere interne implementatie. Voor sessies bestaan er bijvoorbeeld drivers zoals file, cookie, database en redis, en je wisselt ertussen via de driver-sleutel in het configuratiebestand.

Gebruik binnen het framework

Er bestaan klassen die wel Manager in hun naam hebben, maar niet van Illuminate\Support\Manager erven.

Klasse	Erft van `Manager`?
`Illuminate\Session\SessionManager`	✅ Erft ervan
`Illuminate\Cache\CacheManager`	❌ Erft er niet van (eigen implementatie)
`Illuminate\Queue\QueueManager`	❌ Erft er niet van (eigen implementatie)
`Laravel\Socialite\SocialiteManager`	✅ Erft ervan

Ook de klassen die er niet van erven volgen hetzelfde basisidee van uitbreiden via extend(). Wie het Manager-patroon begrijpt, begrijpt daarmee ook hoe het framework als geheel werkt.

Hoe het in de basis werkt

driver() — een driver ophalen

Als je driver() aanroept, wordt de driver in de volgende stappen opgelost. Als je de daadwerkelijke broncode bekijkt, wordt de methodenaam samengesteld uit de drivernaam via Str::studly().

// Uit Illuminate\Support\Manager::createDriver()
protected function createDriver($driver)
{
    if (isset($this->customCreators[$driver])) {
        return $this->callCustomCreator($driver);
    }

    $method = 'create'.Str::studly($driver).'Driver';

    if (method_exists($this, $method)) {
        return $this->$method();
    }

    throw new InvalidArgumentException("Driver [$driver] not supported.");
}

Voor de file-driver wordt dus createFileDriver() aangeroepen, en voor de my-custom-driver createMyCustomDriver().

extend() — een custom driver registreren

Door een drivernaam en een closure aan extend() door te geven, kun je je eigen driver registreren. Het argument van de closure is de containerinstantie.

use Illuminate\Support\Facades\Session;

Session::extend('redis-cluster', function ($app) {
    return new RedisClusterSessionHandler(
        $app->make('redis'),
        $app['config']['session'],
    );
});

Omdat extend() de closure aan $this bindt, heb je binnen de closure toegang tot de properties en methodes van de Manager.

// Uit Illuminate\Support\Manager::extend()
public function extend($driver, Closure $callback)
{
    try {
        $callback = $callback->bindTo($this, static::class) ?? throw new RuntimeException;
    } catch (Throwable) {
        $callback = $callback->bindTo(null, static::class);
    }

    $this->customCreators[$driver] = $callback;

    return $this;
}

__call — delegatie naar de standaarddriver

De Manager-klasse implementeert __call, waardoor methodeaanroepen die niet op de Manager zelf bestaan automatisch worden gedelegeerd naar de standaarddriver.

public function __call($method, $parameters)
{
    return $this->driver()->$method(...$parameters);
}

Zo kun je de Manager rechtstreeks gebruiken, zoals SessionManager::get('key'), terwijl het eigenlijke werk aan de driver wordt overgelaten.

Implementatievoorbeeld: SessionManager

Als je Illuminate\Session\SessionManager bekijkt, zie je concreet hoe je Manager gebruikt.

namespace Illuminate\Session;

use Illuminate\Support\Manager;

class SessionManager extends Manager
{
    // Verplicht: geeft de standaarddriver terug
    public function getDefaultDriver()
    {
        return $this->config->get('session.driver');
    }

    // Aanmaken van de file-driver
    protected function createFileDriver()
    {
        return $this->createNativeDriver();
    }

    // Aanmaken van de database-driver
    protected function createDatabaseDriver()
    {
        $table = $this->config->get('session.table');
        $lifetime = $this->config->get('session.lifetime');

        return $this->buildSession(new DatabaseSessionHandler(
            $this->getDatabaseConnection(), $table, $lifetime, $this->container
        ));
    }

    // Aanmaken van de redis-driver
    protected function createRedisDriver()
    {
        $handler = $this->createCacheHandler('redis');
        // ...
        return $this->buildSession($handler);
    }
}

Manager gebruiken in je eigen package

Basisimplementatie

We maken een custom klasse die van Manager erft, met een notificatieservice als voorbeeld.

Maak een klasse die van Manager erft

namespace App\Notifications;

use Illuminate\Support\Manager;

class NotificationManager extends Manager
{
    public function getDefaultDriver(): string
    {
        return $this->config->get('notifications.driver', 'slack');
    }

    protected function createSlackDriver(): SlackNotifier
    {
        return new SlackNotifier(
            $this->config->get('notifications.slack'),
        );
    }

    protected function createEmailDriver(): EmailNotifier
    {
        return new EmailNotifier(
            $this->config->get('notifications.email'),
        );
    }

    protected function createLogDriver(): LogNotifier
    {
        return new LogNotifier(
            $this->container->make('log'),
        );
    }
}

Registreer in een service provider

namespace App\Providers;

use App\Notifications\NotificationManager;
use Illuminate\Support\ServiceProvider;

class NotificationServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->singleton(NotificationManager::class, function ($app) {
            return new NotificationManager($app);
        });
    }
}

Voeg een custom driver toe

// In bijvoorbeeld AppServiceProvider::boot()

$manager = app(NotificationManager::class);

$manager->extend('teams', function ($app) {
    return new TeamsNotifier(
        $app['config']['notifications.teams'],
    );
});

Gebruik hem

$manager = app(NotificationManager::class);

// Gebruik de standaarddriver
$manager->send('Bericht');

// Geef een specifieke driver op
$manager->driver('email')->send('Bericht');

// Een eenmaal opgeloste driver wordt gecachet
$manager->driver('slack'); // Dezelfde instantie wordt teruggegeven

MultipleInstanceManager

Illuminate\Support\MultipleInstanceManager is een klasse die in Laravel 10 is toegevoegd. Waar Manager de “soorten” drivers beheert, kan MultipleInstanceManager meerdere benoemde “instanties” beheren.

Verschillen met Manager

	`Manager`	`MultipleInstanceManager`
Beheereenheid	Soort driver (`file`, `redis`, enz.)	Benoemde instanties (`mailer1`, `mailer2`, enz.)
Configuratie	Eén standaarddriver	Configuratie per instantie
Typisch gebruik	Sessies, cache, enz.	Mail, logging en andere zaken die meerdere verbindingen nodig hebben
Ophaalmethode	`driver()`	`instance()`

Verplichte methodes

Als je van MultipleInstanceManager erft, moet je drie methodes implementeren.

// Uit de broncode
abstract public function getDefaultInstance();
abstract public function setDefaultInstance($name);
abstract public function getInstanceConfig($name);

getInstanceConfig() geeft de configuratie-array terug die bij de naam hoort. De configuratie moet altijd een driver-sleutel bevatten (of de sleutel die je via $driverKey hebt opgegeven).

Resolutieflow

Implementatievoorbeeld in je eigen package

Als voorbeeld nemen we een package dat gelijktijdig meerdere sms-gateways ondersteunt.

namespace App\Sms;

use Illuminate\Support\MultipleInstanceManager;

class SmsManager extends MultipleInstanceManager
{
    // Naam van de standaardinstantie
    public function getDefaultInstance(): string
    {
        return $this->config->get('sms.default', 'primary');
    }

    public function setDefaultInstance($name): void
    {
        $this->config->set('sms.default', $name);
    }

    // Geeft de configuratie terug die bij de instantienaam hoort
    public function getInstanceConfig($name): array
    {
        return $this->config->get("sms.gateways.{$name}");
    }

    // Aanmaken van de twilio-driver (de configuratie-array wordt doorgegeven)
    protected function createTwilioDriver(array $config): TwilioSmsGateway
    {
        return new TwilioSmsGateway(
            $config['account_sid'],
            $config['auth_token'],
        );
    }

    // Aanmaken van de vonage-driver
    protected function createVonageDriver(array $config): VonageSmsGateway
    {
        return new VonageSmsGateway(
            $config['api_key'],
            $config['api_secret'],
        );
    }
}

Het bijbehorende configuratiebestand:

// config/sms.php
return [
    'default' => 'primary',

    'gateways' => [
        'primary' => [
            'driver' => 'twilio',
            'account_sid' => env('TWILIO_ACCOUNT_SID'),
            'auth_token' => env('TWILIO_AUTH_TOKEN'),
        ],
        'backup' => [
            'driver' => 'vonage',
            'api_key' => env('VONAGE_API_KEY'),
            'api_secret' => env('VONAGE_API_SECRET'),
        ],
        'marketing' => [
            'driver' => 'twilio',
            'account_sid' => env('TWILIO_MARKETING_SID'),
            'auth_token' => env('TWILIO_MARKETING_TOKEN'),
        ],
    ],
];

Bij gebruik geef je de naam op via instance().

$sms = app(SmsManager::class);

// Gebruik de standaardinstantie (primary = twilio)
$sms->send('+81901234xxxx', 'Verificatiecode: 123456');

// Geef een instantie op via de naam
$sms->instance('backup')->send('+81901234xxxx', 'Verificatiecode: 123456');

// Gebruik de marketinginstantie
$sms->instance('marketing')->send('+81901234xxxx', 'Aankondiging van de campagne');

Aan MultipleInstanceManager kun je, net als bij Manager, custom drivers toevoegen via extend(). Ook __call is geïmplementeerd, dus methodes die niet op de instantie zelf bestaan worden gedelegeerd naar de standaardinstantie.

Drivercache beheren

Cachebewerkingen van Manager

// Alle drivers ophalen
$drivers = $manager->getDrivers();

// De cache van alle drivers wissen
$manager->forgetDrivers();

Cachebewerkingen van MultipleInstanceManager

// Een specifieke instantie verwijderen
$manager->forgetInstance('backup');

// De standaardinstantie verwijderen
$manager->forgetInstance();

// Meerdere instanties in één keer verwijderen
$manager->forgetInstance(['primary', 'backup']);

// De instantie verwijderen en ook de cache wissen
$manager->purge('backup');

Samenvatting

Manager beheert de “soorten” drivers. Je implementeert createXxxDriver()-methodes en breidt uit via extend()
MultipleInstanceManager beheert “instanties” van drivers per naam. Geschikt voor packages die meerdere verbindingsconfiguraties nodig hebben
Niet elke klasse met Manager in de naam erft van Illuminate\Support\Manager. CacheManager en QueueManager hebben een eigen implementatie

Macroable-trait

Leer hoe je met de Macroable-trait eigen methodes toevoegt aan bestaande klassen.

AI-ontwikkeling

Design patterns

Package-ontwikkeling

Applicatiestructuur

Nieuwe functies in Laravel 13

Eloquent in detail

Validatie-uitbreidingen

Authenticatie uitbreiden

Beveiliging

Queues

Testen

Illuminate\Support\Manager — anatomie van het driversysteem

Wat is Manager?

Gebruik binnen het framework

Hoe het in de basis werkt

driver() — een driver ophalen

extend() — een custom driver registreren

__call — delegatie naar de standaarddriver

Implementatievoorbeeld: SessionManager

Manager gebruiken in je eigen package

Basisimplementatie

MultipleInstanceManager

Verschillen met Manager

Verplichte methodes

Resolutieflow

Implementatievoorbeeld in je eigen package

Drivercache beheren

Cachebewerkingen van Manager

Cachebewerkingen van MultipleInstanceManager

Samenvatting

Macroable-trait

​Wat is Manager?

​Gebruik binnen het framework

​Hoe het in de basis werkt

​driver() — een driver ophalen

​extend() — een custom driver registreren

​__call — delegatie naar de standaarddriver

​Implementatievoorbeeld: SessionManager

​Manager gebruiken in je eigen package

​Basisimplementatie

​MultipleInstanceManager

​Verschillen met Manager

​Verplichte methodes

​Resolutieflow

​Implementatievoorbeeld in je eigen package

​Drivercache beheren

​Cachebewerkingen van Manager

​Cachebewerkingen van MultipleInstanceManager

​Samenvatting

Macroable-trait

Wat is Manager?

Gebruik binnen het framework

Hoe het in de basis werkt

driver() — een driver ophalen

extend() — een custom driver registreren

__call — delegatie naar de standaarddriver

Implementatievoorbeeld: SessionManager

Manager gebruiken in je eigen package

Basisimplementatie

MultipleInstanceManager

Verschillen met Manager

Verplichte methodes

Resolutieflow

Implementatievoorbeeld in je eigen package

Drivercache beheren

Cachebewerkingen van Manager

Cachebewerkingen van MultipleInstanceManager

Samenvatting