Connaissance de base et application des modèles de conception PHP

Cet article présente principalement les connaissances de base et l'application des modèles de conception PHP. Les amis intéressés peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Mode arbre d'inscription php

Qu'est-ce que le mode arbre d'inscription ?

Bien entendu, le mode arbre d'enregistrement est également appelé mode d'enregistrement et mode registraire. La raison pour laquelle je suis prétentieux quant à son nom ici est que je pense que l'arbre d'enregistrement des noms est plus facile à comprendre pour les gens. Comme les deux articles précédents, notre article commence toujours par le nom. Le modèle d'arborescence d'enregistrement est une méthode de conception de modèle qui enregistre les instances d'objet dans une arborescence d'objets globale et sélectionne dans l'arborescence d'objets si nécessaire. Cela me rappelle l'achat de haws confits sur un bâton quand j'étais enfant. Le vendeur de haws confits mettait les haws confits sur un gros poteau et les gens les enlevaient lorsqu'ils les achetaient. La différence est que dans le mode arbre d'enregistrement, il y en aura encore après avoir été cueillis, et ils peuvent être cueillis plusieurs fois, mais les haws confits auront disparu après avoir été cueillis une fois. . .

Pourquoi utiliser le mode arbre d'inscription ?

Le mode singleton résout le problème de la création d'une instance d'objet unique dans l'ensemble du projet, et le mode usine résout le problème de la création d'une instance d'objet sans utiliser new. Alors, quel problème le mode arbre d’enregistrement veut-il résoudre ? Avant d’aborder cette question, il faut encore considérer les limites auxquelles sont actuellement confrontés les deux premiers modèles. Tout d'abord, le processus de création d'un objet unique en mode singleton lui-même comporte également un jugement, c'est-à-dire si l'objet existe. S'il existe, l'objet est renvoyé ; s'il n'existe pas, l'objet est créé et renvoyé. Chaque fois qu'un objet instance est créé, il doit y avoir une telle couche de jugement. Le modèle d’usine considère davantage la question de la maintenance prolongée. En général, le modèle singleton et le modèle d'usine peuvent produire des objets plus raisonnables. Comment appeler commodément ces objets ? De plus, les objets ainsi créés dans le projet sont comme des soldats dispersés, ce qui rend la gestion et l'agencement globaux peu pratiques. Par conséquent, le modèle d’arbre d’enregistrement a vu le jour. Que vous génériez des objets via le mode singleton, le mode usine ou une combinaison des deux, ils sont tous « insérés » dans l'arborescence d'enregistrement. Lorsque j'utilise un objet, je le récupère directement depuis l'arborescence d'enregistrement. C'est aussi pratique et pratique que d'utiliser des variables globales. Et le modèle d'arbre d'enregistrement fournit également une très bonne idée pour d'autres modèles.

Comment mettre en place un arbre d'inscription ?

Grâce à la description ci-dessus, nous semblons avoir facilement trouvé la solution. Nous avons d’abord besoin d’une classe comme arbre d’enregistrement, bien sûr. Tous les objets sont "insérés" dans l'arborescence d'enregistrement. Cet arbre d'enregistrement doit être servi par une variable statique. Et cet arbre d'enregistrement devrait être un tableau à deux dimensions. Cette classe doit avoir une méthode pour insérer des instances d'objet (set()), et en conséquence, il doit y avoir une méthode pour annuler des instances d'objet (_unset()). Bien entendu, le plus important est d’avoir une méthode pour lire l’objet (get()). Avec ceux-ci, nous pouvons compléter avec plaisir le mode arbre d'enregistrement ~~~

Faisons une petite combinaison des trois modes. La simple création d'un objet instance est beaucoup moins compliquée, mais lorsqu'elle est appliquée à de grands projets, la commodité est évidente.

