Analyse des conteneurs de services et des injections de dépendances en PHP

Cet article présente principalement le conteneur de services et l'injection de dépendances en PHP. Il a une certaine valeur de référence. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent s'y référer

Injection de dépendances

. Lorsque la classe A doit dépendre de la classe B, c'est-à-dire lorsqu'un objet de classe B doit être instancié dans la classe A pour être utilisé, si les fonctions de la classe B changent, cela entraînera également l'utilisation de la classe B dans la classe A à également Suite à la modification, la classe A et la classe B sont fortement couplées. La solution à l'heure actuelle est que la classe A s'appuie sur l'interface de la classe B et confie l'instanciation de classes spécifiques à l'extérieur.

Prenons comme exemple le module de notification couramment utilisé dans notre métier.

<?php

/**
 * 定义了一个消息类
 * Class Message 
 */
class  Message{

  public function seed()
  {
      return &#39;seed email&#39;;

  }
}
/*
 * 订单产生的时候 需要发送消息
 */
class Order{

    protected $messager = &#39;&#39;;

    function __construct()
    {
        $this->messager = new Message();

    }

    public function seed_msg()
    {

        return $this->messager->seed();

    }
}
$Order = new Order();
$Order->seed_msg();

Le code ci-dessus est notre méthode d'écriture traditionnelle. Tout d'abord, la classe envoyée par le message. Ensuite, là où nous devons envoyer un message, appelez l'interface d'envoi du message. Un jour, vous devrez ajouter une interface d'envoi de messages texte pour répondre à différents besoins. Ensuite, vous constaterez que vous devez apporter des modifications dans la classe Message. Vous devez également apporter des modifications dans la classe Order. Cela semble très gênant. A cette époque, l’idée de l’injection de dépendances est née. Faisons un ajustement au code

<?php

/**
 * 为了约束我们先定义一个消息接口
 * Interface Message
 */
interface  Message{

  public function seed();
}

/**
 * 有一个发送邮件的类
 * Class SeedEmail
 */
class SeedEmail implements Message
{

    public function seed()
    {

        return  &#39;seed email&#39;;

        // TODO: Implement seed() method.
    }

}

/** 
 *新增一个发送短信的类
 * Class SeedSMS
 */
class SeedSMS implements Message
{
    public function seed()
    {
        return &#39;seed sms&#39;;
        // TODO: Implement seed() method.
    }


}
/*
 * 订单产生的时候 需要发送消息
 */
class Order{

    protected $messager = &#39;&#39;;

    function __construct(Message $message)
    {
        $this->messager = $message;

    }
    public function seed_msg()
    {
        return $this->messager->seed();
    }
}
//我们需要发送邮件的时候
$message = new SeedEmail();
//将邮件发送对象作为参数传递给Order
$Order = new Order($message);
$Order->seed_msg();


//我们需要发送短信的时候
$message = new SeedSMS();
$Order = new Order($message);
$Order->seed_msg();

afin que nous puissions réaliser l'idée de l'injection de dépendances. Est-il très pratique d'étendre ?

Conteneur de services

Le conteneur de services que je comprends est une usine qui génère automatiquement des classes.

<?php
/**
 * 为了约束我们先定义一个消息接口
 * Interface Message
 */
interface  Message{

    public function seed();
}

/**
 * 有一个发送邮件的类
 * Class SeedEmail
 */
class SeedEmail implements Message
{

    public function seed()
    {

        return  &#39;seed email&#39;;

        // TODO: Implement seed() method.
    }

}

/**
 *新增一个发送短信的类
 * Class SeedSMS
 */
class SeedSMS implements Message
{
    public function seed()
    {
        return &#39;seed sms&#39;;
        // TODO: Implement seed() method.
    }

}


/**
 * 这是一个简单的服务容器
 * Class Container
 */
class Container
{
    protected $binds;

    protected $instances;

    public function bind($abstract, $concrete)
    {
        if ($concrete instanceof Closure) {
            $this->binds[$abstract] = $concrete;
        } else {
            $this->instances[$abstract] = $concrete;
        }
    }

    public function make($abstract, $parameters = [])
    {
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }

        array_unshift($parameters, $this);

        return call_user_func_array($this->binds[$abstract], $parameters);
    }
}

//创建一个消息工厂
$message = new  Container();
//将发送短信注册绑定到工厂里面
$message->bind(&#39;SMS&#39;,function (){
     return   new  SeedSMS();
});
//将发送邮件注册绑定到工厂
$message->bind(&#39;EMAIL&#39;,function (){
   return new  SeedEmail();
});
//需要发送短信的时候
$SMS  = $message->make(&#39;SMS&#39;);
$SMS->seed();

container est un conteneur de service simple avec deux méthodes bind et make
bind lie les objets de service au conteneur. make supprime l'objet du conteneur.

bind

Vous devez transmettre un bind dans la méthode concrete Nous pouvons transmettre un objet d'instance ou une fonction de fermeture.
Vous pouvez voir que j'utilise une fonction de fermeture. En fait, vous pouvez aussi l'écrire comme ceci

$sms = new  SeedSMS();
$message->bind('SMS',$sms);

La différence entre cette dernière méthode d'écriture et la fermeture est que nous devons instancier l'objet. d'abord avant de pouvoir y accéder. Services faciles à lier. Les fermetures instancient uniquement les objets lorsque nous utilisons ce service. On constate que les fermetures présentent de nombreux avantages. La méthode

make

make est la méthode pour quitter le conteneur. Il détermine d'abord s'il existe un objet de service actuel et existant dans la variable instances, et renvoie directement s'il y en a. Dans le cas contraire, un objet sera renvoyé via call_user_func_array. Pour l'utilisation de call_user_func_array, vous pouvez voir l'utilisation de call_user_func dans
PHP

Ce qui précède est l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun pour un contenu plus connexe. , veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Analyse du processus en cours d'exécution du conteneur PHP Pimple

Solution pour la sortie d'exécution PHP gitbash en chinois tronqué code

Fonctions de tableau couramment utilisées en PHP

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!