League Container

If you need to execute logic immediately when a service provider is added to the container (such as setting up inflectors or loading configuration files), implement the League\Container\ServiceProvider\BootableServiceProviderInterface.

By implementing this interface, you can define a boot(): void method. Unlike the register() method which is lazily invoked only when a service is requested, the boot() method is invoked eagerly as soon as the provider is registered with the container.

Use the boot() method for:

• Applying inflectors.
• Registering further service providers.
• Loading configuration files.

Note: If you attempt to register further service providers from a non-bootable provider, they will be ignored.

<?php 

namespace Acme\ServiceProvider;

use League\Container\ServiceProvider\AbstractServiceProvider;
use League\Container\ServiceProvider\BootableServiceProviderInterface;

class SomeServiceProvider extends AbstractServiceProvider implements BootableServiceProviderInterface
{
    public function boot(): void
    {
        $this->getContainer()
             ->inflector('SomeType')
             ->invokeMethod('someMethod', ['some_arg'])
         ;
    }

    public function provides(string $id): bool
    {
        // ...
    }

    public function register(): void
    {
        // ...
    }
}

Standard service providers are lazy. If you need to perform actions immediately when the provider is added to the container (such as setting up inflectors or loading configuration files), you must implement the League\Container\ServiceProvider\BootableServiceProviderInterface.

By implementing this interface, you can define a boot() method. Unlike register(), the boot() method is invoked eagerly as soon as the service provider is registered with the container.

Note: If you intend to apply inflectors or register further service providers from within a provider, that provider must be a bootable service provider.

<?php

namespace Acme\ServiceProvider;

use League\Container\ServiceProvider\AbstractServiceProvider;
use League\Container\ServiceProvider\BootableServiceProviderInterface;

class SomeServiceProvider extends AbstractServiceProvider implements BootableServiceProviderInterface
{
    protected $provides = [
        // ...
    ];

    public function boot()
    {
        // This is executed eagerly upon registration
        $this->getContainer()
             ->inflector('SomeType')
             ->invokeMethod('someMethod', ['some_arg']);
    }

    public function register()
    {
        // ...
    }
}

The compiled container is optimized for performance but introduces the following constraints:

• No Event Dispatch: Methods like on(), afterResolve(), and afterResolving() are ignored. Use addMethodCall() for configuration instead.
• No Runtime Additions: You cannot call add(), addShared(), or any definition methods after compilation. All services must be defined at compile time. If you need runtime flexibility, use the dynamic container.
• No getNew() Method: The compiled container implements Psr\\\Container\\\ContainerInterface only. Use get() on non-shared definitions to obtain new instances.
• No Closure Support: Closures cannot be serialized. Refactor them into factory classes or static methods.
• No Custom Delegates: Only the ReflectionContainer delegate (used for autowiring) is compiled. Custom delegates must be replaced with explicit service definitions.

The ReflectionContainer supports modern PHP type system features, including:

• Union Types: Resolving dependencies that use TypeA|TypeB syntax.
• Nullable Types: Handling parameters marked with ?Type.
• Promoted Constructor Properties: Automatically resolving dependencies defined directly in the constructor signature.

When using union types, ensure that the specific implementation required by the union is registered in the container (e.g., via $container->add(Interface::class, Implementation::class)).

// Example of a service using union types and nullable dependencies
class AdvancedService
{
    public function __construct(
        private readonly CacheInterface $cache,
        private readonly DatabaseLogger|FileLogger $logger,
        private readonly ?string $apiKey = null
    ) {}
}

$container = new League\Container\Container();
$container->delegate(new League\Container\ReflectionContainer());

// You must register implementations for interfaces used in union types
$container->add(CacheInterface::class, RedisCache::class);
$container->add(DatabaseLogger::class);

$service = $container->get(AdvancedService::class);

If you need to execute logic immediately when a provider is added (such as configuring inflectors or loading configuration files), implement the League\Container\ServiceProvider\BootableServiceProviderInterface.

Unlike the register() method which is called lazily, the boot() method is invoked eagerly as soon as the service provider is registered with the container.

Important: If you intend to apply inflectors or register further service providers from within a provider, that provider must be a BootableServiceProviderInterface implementation; otherwise, those actions will be ignored.

<?php 

namespace Acme\ServiceProvider;

use League\Container\ServiceProvider\AbstractServiceProvider;
use League\Container\ServiceProvider\BootableServiceProviderInterface;

class SomeServiceProvider extends AbstractServiceProvider implements BootableServiceProviderInterface
{
    public function boot(): void
    {
        $this->getContainer()
             ->inflector('SomeType')
             ->invokeMethod('someMethod', ['some_arg'])
         ;
    }

    public function provides(string $id): bool
    {
        // ...
    }

    public function register(): void
    {
        // ...
    }
}