Over the past few years, dependency injection has been a frequently discussed topic among many corporate developers. Many were concerned that they might spend too much time creating their application architecture without actually accomplishing anything. In this article, I'll outline the benefits of dependency injection for PHP developers creating large, scalable projects.

Dependency Injection:

class Author {
    private $firstName;
    private $lastName;
    public function __construct($firstName, $lastName) {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
    }
    public function getFirstName() {
        return $this->firstName;
    }
    public function getLastName() {
        return $this->lastName;
    }
}
class Question {
    private $author;
    private $question;
    public function __construct($question, $authorFirstName, $authorLastName) {
        $this->author = new Author($authorFirstName, $authorLastName);
        $this->question = $question;
    }
    public function getAuthor() {
        return $this->author;
    }
    public function getQuestion() {
        return $this->question;
    }
}

Despite the fact that many programmers would consider this to be good code, it has a number of issues: 

class Author {
    private $firstName;
    private $lastName;
    
    public function __construct($firstName, $lastName) {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
    }
    public function getFirstName() {
        return $this->firstName;
    }
    public function getLastName() {
        return $this->lastName;
    }
}
class Question {
    private $author;
    private $question;
    public function __construct($question, Author $author) {
        $this->author = $author;
        $this->question = $question;
    }
    public function getAuthor() {
        return $this->author;
    }
    public function getQuestion() {
        return $this->question;
    }
}

illogical startup code

As the project expands, you end up with many levels of objects that must be created when your application starts, so you start passing your dependencies in your class constructors. Depending on the size of your application, creating every object needed to launch it can take a long time and negatively affect performance (as well as produce messy code). Here's an illustration:

/* 
Please be aware that this situation doesn't depend on the application's nature.. I only wanted to show how hard-to-maintain/awful such code can be: 
*/
$filePath = "/path/to/file";
$fileBuilderFactory = new ConcreteFileBuilderFactory();
$filesXmlBuilderFactory = new ConcreteFilesXmlBuilderFactory($fileBuilderFactory);
$softwaresRetrieverCriteriaBuilderFactory = new ConcreteSoftwaresRetrieverCriteriaBuilderFactory($filesXmlBuilderFactory);
$softwareRetrieverCriteriaBuilderFactory = new ConcreteSoftwaresSoftwareRetrieverCriteriaBuilderFactory($filesXmlBuilderFactory);
$filesJsonBuilderFactory = new ConcreteFilesJsonBuilderFactory($fileBuilderFactory);
$objectBuildderFactory = new ConcreteSoftwaresSoftwareObjectBuilderFactory();
$softwaresSoftwareBuilderFactory = new ConcreteSoftwaresSoftwareBuilderFactory($objectBuildderFactory);
$xmlSoftwareRepository = new XmlSoftwareRepository($softwaresSoftwareBuilderFactory);
$softwaresBuilderFactory = new ConcreteSoftwaresBuilderFactory($xmlSoftwareRepository, $softwareRetrieverCriteriaBuilderFactory, $filesJsonBuilderFactory);
$xmlSoftwaresRepository = new XmlSoftwaresRepository($softwaresBuilderFactory);
$softwareToHashMap = new ConcreteSoftwareToHashMap();
$softwaresToHashMap = new ConcreteSoftwaresToHashMap($softwareToHashMap);
$jsonSoftwaresService = new JsonSoftwaresService($softwaresToHashMap);
$di = new DependencyInjection($softwaresRetrieverCriteriaBuilderFactory, $xmlSoftwaresRepository, $jsonSoftwaresService);

This startup code is not particularly long. Your startup code could get much heavier than this if you create a big application. 

$objectFilePath = "/path/to/serialized/object/file";
$di = unserialize(file_get_contents($objectFilePath));

Use Dependency Injection When