PHP-DI

https://php-di.org/doc
Admin
PHP-DI is a powerful, practical, and lightweight dependency injection container for PHP designed to...
Tokens:20,407
Snippets:319
Trust Score:9.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install PHP-DI Slim bridge

Source: https://php-di.org/doc/frameworks/slim.html

Use Composer to install the bridge package.

```bash
composer require php-di/slim-bridge
```

--------------------------------

### Install doctrine/cache library

Source: https://php-di.org/doc/migration/5.0.html

Install the doctrine/cache library if a cache is configured for the container.

```bash
composer require doctrine/cache
```

--------------------------------

### Full Bootstrap Configuration Example

Source: https://php-di.org/doc/frameworks/zf1.html

A comprehensive Bootstrap method including environment-specific configuration and caching.

```php
    protected function _initContainer()
    {
        $configuration = new Zend_Config($this->getOptions());

        $builder = new ContainerBuilder();
        $builder->addDefinitions(APPLICATION_PATH . '/configs/config.php');
        $builder->addDefinitions(APPLICATION_PATH . '/configs/config.' . APPLICATION_ENV . '.php');
        $builder->addDefinitions(APPLICATION_PATH . '/configs/parameters.php');

        if (APPLICATION_ENV === 'production') {
            $cache = new MemcachedCache();
            $memcached = new Memcached();
            $memcached->addServer('localhost', 11211);
            $cache->setMemcached($memcached);
        } else {
            $cache = new ArrayCache();
        }
        $cache->setNamespace('MyApp');
        $builder->setDefinitionCache($cache);

        $this->container = $builder->build();

        $dispatcher = new \DI\Bridge\ZendFramework1\Dispatcher();
        $dispatcher->setContainer($this->container);
        Zend_Controller_Front::getInstance()->setDispatcher($dispatcher);
    }
```

--------------------------------

### Install PHP-DI Silex Bridge

Source: https://php-di.org/doc/frameworks/silex.html

Use Composer to add the bridge to your project.

```bash
$ composer require php-di/silex-bridge
```

--------------------------------

### Install PHP-DI ZF2 bridge

Source: https://php-di.org/doc/frameworks/zf2.html

Install the required bridge package via Composer.

```bash
composer require php-di/zf2-bridge
```

--------------------------------

### Definition Compilation Example

Source: https://php-di.org/doc/performances.html

Shows a standard definition and its corresponding compiled PHP output.

```php
return [
    'Logger' => DI\create()
        ->constructor('/tmp/app.log')
        ->method('setLevel', 'warning'),
];
```

```php
$object = new Logger('/tmp/app.log');
$object->setLevel('warning');
return $object;
```

--------------------------------

### Standard Dependency Injection Example

Source: https://php-di.org/doc/lazy-injection.html

Demonstrates a scenario where a dependency is injected but not used, highlighting the potential for lazy injection.

```php
<?php
class ProductExporter
{
    private $pdfWriter;
    private $csvWriter;

    public function __construct(PdfWriter $pdfWriter, CsvWriter $csvWriter)
    {
        $this->pdfWriter = $pdfWriter;
        $this->csvWriter = $csvWriter;
    }

    public function exportToPdf()
    {
        $this->pdfWriter->write(...);
    }

    public function exportToCsv()
    {
        $this->csvWriter->write(...);
    }
}

$productExporter = $container->get(ProductExporter::class);
$productExporter->exportToCsv();
```

--------------------------------

### Install ProxyManager Dependency

Source: https://php-di.org/doc/lazy-injection.html

Required command to install the library necessary for lazy injection functionality.

```bash
composer require ocramius/proxy-manager
```

--------------------------------

### Install PHP-DI ZF1 Bridge

Source: https://php-di.org/doc/frameworks/zf1.html

Install the necessary bridge package via Composer.

```bash
composer require php-di/zf1-bridge
```

--------------------------------

### Basic Autowiring Example

Source: https://php-di.org/doc/autowiring.html

Classes with type-hinted constructor parameters are automatically instantiated and injected by PHP-DI.

```php
class UserRepository
{
    // ...
}

class UserRegistrationService
{
    public function __construct(UserRepository $repository)
    {
        // ...
    }
}
```

```php
$repository = new UserRepository();
$service = new UserRegistrationService($repository);
```

--------------------------------

### Legacy scope configuration

Source: https://php-di.org/doc/scopes.html

Example of using Scope::PROTOTYPE in PHP-DI versions prior to 6.

```php
return [
    Form::class => create()
        ->scope(Scope::PROTOTYPE), // a new form is created every time it is injected
];

class Service
{
    public function __construct(Form $form)
    {
        $this->form = $form;
    }
}
```

--------------------------------

### Install ProxyManager for lazy injection

Source: https://php-di.org/doc/migration/5.0.html

Install the ProxyManager package explicitly if lazy injection functionality is required.

```bash
composer require "ocramius/proxy-manager:~1.0"
```

--------------------------------

### Define classes for dependency injection

Source: https://php-di.org/doc/getting-started.html

Example classes demonstrating constructor injection where UserManager depends on Mailer.

```php
class Mailer
{
    public function mail($recipient, $content)
    {
        // send an email to the recipient
    }
}
```

```php
class UserManager
{
    private $mailer;

    public function __construct(Mailer $mailer)
    {
        $this->mailer = $mailer;
    }

    public function register($email, $password)
    {
        // The user just registered, we create his account
        // ...

        // We send him an email to say hello!
        $this->mailer->mail($email, 'Hello and welcome!');
    }
}
```

--------------------------------

### Install Annotations Dependency

Source: https://php-di.org/doc/migration/5.0.html

Required Composer command when using annotations in PHP-DI 5.0.

```bash
composer require doctrine/annotations
```

--------------------------------

### Install PHP-DI via Composer

Source: https://php-di.org/doc/getting-started.html

Use this command to add the PHP-DI package to your project dependencies.

```bash
composer require php-di/php-di
```

--------------------------------

### Configure PhpStorm Metadata for Container Support

Source: https://php-di.org/doc/ide-integration.html

Create a .phpstorm.meta.php file to instruct PhpStorm on how to resolve return types from container get() methods.

```php
<?php
namespace PHPSTORM_META
{
    override(\Psr\Container\ContainerInterface::get(0), map([
        '' => '@',
    ]));
    override(\DI\Container::get(0), map([
        '' => '@',
    ]));
}
```

