Introduction détaillée à l'injection de dépendances PHP (avec exemples)

Cet article vous apporte une introduction détaillée à l'injection de dépendances PHP (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Injection de dépendances

Pensée traditionnelle

Lorsqu'une application utilise une classe Foo, elle créera la classe Foo et appellera les méthodes de la classe Foo.
Si une classe Bar est requise dans cette méthode, la classe Bar sera créée et la méthode de la classe Bar sera appelée.
Si cette méthode nécessite une classe Bim, elle créera la classe Bim puis effectuera d'autres travaux.

/**
*  Foo
*/
class Foo 
{

    public function doSomething($value='')
    {
        # code...
        $Bar = new Bar();
        $Bar->doSomething();
        echo 'Foo doSomething','<br />' ;
    }
}

/**
*  Bar
*/
class Bar 
{
    

    public function doSomething($value='')
    {
        # code...
        $Bim = new Bim();
        $Bim->doSomething();
        echo 'Bar doSomething','<br />' ;
    }
}

/**
* Bim
*/
class Bim
{
    

    public function doSomething($value='')
    {
        # code...
        echo 'Bim doSomething','<br />'  ;
    }
}

$doSomething = new Foo();
$doSomething->doSomething();

Injection de dépendances

L'application utilise la classe Foo, la classe Foo a besoin de la classe Bar,
La classe Bar a besoin de la classe Bim, puis créez d'abord la classe Bim, puis créez la classe Bar et injectez Bim, créez la classe Foo et injectez la classe Bar
Ensuite, appelez la méthode Foo, Foo appelle la méthode Bar, puis effectuez d'autres travaux.

/**
* Bim2
*/
class Bim2 
{
    
    public function doSomething($value='')
    {
        # code...
        echo 'Bim2 doSomething','<br />' ;
    }

}

/**
*  Bar2
*/
class Bar2
{

    private $bim2 ;

    public function __construct(Bim2 $bim2)
    {
        # code...
        $this->bim2 = $bim2 ;
    }

    public function doSomething($value='')
    {
        # code...
        $this->bim2->doSomething();
        echo "Bar2 doSomething",'<br />';
    }
}

/**
* Foo
*/
class Foo2
{
    
    private $bar2 ;
    public function __construct(Bar2 $bar2)
    {
        # code...
        $this->bar2 = $bar2 ;
    }

    public function doSomething($value='')
    {
        # code...
        $this->bar2->doSomething();
        echo "Foo2 doSomething",'<br />';
    }
}

$doSomething2 = new Foo2(new Bar2(new Bim2()));
$doSomething2->doSomething();

C'est le modèle d'inversion de contrôle. Le contrôle des dépendances est inversé jusqu'au début de la chaîne d'appel. De cette façon, vous avez un contrôle total sur les dépendances et contrôlez le comportement de votre programme en ajustant les différents objets injectés.
Par exemple, la classe Foo utilise memcache, et vous pouvez utiliser redis à la place sans modifier le code de la classe Foo.
L'idée derrière l'utilisation d'un conteneur d'injection de dépendances est que si l'application a besoin d'obtenir la classe Foo, elle récupère la classe Foo du conteneur, le conteneur crée la classe Bim, puis crée la classe Bar et injecte Bim, puis crée la classe Foo et injecte Bar. L'application appelle la méthode Foo, Foo appelle la méthode Bar, puis effectue d'autres travaux

Extension : le conteneur est responsable de l'instanciation, de l'injection des dépendances, du traitement des dépendances, etc.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!