Comprendre la série de conteneurs d'injection de dépendances PHP (1) Qu'est-ce que

Cet article est le premier chapitre de la série sur l'implémentation des conteneurs d'injection de dépendances PHP.
Aujourd'hui, ne parlons pas des conteneurs. Tout d'abord, nous utiliserons quelques exemples spécifiques pour introduire le concept d'injection de dépendances afin de prouver quels problèmes ce modèle peut résoudre et quels avantages il peut apporter aux développeurs.
Si vous connaissez déjà le concept d'injection de dépendances, vous pouvez ignorer cet article.

L'injection de dépendances est peut-être l'un des modèles de conception les plus simples que je connaisse. Dans de nombreux cas, vous avez peut-être utilisé l'injection de dépendances inconsciemment. Mais c’est aussi l’un des plus difficiles à expliquer. Je pense que cela s'explique en partie par le fait que la plupart des exemples introduisant l'injection de dépendances manquent de signification pratique et sont difficiles à comprendre. Étant donné que PHP est principalement utilisé pour le développement Web, examinons d'abord un exemple simple de développement Web.

HTTP lui-même est un protocole de connexion sans état. Afin de permettre à l'application de stocker les informations utilisateur lorsque le client initie une requête WEB, nous devons utiliser une technologie pour obtenir une interaction avec l'état de stockage. Bien sûr, le moyen le plus simple consiste à utiliser des cookies, et le meilleur moyen consiste à utiliser le mécanisme de session intégré à PHP.

$_SESSION['language'] = 'fr';

Le code ci-dessus stocke la langue de l'utilisateur dans la variable de session nommée langue, donc dans les requêtes ultérieures de l'utilisateur, la langue peut être obtenue via le tableau global $_SESSION :

$user_language = $_SESSION['language'];

L'injection de dépendances est principalement utilisée pour le développement orienté objet. Supposons maintenant que nous ayons une classe SessionStorage, qui encapsule le mécanisme de session PHP :

class SessionStorage
{
  function __construct($cookieName = 'PHP_SESS_ID')
  {
    session_name($cookieName);
    session_start();
  }
  function set($key, $value)
  {
    $_SESSION[$key] = $value;
  }
  function get($key)
  {
    return $_SESSION[$key];
  }
  // ...
}

Il existe également une classe User qui fournit des fonctionnalités plus avancées. L'encapsulation :

class User
{
  protected $storage;
  function __construct()
  {
    $this->storage = new SessionStorage();
  }
  function setLanguage($language)
  {
    $this->storage->set('language', $language);
  }
  function getLanguage()
  {
    return $this->storage->get('language');
  }
  // ...
}

Le code est très simple, et il est également très simple d'utiliser la classe User :

$user = new User();
$user->setLanguage('fr');
$user_language = $user->getLanguage();

Tout va bien, sauf si votre programme a besoin d'une meilleure évolutivité. Supposons maintenant que vous souhaitiez modifier la valeur de la clé COOKIE qui enregistre session_id. Voici quelques méthodes alternatives :

Lors de la création d'une instance SessionStorage dans la classe User, utilisez la chaîne 'SESSION_ID' codée en dur dans le constructeur SessionStorage :

class User
{
    function __construct()
    {
        $this->storage = new SessionStorage('SESSION_ID');
    }
    // ...
}

Définissez une constante (nommée STORAGE_SESSION_NAME) en dehors de la classe User

class User
{
  function __construct()
  {
    $this->storage = new SessionStorage(STORAGE_SESSION_NAME);
  }
  // ...
}
define('STORAGE_SESSION_NAME', 'SESSION_ID');

Passez le nom de la session via le paramètre dans le constructeur de la classe User

class User
{
  function __construct($sessionName)
  {
    $this->storage = new SessionStorage($sessionName);
  }
  // ...
}
$user = new User('SESSION_ID');

Le nom de la session est toujours passé via les paramètres dans le constructeur de la classe User, mais cette fois les paramètres sont sous la forme d'un tableau

