Analyse connexe des conteneurs de services et de l'injection de dépendances en PHP

Injection de dépendances

Lorsque la classe A doit dépendre de la classe B, c'est-à-dire que la classe B doit être instanciée dans la classe A Lorsqu'un objet est utilisé, si les fonctions de la classe B changent, les endroits où la classe B est utilisée dans la classe A seront également modifiés, ce qui entraînera un couplage élevé entre la classe A et la classe B. 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.

Général

<?php

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

class  Message{

  public function seed()
  {
      return &#39;灰太狼准备吃羊&#39;;
  }

}

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

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

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

    public function seed_msg()
    {
        return $this->messager->seed();
    }
}

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

Le code ci-dessus est notre manière traditionnelle d'écrire. 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 à 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.

L'idée de s'appuyer sur l'injection

<?php

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

interface  Message{
  public function seed();
}

/**
 * 有一个发送邮件的类
 * Class SeedEmail
 */
class SeedEmail implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发邮件给红太狼说要吃烤全羊&#39;;
    }
}

/** 
 *新增一个发送短信的类
 * Class SeedSMS
 */
class SeedSMS implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发短信给红太狼说要吃烤全羊&#39;;
    }
}

/*
 * 订单产生的时候 需要发送消息
 */

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);
echo $Order->seed_msg();

echo "\n";

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

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

Conteneur de service

<?php

/**
 * 为了约束我们先定义一个消息接口
 * Interface Message
 */
interface  Message{
    public function seed();
}

/**
 * 有一个发送邮件的类
 * Class SeedEmail
 */
class SeedEmail implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发邮件给红太狼说要吃烤全羊&#39;;
    }
}

/** 
 *新增一个发送短信的类
 * Class SeedSMS
 */
class SeedSMS implements Message
{
    public function seed()
    {
        return  &#39;灰太狼发短信给红太狼说要吃烤全羊&#39;;
    }
}

/**
 * 这是一个简单的服务容器
 * 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('SMS',function (){
     return   new  SeedSMS();
});

//将发送邮件注册绑定到工厂
$message->bind('EMAIL',function (){
   return new  SeedEmail();
});

//需要发送短信的时候
$SMS  = $message->make('SMS');
echo $SMS->seed();

echo "\n";

$EMAIL  = $message->make('EMAIL');
echo $EMAIL->seed();

le conteneur est un conteneur de service simple qui contient bind,make Deux méthodes

bind consistent à lier l'objet de service au conteneur.

make prend l'objet du conteneur.

bind

Dans la méthode bind, vous devez transmettre un objet concret. Nous pouvons transmettre un objet 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 d'abord instancier l'objet avant. nous pouvons procéder facilement. Les fermetures instancient uniquement les objets lorsque nous utilisons ce service. On constate que les fermetures présentent de nombreux avantages.

make

La méthode make est la méthode hors du conteneur. Il détermine d'abord s'il existe un objet de service actuel et existant dans la variable instances et, si c'est le cas, le renvoie directement. Sinon, un objet sera renvoyé via call_user_func_array. L'utilisation de call_user_func_array peut être consultée dans
Utilisation de call_user_func en PHP

Pour plus d'articles techniques liés à PHP, veuillez visiter Tutoriel PHPChronique pour apprendre !

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!