PHP-Entwurfsmuster (Nachdruck)

Originallink: http://www.cnblogs.com/siqi/archive/2012/09/09/2667562.html

1. Singleton-Modus

Der Singleton-Modus bedeutet, wie der Name schon sagt, dass es nur eine Instanz gibt. Als Objekterstellungsmodus stellt der Singleton-Modus sicher, dass es nur eine Instanz einer bestimmten Klasse gibt, instanziiert sich selbst und stellt diese Instanz dem gesamten System zur Verfügung.

Es gibt drei Hauptpunkte des Singleton-Musters:

1. Erstens kann eine Klasse nur eine Instanz haben;
2. Das zweite ist, dass es diese Instanz selbst erstellen muss
3. Das dritte ist, dass es diese Instanz dem gesamten System bereitstellen muss selbst.

Warum den PHP-Singleton-Modus verwenden

1. 1. Die Anwendung von PHP liegt hauptsächlich in der Datenbankanwendung, Wenn Sie bei der objektorientierten Entwicklung den Singleton-Modus verwenden, können Sie eine große Anzahl neuer Vorgänge vermeiden, die Ressourcen verbrauchen, und Sie können so auch Datenbankverbindungen reduzieren Es ist weniger wahrscheinlich, dass zu viele Verbindungen entstehen.
2. 2. Wenn das System eine -Klasse benötigt, um bestimmte Konfigurationsinformationen global zu steuern , Dann kann es einfach im Singleton-Modus implementiert werden. Weitere Informationen finden Sie im FrontController-Teil von zend Framework.
3. 3. In einer Seitenanforderung erleichtert das Debuggen, Da der gesamte Code (z. B. Datenbankoperationsklasse db) in einer Klasse konzentriert ist, können wir Hooks in der Klasse setzen und Protokolle ausgeben, um var_dump und echo überall zu vermeiden.

Beispiel:

/**
* Singleton-Muster des Entwurfsmusters
* $_instance muss als statische private Variable deklariert werden
* Der Konstruktor muss als privat deklariert werden verhindern Externes Programm neue Klasse verliert dadurch die Bedeutung des Singleton-Modus
* Die Methode getInstance() muss auf öffentlich gesetzt werden, und diese Methode muss aufgerufen werden, um einen Verweis auf die Instanz zurückzugeben
* :: Der Operator kann nur darauf zugreifen statische Variablen und statische Variablen Funktion
* Neue Objekte verbrauchen Speicher
* Verwendungsszenarien: Der am häufigsten verwendete Ort ist die Datenbankverbindung.
* Nachdem Sie den Singleton-Modus zum Generieren eines Objekts verwendet haben, kann das Objekt von vielen anderen Objekten verwendet werden.
*/
class man
{
//Speichern Sie die Instanz in diesem Attribut  private statisch $_instance;
 //Der Konstruktor wird als privat deklariert, um die direkte Erstellung von zu verhindern Objekte  private function __construct()
 {
  echo 'Ich wurde instanziiert! ';
}
 //Einzelinstanzmethode öffentlich statisch Funktion get_instance()
{
 var_dump(isset(self::$_instance));
 
 if (!isset(self::$_instance))
                                                                                                 ();
} return self::$ _instance
;
} //Benutzer am Kopieren der Objektinstanz hindern
private
Funktion __clone() { } function test()
 {
  echo("test"); }}

// Diese Schreibweise ist falsch, da der Konstruktor als privat deklariert ist
//$test = new man;
// Im Folgenden wird das Singleton-Objekt der Beispielklasse abgerufen $ test
= man::get_instance();

$test = man::get_instance();$test
->test ();
// Das Kopieren des Objekts führt zu einem E_USER_ERROR.
//$test_clone = clone $test;


2. Einfaches Factory-Muster

①Abstrakte Basisklasse: Definieren Sie einige abstrakte Methoden in die zu verwendende Klasse Implementieren Sie

in der Unterklasse ② Von der abstrakten Basisklasse geerbte Unterklasse: Implementieren Sie die abstrakte Methode in der Basisklasse