--------------------------------

### Define Geolocation Services

Source: https://php-di.org/doc/understanding-di.html

Example classes for different geolocation providers.

```php
class GoogleMaps
{
    public function getCoordinatesFromAddress($address) {
        // calls Google Maps webservice
    }
}
class OpenStreetMap
{
    public function getCoordinatesFromAddress($address) {
        // calls OpenStreetMap webservice
    }
}
```

--------------------------------

### Legacy environment variable factory

Source: https://php-di.org/doc/scopes.html

Example of a factory configuration that was previously used to attempt dynamic value resolution.

```php
return [
    'config' => factory(function () {
        return getenv('CONFIG_VAR');
    })->scope(Scope::PROTOTYPE),

    Service1::class => create()
        ->constructor(get('config')),
    Service2::class => create()
        ->constructor(get('config')),
];
```

--------------------------------

### Define environment-dependent parameters

Source: https://php-di.org/doc/environments.html

Example of defining parameters that vary by environment within a PHP-DI configuration array.

```php
<?php
return [
    // These values change according to the environment
    'db.host' => 'localhost',
    'db.port' => 3336,

    'DbAdapter' => DI\create()
        ->constructor(DI\get('db.host'), DI\get('db.port')),
];
```

--------------------------------

### Install PHP-DI Symfony Bridge

Source: https://php-di.org/doc/frameworks/symfony2.html

Use Composer to add the bridge dependency to your Symfony project.

```bash
composer require php-di/symfony-bridge
```

--------------------------------

### Inject dependencies within a controller

Source: https://php-di.org/doc/inject-on-instance.html

Example of using injectOn inside a class constructor to populate dependencies.

```php
class MyController {
    public function __construct() {
        // get container ...
        $container->injectOn($this);
    }
}
```

--------------------------------

### get(string $id)

Source: https://php-di.org/doc/container.html

Retrieves an entry from the container by its identifier.

```APIDOC
## get(string $id)

### Description
Retrieves an entry from the container by its identifier. This method is part of the Psr\Container\ContainerInterface.

### Parameters
- **id** (string) - Required - The identifier of the entry to look for.
```

--------------------------------

### Initialize a basic container

Source: https://php-di.org/doc/container-configuration.html

The simplest way to instantiate the container with default settings.

```php
$container = new Container();
```

--------------------------------

### Manual instantiation

Source: https://php-di.org/doc/scopes.html

Alternative approach using manual instantiation within the service.

```php
class Service
{
    public function __construct()
    {
        $this->form = new Form(/* parameters */);
    }
}
```

--------------------------------

### Initialize Silex with PHP-DI

Source: https://php-di.org/doc/frameworks/silex.html

Replace the standard Silex Application with the PHP-DI bridge version.

```php
<?php

require_once __DIR__.'/../vendor/autoload.php';

$app = new DI\Bridge\Silex\Application();

$app->get('/hello/{name}', function ($name) use ($app) {
    return 'Hello '.$app->escape($name);
});

$app->run();
```

--------------------------------

### Creating Instances with make()

Source: https://php-di.org/doc/container.html

Instantiate objects by resolving dependencies, optionally overriding constructor parameters.

```php
class GithubProfile
{
    public function __construct(ApiClient $client, $user)
    ...
}

$container->make('GithubProfile', [
    'user' => 'torvalds',
]);
```

--------------------------------

### Initialize the container

Source: https://php-di.org/doc/getting-started.html

Methods for creating a container instance, either directly or via a builder for advanced configuration.

```php
$container = new DI\Container();
```

```php
$builder = new DI\ContainerBuilder();
$builder->...
$container = $builder->build();
```

--------------------------------

### Create Slim application with PHP-DI

Source: https://php-di.org/doc/frameworks/slim.html

Initialize the Slim application using the PHP-DI Bridge class instead of the standard Slim Factory.

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

$app = \DI\Bridge\Slim\Bridge::create();
```

```php
$container = /* create your container */;

$app = \DI\Bridge\Slim\Bridge::create($container);
```

--------------------------------

### Enable Proxy File Writing

Source: https://php-di.org/doc/lazy-injection.html

Configuring the container to write generated proxies to the filesystem for production performance.

```php
// Enable writing proxies to file in the tmp/proxies directory
$containerBuilder->writeProxiesToFile(true, __DIR__ . '/tmp/proxies');
```

--------------------------------

### Split configuration files by environment

Source: https://php-di.org/doc/environments.html

Separate configuration files for production and development environments, alongside a base configuration file.

```php
<?php
// config.prod.php
return [
    'db.host' => '178.231.21.29',
    'db.port' => 5000,
];
```

```php
<?php
// config.dev.php
return [
    'db.host' => 'localhost',
    'db.port' => 3336,
];
```

```php
<?php
// config.php
return [
    'DbAdapter' => DI\create()
        ->constructor(DI\get('db.host'), DI\get('db.port')),
];
```

--------------------------------

### Create Container with Defaults

Source: https://php-di.org/doc/migration/7.0.html

Instantiate the container directly without the ContainerBuilder, optionally passing definitions.

```php
$container = new \DI\Container();

// With definitions:
$container = new \DI\Container([
    \Psr\Log\LoggerInterface::class => get(MyLogger::class),
]);
```

--------------------------------

### Define simple value entries

Source: https://php-di.org/doc/php-definitions.html

Use this format to define configuration parameters like hostnames, ports, or arrays of data.

```php
return [
    'database.host'     => 'localhost',
    'database.port'     => 5000,
    'report.recipients' => [
        'bob@example.com',
        'alice@example.com',
    ],
];
```

--------------------------------

### Load environment-specific configurations

Source: https://php-di.org/doc/environments.html

Configure the ContainerBuilder to include both the main configuration and the environment-specific file.

```php
$builder = new ContainerBuilder();

// Main configuration
$builder->addDefinitions("config.php");

// Config file for the environment
$builder->addDefinitions("config.$environment.php");

