What does php dependency injection mean?

In PHP, dependency injection refers to the automatic injection of class dependencies through the constructor. Once object type constraints are placed on parameters in the controller architecture method and operation method, dependency injection will be automatically eliminated. Since the parameters for accessing the controller come from URL requests, ordinary variables are automatically obtained through parameter binding, and object variables are obtained through dependencies. Injection generation.

The operating environment of this article: Windows 10 system, PHP version 7.1, Dell G3 computer.

What does php dependency injection mean?

Dependency injection essentially refers to the automatic injection of class dependencies through the constructor. For example, once the parameters are injected in the controller architecture method and operation method, Object type constraints will automatically trigger dependency injection. Since the parameters of the access controller come from URL requests, ordinary variables are automatically obtained through parameter binding, and object variables are generated through dependency injection.

The so-called dependency, for example, is a class Person and another class Car. If a method of Person, such as drive, needs to reference Car, the Person class is said to depend on the Car class, extending to the object. This dependency relationship still holds. For example, the object boy of the Person class depends on the object Toyota of the Car class. Let’s talk about the implementation of this drive method. Assume that the code is as follows:

Public Person{
...
public void drive(){
  Car toyota=new Car("TOYOTA");
  toyota.挂档;
  toyota.踩油门;
  toyota.打方向;
}
}

The dependencies in this result in the object boy needing to be responsible for the creation of the object toyota, and even the management of the entire life cycle, and this will obviously It brings disadvantages such as high coupling and difficulty in maintenance. For example, if you want this boy to drive an Audi, you need to modify the Person-like code.

Therefore, a very famous principle has been proposed in Java design theory, the Dependence Inversion principle. Its core idea is to convert the dependencies between concrete classes into abstract dependencies as much as possible. , that is to say, the class Person should depend on the abstract class ICar, rather than the specific class Car. Java here strongly recommends the use of abstraction and interfaces. As for the difference between abstraction and interfaces, any JAVA book will introduce it. I won’t say any more here.

This dependency inversion principle is also reflected in many design patterns, such as factory mode and build mode. I personally think that control inversion IoC can actually be considered a design pattern that implements this principle. Inversion of control, I have never quite understood what the word control means, but another term for inversion of control is dependence injection, which I personally find easier to understand. Let's take the example of boy and toyota above. The core is to inject the object toyota that boy depends on into boy, without boy having to reference toyota himself. This injection process is usually completed by a control program, without the need for boy to reference toyota. Object to care about, for example:

Public Person{
private ICar car;
public Person(ICar onecar){
  car=onecar;
}
public void drive(){
  car.挂档;
  car.踩油门;
  car.打方向;
}
}

At this time, the process of injecting and calling is very simple, as follows:

Toyota toyota=new Toyota();
Person boy=new Person(toyota);
boy.drive();

Note: Here we assume that the Toyota class is an ICar interface class a specific implementation.

This example demonstrates an example of the simplest injection method, that is, constructor method injection, which is achieved by injecting dependent objects into the constructor of the object. There is also a commonly used injection method, which is attribute injection, which means that it is achieved by injecting dependent objects into the attributes of the object. Let’s take the examples of boy and toyota, as follows:

Public Person{
private ICar car;
public Person(){
}
public void drive(){
  car.挂档;
  car.踩油门;
  car.打方向;
}
public ICar getCar(){
  return this.car;
}
public void setCar(ICar onecar){
  car=onecar;
}
}

At this time, The process of injecting and calling becomes as follows:

Toyota toyota=new Toyota();
Person boy=new Person();
boy.setCar(toyota);
boy.drive();

At this point, the concept of dependency injection should be relatively clear. Let’s take a look at how to implement IoC in Spring and see how Spring can become a mature IoC container, Spring actually mainly implements IoC through two concepts. First, through the XML configuration file, the objects and dependent objects are configured into an XML file. Of course, the XML file needs to comply with the specifications specified by Spring, and then through the architecture BeanFactroy class to automatically implement the injection process described above, or take boy and toyota as examples, as follows:

First, the Person class is still the same,

Then add points to the xml configuration file Thing-(assumed to be bean.xml):

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
   <bean id="oneCar" class="Toyota"> <!-- Toyota类是ICar的一个实现-->
   </bean>
   <bean id="onePerson" class="Person"> <!--本例以属性方式注入为例 -->
       <property name="car"> 
           <ref bean="oneCar"></ref>
       </property>
   </bean>
</beans>

Finally, the calling process becomes as follows:

BeanFactory factory=new XmlBeanFactory("bean.xml");
Person boy=(Person )factory.getBean("onePerson");
boy.drive();

Recommended learning: "PHP Video Tutorial"

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