③Factory Klasse: verwenden, um alle entsprechenden Unterklassen zu instanziieren

/**
*
* Definieren Sie eine abstrakte Klasse und lassen Sie Unterklassen sie erben und implementieren
*
*/
                                                                                                                     🎜>abstract public function
getValue($num1,$num2);//Es ist dringend erforderlich, dass Unterklassen diese Funktionsfunktion implementieren müssen } 🎜 >*/ class OperationAdd extends Operation { public

function
getValue(
$num1,$num2){
   
return $num1+
$num2;  }                                                                                                 verlängert
Betrieb {  public function getValue($num1,$num2
){             🎜>return $num1- $num2;
* Multiplikationsklasse
 
*/ 
Klasse
OperationMul erweitert Operation { 
public function getValue($num1
,$num2){                                                                   🎜>; } } class OperationDiv
extends Operation {                                                               🎜>){                                                                                         Ausnahme("Der Teiler darf nicht 0 sein");
                                       
(
Ausnahme $e){
                                                                             ".
$e->getMessage(); } }
}

Durch die Verwendung objektorientierter Vererbungsfunktionen können wir das ursprüngliche Programm leicht erweitern, wie zum Beispiel: „Potenz“, „Quadratwurzel“, „Logarithmus“, „trigonometrische Funktion“, „Statistik“. usw., um auch das Laden unnötigen Codes zu vermeiden.

Wenn wir jetzt eine Restklasse hinzufügen müssen, ist das ganz einfach

Wir müssen nur eine weitere Klasse schreiben (diese Klasse erbt die virtuelle Basisklasse), in Entsprechende Funktionen werden in der Klasse abgeschlossen (z. B. Leistungsberechnung), und der Kopplungsgrad wird stark reduziert, was zukünftige Wartung und Erweiterung erleichtert

 /**
* Finden Sie den Rest (Rest)
*
 */
  classOperationRemextendsOperation {
  public function getValue($num1,$num2 ){
                                                                                            Es gibt immer noch ein ungelöstes Problem: Wie kann das Programm das entsprechende Objekt entsprechend der Bedienereingabe des Benutzers instanziieren? Lösung: Verwenden Sie eine separate Klasse, um den Instanziierungsprozess zu implementieren.

  /*

*

* Ingenieursklasse, die hauptsächlich zum Erstellen von Objekten verwendet wird
* Funktion: Gemäß den Eingabeoperationssymbolen kann die Fabrik das entsprechende Objekt instanziieren *

*/

KlasseFabrik{ $operate
){
 
Schalter
($operate ){ 
Fall '+':                                                                      new
OperationAdd();                                                                                                                                     > neu OperationSub (); $result=$test->getValue(23,0); echo
 $result;

Weitere Hinweise zu diesem Modus:

Werksmodus:
Nehmen Sie den Transport als Beispiel: Bitte fordern Sie an, dass Sie sowohl den Transport als auch den Transportprozess des Werkzeugs anpassen können Produktion
1> Kundenspezifischer Transport
1. Definieren Sie eine Schnittstelle, die die Methode zur Lieferung des Werkzeugs enthält (Start, Betrieb, Stopp)
2. Flugzeuge, Autos usw. umsetzen lassen
2> Anpassungsfabrik (ähnlich wie oben)
1. Definieren Sie eine Schnittstelle, die die Arbeit enthält Werkzeugherstellungsmethode (Starten, Ausführen, Stoppen)
2. Schreiben Sie Fabrikklassen für die Herstellung von Flugzeugen bzw. Autos, um diese Schnittstelle zu erben und zu implementieren

Originaltextadresse: http://bbs.phpchina.com/thread-242243-1-1.html

3. Beobachtermuster

Das Beobachtermuster ist Ein Verhaltensmuster besteht darin, eine Eins-zu-Viele-Abhängigkeitsbeziehung zwischen Objekten zu definieren, sodass alle davon abhängigen Objekte benachrichtigt und automatisch aktualisiert werden, wenn sich der Status eines Objekts ändert. Es trennt das Beobachterobjekt und das beobachtete Objekt perfekt. Eine Liste der Abhängigkeiten (Beobachter), die am Prinzipal interessiert sind, kann in einem separaten Objekt (dem Prinzipal) verwaltet werden. Lassen Sie alle Beobachter einzeln eine gemeinsame Observer-Schnittstelle implementieren, um die direkte Abhängigkeit zwischen den Haupt- und abhängigen Objekten zu beseitigen. (Ich kann es sowieso nicht verstehen)

Verwendete spl (Standard-PHP-Bibliothek)

class MyObserver1 implements SplObserver {
 public function update(SplSubject $subject) {
 echo __CLASS__ ' - ' > MyObserver2 implementiert SplObserver {
 
public
function update(SplSubject $subject) {
 echo __CLASS__ ' - ' implementiert SplSubject {
private $_observers; private
$_name
;
öffentliche Funktion __construct(
$name) {                                                                                   🎜>                                                                            >$observer) 🎜> $this
-> _observers->attach($observer); } 
public function detach(SplObserver $observer) { );
} public function
notify() { as $observer
) {
                                                                                      } öffentlich function getName() {                                                                                            🎜>}
$observer1 = neu MyObserver1();

$observer2 = new MyObserver2();$subject =
new MySubject("test ");$subject->attach(
$observer1
) ;$subject->attach($observer2
);

$subject

->notify();

Referenz-Originaltext: http://www.php.net/manual/zh/class. splsubject .php

4. Strategiemodus

In diesem Modus wird der -Algorithmus aus a extrahiert komplexe Klasse von , sodass bequem durch ersetzt werden kann. Wenn Sie beispielsweise das Ranking von Seiten in Suchmaschinen ändern möchten, ist der Strategiemodus eine gute Wahl. Denken Sie an die Teile einer Suchmaschine ——Ein Teil durchläuft die Seiten, ein Teil sortiert jede Seite und der andere Teil sortiert basierend auf den Ergebnissen der Anordnung. In komplexen Beispielen gehören diese Teile alle zur selben Klasse. Mithilfe des Strategiemusters können Sie den Anordnungsteil in eine andere Klasse einfügen, um die Anordnung der Seite zu ändern, ohne dass sich dies auf den restlichen Code der Suchmaschine auswirkt.

Als einfacheres Beispiel wird unten eine Benutzerlistenklasse gezeigt, die eine Benutzerliste basierend auf Einem Satz bereitstellt von Plug-and-Play-Strategien zum Finden einer Reihe von Benutzermethoden

//Schnittstelle definierenSchnittstelle IStrategy {
 Funktion Filter($record);
}
//Schnittstellenmethode 1 implementierenKlasse FindAfterStrategy implementiert IStrategy {
 privat $_name;
 public function __construct($name) {
 $this-> ;_name = $name;
}
public function filter($record) {
>return strcmp ( $this->_name, $record ) }
}

//Schnittstellenmethode 1 implementierenKlasse RandomStrategy implementiert IStrategy { 
öffentliche Funktion filter($record) {                                                                                       
//Hauptklasse
Klasse
UserList {
  private $_list = array ();
 public function __construct($names ) {
 if ( $names != null) {
                                                                                                                                   🎜> öffentlich Funktion add($name) {
                                                                                                                      $filter) { $recs = array (); foreach
( $this-> ;_list as
$user
) {
 user
;
} >new UserList ( array ( „Andy“, „Jack“,
„Lori“, „Megan“ ) );$f1
=
$ul
->find ( new FindAfterStrategy ( "J" ) );print_r ( $f1
);$ f2 = $ul
->find ( new RandomStrategy () );
print_r ( $f2 ); >
Strategiemuster eignen sich sehr gut für komplexe Datenverwaltungssysteme oder Datenverarbeitungssysteme, die beide eine hohe Flexibilität bei der Datenfilterung, -suche oder -verarbeitung erfordern Das Obige stellt das PHP-Entwurfsmuster (nachgedruckt) vor, einschließlich Aspekten des Inhalts. Ich hoffe, es wird für Freunde hilfreich sein, die sich für PHP-Tutorials interessieren.