Explication détaillée du modèle de conception PHP sur l'utilisation de l'injection de dépendances

Avant-propos

Parlons enfin de ce fameux Principe de conception En fait, il est plus simple que les autres Design Patterns.
L'essence de l'injection de dépendances est de séparer les parties irremplaçables d'une classe des parties remplaçables et de les utiliser par injection, atteignant ainsi l'objectif de découplage.

Voici un exemple de lien de base de données. J'espère que tout le monde comprend que

une classe de connexion à une base de données

class Mysql{
    private $host;
    private $port;
    private $username;
    private $password;
    private $db_name;
    public function construct(){
        $this->host = '127.0.0.1';
        $this->port = 22;
        $this->username = 'root';
        $this->password = '';
        $this->db_name = 'my_db';
    }
    public function connect(){
        return mysqli_connect($this->host,$this->username ,$this->password,$this->db_name,$this->port); 
    }
}

doit généralement être conçue en utilisant

$db = new Mysql();
$con = $db->connect();

Puisqu’il s’agit d’un singleton, nous n’allons pas compliquer les choses ici.

Injection de dépendances

De toute évidence, la configuration de la base de données est une pièce remplaçable, nous devons donc la supprimer.

class MysqlConfiguration
{
    private $host;
    private $port;
    private $username;
    private $password;
    private $db_name;
    public function construct(string $host, int $port, string $username, string $password,string $db_name)
    {
        $this->host = $host;
        $this->port = $port;
        $this->username = $username;
        $this->password = $password;
        $this->db_name = $db_name;
    }
    public function getHost(): string
    {
        return $this->host;
    }
    public function getPort(): int
    {
        return $this->port;
    }
    public function getUsername(): string
    {
        return $this->username;
    }
    public function getPassword(): string
    {
        return $this->password;
    }
    public function getDbName(): string
    {
        return $this->db_name;
    }
}

Ensuite, la partie non remplaçable est comme ceci :

class Mysql
{
    private $configuration;
    public function construct(DatabaseConfiguration $config)
    {
        $this->configuration = $config;
    }
    public function connect(){
        return mysqli_connect($this->configuration->getHost(),$this->configuration->getUsername() ,
        $this->configuration->getPassword,$this->configuration->getDbName(),$this->configuration->getPort()); 
    }
}

Cela complète la séparation du fichier de configuration et de la logique de connexion.

Utilisez

$config = new MysqlConfiguration('127.0.0.1','root','','my_db',22);
$db = new Mysql($config);
$con = $db->connect();

$config pour injecter Mysql, ce qui est appelé injection de dépendances.

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!