class User
{
  function __construct($storageOptions)
  {
    $this->storage = new SessionStorage($storageOptions['session_name']);
  }
  // ...
}
$user = new User(array('session_name' => 'SESSION_ID'));

Ce qui précède est tout à fait mauvais.
Le codage en dur du nom de session dans la classe d'utilisateurs ne résout pas vraiment le problème. Si vous devez modifier la valeur de la clé COOKIE qui enregistre le session_id à l'avenir, vous devez modifier à nouveau la classe d'utilisateurs (la classe User ne devrait pas s'en soucier. sur la valeur de la clé COOKIE).
La manière d'utiliser les constantes est également mauvaise, ce qui fait que la classe User dépend d'un paramètre constant.
Il est relativement préférable de transmettre le nom de la session via les paramètres ou le tableau du constructeur de la classe User, mais ce n'est pas parfait. Cela interfère avec les paramètres du constructeur de la classe User, car la façon de stocker la session n'est pas ce que l'on veut. La classe User doit s’en soucier. La classe User ne doit pas leur être associée.

De plus, il y a un autre problème qui n'est pas facile à résoudre : comment changer la classe SessionStorage. Il existe de nombreux scénarios d'application pour cela, par exemple, vous souhaitez utiliser une classe de simulation de session pour des tests ou vous souhaitez stocker la session dans une base de données ou une mémoire. Avec l’implémentation actuelle, il est difficile de faire cela sans changer la classe User.

Maintenant, utilisons l'injection de dépendances. Rappelez-vous que nous avons déjà créé l'objet SessionStorage dans la classe User. Nous le modifions maintenant pour que l'objet SessionStorage soit transmis via le constructeur de la classe User.

class User
{
  function __construct($storage)
  {
    $this->storage = $storage;
  }
  // ...
}

C'est le cas le plus classique d'injection de dépendances, sans exception. Il y a maintenant quelques petits changements dans l'utilisation de la classe User. Vous devez d'abord créer l'objet SessionStorage.

$storage = new SessionStorage('SESSION_ID');
$user = new User($storage);

Maintenant, il est très simple de configurer l'objet de stockage de session, et il est également très simple de modifier l'objet de stockage de session. Tout cela n'a pas besoin de mettre à jour la classe User, réduisant ainsi le couplage entre. cours d'affaires.
Le site Web de Pico Container décrit l'injection de dépendances comme ceci :

L'injection de dépendances est une méthode permettant de transmettre des composants dépendants à une classe via le constructeur, la méthode ou l'écriture directe de la classe.

L'injection de dépendances ne se limite donc pas à l'injection de constructeur. Jetons un coup d'œil à plusieurs méthodes d'injection :

Injection de constructeur

class User
{
  function __construct($storage)
  {
    $this->storage = $storage;
  }
  // ...
}

Injection de méthode Setter

class User
{
  function setSessionStorage($storage)
  {
    $this->storage = $storage;
  }
  // ...
}

Injection d'attribut direct

class User
{
  public $sessionStorage;
}
$user->sessionStorage = $storage;

根据经验，一般通过构造函数注入的是强依赖关系的组件，setter方式用来注入可选的依赖组件。

现在，大多数流行的PHP框架都采用了依赖注入的模式实现业务组件间的高内聚低耦合。

// symfony: 构造函数注入的例子
$dispatcher = new sfEventDispatcher();
$storage = new sfMySQLSessionStorage(array('database' => 'session', 'db_table' => 'session'));
$user = new sfUser($dispatcher, $storage, array('default_culture' => 'en'));
// Zend Framework: setter方式注入的例子
$transport = new Zend_Mail_Transport_Smtp('smtp.gmail.com', array(
  'auth'     => 'login',
  'username' => 'foo',
  'password' => 'bar',
  'ssl'      => 'ssl',
  'port'     => 465,
));
$mailer = new Zend_Mail();
$mailer->setDefaultTransport($transport);

 以上就是理解PHP依赖注入容器系列(一) 什么是的内容，更多相关内容请关注PHP中文网（www.php.cn）！