Detailed explanation of Ioc and Di examples in php

I have been using the ThinkPHP5 framework recently. After looking at its source code, I found that dependency injection (inversion of control) is also used in many places. I feel it is necessary to briefly talk with you about what dependency injection is and how to use it.

Let’s look at an example first:

<?php

class A
{
	public $b;
	public $c;
	public function A()
	{
		//TODO
	}
	public function Method()
	{
		$this->b=new B();
		$this->c=new C();
		
		$this->b->Method();
		$this->c->Method();
		
		//TODO
	} 
}

class B
{
	public function B()
	{
		//TODO
	}
	public function Method()
	{
		//TODO
		echo &#39;b&#39;;
	}
}

class C
{
	public function C()
	{
		//TODO
	}
	public function Method()
	{
		//TODO
		echo &#39;c&#39;;
	}
}

$a=new A();
$a->Method();

?>

The above code, we can easily understand one sentence:

Class A depends on B Class and Class C

That is to say, if in the future development process, we need to modify Class B or Class C, once it involves renaming the function, changing the number of function parameters, or even adjusting the entire class structure, we will also have to modify it. Category A makes corresponding adjustments, and the independence of category A is lost. This is very inconvenient during the development process. This is what we call "one thing affects the whole body". If the two categories are written by two people separately, Conflicts often arise at this time. . .

If we really need to change categories B and C, is there any way to not change the code of category A or to change it as little as possible? Inversion of control is used here.

High-level modules should not depend on low-level modules, both should rely on abstractions.

Inversion of control (IOC) is an idea, and dependency injection (DI) is a method of implementing this idea.

The first method is called: constructor injection (this method is not recommended, but it is better than not using it)

class A
{
	public $b;
	public $c;
	public function A($b,$c)
	{
		$this->b=$b;
		$this->c=$c;
	}
	public function Method()
	{
		$this->b->Method();
		$this->c->Method();
	} 
}

Client The class is written like this:

$a=new A(new B(),new C());
$a->Method();

The constructor of class A depends on class B and class C. It is passed in through the parameters of the constructor. At least one thing is achieved, which is B The creation of class object b and class C object c have been moved outside class A, so once class B and class C are changed, class A does not need to be modified, just change it in the client class.

If One day, we need to expand class B and make two subclasses of class B

class B
{
	public function B()
	{
		//TODO
	}
	public function Method()
	{
		//TODO
		echo 'b';
	}
}
class B1 extends B
{
	public function B1()
	{
		//TODO
	}
	public function Method()
	{
		echo 'b1';
	}
}
class B2 extends B
{
	public function B2()
	{
		//TODO
	}
	public function Method()
	{
		echo 'b2';
	}
}

is also very simple. The client class is written like this:

$a=new A(new B2(),new C());
$a->Method();

So class A does not need to care about which subclasses class B has, as long as it is concerned about the client class.

The second method is called: factory mode injection (recommended)

class Factory
{
	public function Factory()
	{
		//TODO
	}
	public function create($s)
	{
		switch($s)
		{
			case 'B':
			{
				return new B();
				break;
			}
			case 'C':
			{
				return new C();
				break;
			}
			default:
			{
				return null;
				break;
			}
		}
	}
}

Our Class A code is changed to:

class A
{
	public $b;
	public $c;
	public function A()
	{
		//TODO
	}
	public function Method()
	{
		$f=new Factory();
		$this->b=$f->create('B');
		$this->c=$f->create('C');
		
		$this->b->Method();
		$this->c->Method();
		
		//TODO
	} 
}

In fact, a small part has been decoupled. At least if the constructors of classes B and C change, such as modifying function parameters, etc., we only need to change the Factory class. That's it.

Abstraction should not depend on details, details should depend on abstraction.

Abstract the methods in classes B and C and make an interface

interface IMethod
{
	public function Method();
}

In this way, the $b variable in class A The $c variable is no longer a concrete variable, but an abstract type variable. I don’t know how their Method is implemented until the moment it is run.

class B implements IMethod
{
	public function B()
	{
		//TODO
	}
	public function Method()
	{
		//TODO
		echo 'b';
	}
}

class C implements IMethod
{
	public function C()
	{
		//TODO
	}
	public function Method()
	{
		//TODO
		echo 'c';
	}
}

To summarize a few points:

1. We move the creation of class B objects and class C objects in class A to class A External

2. Originally, class A relied on class B and class C, but now it has become that A depends on Factory, and Factory depends on B and C.

Related recommendations:

Detailed example code explanation of PHP Inversion of Control (IOC) and Dependency Injection (DI)

Share practical tutorials on PHP Dependency Injection (DI) and Inversion of Control (IoC)

PHP Dependency Injection (DI) and Inversion of Control (IoC) )Example tutorial

The above is the detailed content of Detailed explanation of Ioc and Di examples in php. For more information, please follow other related articles on the PHP Chinese website!