


Disco with Design Patterns: A Fresh Look at Dependency Injection
Feb 15, 2025 pm 01:14 PMCore 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() { // 實例化 $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!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

ToversionaPHP-basedAPIeffectively,useURL-basedversioningforclarityandeaseofrouting,separateversionedcodetoavoidconflicts,deprecateoldversionswithclearcommunication,andconsidercustomheadersonlywhennecessary.StartbyplacingtheversionintheURL(e.g.,/api/v

TosecurelyhandleauthenticationandauthorizationinPHP,followthesesteps:1.Alwayshashpasswordswithpassword_hash()andverifyusingpassword_verify(),usepreparedstatementstopreventSQLinjection,andstoreuserdatain$_SESSIONafterlogin.2.Implementrole-basedaccessc

PHPdoesnothaveabuilt-inWeakMapbutoffersWeakReferenceforsimilarfunctionality.1.WeakReferenceallowsholdingreferenceswithoutpreventinggarbagecollection.2.Itisusefulforcaching,eventlisteners,andmetadatawithoutaffectingobjectlifecycles.3.YoucansimulateaWe

Proceduralandobject-orientedprogramming(OOP)inPHPdiffersignificantlyinstructure,reusability,anddatahandling.1.Proceduralprogrammingusesfunctionsorganizedsequentially,suitableforsmallscripts.2.OOPorganizescodeintoclassesandobjects,modelingreal-worlden

To safely handle file uploads in PHP, the core is to verify file types, rename files, and restrict permissions. 1. Use finfo_file() to check the real MIME type, and only specific types such as image/jpeg are allowed; 2. Use uniqid() to generate random file names and store them in non-Web root directory; 3. Limit file size through php.ini and HTML forms, and set directory permissions to 0755; 4. Use ClamAV to scan malware to enhance security. These steps effectively prevent security vulnerabilities and ensure that the file upload process is safe and reliable.

Yes, PHP can interact with NoSQL databases like MongoDB and Redis through specific extensions or libraries. First, use the MongoDBPHP driver (installed through PECL or Composer) to create client instances and operate databases and collections, supporting insertion, query, aggregation and other operations; second, use the Predis library or phpredis extension to connect to Redis, perform key-value settings and acquisitions, and recommend phpredis for high-performance scenarios, while Predis is convenient for rapid deployment; both are suitable for production environments and are well-documented.

In PHP, the main difference between == and == is the strictness of type checking. ==Type conversion will be performed before comparison, for example, 5=="5" returns true, and ===Request that the value and type are the same before true will be returned, for example, 5==="5" returns false. In usage scenarios, === is more secure and should be used first, and == is only used when type conversion is required.

The methods of using basic mathematical operations in PHP are as follows: 1. Addition signs support integers and floating-point numbers, and can also be used for variables. String numbers will be automatically converted but not recommended to dependencies; 2. Subtraction signs use - signs, variables are the same, and type conversion is also applicable; 3. Multiplication signs use * signs, which are suitable for numbers and similar strings; 4. Division uses / signs, which need to avoid dividing by zero, and note that the result may be floating-point numbers; 5. Taking the modulus signs can be used to judge odd and even numbers, and when processing negative numbers, the remainder signs are consistent with the dividend. The key to using these operators correctly is to ensure that the data types are clear and the boundary situation is handled well.
