what is php dependency injection

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 deal with dependencies between classes. relation.

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

The following code is shown:

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

This method An improvement over the first solution, class A 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. However, 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 option is to use the set method to pass in

as shown in the following code:

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

This option also exists and the second option The same drawback, 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 twittee:

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

How can we manage the relationship between A and B after having the container class? Let’s talk about the dependencies 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 It is instantiated immediately when it is passed in, but 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 lazy loading and so on.

The above content is for reference only!

Recommended tutorial: PHP video tutorial

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