Wie können wir die Konzepte der Reflexion und Abhängigkeitsinjektion in PHP auf leicht verständliche Weise verstehen?

Bitte geben Sie mir einen Rat, danke

Antwortinhalt:

Bitte geben Sie mir einen Rat, danke

Kein Grund zu verstehen, wirklich, ich mache keine Witze.
Es sei denn, Sie entwickeln Frameworks wie ZendFramework, ThinkPHP, CakePHP usw., gibt es fast keine Chance, dies zu nutzen.
Dies ist eine sehr untergeordnete Sache, insbesondere das Anwendungsszenario der Abhängigkeitsinjektion dient der Unterstützung der Entwicklung. Das ausgewählte Framework muss nur die Abhängigkeitsinjektion unterstützen. In der Geschäftslogik bin ich noch nie auf ein Problem gestoßen, das durch Reflexion gelöst werden muss. Es wird auch nur von Frameworks verwendet.

Oh, Sie müssen das Konzept nur kennen.
Reflexion besteht darin, ihre Informationen durch umgekehrte Analyse von Objektinstanzen zu erhalten
Abhängigkeitsinjektion bezieht sich auf die automatische Analyse der beim Erstellen von Objekten und Aufrufen von Methoden erforderlichen Parameter und die automatische Injektion der Parameter. Normalerweise müssen Instanzen solcher Objekte durch spezifische Methoden erhalten werden und sind durch einfache neue Methoden nur schwer zu konstruieren.

Die sogenannte Reflexion besteht darin, Klasseninformationen dynamisch abzurufen und Änderungen vorzunehmen. Zum Beispiel einige magische Methoden __FUNCTION__, __METHOD__. Um fortgeschrittener zu sein, können Sie ReflectionClass verwenden, bei dem es sich um den Erwerb von Reflection-Klassen handelt.
Abhängigkeitsinjektion, auch Umkehrung der Kontrolle genannt. Ich werde eine Codedemonstration veröffentlichen, wenn ich Zeit habe

Ich kann es nicht genau erklären, es sind hauptsächlich einige magische Methoden der Klasse
Sie können auf Baidu nach PHP-Serialisierungsschwachstellen suchen

1 Lassen Sie mich zunächst die mir bekannte „Abhängigkeitsinjektion“ erläutern. Unter Abhängigkeitsinjektion versteht man die gleichzeitige Übergabe des abhängigen Objekts in Form von Parametern, anstatt bei der Verwendung ein neues anzuzeigen. Nimm eine Hirse:

<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 Erweiterung:
//Abhängigkeitsklasse Mensch
abstrakte Klasse Mensch
{
}

//Inherit Woman
class Woman erweitert Human
{
}

Klasse Mensch erweitert Mensch
{

<code>protected $wife;

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

}

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

Zusammenfassung: Wenn Sie sich auf eine zuvor deklarierte Klasse verlassen, kann diese Klasse jede Klasse sein, die die abhängige Klasse erbt (dasselbe gilt für Schnittstellen)

Reflection ist eine umgekehrte Zuordnung, die verwendet wird, um Informationen über eine Klasse (nicht nur eine Klasse) zu erhalten. Sie möchten beispielsweise wissen, welche Methoden eine Klasse enthält, welche Parameter diese Methoden übergeben müssen und welchen Typ jeder Parameter hat .

Abhängigkeitsinjektion erfordert Reflexion, wie zum Beispiel:

<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 hat auch viele Verwendungsmöglichkeiten, z. B. das Erstellen einer Reihe von Behauptungen in Komponententests, das Bestimmen des Erwerbs einiger privater Eigenschaften und das Generieren von PHPDocument-Dokumenten (da Reflektion Kommentare zu Methoden und Klassen erhalten kann)

Bei der Umkehrung der Kontrolle und der Abhängigkeitsinjektion muss diese Funktion natürlich verwendet werden.

In Bezug auf die Abhängigkeitsinjektion können Sie sich auf diesen Artikel in meinem Blog beziehen. Obwohl er für das Laravel-Framework geschrieben wurde, ist er auch universell (die von Laravel verwendeten Entwurfsmuster sind sehr umfangreich und werden nicht missbraucht. Sie sind einfach richtig und sehr zum Lernen geeignet):

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

Abhängigkeitsinjektion dient dazu, Klassenobjekte dynamisch zu laden und zu instanziieren. Wird im Allgemeinen verwendet, um Konfigurationsdateien zu lesen und bei Bedarf zu laden.

Darüber hinaus kann die Reflexion auch dynamisch auf die Mitglieder eines Objekts zugreifen. Die Reflexion der Skriptsprache PHP ist leistungsfähiger und kann dem Objekt auch neue Mitglieder hinzufügen, indem die Zuordnungstabelle innerhalb des Objekts geändert wird.

ie8 verwendet e.cancelBubble=true
andere verwenden e.stopPropagation()

Nach meinem Verständnis wird das Objekt in den Konstruktor der Klasse geladen. Um es zu entkoppeln, wird die Schnittstelle im Allgemeinen nach Abschluss der Konfiguration zur Montage in die Hauptklasse geladen mehrere Funktionen erreichen
Reflexion besteht darin, die Attribute und Methoden in der Klasse herauszunehmen

给你推荐个地址吧，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类的构造函数需要什么参数，这个需要的参数也叫作依赖, 然后解决依赖. 这个就叫依赖注入. 一般通过依赖注入的方式来实现控制反转. 上述的那个专门的类一般也叫服务容器.