<?php
//创建单例
class Single{
 public $hash;
 static protected $ins=null;
 final protected function __construct(){
  $this->hash=rand(1,9999);
 }
 static public function getInstance(){
  if (self::$ins instanceof self) {
   return self::$ins;
  }
  self::$ins=new self();
  return self::$ins;
 } 
}
//工厂模式
class RandFactory{
 public static function factory(){
  return Single::getInstance();
 }
}
//注册树
class Register{
 protected static $objects;
 public static function set($alias,$object){
  self::$objects[$alias]=$object;
 }
 public static function get($alias){
  return self::$objects[$alias];
 }
 public static function _unset($alias){
  unset(self::$objects[$alias]);
 }
}
Register::set(&#39;rand&#39;,RandFactory::factory());
$object=Register::get(&#39;rand&#39;);
print_r($object);

À ce stade, l'introduction des trois modes de conception est terminée. Divers modèles de conception eux-mêmes se compléteront les uns les autres. Lors de l'introduction d'autres modèles à l'avenir, un ou plusieurs autres modèles de conception seront plus ou moins utilisés.

Peu importe si vous ne comprenez pas un certain modèle, je crois qu'avec l'approfondissement de la programmation, il y aura une surprise d'illumination soudaine. J'espère que vous progresserez avec moi.

Mode usine php

Alors, qu'est-ce que le mode usine ?

À en juger par le nom, il ne semble y avoir aucune idée. Le mode usine, lié à la production ? Ou est-ce lié au processus de production ? Serait-ce lié aux dirigeants de l’usine ? Est-ce lié au secrétaire à la direction ? Secrétaire... D'accord, n'allons pas trop près. Le modèle dit d'usine est en réalité lié à la production. Que produire ? Ce qui est produit est un objet instance. Quel matériel est utilisé pour le produire ? Produit dans une classe d'usine. Comment le produire ? La classe d'usine appelle ses propres méthodes statiques pour produire des instances d'objet.

Le modèle de fabrique a une construction clé, qui est une méthode statique nommée Factory selon le principe général. Cependant, ce n'est qu'un principe. Bien que la méthode de fabrique puisse être nommée arbitrairement, cette méthode statique peut également accepter. paramètres de toutes les données et doit renvoyer un objet.

Pourquoi utiliser le mode usine ?

De nombreuses personnes qui n'ont jamais été exposées au modèle d'usine ne peuvent s'empêcher de se demander : pourquoi dois-je consacrer autant d'efforts à construire une classe d'usine pour créer des objets ? Au lieu d’appliquer des éléments tels qu’une maintenance facile et une évolutivité, nous pouvons considérer un problème aussi simple. Si dans le projet, nous créons des objets via une classe. Lorsqu'elle est presque terminée ou est terminée et que la fonction doit être étendue, il s'avère que le nom de classe d'origine n'est pas très approprié ou que la classe doit ajouter des paramètres de constructeur pour réaliser l'expansion de la fonction. Putain de merde ! J'ai créé de nombreuses instances d'objet via cette classe. Dois-je encore les modifier une par une ? Ce n'est que maintenant que nous ressentons la profondeur d'une « cohésion élevée et d'un faible couplage ». Pas de problème, les méthodes d'usine peuvent résoudre ce problème.

　　再考虑一下，我要连接数据库，在php里面就有好几种方法，mysql扩展，mysqli扩展，PDO扩展。我就是想要一个对象用来以后的操作，具体要哪个，视情况而定喽。既然你们都是连接数据库的操作，你们就应该拥有相同的功能，建立连接，查询，断开连接...（此处显示接口的重要性）。总而言之，这几种方法应该“团结一致，一致对外”。如何实现呢？利用工厂模式。

工厂模式如何实现？

　　相对于单例模式，上面我们提供了足够的信息，工厂类，工厂类里面的静态方法。静态方法里面new一下需要创建的对象实例就搞定了。当然至于考虑上面的第二个问题，根据工厂类静态方法的参数，我们简单做个判断就好了。管你用if..else..还是switch..case..，能快速高效完成判断该创建哪个类的工作就好了。最后，一定要记得，工厂类静态方法返回一个对象。不是两个，更不是三个。

基本的工厂类：

//要创建对象实例的类
class MyObject{
}
 //工厂类
class MyFactory{
public static function factory(){
return new MyObject():
 }
}
$instance=MyFactory::factory();

一个稍微复杂的工厂模式：

<?php
interface Transport{
 public function go();
}
class Bus implements Transport{
 public function go(){
  echo "bus每一站都要停";
 }
}
class Car implements Transport{
 public function go(){
  echo "car跑的飞快";
 }
}
class Bike implements Transport{
 public function go(){
  echo "bike比较慢";
 }
}
class transFactory{
 public static function factory($transport)
 {
  switch ($transport) {
   case &#39;bus&#39;:
    return new Bus();
    break;
   case &#39;car&#39;:
    return new Car();
    break;
   case &#39;bike&#39;:
    return new Bike();
    break;
  }
 }
}
$transport=transFactory::factory(&#39;car&#39;);
$transport->go();

　　需要工厂静态方法为factory()的时候，千万别再傻乎乎的把工厂类命名为Factory了。为啥啊？别忘了同名构造函数的事儿啊~

　　最后还是谈点感受吧，很多新手比较眼高手低，刚刚会了if..else..，session,cookie就要来点高大上的了。与人交谈动辄可扩展性，可维护性之类云云，至于实例的话，就会一时语塞。有时候觉得，无论自己写代码还是和别人学习，都处于“众里寻他千百度”的时候，真正踏实学习后，蓦然回首，“那人却在灯火阑珊处”，大呼：“原来这TM就是***啊”。

　　笔者不敢承认自己会模式设计，我也是个不足一年的初学者，分享博客只是想记录自己的学习历程，能得到知道更是求之不得。如果能给别人带来帮助，那就更好啦~~~

php单列模式

模式设计是什么？

     初学者一开始会被这高大上的名称给唬住。而对于有丰富编程经验的老鸟来说，模式设计又是无处不在。很多接触的框架就是基于各种模式设计形成的。 简单说，在写代码的过程中一开始往往接触的是面向过程的，简单的基础的编程。这个时候我们往往追求的是代码能够实现某项功能就万事大吉。管他代码多么冗余，管他代码是否可重用，管他效率如何，能实现功能就好。但是，真正应用于实际的，更被大家采纳的是那些高效的，可重用的，便于团队开发的代码。基于这些因素，你不能像练手一样，随便命名函数名，随便放置脚本。模式设计告诉是给人们组织代码提供一种思路，实现可重用代码、让代码更容易被他人理解、保证代码可靠性。

　　在所有模式设计中，有三种基础设计模式，单例模式，工厂模式，注册树模式，其他模式往往基于这几种模式，下面介绍的是单例模式。

什么是单例模式？

　　根据这个名称，我们很容易了解到，单例模式指的是在整个应用中只有一个对象实例的设计模式。

为什么要用单例模式？

　　php常常和数据库打交道，如果在应用中如果频繁建立连接对象，进行new操作的话，会消耗大料的系统内存资源，这并不是我们希望看到的。再则，在团队合作项目中，单例模式可以有效避免不同程序员new自己的对象，造成人为的系统消耗。

如何建立单例模式？

　　在看到这个问题的时候，相信优秀的程序员很可能自己试着根据要求去创建单例模式，而不是坐等前人的经验。区别于其他博友告诉你什么样的模式是单例模式，我人更愿意和有面向对象编程基本经验的你考虑一下如何自己建立单例模式。

　　我们首先从题目出发，单例模式是只有一个对象实例的设计模式。这一点是很让人蛋疼的。我们平常创建的类不是能创建很多对象的，就是不能创建对象的（抽象类）。要创建对象需要有类这是必须的，而且不能是抽象类。这个类要防止别人可以多次创建函数。我们自然而然考虑到了从构造函数入手。但是，每次new操作都会调用构造函数，也就是会多次创建对象实例。这和我们设计初衷相悖了。在此处务必申明构造函数为private或者protected这样才能解决这个问题。

　　构造函数被申明为private或者protected这注定无法通过new的方法创建实例对象了。而且我们发现，经过这一步处理后，解决问题的前景变得明朗起来？为什么呢？既然无法通过new方法创建对象实例，那么我们只能通过类内的方法来创建对象实例了。 这个时候我们面临一个有趣的先有鸡还是先有蛋的问题。我们往往往往是创建了对象后才调用对象的方法，而此时需要调用类里面的方法来创建对象。不受是否创建对象影响都能调用的方法的解决方案毋庸置疑那就是利用关键字--static。

　　在类内创建静态方法完成完成什么工作呢？回归主题：确保只创建一个实例对象。如何确保只有一个呢？这很简单，if判断一下啊。存在的话直接返回，不存在自己创建一个嘛。当然这个实例对象是类的静态属性。至此，单例模式要求的功能实现完成。真的完成了么?还不算~如果有个类继承本类，将构造方法申明为public那不又坏事儿了？那有必要在构造方法前加final关键字了。

最后贴上单例模式代码，代码解释都在上面了~~

<?php
class Single{
 public $hash;
 static protected $ins=null;
  final protected function __construct(){
  $this->hash=rand(1,9999);
 }
 static public function getInstance(){
  if (self::$ins instanceof self) {
   return self::$ins;
  }
  self::$ins=new self();
  return self::$ins;
 } 
}

总结：以上就是本篇文的全部内容，希望能对大家的学习有所帮助。

相关推荐：

PHP实现自动发送邮件功能代码(qq 邮箱)_php实例

php实现追加内容到txt文件中的方法

PHP无限循环获取MySQL数据

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!