1. Singleton-Modus
Der Singleton-Modus bedeutet, wie der Name schon sagt, dass es nur eine Instanz gibt. Als Objekterstellungsmuster stellt das Singleton-Muster sicher, dass eine Klasse nur eine Instanz hat, sich selbst instanziiert und diese Instanz dem gesamten System zur Verfügung stellt.
Es gibt drei Hauptpunkte des Singleton-Musters:
Erstens kann eine Klasse nur eine Instanz haben.
Zweitens muss sie diese erstellen durch sich selbst Instanz;
Drittens muss es diese Instanz selbst dem gesamten System bereitstellen.
Warum den PHP-Singleton-Modus verwenden?
1. PHP wird hauptsächlich in Datenbankanwendungen verwendet. Bei der objektorientierten Entwicklung gibt es eine große Anzahl von Datenbankoperationen Sie verwenden den Singleton-Modus, um eine große Anzahl von Ressourcen zu vermeiden, die durch neue Vorgänge verbraucht werden, und die Datenbankverbindungen zu reduzieren, sodass zu viele Verbindungen weniger wahrscheinlich sind.
2. Wenn eine Klasse zur globalen Steuerung bestimmter Konfigurationsinformationen im System benötigt wird, kann diese einfach mithilfe des Singleton-Modus implementiert werden. Dies ist im FrontController-Teil von zend Framework zu finden.
3. In einer Seitenanforderung ist das Debuggen einfach, da der gesamte Code (z. B. Datenbankoperationsklasse db) in einer Klasse konzentriert ist und Protokolle ausgegeben werden, um überall var_dump zu vermeiden , Echo.
Beispiel:
/**
* 设计模式之单例模式
* $_instance必须声明为静态的私有变量
* 构造函数必须声明为私有,防止外部程序new类从而失去单例模式的意义
* getInstance()方法必须设置为公有的,必须调用此方法以返回实例的一个引用
* ::操作符只能访问静态变量和静态函数
* new对象都会消耗内存
* 使用场景:最常用的地方是数据库连接。
* 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。
*/
class man
{
//保存例实例在此属性中
private static $_instance;
//构造函数声明为private,防止直接创建对象
private function __construct()
{
echo '我被实例化了！';
}
//单例方法
public static function get_instance()
{
var_dump(isset(self::$_instance));
if(!isset(self::$_instance))
{
self::$_instance=new self();
}
return self::$_instance;
}
//阻止用户复制对象实例
private function __clone()
{
trigger_error('Clone is not allow' ,E_USER_ERROR);
}
function test()
{
echo("test");
}
}
// 这个写法会出错，因为构造方法被声明为private
//$test = new man;
// 下面将得到Example类的单例对象
$test = man::get_instance();
$test = man::get_instance();
$test->test();
// 复制对象将导致一个E_USER_ERROR.
//$test_clone = clone $test;Nach dem Login kopieren
2. Einfaches Fabrikmuster
①Abstrakte Basisklasse: in Klasse Define einige abstrakte Methoden zur Implementierung in Unterklassen
② Von der abstrakten Basisklasse geerbte Unterklassen: Implementieren abstrakter Methoden in der Basisklasse
③Factory-Klasse: wird zum Instanziieren aller entsprechenden Unterklassen
verwendet 
/**
*
* 定义个抽象的类，让子类去继承实现它
*
*/
abstract class Operation{
//抽象方法不能包含函数体
abstract public function getValue($num1,$num2);//强烈要求子类必须实现该功能函数
}
/**
* 加法类
*/
class OperationAdd extends Operation {
public function getValue($num1,$num2){
return $num1+$num2;
}
}
/**
* 减法类
*/
class OperationSub extends Operation {
public function getValue($num1,$num2){
return $num1-$num2;
}
}
/**
* 乘法类
*/
class OperationMul extends Operation {
public function getValue($num1,$num2){
return $num1*$num2;
}
}
/**
* 除法类
*/
class OperationDiv extends Operation {
public function getValue($num1,$num2){
try {
if ($num2==0){
throw new Exception("除数不能为0");
}else {
return $num1/$num2;
}
}catch (Exception $e){
echo "错误信息：".$e->getMessage();
}
}
}Nach dem Login kopieren
Durch die Verwendung objektorientierter Vererbungsfunktionen können wir das ursprüngliche Programm leicht erweitern, wie zum Beispiel: „Potenzierung“, „Quadratwurzel“, „Logarithmus“, „trigonometrische Funktion“, „ Statistiken 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 Basis). Klasse ), Vervollständigen Sie die entsprechenden Funktionen in der Klasse (z. B. die Berechnung der Potenzierung) und reduzieren Sie den Kopplungsgrad erheblich, was die zukünftige Wartung und Erweiterung erleichtert
/**
* 求余类（remainder）
*
*/
class OperationRem extends Operation {
public function getValue($num1,$num2){
return $num1%$num12;
}
}Nach dem Login kopieren
Es gibt immer noch ein ungelöstes Problem. Das heißt, 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.
/**
* 工程类，主要用来创建对象
* 功能：根据输入的运算符号，工厂就能实例化出合适的对象
*
*/
class Factory{
public static function createObj($operate){
switch ($operate){
case '+':
return new OperationAdd();
break;
case '-':
return new OperationSub();
break;
case '*':
return new OperationSub();
break;
case '/':
return new OperationDiv();
break;
}
}
}
$test=Factory::createObj('/');
$result=$test->getValue(23,0);
echo $result;Nach dem Login kopieren
Weitere Hinweise zu diesem Muster:
Factory-Modus:
Nehmen Sie den Transport als Beispiel: Bitte können Sie sowohl den Transport als auch den Produktionsprozess des Transports anpassen
1> Transport anpassen
1. Definieren Sie eine Schnittstelle, die Liefertools enthält. Methoden (Start, Ausführung, Stopp)
2. Lassen Sie Flugzeuge, Autos usw. sie umsetzen
2> Kundenspezifische Fabrik (ähnlich wie oben)
1. Definieren Sie eine Schnittstelle, die Lieferwerkzeuge enthält. Herstellungsmethode (Starten, Ausführen, Stoppen)
2. Schreiben Sie Fabrikklassen für die Herstellung von Flugzeugen bzw. Autos, um diese Schnittstelle zu erben und zu implementieren
3. Beobachtermodus
Der Beobachter Muster ist ein Verhaltensmuster, das eine Eins-zu-Viele-Abhängigkeitsbeziehung zwischen Objekten definiert, sodass bei einer Änderung des Status eines Objekts alle davon abhängigen Objekte benachrichtigt und automatisch aktualisiert werden. 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__ . ' - ' . $subject->getName();
}
}
class MyObserver2 implements SplObserver {
public function update(SplSubject $subject) {
echo __CLASS__ . ' - ' . $subject->getName();
}
}
class MySubject implements SplSubject {
private $_observers;
private $_name;
public function __construct($name) {
$this->_observers = new SplObjectStorage();
$this->_name = $name;
}
public function attach(SplObserver $observer) {
$this->_observers->attach($observer);
}
public function detach(SplObserver $observer) {
$this->_observers->detach($observer);
}
public function notify() {
foreach ($this->_observers as $observer) {
$observer->update($this);
}
}
public function getName() {
return $this->_name;
}
}
$observer1 = new MyObserver1();
$observer2 = new MyObserver2();
$subject = new MySubject("test");
$subject->attach($observer1);
$subject->attach($observer2);Nach dem Login kopieren
$subject->notify( <). 🎜 >
4. Strategiemodus
In diesem Modus wird der Algorithmus aus einer komplexen Klasse extrahiert und kann daher leicht ersetzt werden. 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 – einen, der Seiten durchsucht, einen, der jede Seite bewertet, und einen anderen, der die Ergebnisse basierend auf dem Ranking sortiert. 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 zeigt das Folgende eine Benutzerlistenklasse, die eine Möglichkeit bietet, eine Gruppe von Benutzern basierend auf einer Reihe von Plug-and-Play-Richtlinien zu finden
//定义接口
interface IStrategy {
function filter($record);
}
//实现接口方式1
class FindAfterStrategy implements IStrategy {
private $_name;
public function __construct($name) {
$this->_name = $name;
}
public function filter($record) {
return strcmp ( $this->_name, $record ) <= 0;
}
}
//实现接口方式1
class RandomStrategy implements IStrategy {
public function filter($record) {
return rand ( 0, 1 ) >= 0.5;
}
}
//主类
class UserList {
private $_list = array ();
public function __construct($names) {
if ($names != null) {
foreach ( $names as $name ) {
$this->_list [] = $name;
}
}
}
public function add($name) {
$this->_list [] = $name;
}
public function find($filter) {
$recs = array ();
foreach ( $this->_list as $user ) {
if ($filter->filter ( $user ))
$recs [] = $user;
}
return $recs;
}
}
$ul = new UserList ( array (
"Andy",
"Jack",
"Lori",
"Megan"
) );
$f1 = $ul->find ( new FindAfterStrategy ( "J" ) );
print_r ( $f1 );
$f2 = $ul->find ( new RandomStrategy () );Nach dem Login kopieren
print_r ($f2);
Strategiemuster eignet sich sehr gut für komplexe Datenverwaltungssysteme oder Datenverarbeitungssysteme, die beide komplexere Datenfilterungs-, Such- oder Verarbeitungsmethoden erfordern . Hohe Flexibilität