$container = $builder->build();
```

--------------------------------

### Enable filesystem cache

Source: https://php-di.org/doc/frameworks/zf2.html

Configure the filesystem adapter for caching definitions.

```php
return [
    'phpdi-zf2' => [
        'cache' => [
            'adapter' => 'filesystem',
            'namespace' => 'your_di_cache_key',
            'directory' => 'your_cache_directory', // default value is data/php-di/cache
        ],
    ]
];
```

--------------------------------

### Configure Dispatcher in Bootstrap

Source: https://php-di.org/doc/frameworks/zf1.html

Initialize the container and set the custom dispatcher in the application Bootstrap.

```php
    protected function _initContainer()
    {
        $builder = new \DI\ContainerBuilder();
        $builder->useAttributes(true);
        $container = $builder->build();

        $dispatcher = new \DI\Bridge\ZendFramework1\Dispatcher();
        $dispatcher->setContainer($container);

        Zend_Controller_Front::getInstance()->setDispatcher($dispatcher);
    }
```

--------------------------------

### Optimize container for production

Source: https://php-di.org/doc/container-configuration.html

Enable compilation and proxy file writing to improve performance in production environments.

```php
$builder = new \DI\ContainerBuilder();
$builder->enableCompilation(__DIR__ . '/tmp');
$builder->writeProxiesToFile(true, __DIR__ . '/tmp/proxies');

$container = $builder->build();
```

--------------------------------

### Define objects with DI\create()

Source: https://php-di.org/doc/php-definitions.html

Use DI\create() to instantiate classes, map interfaces to implementations, or define custom entry names.

```php
return [
    // instantiate the Logger class to create the object
    'Logger' => DI\create(),
    // mapping an interface to an implementation
    'LoggerInterface' => DI\create('MyLogger'),
    // using an arbitrary name for the entry
    'logger.for.backend' => DI\create('Logger'),
];
```

--------------------------------

### Using Short Syntax with PHP 5.6

Source: https://php-di.org/doc/migration/5.0.html

Leverage PHP 5.6 function imports for cleaner definition syntax.

```php
use function DI\get;
use function DI\object;

return [
    'entity_manager'     => get(EntityManager::class),
    EntityManager::class => object()
        ->constructor(get('SomeDependency')),
];
```

--------------------------------

### Alias DI\create as object

Source: https://php-di.org/doc/migration/6.0.html

Use this alias for a quick upgrade path if you were previously using DI\object().

```php
use function DI\create as object;
```

--------------------------------

### Inject Dependencies into Controllers

Source: https://php-di.org/doc/frameworks/symfony2.html

Demonstrates constructor and property injection patterns for controllers managed by PHP-DI.

```php
class ProductController
{
    private $productService;

    public function __construct(ProductService $productService)
    {
        $this->productService = $productService;
    }

    public function clearAction()
    {
        $this->productService->clearStock();
    }
}
```

```php
use DI\Attribute\Inject;

class ProductController
{
    #[Inject]
    private ProductService $productService;

    public function clearAction()
    {
        $this->productService->clearStock();
    }
}
```

--------------------------------

### Loading definitions from a file

Source: https://php-di.org/doc/php-definitions.html

Define injections in a separate PHP file that returns an array and load it via the container builder.

```php
<?php
return [
    // place your definitions here
];
```

```php
$containerBuilder->addDefinitions('config.php');
```

--------------------------------

### Migrate definition format from array to function helpers

Source: https://php-di.org/doc/migration/4.0.html

Replaces the legacy array-based configuration with the new DI\object() helper syntax.

```php
// Before
return [
    'My\Class' => [
        'constructor' => [
            'host' => 'db.host',
            'port' => 'db.port',
        ],
        'methods' => [
            'setFoo' => [ 'My\Foo' ],
        ],
    ],
];

// After
return [
    'My\Class' => DI\object()
        ->constructor(DI\link('db.host'), DI\link('db.port'))
        ->method('setFoo', DI\link('My\Foo'))
];
```

--------------------------------

### Eagerly Load Factory Instances

Source: https://php-di.org/doc/php-definitions.html

Instantiate the factory class directly at definition time, though this is generally not recommended.

```php
return [
    // not recommended!
    Foo::class => DI\factory([new FooFactory, 'create']),
];
```

--------------------------------

### make(string $name, array $parameters = [])

Source: https://php-di.org/doc/container.html

Resolves an entry every time it is called, creating a new instance or executing the factory.

```APIDOC
## make(string $name, array $parameters = [])

### Description
Resolves an entry every time it is called. If the entry is an object, a new instance is created; if it is a factory, the factory is called.

### Parameters
- **name** (string) - Required - The identifier of the entry to resolve.
- **parameters** (array) - Optional - Constructor parameters to override or provide for the object being created.
```

--------------------------------

### Build container with ContainerBuilder

Source: https://php-di.org/doc/container-configuration.html

Use the ContainerBuilder class to customize container options before building.

```php
$builder = new \DI\ContainerBuilder();
$container = $builder->build();
```

--------------------------------

### Retrieve objects from the container

Source: https://php-di.org/doc/getting-started.html

Comparison between manual dependency wiring and using the container to resolve dependencies automatically.

```php
$mailer = new Mailer();
$userManager = new UserManager($mailer);
```

```php
$userManager = $container->get('UserManager');
```

--------------------------------

### Map Interfaces to Implementations

Source: https://php-di.org/doc/best-practices.html

Configure the container to resolve interface type-hints to specific service implementations.

```php
<?php
// config.php
return [
    // ...
    OrderServiceInterface::class => DI\get(OrderService::class),
];
```

--------------------------------

### Static definition configuration

Source: https://php-di.org/doc/migration/5.0.html

Recommended approach for adding definitions to the ContainerBuilder when using a cache.

```php
$builder = new ContainerBuilder();
$builder->setDefinitionCache(new ApcCache());

// Good
$builder->addDefinitions('file.php');
$builder->addDefinitions([
    'foo' => DI\object('MyClass'),
]);
```

--------------------------------

### Configure constructor parameters with DI\create()

Source: https://php-di.org/doc/php-definitions.html

Define specific constructor arguments for objects created via DI\create().

```php
return [
    'Logger' => DI\create()
        ->constructor('app.log', DI\get('log.level'), DI\get('FileWriter')),
];
```

--------------------------------

### Define injections via configuration

Source: https://php-di.org/doc/frameworks/zf2.html

Define dependency mappings in a dedicated PHP-DI configuration file.

```php
<?php
return [
    'Application\Service\GreetingServiceInterface' => DI\create('Application\Service\GreetingService'),
];
```

--------------------------------

### Use controllers as services

Source: https://php-di.org/doc/frameworks/slim.html

Register a controller class to allow PHP-DI to handle instantiation and dependency injection.

```php
class UserController
{
    private $userRepository;

    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function delete($request, $response)
    {
        $this->userRepository->remove($request->getAttribute('id'));

        $response->getBody()->write('User deleted');
        return $response;
    }
}

