Présentation de trois modèles de conception couramment utilisés en PHP : le modèle de conception singleton, le modèle de conception d'usine et le modèle de conception d'observateur.

Cet article présente brièvement les trois modèles de conception les plus couramment utilisés en PHP : le modèle de conception singleton, le modèle de conception d'usine et le modèle de conception d'observateur. Ce sont tous des résumés d'expériences personnelles. J'espère que vous les aimerez

Cet article est une note et un résumé des trois modèles de conception couramment utilisés en PHP, quel que soit le langage utilisé pour développer quelque chose, presque tous. ils seront utilisés pour concevoir des modèles, pourquoi avons-nous besoin de modèles de conception ? Quel rôle et quelle signification sa naissance a-t-elle pour nous, développeurs ?

Je pense que ceux qui développent iOS seront familiers avec les modèles de conception, n'est-ce pas ? Par exemple, modèle de conception singleton, modèle de conception d'usine, Modèle d'observateur, modèle de conception de framework MVC, etc.

Ensuite, apprenons les trois modèles de conception les plus couramment utilisés en PHP : le modèle de conception singleton, le modèle de conception d'usine et le modèle de conception d'observateur.

Modèle de conception à cas unique

Le soi-disant Modèle à cas unique signifie qu'au plus une instance de la classe existe dans l'application . Une fois créé, il existera toujours dans la mémoire !

Le modèle de conception singleton est souvent utilisé dans la conception de classes de base de données. Le modèle singleton est utilisé pour se connecter à la base de données une seule fois afin d'empêcher l'ouverture de plusieurs connexions à la base de données.

Une classe singleton doit avoir les caractéristiques suivantes :

Une classe singleton ne peut pas être créée par instanciation directe, mais ne peut être instanciée que par la classe elle-même. Par conséquent, pour obtenir un tel effet restrictif, le constructeur doit être marqué privé, empêchant ainsi l'instanciation de la classe.

Nécessite une variable membre statique privée pour enregistrer l'instance de classe et exposer une méthode statique publique qui peut accéder à l'instance.

En PHP, afin d'empêcher d'autres personnes de cloner des instances de classe singleton, une méthode clone() privée vide est généralement fournie pour cela.

Exemples de modèle singleton :

<?php
 
/**
* Singleton of Database
*/
class Database
{
  // We need a static private variable to store a Database instance.
  privatestatic $instance;
 
  // Mark as private to prevent it from being instanced.
  privatefunctionconstruct()
  {
    // Do nothing.
  }
 
  privatefunctionclone() 
  {
    // Do nothing.
  }
 
  publicstatic functiongetInstance() 
  {
    if (!(self::$instanceinstanceofself)) {
      self::$instance = newself();
    }
 
    returnself::$instance;
  }
}
 
$a =Database::getInstance();
$b =Database::getInstance();
 
// true
var_dump($a === $b);

Modèle de conception d'usine

Le modèle de conception d'usine est souvent utilisé en fonction de différents paramètres d'entrée ou de la configuration de l'application. La différence est de créer une instance spécifiquement utilisée pour instancier et renvoyer sa classe correspondante.

Donnons un exemple. Supposons que le rectangle et le cercle aient la même méthode. Ensuite, lorsque nous utiliserons l'API fournie par la classe de base pour créer une instance, nous créerons automatiquement une instance de la classe correspondante en passant des paramètres. . Ils ont tous accès aux Fonctions de périmètre et de superficie.

<?php
 
interfaceInterfaceShape 
{
 functiongetArea();
 functiongetCircumference();
}
 
/**
* 矩形
*/
class Rectangle implementsInterfaceShape
{
  private $width;
  private $height;
  
  publicfunctionconstruct($width, $height)
  {
    $this->width = $width;
    $this->height = $height;
  }
 
  publicfunctiongetArea() 
  {
    return $this->width* $this->height;
  }
 
  publicfunctiongetCircumference()
  {
    return 2 * $this->width + 2 * $this->height;
  }
}
 
/**
* 圆形
*/
class Circle implementsInterfaceShape
{
  private $radius;
 
  functionconstruct($radius)
  {
    $this->radius = $radius;
  }
 
 
  publicfunctiongetArea() 
  {
    return M_PI * pow($this->radius, 2);
  }
 
