Principle of dependency injection in php

The principle of php dependency injection

The examples in this article describe the principle and usage of PHP dependency injection. Share it with everyone for your reference, the details are as follows:

Introduction

Do you know what dependency injection is?

Although the concept of dependency injection (DI) sounds profound, if you have used some emerging PHP frameworks, you must be familiar with DI, because they all use dependency injection to process classes. Dependencies between classes.

Three options for passing dependencies in php

In fact, to understand DI, you must first understand how to pass dependencies in php.

The first solution, and the most undesirable solution, is to directly use the new keyword in class A to create a class B, as shown in the following code:

<?php
class A
{
  public function __construct()
  {
    $b = new B();
  }
}

Why is this solution Is it not advisable? Because in this case, A and B are coupled together, which means that class A cannot work without class B.

The second option is to pass in the required class B in the method of class A, as shown in the following code:

<?php
class A
{
  public function __construct(B $b)
  {
  }
}

This method is an improvement over the first option, class A It does not have to be bundled with class B, as long as the incoming class meets the needs of class A, it can also be class C, class D, etc.

But the disadvantage of this solution is that if class A depends on many classes, the parameter list will be very long and confusion may easily occur.

The third solution is to use the set method to pass it in, as shown in the following code:

<?php
class A
{
  public function setB(B $b)
  {
    $this->b = $b;
  }
}

This solution also has the same drawbacks as the second solution. When the number of dependent classes increases, We need many, many set methods.

At this time we were thinking that it would be great if there was a special class (or a container) that could help us manage these dependencies.

A simple example of dependency injection

The following code comes from twitter:

<?php
class Container {
 private $s=array();
 function __set($k, $c) { $this->s[$k]=$c; }
 function __get($k) { return $this->s[$k]($this); }
}

With the container class, how can we manage the dependency relationship between A and B? Let’s talk in code:

<?php
class A
{
  private $container;
  public function __construct(Container $container)
  {
    $this->container = $container;
  }
  public function doSomeThing()
  {
    //do something which needs class B
    $b = $this->container->getB();
    //to do
  }
}

Then inject class B into the container class:

$c = new Container();
$c->setB(new B());

You can also pass in an anonymous function so that class B will not be instantiated when it is passed in. Instead, the instantiation work is completed only when it is actually called:

$c = new Container();
$c->setB(function (){
  return new B();
});

This is just a very simple example. In practice, there are many things to consider for container classes, such as delayed loading and so on.

For more PHP related knowledge, please visit PHP Chinese website!

The above is the detailed content of Principle of dependency injection in php. For more information, please follow other related articles on the PHP Chinese website!