// Notice how we register the controller using the class name?
// PHP-DI will instantiate the class for us only when it's actually necessary
$app->delete('/user/{id}', [UserController::class, 'delete']);
```

--------------------------------

### Importing helper functions

Source: https://php-di.org/doc/php-definitions.html

Import DI helper functions to simplify the definition syntax.

```php
use function DI\create;
use function DI\get;

return [
    'Foo' => create()
        ->constructor(get('Bar')),
];
```

--------------------------------

### Extending autowiring with constructor parameters

Source: https://php-di.org/doc/definition-overriding.html

Using DI\autowire() to provide specific values for parameters that cannot be autowired, while keeping others autowired.

```php
class Foo
{
    public function __construct(Bar $param1, $param2)
    {
    }
}

return [
    Foo::class => DI\autowire()
        ->constructorParameter('param2', 'Hello!'),
];
```

--------------------------------

### Configure method injections with DI\create()

Source: https://php-di.org/doc/php-definitions.html

Inject dependencies via setter or other methods using the method() helper.

```php
return [
    'Database' => DI\create()
        ->method('setLogger', DI\get('Logger')),
    // you can call a method twice
    'Logger' => DI\create()
        ->method('addBackend', 'file')
        ->method('addBackend', 'syslog'),
];
```

--------------------------------

### Register PHP-DI in application config

Source: https://php-di.org/doc/frameworks/zf2.html

Add the module and factory to the application configuration file.

```php
    // ...
    'modules' => [
        ...
        'DI\ZendFramework2',
        ...
    ],

    'service_manager' => [
        // ...
        'factories' => [
            'DI\Container' => 'DI\ZendFramework2\Service\DIContainerFactory',
        ],
    ],
```

--------------------------------

### Configure constructor parameters with DI\autowire()

Source: https://php-di.org/doc/php-definitions.html

Explicitly set constructor parameters while maintaining autowiring for other dependencies.

```php
return [
    'Logger' => DI\autowire()
        ->constructor('app.log', DI\get('log.level'), DI\get('FileWriter')),
];
```

--------------------------------

### Retrieve Service from Container

Source: https://php-di.org/doc/understanding-di.html

Using the container to resolve a service instance.

```php
$storeService = $container->get('StoreService');
```

--------------------------------

### Configure AppKernel for PHP-DI

Source: https://php-di.org/doc/frameworks/symfony2.html

Extend the DI\Bridge\Symfony\Kernel class and implement buildPHPDIContainer to configure the container.

```php
class AppKernel extends \DI\Bridge\Symfony\Kernel
{
    // ...

    protected function buildPHPDIContainer(ContainerBuilder $builder)
    {
        // Configure your container here
        // https://php-di.org/doc/container-configuration.html
        $builder->addDefinitions(__DIR__ . '/config/config.php');

        return $builder->build();
    }
}
```

--------------------------------

### Configure property injections with DI\create()

Source: https://php-di.org/doc/php-definitions.html

Inject dependencies directly into object properties.

```php
return [
    'Foo' => DI\create()
        ->property('bar', DI\get('Bar')),
];
```

--------------------------------

### Nested closure factory definitions

Source: https://php-di.org/doc/migration/6.0.html

Demonstrates how closures are now interpreted as factory definitions when nested.

```php
return [
    'db.name' => env('DB_NAME', function ($container) {
        // Computes a default value if the environment variable doesn't exist
        return $container->get('db.prefix') . '_foo';
    }),

    // is the same as:
    'db.name' => env('DB_NAME', factory(function ($container) {
        // Computes a default value if the environment variable doesn't exist
        return $container->get('db.prefix') . '_foo';
    })),
];
```

--------------------------------

### Configure a lightweight container

Source: https://php-di.org/doc/container-configuration.html

Disable autowiring and attributes to use the container in a simplified mode.

```php
$builder = new \DI\ContainerBuilder();
$builder->useAutowiring(false);
$builder->useAttributes(false);

$container = $builder->build();
```

--------------------------------

### Enable Redis cache

Source: https://php-di.org/doc/frameworks/zf2.html

Configure the Redis adapter for caching definitions.

```php
return [
    'phpdi-zf2' => [
        'cache' => [
            'namespace' => 'your_di_cache_key',
            'adapter' => 'redis',
            'host' => 'localhost', // default is localhost
            'port' => 6379, // default is 6379
        ],
    ]
];
```

--------------------------------

### Compile Container with Proxies

Source: https://php-di.org/doc/lazy-injection.html

Pre-generating proxy classes during container compilation for production environments.

```php
// Enable writing proxies to file in the var/cache directory at container compile time
$containerBuilder->enableCompilation(__DIR__ . '/var/cache');
$containerBuilder->writeProxiesToFile(true, __DIR__ . '/var/cache');
```

--------------------------------

### Inject services via type-hinting

Source: https://php-di.org/doc/frameworks/slim.html

Inject services into closure-based controllers by type-hinting the class.

```php
$app->get('/', function (ResponseInterface $response, Twig $twig) {
    return $twig->render($response, 'home.twig');
});
```

--------------------------------

### Manual Dependency Injection

Source: https://php-di.org/doc/understanding-di.html

Manually instantiating and injecting dependencies without a container.

```php
$geolocationService = new GoogleMaps();
$storeService = new StoreService($geolocationService);
```

--------------------------------

### Registering Entries with set()

Source: https://php-di.org/doc/container.html

Manually register values or definitions in the container. Use \DI\value to store closures as raw values instead of factories.

```php
$container->set('foo', 'bar');
$container->set('MyInterface', \DI\create('MyClass'));

