Grundkenntnisse und Anwendung von PHP-Designmustern

In diesem Artikel werden hauptsächlich die Grundkenntnisse und die Anwendung von PHP-Designmustern vorgestellt. Ich hoffe, dass er für alle hilfreich ist.

PHP-Registrierungsbaummodus

Was ist der Registrierungsbaummodus?

Natürlich wird der Registrierungsbaummodus auch Registrierungsmodus und Registrarmodus genannt. Der Grund, warum ich den Namen hier so prätentiös nenne, liegt darin, dass ich der Meinung bin, dass der Namensregistrierungsbaum für die Menschen leichter zu verstehen ist. Wie die beiden vorherigen Artikel beginnt auch unser Artikel immer noch mit dem Namen. Das Registrierungsbaummuster ist eine Musterentwurfsmethode, die Objektinstanzen in einem globalen Objektbaum registriert und bei Bedarf aus dem Objektbaum auswählt. Das erinnert mich daran, wie ich als Kind kandierte Kornblumen am Stiel kaufte. Der Verkäufer kandierter Kornblumen klebte die kandierten Kornblumen auf eine große Stange und die Leute nahmen sie ab, wenn sie sie kauften. Der Unterschied besteht darin, dass im Registrierungsbaummodus nach dem Pflücken noch welche vorhanden sind und viele Male gepflückt werden können, die kandierten Hagebutten jedoch nach einmaligem Pflücken verschwunden sind. . .

Warum den Registrierungsbaummodus verwenden?

Der Singleton-Modus löst das Problem, wie eine eindeutige Objektinstanz im gesamten Projekt erstellt wird, und der Factory-Modus löst das Problem, wie ein Instanzobjekt erstellt wird, ohne new zu verwenden. Welches Problem möchte der Registrierungsbaummodus also lösen? Bevor wir uns mit diesem Thema befassen, müssen wir noch die Einschränkungen berücksichtigen, mit denen die ersten beiden Modelle derzeit konfrontiert sind. Erstens hat der Prozess der Erstellung eines eindeutigen Objekts im Singleton-Modus selbst auch eine Beurteilung, dh ob das Objekt existiert. Wenn es existiert, wird das Objekt zurückgegeben; wenn es nicht existiert, wird das Objekt erstellt und zurückgegeben. Jedes Mal, wenn ein Instanzobjekt erstellt wird, muss eine solche Beurteilungsebene vorhanden sein. Das Werksmodell berücksichtigt eher die Frage der erweiterten Wartung. Im Allgemeinen können das Singleton-Muster und das Factory-Muster sinnvollere Objekte erzeugen. Wie kann man diese Objekte bequem aufrufen? Darüber hinaus ähneln die auf diese Weise im Projekt erstellten Objekte verstreuten Soldaten, was die Gesamtverwaltung und -anordnung erschwert. Aus diesem Grund entstand das Registrierungsbaummodell. Unabhängig davon, ob Sie Objekte im Singleton-Modus, im Factory-Modus oder in einer Kombination aus beiden generieren, werden sie alle in den Registrierungsbaum „eingefügt“. Wenn ich ein Objekt verwende, hole ich es einfach direkt aus dem Registrierungsbaum. Dies ist genauso bequem und praktisch wie die Verwendung globaler Variablen. Und auch für andere Muster bietet das Registrierungsbaummuster eine sehr gute Idee.

Wie implementiert man einen Registrierungsbaum?

Durch die obige Beschreibung scheinen wir die Lösung leicht gefunden zu haben. Zuerst brauchen wir natürlich eine Klasse als Registrierungsbaum. Alle Objekte werden in den Registrierungsbaum „eingefügt“. Dieser Registrierungsbaum sollte von einer statischen Variablen bedient werden. Und dieser Registrierungsbaum sollte ein zweidimensionales Array sein. Diese Klasse sollte eine Methode zum Einfügen von Objektinstanzen (set()) und entsprechend eine Methode zum Rückgängigmachen von Objektinstanzen (_unset()) haben. Das Wichtigste ist natürlich, eine Methode zum Lesen des Objekts zu haben (get()). Damit können wir den Registrierungsbaummodus problemlos abschließen ~~~

Machen wir eine kleine Kombination der drei Modi. Das einfache Erstellen eines Instanzobjekts ist weitaus weniger kompliziert, aber bei der Anwendung auf große Projekte liegt die Bequemlichkeit auf der Hand.

<?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);

An diesem Punkt ist die Einführung der drei Designmodi abgeschlossen. Verschiedene Musterdesigns selbst werden sich gegenseitig ergänzen, wenn in Zukunft andere Muster eingeführt werden.

Es spielt keine Rolle, ob Sie ein bestimmtes Modell nicht verstehen. Ich glaube, dass Sie mit der Vertiefung der Programmierung eine überraschende Erleuchtung erleben werden.

php-Factory-Modus

Was ist also der Factory-Modus?

Dem Namen nach zu urteilen, scheint es keine Ahnung zu geben. Fabrikmodus, bezogen auf die Produktion? Oder hängt es mit dem Produktionsprozess zusammen? Könnte es immer noch etwas mit den Fabrikführern zu tun haben? Hängt es mit dem Führungssekretär zusammen? Sekretärin... Okay, lassen Sie uns nicht zu nahe kommen. Das sogenannte Fabrikmodell hat wirklich etwas mit der Produktion zu tun. Was soll produziert werden? Was erzeugt wird, ist ein Instanzobjekt. Mit welcher Ausrüstung wird es hergestellt? Hergestellt durch eine Fabrikklasse. Wie wird es hergestellt? Die Factory-Klasse ruft ihre eigenen statischen Methoden auf, um Objektinstanzen zu erzeugen.

Das Factory-Muster verfügt über ein Schlüsselkonstrukt, das nach dem allgemeinen Prinzip eine statische Methode namens Factory ist. Dies ist jedoch nur ein Prinzip. Obwohl die Factory-Methode beliebig benannt werden kann, kann diese statische Methode auch akzeptiert werden Parameter aller Daten und müssen ein Objekt zurückgeben.

Warum den Werksmodus verwenden?

Viele Menschen, die noch nie mit dem Factory-Muster in Berührung gekommen sind, kommen nicht umhin zu fragen: Warum muss ich so viel Mühe aufwenden, um eine Factory-Klasse zu erstellen, um Objekte zu erstellen? Anstatt Dinge wie einfache Wartung und Skalierbarkeit anzuwenden, können wir ein so einfaches Problem betrachten. Im Projekt erstellen wir Objekte über eine Klasse. Wenn es fast abgeschlossen ist oder abgeschlossen ist und die Funktion erweitert werden muss, stellt sich heraus, dass der ursprüngliche Klassenname nicht sehr geeignet ist oder dass die Klasse Konstruktorparameter hinzufügen muss, um eine Funktionserweiterung zu erreichen. Heilige Scheiße! Ich habe über diese Klasse viele Objektinstanzen erstellt. Muss ich sie trotzdem einzeln ändern? Erst jetzt spüren wir die Breite und Tiefe von „hoher Kohäsion und geringer Kopplung“. Kein Problem, Factory-Methoden können dieses Problem lösen.

　　再考虑一下，我要连接数据库，在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数据

Das obige ist der detaillierte Inhalt vonGrundkenntnisse und Anwendung von PHP-Designmustern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!