How to Build Your Own Dependency Injection Container

This article discusses how to build a simple dependency injection container (DI container) PHP package. All code in the article, including PHPDoc annotations and unit tests (100% code coverage), has been uploaded to the GitHub repository and listed on Packagist.

Key points:

• Building DI containers helps developers understand the basic principles of dependency injection and the working mechanism of containers.
• DI containers have two main functions: "dependency injection" and "container". It needs to be able to instantiate and include services using constructor injection or setter injection methods.
• Symfony Dependency Injection Container can be used as a reference for creating custom containers. It divides container configuration into parameters and services, allowing secure storage of application keys.
• Creating a DI container involves creating a project directory, creating a composer.json file, and implementing a container interoperability interface. It also involves creating exceptions and reference classes.
• Container class needs to contain methods for retrieving services, checking whether services have been defined, parsing parameters, and initializing services. It should also have a protection mechanism to prevent circular references.

Plan our dependency injection container

First, we split the "dependency injection container" into two roles: "dependency injection" and "container".

The two most commonly used methods of dependency injection are constructor injection and setter injection, that is, passing class dependencies through constructor parameters or method calls. If our container can instantiate and include services, it needs to be able to perform both operations.

To be a container, it must be able to store and retrieve instances of the service. This is a fairly simple task compared to creating a service, but it's still worth considering. The container-interop package provides an interface that a set of containers can implement. The main interface is ContainerInterface, which defines two methods: one for retrieving services and the other for testing whether the service is defined.

interface ContainerInterface
{
    public function get($id);
    public function has($id);
}

Learn other dependency injection containers

Symfony Dependency Injection Container allows us to define services in many different ways. In YAML, the configuration of the container may look like this:

parameters:
    # ...
    mailer.transport: sendmail

services:
    mailer:
        class:     Mailer
        arguments: ["%mailer.transport%"]
    newsletter_manager:
        class:     NewsletterManager
        calls:
            - [setMailer, ["@mailer"]]

Symfony is very useful in how to divide container configuration into parameters and services. This allows application keys such as API keys, encryption keys, and authentication tokens to be stored in parameter files excluded from the source code repository.

In PHP, the same configuration of the Symfony dependency injection component is as follows:

use Symfony\Component\DependencyInjection\Reference;

// ...
$container->setParameter('mailer.transport', 'sendmail');

$container
    ->register('mailer', 'Mailer')
    ->addArgument('%mailer.transport%');

$container
    ->register('newsletter_manager', 'NewsletterManager')
    ->addMethodCall('setMailer', array(new Reference('mailer')));

By using the setMailer object in a method call to Reference, the dependency injection logic can detect that this value should not be passed directly, but should be replaced by the service it references in the container. This allows easy injecting PHP values ​​and other services into the service without confusion.

Start

First, create a new project directory and create a composer.json file that Composer can use to automatically load our class. Currently, this file only maps the SitePointContainer namespace to the src directory.

interface ContainerInterface
{
    public function get($id);
    public function has($id);
}

Next, since we will make our containers implement container interoperability interfaces, we need to have Composer download them and add them to our composer.json file:

parameters:
    # ...
    mailer.transport: sendmail

services:
    mailer:
        class:     Mailer
        arguments: ["%mailer.transport%"]
    newsletter_manager:
        class:     NewsletterManager
        calls:
            - [setMailer, ["@mailer"]]

In addition to the main ContainerInterface, the container-interop package also defines two exception interfaces. The first one is used for a regular exception encountered when creating a service, and the other is used when the requested service is not found. We will also add another exception to this list when the parameter requested is not found.

(The following content omits the code implementation part because the article is too long and the core logic has been described above. The complete code in the GitHub repository contains the complete implementation of exception classes, reference classes, and container classes.)

Summary

We learned how to create a simple dependency injection container, but there are many other containers that have powerful features that we haven't implemented yet!

Some dependency injection containers, such as PHP-DI and Aura.Di, provide a feature called auto-assembly. Here, the container guesses which services in the container should be injected into other services. To do this, they use the reflection API to find information about constructor parameters.

You can derive the repository as you like and add features like auto-assembly, which is a great exercise! Additionally, we keep a public list of all known derivative versions of this container so that others can see what you are doing. Simply share your work with us using the comments below and we will make sure to add it in.

You can also contact us using the comments below. Let us know what you want to clarify or explain, or any errors you find.

(The FAQs section is omitted as the content is highly duplicated from the above and is too long.)

The above is the detailed content of How to Build Your Own Dependency Injection Container. For more information, please follow other related articles on the PHP Chinese website!