// Use \DI\value if you need to set a closure as raw value,
// because closures are interpreted as factories by default
$container->set('myClosure', \DI\value(function() { /* ... */ }));
```

--------------------------------

### Configure PHP-DI module

Source: https://php-di.org/doc/frameworks/zf2.html

Override default module settings in global or local autoload configuration files.

```php
return [
    'phpdi-zf2' => [
        ...
    ]
];
```

--------------------------------

### Inject Services into Factories

Source: https://php-di.org/doc/php-definitions.html

Inject other registered services into factories using type-hinting.

```php
return [
    'LoggerInterface' => DI\create('MyLogger'),

    'Foo' => function (LoggerInterface $logger) {
        return new Foo($logger);
    },
];
```

--------------------------------

### Integrate with other containers using Acclimate

Source: https://php-di.org/doc/container-configuration.html

Use a composite container to combine PHP-DI with other frameworks like Symfony.

```php
$container = new Acclimate\Container\CompositeContainer();

// Add Symfony's container
$container->addContainer($acclimate->adaptContainer($symfonyContainer));

// Configure PHP-DI container
$builder = new \DI\ContainerBuilder();
$builder->wrapContainer($container);

// Add PHP-DI container
$phpdiContainer = $builder->build();
$container->addContainer($phpdiContainer);

// Good to go!
$foo = $container->get('foo');
```

--------------------------------

### Define aliases with DI\get()

Source: https://php-di.org/doc/php-definitions.html

Map an entry to another entry or interface using DI\get().

```php
return [
    'doctrine.entity_manager' => DI\get('Doctrine\ORM\EntityManager'),
];
```

```php
return [
    // mapping an interface to an implementation (autowire the MyLogger class if not otherwise defined)
    'LoggerInterface' => DI\get('MyLogger'),
];
```

--------------------------------

### Register Middleware as a Service

Source: https://php-di.org/doc/frameworks/silex.html

Define middleware using a class name to enable automatic instantiation via PHP-DI.

```php
class AuthMiddleware
{
    public function beforeRoute(Request $request, Application $app)
    {
        // ...
    }
}

$app->before([AuthMiddleware::class, 'beforeRoute']);
```

--------------------------------

### Configure the Container

Source: https://php-di.org/doc/frameworks/silex.html

Pass a custom ContainerBuilder to the application to define services or configure caching.

```php
$containerBuilder = new DI\ContainerBuilder();

// E.g. setup a cache
$containerBuilder->setDefinitionCache(new ApcCache());

// Add definitions
$containerBuilder->addDefinitions([
    // place your definitions here
]);

// Register a definition file
$containerBuilder->addDefinitions('config.php');

$app = new DI\Bridge\Silex\Application($containerBuilder);
```

--------------------------------

### Define Full Injection with DI\create()

Source: https://php-di.org/doc/best-practices.html

Explicitly define all constructor parameters when autowiring is insufficient, such as when dealing with scalar values.

```php
<?php
// config.php
return [
    // ...
    OrderService::class => DI\create()
        ->constructor(DI\get(SomeOtherService::class), 'a value'),
];
```

--------------------------------

### Factory object pattern

Source: https://php-di.org/doc/scopes.html

Recommended approach using a factory class to create objects on demand.

```php
return [
    FormFactory::class => create(),
];

class Service
{
    public function __construct(FormFactory $formFactory)
    {
        $this->form = $formFactory->createForm();
    }
}
```

--------------------------------

### Define injections using PHP definitions

Source: https://php-di.org/doc/getting-started.html

Configuration array for defining services and their dependencies explicitly.

```php
return [
    'api.url'    => 'http://api.example.com',
    'Webservice' => function (Container $c) {
        return new Webservice($c->get('api.url'));
    },
    'Controller' => DI\create()
        ->constructor(DI\get('Webservice')),
];
```

--------------------------------

### Register definitions via array

Source: https://php-di.org/doc/container-configuration.html

Pass an array of definitions directly to the constructor during initialization.

```php
$container = new DI\Container([
    // place your definitions here
]);
```

--------------------------------

### Inject Attribute Usage

Source: https://php-di.org/doc/attributes.html

Demonstrates various ways to use the #[Inject] attribute for property, constructor, and method injection.

```php
use DI\Attribute\Inject;

class Example
{
    /**
     * Attribute combined with a type on the property:
     */
    #[Inject]
    private Foo $property1;

    /**
     * Explicit definition of the entry to inject:
     */
    #[Inject('db.host')]
    private $property2;

    /**
     * Alternative to the above:
     */
    #[Inject(name: 'db.host')]
    private $property3;

