PHP Inversion of Control and Dependency Injection

Let’s look at an example first:

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 'b';
	}
}

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

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

?>

The above code, we can easily understand one sentence:

A classDepend on Class B and Class C

In other words, if in the future development process, Class B or Class C needs to be modified, once the

function is renamed, the function If the number of parameters changes, or even if the entire class structure is adjusted, we must also make corresponding adjustments to Class A. The independence of Class A is lost, which is very inconvenient during the development process, which 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,

Dependency Injection (DI) is a method to implement 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();
	} 
}

The client 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 class B

objectThe creation of class b and C object c has 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. It only needs to be concerned about in the client class.

The second method is called:

Factory modeInjection (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

constructor of classes B and C changes, such as modifying function parameters, etc., we Just change the Factory class.

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, A The $b

variables and $c variables in the class are no longer a specific variable, but an abstract class type variable. Until the moment of running, their identity is unknown. How is the Method method implemented?

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';
	}
}

Summary Several points:

1. We move the creation of class B objects and class C objects in class A Out of Class A

2. Originally Class A relied on Class B and Class C, but now A depends on Factory, and Factory depends on B and C.

The above is the detailed content of PHP Inversion of Control and Dependency Injection. For more information, please follow other related articles on the PHP Chinese website!