Core points

• Dependency Injection (DI) enables flexible dependency management by separating object creation and usage.
• Dependency injection container simplifies the management of object dependencies, especially when the number of dependencies is huge, it is implemented by automating object creation and configuration.
• Disco, an annotation-based DI container, simplifies configuration with annotations such as @Bean and @Configuration, thus simplifying the setup of the service.
• Disco supports advanced features such as singleton instantiation, delayed loading, and session/request scope management to optimize resource utilization and service lifecycle.
• Disco's integration with Symfony components helps create a basic HTTP-based framework that demonstrates the compatibility and practicality of Disco in modern web application development.
• This article shows a practical example of using Disco to implement the DI pattern, laying the foundation for developers to build efficient, scalable, and easy-to-maintain web applications.

The core of dependency injection lies in the reusability of the code. It is a design pattern designed to improve the reusability of advanced code by separating object creation/configuration from usage.

Consider the following code:

class Test {

    protected $dbh;

    public function __construct(\PDO $dbh)
    {
        $this->dbh = $dbh;
    }

}

$dbh  = new PDO('mysql:host=localhost;dbname=test', 'username', 'password');
$test = new Test($dbh);

As you can see, instead of creating a PDO object inside the class, we create it outside the class and pass it in as a dependency via a constructor. This way, we can use the driver of our choice without having to use the driver defined inside the class.

Alejandro Gervasio and Fabien Potencier both provide wonderful explanations of the concept of DI.

However, this pattern has one disadvantage: when the number of dependencies increases, it is necessary to create/configure many objects before passing them to the dependent objects. It may end up producing a lot of boilerplate code, as well as a long queue of parameter in the constructor. At this time, you need to dependency injection container!

Dependency injection container (DI container for short) is an object that knows how to create a service and handle its dependencies.

In this article, we will use an emerging DI container, Disco, to further demonstrate this concept.

For more information on dependency injection containers, see our other articles on this topic.

Because frameworks are a great example of deploying DI containers, we will create a basic HTTP-based framework at the end of the article with Disco and some Symfony components.

Installation

To install Disco, we use Composer as usual:

composer require bitexpert/disco

To test the code, we will use PHP's built-in web server:

class Test {

    protected $dbh;

    public function __construct(\PDO $dbh)
    {
        $this->dbh = $dbh;
    }

}

$dbh  = new PDO('mysql:host=localhost;dbname=test', 'username', 'password');
$test = new Test($dbh);

As a result, the application will be able to access the http://miracleart.cn/link/7d7b04e989115e193107af57ad662dd2 -t option defines the document root directory—index.php directory where the file is located .

Beginner

Disco is a DI container that is interoperable with containers. Disco is controversially a DI container based on annotation.

Note that the container-interop package contains a set of interfaces to standardize the characteristics of container objects. To understand how it works, see our tutorial on building our own SitePoint dependency injection container, which is also based on container-interop.

To add a service to the container, we need to create a configuration class. This type should use @Configuration annotation mark:

composer require bitexpert/disco

Each container service should be defined as a public or protected method in the configuration class. Disco calls each service a bean, which stems from the Java culture.

Inside each method, we define how the service is created. Each method must be marked with @Bean (which means this is a service) and the return object's type is marked with @return annotation.

This is a simple Disco configuration class example containing a "Bean":

php -S localhost:8000 -t web

@Bean Annotation accepts some configuration parameters to specify the nature of the service. These parameters specify whether the service should be a singleton object, delay loading (if the object is resource-intensive), or persisting its state during the lifetime of the session.

By default, all services are defined as singleton services.

For example, the following bean creates a singleton lazy loading service:

<?php
/**
 * @Configuration
 */
class Services {
    // ...
}

Disco uses ProxyManager to delay loading of services. It also uses it to inject additional behavior (defined by annotations) into the methods of the configuration class.

After creating the configuration class, we need to create an instance of AnnotationBeanFactory and pass the configuration class to it. This will be our container.

Finally, we register the container to BeanFactoryRegistry:

<?php
/**
 * @Configuration
 */
class Configuration {

    /**
     * @Bean
     * @return SampleService
     */
    public function getSampleService()
    {
        // 實(shí)例化
        $service  = new SampleService();

        // 配置
        $service->setParameter('key', 'value');
        return $service;
    }
}

How to get services from container

Because Disco is compatible with container/interoperability, we can use get() and has() methods on container objects:

<?php
// ...

/**
 * @Bean({"singleton"=true, "lazy"=true})
 * @return \Acme\SampleService
 */
public function getSampleService()
{
    return new SampleService();
}

// ...

(The following content is similar to the original text. To maintain space, some details are omitted here, but key information and structure are retained)

Scope of Service

Container parameters

Practical Application of Disco

Create a response listener

Conclusion

This article only pseudo-original processing of the original text, and made subtle adjustments and rewritten content, striving to make the article smoother and more natural without changing the general meaning of the original text. The image format and position remain unchanged.

The above is the detailed content of Disco with Design Patterns: A Fresh Look at Dependency Injection. For more information, please follow other related articles on the PHP Chinese website!