    /**
     * The constructor is of course always called, but the
     * #[Inject] attribute can be used on a parameter
     * to specify what to inject.
     */
    public function __construct(Foo $foo, #[Inject('db.host')] $dbHost)
    {
    }

    /**
     * #[Inject] tells PHP-DI to call the method.
     * By default, PHP-DI uses the PHP types to find the service to inject:
     */
    #[Inject]
    public function method1(Foo $param)
    {
    }

    /**
     * #[Inject] can be used at the parameter level to
     * specify what to inject.
     * Note: #[Inject] *must be place* on the function too.
     */
    #[Inject]
    public function method2(#[Inject('db.host')] $param)
    {
    }

    /**
     * Explicit definition of the entries to inject:
     */
    #[Inject(['db.host', 'db.name'])]
    public function method3($param1, $param2)
    {
    }

    /**
     * Explicit definition of parameters by their name
     * (types are used for the other parameters):
     */
    #[Inject(['param2' => 'db.host'])]
    public function method4(Foo $param1, $param2)
    {
    }
}
```

--------------------------------

### Retrieve environment variables with DI\env()

Source: https://php-di.org/doc/php-definitions.html

Access environment variables, optionally providing a default value or another entry as a fallback.

```php
return [
    'db1.url' => DI\env('DATABASE_URL'),
    // with a default value
    'db2.url' => DI\env('DATABASE_URL', 'postgresql://user:pass@localhost/db'),
    // with a default value that is another entry
    'db2.host' => DI\env('DATABASE_HOST', DI\get('db.host')),
];
```

--------------------------------

### Enable Attributes

Source: https://php-di.org/doc/attributes.html

Activate attribute support in the container builder.

```php
$containerBuilder->useAttributes(true);
```

--------------------------------

### Use Silex Service Providers

Source: https://php-di.org/doc/frameworks/silex.html

Standard Silex providers remain compatible, though aliasing may be required for type-hinting services registered by string names.

```php
$app->register(new Silex\Provider\TwigServiceProvider(), [
    'twig.path' => __DIR__ . '/views',
]);

$app->get('/', function () use ($app) {
    return $app['twig']->render('home.twig');
});
```

```php
$builder = new ContainerBuilder();

$builder->addDefinitions([
    'Twig_Environment' => \DI\get('twig'), // alias
]);

// ...

// Twig can now be injected in closures:
$app->post('/', function (Twig_Environment $twig) {
    return $twig->render('home.twig');
});
```

--------------------------------

### Configure Container Mapping

Source: https://php-di.org/doc/understanding-di.html

Configuring the container to define which implementation to inject.

```php
$container->set('StoreService', \DI\create('GoogleMaps'));
```

--------------------------------

### Using the ::class constant

Source: https://php-di.org/doc/php-definitions.html

Utilize the PHP 5.5 ::class magic constant for cleaner definition mapping.

```php
use Psr\Log\LoggerInterface;
use Monolog\Logger;

return [
    LoggerInterface::class => DI\create(Logger::class)
];
```

--------------------------------

### Manual constructor injection with injectOn

Source: https://php-di.org/doc/inject-on-instance.html

When using injectOn, constructor dependencies must be provided manually during object instantiation.

```php
$object = new MyClass($someDependency, $someOtherDependency);
$container->injectOn($object);
```

--------------------------------

### Enable Container Compilation

Source: https://php-di.org/doc/performances.html

Call enableCompilation on the ContainerBuilder to specify the directory for storing the compiled container.

```php
$containerBuilder = new \DI\ContainerBuilder();
$containerBuilder->enableCompilation(__DIR__ . '/var/cache');

// […]

$container = $containerBuilder->build();
```

--------------------------------

### Invoke controllers with request parameters and DI

Source: https://php-di.org/doc/container.html

Use call() to invoke controllers, allowing them to receive both request data and injected services.

```php
$controller = function ($name, EntityManager $em) {
    // ...
}

$container->call($controller, $_GET); // $_GET contains ['name' => 'John']
```

--------------------------------

### Configure Monolog using a factory function

Source: https://php-di.org/doc/best-practices.html

Uses an anonymous function to instantiate and configure a Monolog logger, returning it as a PSR-3 compatible service.

```php
<?php
// config.php

use Monolog
Logger;
use Monolog\Handler\StreamHandler;

return [
    // ...

    Psr\Log\LoggerInterface::class => DI\factory(function () {
        $logger = new Logger('mylog');

        $fileHandler = new StreamHandler('path/to/your.log', Logger::DEBUG);
        $fileHandler->setFormatter(new LineFormatter());
        $logger->pushHandler($fileHandler);

        return $logger;
    }),
];
```

--------------------------------

### Dynamic definition restrictions with cache

Source: https://php-di.org/doc/migration/5.0.html

Demonstrates that setting definitions via $container->set() is prohibited when a cache is enabled.

```php
$builder = new ContainerBuilder();
$builder->setDefinitionCache(new ApcCache());
$container = $builder->build();

// This still works: you can set values
$container->set('foo', 'hello');
$container->set('bar', new MyClass());

// This doesn't work anymore: you can't set definitions using ->set() when using a cache
$container->set('foo', DI\object('MyClass'));
```

--------------------------------

### Registering PHP definitions

Source: https://php-di.org/doc/php-definitions.html

Register definitions directly in the container constructor or via the container builder.

```php
$container = new DI\Container([
    // place your definitions here
]);

// or using the container builder class:
// ...
$containerBuilder->addDefinitions([
    // place your definitions here
]);
// ...
```

--------------------------------

### Define batch entries with wildcards

Source: https://php-di.org/doc/php-definitions.html

Maps interfaces to implementations using wildcard patterns. Wildcards do not cross namespace boundaries and exact matches take precedence.

```php
return [
    'Blog\Domain\*RepositoryInterface' => DI\create('Blog\Architecture\*DoctrineRepository'),
];
```

--------------------------------

### Define Factories with Closures

Source: https://php-di.org/doc/php-definitions.html

Use closures or the DI\factory() helper to define lazy object creation.

```php
use Psr\Container\ContainerInterface;
use function DI\factory;

return [
    'Foo' => function (ContainerInterface $c) {
        return new Foo($c->get('db.host'));
    },

    // Same as
    'Foo' => DI\factory(function (ContainerInterface $c) {
        return new Foo($c->get('db.host'));
    }),
];
```

--------------------------------

### Create Service Name Aliases

Source: https://php-di.org/doc/frameworks/symfony2.html

Map class or interface names to existing service IDs to enable autowiring and attribute injection.

```php
return [
    ObjectManager::class => DI\get('doctrine.orm.entity_manager'),
];
```

--------------------------------

### Fetch objects from the container

Source: https://php-di.org/doc/getting-started.html

Retrieving a service from the container, typically performed at the application entry point.

```php
$userManager = $container->get('UserManager');
```

--------------------------------

### Enable Autocompletion with Inline PHPDoc

Source: https://php-di.org/doc/ide-integration.html

Use the @var tag to explicitly define the type of a retrieved service for IDE static analysis.

```php
/** @var $repository UserRepository */
$repository = $this->container->get(UserRepository::class);

// the IDE can now autocomplete this statement
$repository->
```

--------------------------------

### Define objects with DI\autowire()

Source: https://php-di.org/doc/php-definitions.html

Use DI\autowire() to customize autowiring behavior by overriding specific configurations.

```php
return [
    // when using no option it is not necessary to write it in the config file
    'MyLogger' => DI\autowire(),

    // mapping an interface to an implementation (autowire the MyLogger class)
    'LoggerInterface' => DI\autowire('MyLogger'),

    // using an arbitrary name for the entry
    'logger.for.backend' => DI\autowire('MyLogger'),
];
```

--------------------------------

### Define lazy injection via annotations

Source: https://php-di.org/doc/migration/4.0.html

Demonstrates the legacy annotation-based lazy injection and the new @Injectable(lazy=true) approach.

```php
class Example {
    /**
     * @Inject(lazy=true)
     * @var Foo
     */
    protected $property1;
}
```

```php
/**
 * @Injectable(lazy=true)
 */
class Foo {
}
```

--------------------------------

### Inject route placeholders

Source: https://php-di.org/doc/frameworks/slim.html

Inject route URL placeholders by matching parameter names to the placeholder names.

```php
$app->get('/hello/{name}', function ($name, ResponseInterface $response) {
    $response->getBody()->write('Hello ' . $name);
    return $response;
});
```

--------------------------------

### Retrieve object from container

Source: https://php-di.org/doc/inject-on-instance.html

The standard approach for obtaining an object with all dependencies injected by the container.

```php
$object = $container->get('foo');
```

--------------------------------

### Using DI\get() vs DI\link()

Source: https://php-di.org/doc/migration/5.0.html

DI\get() replaces the deprecated DI\link() helper to avoid conflicts with native PHP functions.

```php
return [
    EntityManager::class => DI
umber(object)(...),

    // Preferred version
    'entity_manager' => DI
umber(get)(EntityManager::class),
    // Deprecated but still works
    'entity_manager' => DI
umber(link)(EntityManager::class),

    // Example in an object definition:
    'MyClass' => DI
umber(object)()
        ->constructor(DI
umber(get)('SomeDependency')),
];
```

--------------------------------

### Container-managed Factory Creation

Source: https://php-di.org/doc/php-definitions.html

Allow the container to manage the factory instance for better dependency handling.

```php
return [
    Foo::class => DI\factory([FooFactory::class, 'create']),
    // alternative syntax:
    Foo::class => DI\factory('Namespace\To\FooFactory::create'),
];
```

```php
$factory = $container->get(FooFactory::class);
return $factory->create(...);
```

--------------------------------

### Setting entries directly in the container

Source: https://php-di.org/doc/php-definitions.html

Directly register values or definitions into the container instance.

```php
$container->set('db.host', 'localhost');
$container->set('My\Class', \DI\create()
    ->constructor('some raw value')));
```

--------------------------------

### Inject Dependencies in Controllers and Middlewares

Source: https://php-di.org/doc/frameworks/silex.html

Use type-hinting to inject services directly into route closures, middlewares, and param converters.

```php
class Mailer
{
    // ...
}

$app->post('/register/{name}', function ($name, Mailer $mailer) {
    $mailer->sendMail($name, 'Welcome!');

    return 'You have received a new email';
});

// Injection works for middleware too
$app->before(function (Request $request, Mailer $mailer) {
    // ...
});

// And param converters
$app->get('/users/{user}', function (User $user) {
    return new JsonResponse($user);
})->convert('user', function ($user, UserManager $userManager) {
    return $userManager->findById($user);
});
```

--------------------------------

### Replace buildDevContainer

Source: https://php-di.org/doc/migration/7.0.html

Update container initialization by replacing the removed buildDevContainer method.

```php
- $container = \DI\ContainerBuilder::buildDevContainer();
+ $container = new \DI\Container();
```

--------------------------------

### Define arrays in configuration

Source: https://php-di.org/doc/php-definitions.html

Entries can be defined as arrays containing simple values or references to other entries.

```php
return [
    'report.recipients' => [
        'bob@example.com',
        'alice@example.com',
    ],
    'log.handlers' => [
        DI\get('Monolog\Handler\StreamHandler'),
        DI\get('Monolog\Handler\EmailHandler'),
    ],
];
```

--------------------------------

### Define Static Method Factories

Source: https://php-di.org/doc/php-definitions.html

Use static methods as factories for object creation.

```php
class FooFactory
{
    public static function create()
    {
        return ...
    }
}

return [
    Foo::class => DI\factory([FooFactory::class, 'create']),
];
```

--------------------------------

### Defining Factories

Source: https://php-di.org/doc/migration/5.0.html

Closures are now automatically treated as factories; use DI\value() to inject a closure as a raw value.

```php
return [
    'foo' => DI\factory(function () {
        return new Foo();
    }),
    // can now be shortened to:
    'foo' => function () {
        return new Foo();
    },
];
```

```php
    // the closure will be injected instead of being called
    'foo' => DI\value(function () {
        return new Foo();
    }),
```

--------------------------------

### Define basic Slim route

Source: https://php-di.org/doc/frameworks/slim.html

Standard route definition using the PHP-DI bridge.

```php
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Message\ResponseInterface as Response;

$app->get('/hello/{name}', function (Request $request, Response $response) {
    $response->getBody()->write('Hello!');
    return $response;
});

$app->run();
```

--------------------------------

### Mix named parameters and dependency injection

Source: https://php-di.org/doc/container.html

Combine explicit parameters and container-resolved dependencies in a single call.

```php
$container->call(function (Logger $logger, $dbHost, $operation) {
    // ...
}, [
    'operation' => 'delete',
    'dbHost'    => \DI\get('db.host'),
]);
```

--------------------------------

### Basic class definition for autowiring

Source: https://php-di.org/doc/definition-overriding.html

A standard class structure that PHP-DI can resolve via autowiring.

```php
class Foo
{
    public function __construct(Bar $param1)
    {
    }
}
```

--------------------------------

### Decorating object definitions

Source: https://php-di.org/doc/definition-overriding.html

Using DI\decorate() to wrap an existing service definition with a proxy or decorator.

```php
return [
    ProductRepository::class => function () {
        return new DatabaseRepository();
    },
];
```

```php
return [
    ProductRepository::class => DI\decorate(function ($previous, ContainerInterface $c) {
        // Wrap the database repository in a cache proxy
        return new CachedRepository($previous);
    }),
];
```

--------------------------------

### Implement Tight Coupling Without DI

Source: https://php-di.org/doc/understanding-di.html

A service class that directly instantiates its dependency, making it difficult to swap implementations.

```php
class StoreService
{
    public function getStoreCoordinates($store) {
        $geolocationService = new GoogleMaps();
        // or $geolocationService = GoogleMaps::getInstance() if you use singletons

        return $geolocationService->getCoordinatesFromAddress($store->getAddress());
    }
}
```

--------------------------------

### Updating Scope Definitions

Source: https://php-di.org/doc/migration/5.0.html

Transition from using static methods to constants for scope definitions.

```php
return [
    'MyClass' => DI\object()
        ->scope(Scope::PROTOTYPE()), // static method
];
```

```php
return [
    'MyClass' => DI\object()
        ->scope(Scope::PROTOTYPE), // constant
];
```

--------------------------------

### Decorate Existing Definitions

Source: https://php-di.org/doc/php-definitions.html

Override or extend previously defined entries using DI\decorate().

```php
return [
    // decorate an entry previously defined in another file
    'WebserviceApi' => DI\decorate(function ($previous, ContainerInterface $c) {
        return new CachedApi($previous, $c->get('cache'));
    }),
];
```

--------------------------------

### Enable APCu Caching in PHP-DI

Source: https://php-di.org/doc/performances.html

Use enableDefinitionCache to store definitions in APCu, reducing reflection overhead. Only enable this in production environments to avoid stale configuration issues.

```php
$containerBuilder = new \DI\ContainerBuilder();
if (/* is production */) {
    $containerBuilder->enableDefinitionCache();
}
```

--------------------------------

### Invoke classes by name

Source: https://php-di.org/doc/container.html

Resolve and invoke classes directly by their name, avoiding manual instantiation.

```php
$object = $container->get('My\CallableClass');
$container->call($object);

// can be written as
$container->call('My\CallableClass');
```

--------------------------------

### Configure method injections with DI\autowire()

Source: https://php-di.org/doc/php-definitions.html

Inject dependencies via methods while using autowiring for the rest of the object.

```php
return [
    'Database' => DI\autowire()
        ->method('setLogger', DI\get('Logger')),
];
```

--------------------------------

### Conditional Compilation for Environments

Source: https://php-di.org/doc/performances.html

Use conditional logic to enable compilation only in production environments to avoid caching issues during development.

```php
$containerBuilder = new \DI\ContainerBuilder();
if (/* is production */) {
    $containerBuilder->enableCompilation(__DIR__ . '/var/cache');
}
```

--------------------------------

### Configure property injections with DI\autowire()

Source: https://php-di.org/doc/php-definitions.html

Inject dependencies into properties while using autowiring for the rest of the object.

```php
return [
    'Foo' => DI\autowire()
        ->property('bar', DI\get('Bar')),
];
```

--------------------------------

### Implement Constructor Injection

Source: https://php-di.org/doc/best-practices.html

Use constructor injection to define service dependencies, allowing PHP-DI to autowire objects based on type-hints.

```php
class OrderService implements OrderServiceInterface
{
    private $paymentService;

