How can we understand the two concepts of reflection and dependency injection in PHP in an easy-to-understand manner?

Please give me some advice, thank you

Reply content:

Please give me some advice, thank you

No need to understand, really, I’m not kidding you.
Unless you develop frameworks like ZendFramework, ThinkPHP, CakePHP, etc., there is almost no chance to use this.
This is a very low-level thing, especially the application scenario of dependency injection is to assist development. As long as the selected framework supports dependency injection, there is no need to implement it yourself. Reflection is similar. In business logic, I have never encountered a problem that must be solved by reflection. It is also only used by frameworks.

Oh, I read it wrong. You only need to know the concept. In layman’s terms,
Reflection is to obtain its information through reverse analysis of object instances. For example, based on reflection, it automatically generates the PHPDocument file of its corresponding class based on the object instance.
Dependency injection is It refers to automatically analyzing the parameters required when constructing objects and calling methods, and automatically injects the parameters. Usually instances of such objects need to be obtained through specific methods and are difficult to construct through simple new.

The so-called reflection is to dynamically obtain class information and can also make modifications. For example, some magic methods __FUNCTION__, __METHOD__. To be more advanced, you can use reflectionClass, which is reflection class acquisition.
Dependency injection, also called inversion of control. I’ll show you the code when I have time

I can’t explain clearly, it’s mainly some magic methods of the class
You can search PHP serialization vulnerability on Baidu

1 First, let me explain the "dependency injection" that I am familiar with. Dependency injection refers to passing the dependent object in the form of parameters at once, instead of displaying new when using it. Take a millet:

<code>//这就是依赖注入。。。
class Bar
{
}

class Foo
{
    protected $bar;

    public function __construct(Bar $bar)
    {
        $this->bar = $bar;
    }

    public function getBar()
    {
        return $this->bar;
    }
}

$bar = new Bar();
$foo = new Foo($bar); //将类Bar的对象$bar通过参数的形式注入进去
</code>

2 Extension:
//Dependency class Human
abstract class Human
{
}

//Inherits Woman which depends on class Human
class Woman extends Human
{
}

class Man extends Human
{

<code>protected $wife;

public function setWife(Human $human)
{
   $this->wife = $human;
}</code>

}

$man = new Man();
$man->setWife(new Woman());

Summary: When injecting dependency on a previously declared class, this class can be any class that inherits the dependent class (the same applies to interfaces)

Reflection is reverse mapping, used to obtain information about a class (not just a class). For example, you want to know what methods a class contains, what parameters these methods need to pass in, and what type each parameter is.

Dependency injection requires reflection, such as:

<code>class A
{
    protected $b;

    public function __constrcut(B $b)
    {
        $this->b = $b;
    }
}

// 通过控制反转容器生成 A 的实例时，会通过反射发现 A 的构造函数需要一个 B 类的实例
// 于是自动向 A 类的构造函数注入 B 类的实例
$a = IoC::make(A::class);</code>

Reflection also has many uses, such as making a series of assertions in unit tests, determining the acquisition of some private properties, and generating PHPDocument documents (because reflection can obtain comments on methods and classes)

Inversion of control and dependency injection obviously must use this feature.

For dependency injection, you can refer to this article on my blog. Although it is written for the Laravel framework, it is also universal (the design patterns used by Laravel are very rich and not abused. They are just right and very suitable for learning):

https://www.insp.top/article/learn-laravel-container

Dependency injection is to dynamically load class objects and instantiate them. Generally used to read configuration files and load them on demand.

In addition to doing this, reflection can also dynamically access members of the object. The reflection of scripting language php is more powerful, and it can also add new members to the object by modifying the association table inside the object.

For ie8, use e.cancelBubble=true
For others, use e.stopPropagation()

Dependency injection, my understanding is that the object is loaded into the constructor of the class. In order to decouple, the interface is generally chosen. After the configuration is completed, it is loaded into the main class on demand for assembly to achieve multiple functions.
Reflection is to take out Properties and methods in classes

给你推荐个地址吧，http://www.digpage.com/di.html,内容将的是yii2的依赖注入，里面的例子你看一遍差不多能明白是怎么回事了。

https://3v4l.org/1OVmo

<code>class Request 
{
    public function hello()
    {
        return 'hello ';
    }
}

class App
{
    public function name()
    {
        return 'the app';
    }
    public function response(Request $req, App $app)
    {
        return $req->hello().$app->name();
    }
}


//依赖查找 or 自动依赖注入
$c['App']     = new App;
$c['Request'] = new Request;

$r      = new ReflectionMethod('App', 'response');
$params = $r->getParameters();
$params = array_map(function($p) use ($c) {
    $className = $p->getClass()->name;
    return $c[$className]??null;
}, $params);

$res = $r->invokeArgs($c['App'], $params);


//手动依赖注入
$app = new App;
$req = new Request;
$res = $app->response($req, $app);</code>

只是名字比较唬人，其实很简单
反射其实就是获取类的信息（把类也看成是对象，然后通过反射类获取这个对象的一些属性）, 你比如说有个发送邮件的类。

<code><?php class MailerService
{
    public $mail;
    
    public function __construct(Mailer $mail)
    {
       $this->setHandle($mail);
    }
    
    public function setHandle(Mailer $mail)
    {
         $this->mail = $mail;
    }
}</code>

比如说：
我想知道这个类有哪些方法, 那我可以这样:

<code><?php $class = new ReflectionClass('MailerService');
$methods = $class->getMethods();</code>

我想知道这个类的构造函数要传什么参数

<code><?php $method = new ReflectionMethod('MailerService', '__construct');
$paramters = $method->getParameters();</code>

一言以蔽之, 反射就是获取类的信息的.

控制反转也很好理解，不过要先搞清楚, 控制反转和依赖注入不是一回事.
控制反转是一种目的，而实现方法之一就是依赖注入.
所谓的依赖注入就是不自己new class了, 而是由一个专门的类去做, 由这个类去解决类的依赖的问题，比如上面的MailerService类就依赖Mailer类, 这个专门的类会通过反射去获取MailerService类的构造函数需要什么参数，这个需要的参数也叫作依赖, 然后解决依赖. 这个就叫依赖注入. 一般通过依赖注入的方式来实现控制反转. 上述的那个专门的类一般也叫服务容器.