  publicfunctiongetCircumference()
  {
    return 2 * M_PI * $this->radius;
  }
}
 
/**
* 形状工厂类
*/
class FactoryShape 
{ 
  publicstatic functioncreate()
  {
    switch (func_num_args()) {
      case1:
      return newCircle(func_get_arg(0));
      case2:
      return newRectangle(func_get_arg(0), func_get_arg(1));
      default:
        # code...
        break;
    }
  } 
}
 
$rect =FactoryShape::create(5, 5);
// object(Rectangle)#1 (2) { ["width":"Rectangle":private]=> int(5) ["height":"Rectangle":private]=> int(5) }
var_dump($rect);
echo "<br>";
 
// object(Circle)#2 (1) { ["radius":"Circle":private]=> int(4) }
$circle =FactoryShape::create(4);
var_dump($circle);

Modèle de conception d'observateur

Le modèle d'observateur est un modèle de conception très courant. Une utilisation appropriée apportera une grande commodité au programme. S'il est mal effectué, il le sera. donner aux générations futures une idée difficile à entretenir.

Qu'est-ce que le modèle d'observateur ? Un objet se rend observable en fournissant des méthodes qui permettent à un autre objet, un observateur, de s'enregistrer). Lorsqu'un objet observable change, il envoie des messages aux observateurs enregistrés. Ces observateurs utilisent ces informations pour effectuer des opérations indépendantes de l'objet observable. Le résultat est que les objets peuvent communiquer entre eux sans avoir à comprendre pourquoi. Le modèle d'observateur est un système d'événements, ce qui signifie que ce modèle permet à une classe d'observer l'état d'une autre classe. Lorsque l'état de la classe observée change, la classe observatrice peut recevoir des notifications et prendre les actions correspondantes. Le modèle d'opérateur vous fournit ; avec la capacité d’éviter un couplage étroit entre les composants. Vous comprendrez après avoir regardé l’exemple ci-dessous !

<?php
 
/*
观察者接口
*/
interfaceInterfaceObserver
{
  functiononListen($sender, $args);
  functiongetObserverName();
}
 
// 可被观察者接口
interfaceInterfaceObservable
{
  functionaddObserver($observer);
  functionremoveObserver($observer_name);
}
 
// 观察者抽象类
abstractclass Observer implementsInterfaceObserver
{
  protected $observer_name;
 
  functiongetObserverName() 
  {
    return $this->observer_name;
  }
 
  functiononListen($sender, $args)
  {
 
  }
}
 
// 可被观察类
abstractclass Observable implementsInterfaceObservable 
{
  protected $observers = array();
 
  publicfunctionaddObserver($observer) 
  {
    if ($observerinstanceofInterfaceObserver) 
    {
      $this->observers[] = $observer;
    }
  }
 
  publicfunctionremoveObserver($observer_name) 
  {
    foreach ($this->observersas $index => $observer) 
    {
      if ($observer->getObserverName() === $observer_name) 
      {
        array_splice($this->observers, $index, 1);
        return;
      }
    }
  }
}
 
// 模拟一个可以被观察的类
class A extendsObservable 
{
  publicfunctionaddListener($listener) 
  {
    foreach ($this->observersas $observer) 
    {
      $observer->onListen($this, $listener);
    }
  }
}
 
// 模拟一个观察者类
class B extendsObserver 
{
  protected $observer_name = &#39;B&#39;;
 
  publicfunctiononListen($sender, $args) 
  {
    var_dump($sender);
    echo "<br>";
    var_dump($args);
    echo "<br>";
  }
}
 
// 模拟另外一个观察者类
class C extendsObserver 
{
  protected $observer_name = &#39;C&#39;;
 
  publicfunctiononListen($sender, $args) 
  {
    var_dump($sender);
    echo "<br>";
    var_dump($args);
    echo "<br>";
  }
}
 
$a = new A();
// 注入观察者
$a->addObserver(new B());
$a->addObserver(new C());
 
// 可以看到观察到的信息
$a->addListener(&#39;D&#39;);
 
// 移除观察者
$a->removeObserver(&#39;B&#39;);
 
// 打印的信息：
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"

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!