    public function __construct(PaymentServiceInterface $paymentService)
    {
        $this->paymentService = $paymentService;
    }

    public function processOrder($order)
    {
        $this->paymentService->...
    }
}
```

--------------------------------

### Define Scalar Parameters with DI\autowire()

Source: https://php-di.org/doc/best-practices.html

Use autowire to inject specific scalar parameters while allowing the container to automatically resolve other constructor dependencies.

```php
<?php
// config.php
return [
    // ...
    OrderService::class => DI\autowire()
        ->constructorParameter('paramName', 'a value'),
];
```

--------------------------------

### Use named arguments with DI\autowire()

Source: https://php-di.org/doc/php-definitions.html

Utilize PHP 8 named arguments to define specific parameters for autowired objects.

```php
return [
    'Logger' => DI\autowire()
        // set the $filename parameter
        ->constructor(
            filename: 'app.log'
        )
        // set the $handler parameter
        ->method('setHandler', handler: DI\get('SyslogHandler')),
];
```

--------------------------------

### Dynamic definitions without cache

Source: https://php-di.org/doc/migration/5.0.html

Confirms that dynamic definitions remain supported when no cache is utilized.

```php
$container = ContainerBuilder::buildDevContainer();

// All of this still works
$container->set('foo', 'hello');
$container->set('bar', new MyClass());
$container->set('baz', DI\object('MyClass'));
```

--------------------------------

### Use Routing Annotations with PHP-DI

Source: https://php-di.org/doc/frameworks/symfony2.html

Specify the service ID in the @Route annotation to allow PHP-DI to instantiate the controller.

```php
/**
 * @Route(service="My\TestController")
 */
class TestController extends Controller
{
    private $dependency;

    public function __construct(SomeDependency $dependency)
    {
        $this->dependency = $dependency;
    }

    /**
     * @Route("test")
     */
    public function testAction()
    {
        return new Response('ok');
    }
}
```

--------------------------------

### Specify Parameters in Factories

Source: https://php-di.org/doc/php-definitions.html

Use the parameter() method to inject entries that cannot be automatically resolved via type-hinting.

```php
return [
    'Database' => DI\factory(function ($host) {...})
        ->parameter('host', DI\get('db.host')),
];
```

--------------------------------

### Define lazy injection in configuration

Source: https://php-di.org/doc/migration/4.0.html

Configures an entry as lazy using the fluent API in the definition file.

```php
<?php

return [
    'foo' => DI\object('MyClass')
        ->lazy(),
];
```

--------------------------------

### Implement Loose Coupling With DI

Source: https://php-di.org/doc/understanding-di.html

A service class that receives its dependency via the constructor, allowing for flexible implementation swapping.

```php
class StoreService {
    private $geolocationService;

    public function __construct(GeolocationService $geolocationService) {
        $this->geolocationService = $geolocationService;
    }

    public function getStoreCoordinates($store) {
        return $this->geolocationService->getCoordinatesFromAddress($store->getAddress());
    }
}
```

--------------------------------

### Update Container Interface Namespace

Source: https://php-di.org/doc/migration/6.0.html

Replace the deprecated container-interop interface with the PSR-11 standard interface.

```text
Interop\Container\ContainerInterface
```

```text
Psr\Container\ContainerInterface
```

--------------------------------

### Define object entries directly

Source: https://php-di.org/doc/php-definitions.html

Directly instantiate objects within the definition array. Note that this approach is not recommended as it prevents lazy loading and container compilation.

```php
return [
    'Foo' => new Foo(),
];
```

--------------------------------

### Lazy Proxy Behavior

Source: https://php-di.org/doc/lazy-injection.html

Illustrates how a lazy-defined object returns a proxy that initializes only upon method invocation.

```php
class Foo
{
    public function doSomething()
    {
    }
}

$container->set('Foo', \DI\create()->lazy());

// $proxy is a Proxy object, it is not initialized
// It is very lightweight in memory
$proxy = $container->get('Foo');

var_dump($proxy instanceof Foo); // true

// Calling a method on the proxy will initialize it
$proxy->doSomething();
// Now the proxy is initialized, the real instance of Foo has been created and called
```
Tokens:
Raw