php

Design Patterns in PHP - Teil 5: Das Vererbte Singleton-Factory-Registry Pattern

Bereich:

Wenn man die drei Design Patterns aus den vorangegegangen Artikeln kombiniert, bekommt man sowas wie ein "Vererbtes Singleton-Factory-Registry". Dieses "Pattern" setze ich momentan erfolgreich als Basis des Refactoring/Redesigns meines kleinen Frameworks openWebX2 ein.

Als Basis dient hier eine erweiterte Version unserer abstrakten Singleton-Klasse:

```
<?php
```

abstract class SingletonFactoryRegistry {

```
 
```

	// Instanzen werden in einem statischen Array gespeichert -> Registry

```
	private static $instances = array();
```
```
 
```

	// Wie immer die Singleton-Vorraussetzungen:

```
	protected function __construct() {}
```
```
	final private function __clone() {}
```
```
 
```

	// Die um Parameter erweiterte Singleton-Instanz

	final static public function getInstance($mixedParams = NULL) {

```
		static $instances = NULL;
```

		$myHash = md5(serialize($mixedParams));

		return $instances[$myHash] ?: $instances[$myHash] = new static($mixedParams);

```
	}
```
```
 
```

	// Der "Loader", welcher sicherstellt, dass Objekte korrekt

	// instanziiert werden, entweder via Singleton oder via Konstruktor.

	// Diese Instanzen werden dann gespeichert.

```
	// Also eine Art Factory-Registry
```

	final static public function load($strObject, $mixedParams = NULL) {

		$strObjectHash = md5($strObject.serialize($mixedParams));

		if (!isset(self::$instances[$strObjectHash])) {

			// Wenn das Objekt den Singleton benutzt, dann wird es via getInstance

			// instanziiert, ansonsten via Konstruktor.

			self::$instances[$strObjectHash] = (method_exists($strObject, 'getInstance')

												? $strObject::getInstance($mixedParams)

												: new $strObject($mixedParams));

```
			}
```

		return self::$instances[$strObjectHash];

```
	}
```
```
}
```
```
?>
```

Dieses Object können wir nun benutzen um beliebige Objekte zu "laden". Wir legen uns dazu erst mal 2 unterschiedliche Klassen an:

```
<?php
```
```
 
```
```
// Object benutzt das Singleton-Pattern
```

class mySingleton extends SingletonFactoryRegistry {

```
 
```
```
	private $__id = NULL;
```
```
 
```

	// Der Constructor kann einen Parameter bekommen

	protected function __construct($strID = NULL) {

```
		$this->__id = $strID;
```
```
	}
```
```
}
```
```
 
```

// Dieses Object hat einen normalen Konstruktor

```
class myStandard {
```
```
 
```
```
	private $__id = NULL;
```
```
 
```

	public function __construct($strID = NULL) {

```
		$this->__id = $strID;
```
```
	}
```
```
}
```
```
?>
```

Wir können nun beide Arten von Objekten über die load Methode unserer "SingletonFactoryRegistry"-Klasse instanziieren:

```
<?php
```

$myObj1 = SingletonFactoryRegistry::load('mySingleton');

$myObj2 = SingletonFactoryRegistry::load('myStandard');

```
 
```
```
// Parameter:
```

$myObj3 = SingletonFactoryRegistry::load('mySingleton','1');

$myObj4 = SingletonFactoryRegistry::load('myStandard','2');

```
 
```

// Nun testen wir ob das SingletonFactoryRegistry-Pattern funktioniert:

```
 
```

$myObj5 = SingletonFactoryRegistry::load('mySingleton','1');

$myObj6 = SingletonFactoryRegistry::load('myStandard','2');

```
 
```
```
var_dump($myObj1);
```
```
var_dump($myObj2);
```
```
var_dump($myObj3);
```
```
var_dump($myObj4);
```
```
var_dump($myObj5);
```
```
var_dump($myObj6);
```
```
?>
```

Wie erwartet, sehen wir, dass $myObj3 und $myObj5 ebenso auf das identische Objekt verweisen wie $myObj4 und $myObj6:

object(mySingleton)#1 (1) { ["__id":"mySingleton":private]=>  NULL }

object(myStandard)#2 (1) { ["__id":"myStandard":private]=> NULL }

object(mySingleton)#3 (1) { ["__id":"mySingleton":private]=> string(1) "1" }

object(myStandard)#4 (1) { ["__id":"myStandard":private]=> string(1) "2" }

object(mySingleton)#3 (1) { ["__id":"mySingleton":private]=> string(1) "1" }

object(myStandard)#4 (1) { ["__id":"myStandard":private]=> string(1) "2" }

Wir haben uns somite eine Art Object-Cache gebaut, der momentan noch innerhalb eines Prozesses seine Grenzen findet. Interessant wäre aber die Möglichkeit, die Objekte persistent zu speichern. Dieses nehmen wir in den nächsten Folgen unserer kleinen Serie in Angriff ;-)

Jens

Design Patterns in PHP - Teil 4: Das Factory Pattern

Bereich:

php

Das Factory Design Pattern wird immer dann eingesetzt, wenn man Objekte instanzieren will, deren Typ aber erst zur Laufzeit bekannt ist.

Klassisches Beispiel hierfür wäre z.B. ein Datenbankwrapper. Es existieren mehrerer identische Objekte, welche die selben Methoden zur Verfügung stellen, aber auf unterschiedliche Datenbanksystem zugreifen und deren Besonderheiten nach aussen hin "verstecken".

Um dies zu gewährleisten, sollte man mittels Interfaces sicherstellen, dass diese Objekte wirklich nach aussen transparent bzw. identisch sind:

```
<?php
```
```
interface dbObject_interface {
```
```
 
```

	public function dbSetStatement($strSQLStatement);

```
	public function dbFetchArray();
```
```
	public function dbFetchObject();
```
```
	public function dbFetchRow();
```
```
 
```
```
}
```
```
 
```

class dbObject_mysql implements dbObject_interface {

```
	.
```
```
	.
```
```
	.
```

	public function dbSetStatement($strSQLStatement) {

```
		// code
```
```
	}
```
```
	public function dbFetchArray() {
```
```
		// code
```
```
	}
```
```
	public function dbFetchObject() {
```
```
		// code
```
```
	}
```
```
	public function dbFetchRow() {
```
```
		// code
```
```
	}
```
```
	.
```
```
	.
```
```
	.
```
```
}
```
```
 
```

class dbObject_postgresql implements dbObject_interface {

```
	.
```
```
	.
```
```
	.
```

	public function dbSetStatement($strSQLStatement) {

```
		// code
```
```
	}
```
```
	public function dbFetchArray() {
```
```
		// code
```
```
	}
```
```
	public function dbFetchObject() {
```
```
		// code
```
```
	}
```
```
	public function dbFetchRow() {
```
```
		// code
```
```
	}
```
```
	.
```
```
	.
```
```
	.
```
```
}
```
```
?>
```

Nun ist sichergestellt, dass mindestens diese 4 Funktionen nach aussen weitergegeben werden. Nun können wir unser Factory-Objekt erstellen:

```
<?php
```
```
 
```
```
class dbObject {
```
```
 
```

  public function __construct( $strDatabaseType ) {

	// Hier sollte man später mittels Exceptionhandler & z.B.

	// __autoload und class_exists() etwas sicherer agieren.

	$myObject = 'dbObject_'.strtolower($strDatabaseType);

```
	return new $myObject();
```
```
  }	
```
```
}
```
```
 
```
```
 
```

$myDBMysql      = new dbObject('mysql');

$myDBPostgres	 = new dbObject('postgresql');

```
?>
```

Dies waren jetzt erstmal alle Patterns, die ich im täglichen Gebrauch kennen und lieben gelernt habe. Die anderen Entwurfsmuster wie z.B. das Observer-Pattern oder das Decorator-Pattern habe ich mangels Verwendungszweck eher theoretisch kennengelernt.

Interessanter ist es wohl im täglichen Gebrauch mehrere Patterns zu kombinieren. So wäre es z.B. möglich, ein Objekt per Singleton zu instanzieren und dieses dann mittels Registry Pattern komplett zu speichern. Wenn man an z.B. eine Logging-Klasse denkt, wäre dies eventuell sogar über Prozessgrenzen hinweg sinnvoll (Filelocking...). Hier müsste dann das Registry das komplette Objekt z.B. in eine Datenbank oder einem sonstigen Speicher ablegen, der für jeden php-Prozess erreichbar ist.

Design Patterns in PHP - Teil 3: Das Registry Pattern

Bereich:

php

Das Registry Pattern wird sehr oft eingesetzt, um globale Variablen im Context mehrerer Objekte zu vermeiden. Stellen wir uns dieses Entwurfsmuster einfach als eine Art Datenspeicher vor.

Da es sinnvoll ist, hier ein Singleton zu benutzen, um sicherzustellen, dass alle Objekte auf den gleichen Datenspeicher zugreifen, werden wir das Singleton aus Teil2 wieder "erben" und um uns wieder ein wenig Tipparbeit zu ersparen, nutzen wir die Überladung in php:

```
<?php
```
```
abstract class Singleton {
```
```
    protected function __construct() {}
```
```
    final private function __clone() {}
```

    final static public function init() {

```
        static $instance = null;
```

        return $instance ?: $instance = new static;

```
    }
```
```
}
```
```
 
```
```
class Registry extends Singleton {
```
```
 
```
```
	// Unsere gespeicherten Daten:
```
```
	protected $__data = NULL;
```
```
 
```

	// Der Konstruktor, wird über den vererbten

	// init-Aufruf des Singleton aufgegrufen

```
	protected __contruct() {
```

		// was auch immer hier getan werden muss

```
	}
```
```
 
```

	// Nun nutzen wir die überladenen Standardmethoden:

```
 
```
```
	// Der überladene Setter
```

	public function __set($strPropertyName, $mixedValue) {

		$this->__data[$strPropertyName] = $mixedValue;

```
	}
```
```
 
```
```
	// Der Getter
```

	public function __get($strPropertyName) {

		return isset($this->__data[$strPropertyName]) ? $this->__data[$strPropertyName] : NULL;

```
	}
```
```
 
```

	// Pruefen ob eine Property gesetzt ist:

	public function __isset($strPropertyName) {

		return isset($this->__data[$strPropertyName]);

```
	}
```
```
 
```

	// Einen Wert aus der Registry loeschen:

	public function __unset($strPropertyName) {

		// Die isset-Klausel vermeidet Notices...

		if isset($this->__data[$strPropertyName]) unset($this->__data[$strPropertyName]);

```
	}
```
```
}
```
```
?>
```

Nun können wir das Registry von überall nutzen:

```
<?php
```
```
 
```
```
$myReg1 = Registry::init();
```
```
$myReg1->Variable = 'Hallo Welt';
```
```
 
```
```
$myReg2 = Registry::init();
```

echo $myReg2->Variable; // -> Hallo Welt;

```
 
```
```
if (isset($myReg1->Variable)) {
```
```
	unset($myReg1->Variable);
```
```
} 
```
```
 
```
```
echo $myReg2->Variable; // -> NULL;
```
```
 
```
```
?>
```

Im nächsten Teil werden wir das Factory-Pattern kennenlernen.

Design Patterns in PHP - Teil 2: Das Singleton Pattern vererben

Bereich:

php

Wie wir schon im ersten Teil gesehen haben, kann das Singleton-Pattern recht simpel und schnell in php realisiert werden.

Nun sind wir Developer ja von Natur aus bequem und selbst wenn man copy&paste liebt, geht es einem irgendwann auf die Nerven, dass jede Klasse die das Singleton-Pattern nutzen soll immer wieder die identischen Codezeilen enthält.

Seit php5.3 und seinen neuen "late static bindings" ist es jedoch möglich, das Singleton-Pattern in einer einzigen Klasse zu definieren und alle Klassen können einfach dieses Pattern erben:

```
<?php
```
```
abstract class Singleton {
```
```
    // Dieses Mal als "protected", 
```
```
    // damit die Kindklassen
```
```
    // einen eigenen Constructor 
```
```
    // haben können
```
```
    protected function __construct() {}
```
```
 
```
```
    // Das kennen wir schon
```
```
    final private function __clone() {}
```
```
 
```
```
 
```
```
    // Durch die Late static Bindings 
```
```
    // ist es möglich, mittels des 
```
```
    // "static"-Keywords eine Instanz 
```
```
    // der aufrufenden Klasse
```
```
    // zurückzuliefern!
```

    final static public function init() {

```
        static $instance = null;
```

        return $instance ?: $instance = new static;

```
    }
```
```
}
```
```
 
```

class ChildSingleton extends Singleton {

```
 
```

    // protected!! Sonst könnte man den

```
    // Constructor "normal" aufrufen
```
```
    protected function __construct() {
```

        // Hier dann alles, was bei der Instanzierung

```
        // der Childklasse zu tun ist
```
```
    }
```
```
 
```
```
}
```
```
?>
```

Danach können wir die Klasse "ChildSingleton" wieder nur über ihre init-Methode instanzieren:

```
<?php
```
```
// FATAL ERROR!
```
```
$a = new ChildSingleton();
```
```
// Funktioniert:
```
```
$a = ChildSingleton::init();
```
```
$b = ChildSingleton::init();
```
```
?>
```

Testen wir mal, ob alles geht...

```
<?php
```
```
var_dump($a);
```
```
var_dump($b);
```
```
var_dump(($a === $b));
```
```
?>
```
```
 
```
```
object(ChildSingleton)#1 (0) { }
```
```
object(ChildSingleton)#1 (0) { }
```
```
bool(true)
```

Design Patterns in PHP - Teil 1: Das Singleton Pattern

Bereich:

php

Es gibt im Netz wohl endlose Diskussionen darüber, ob das Singleton jetzt böse ist oder nicht. Meines Erachtens ist es in einigen Situationen sehr nützlich.

Das Singleton verhindert, dass es mehrere Instanzen eines Objektes gibt. Es wird immer genau eine Instanz erzeugt, sollte diese bereits existieren, dann wir die Instanz anstelle eines neuen Objektes beim Aufruf zurückgegeben.

In PHP(5) kann man dies recht einfach innerhalb einer Klasse realisieren:

```
<?php
```
```
class ExampleSingleton {
```
```
 
```
```
 
```

    // Wir brauchen eine statische Instanzvariable:

```
 
```
```
    private static $instance = NULL;
```
```
 
```
```
 
```
```
    /*
```
```
     * Verhindern, dass unser Objekt 
```
```
     * geclont werden kann:
```

     * Einfach die Magic-function __clone

```
     * auf "private" setzen.
```
```
     */
```
```
    private function __clone() {}
```
```
 
```
```
 
```

    // Gleiches gilt für den Constructor:

```
 
```
```
    private function __construct() {}
```
```
 
```
```
 
```
```
    // Nun der Singleton-Constructor
```
```
 
```
```
    public static function init() {
```
```
        if (!self::$instance) {
```
```
            self::$instance = new self;
```
```
        }
```
```
        return self::$instance;
```
```
    }
```
```
}
```
```
?>
```

Somit kann man das Objekt nur noch über seinen neuen Singleton-Konstruktor instanzieren:

```
<?php
```
```
// Führt zu einem FATAL ERROR:
```
```
$try1 = new ExampleSingleton();
```
```
// Funktioniert:
```
```
$try2 = ExampleSingleton::init();
```

// Nun nochmal die gleiche Objektinstanz:

```
$try3 = ExampleSingleton::init();
```
```
?>
```

Klassische Beispiele für Singletons wären z.B. Datenbank-Klassen. Wir verhindern, dass mehrere Instanzen dieser Klassen existieren und somit kostbaren Speicher belegen.

In einem konkreten Fall habe ich dieses Pattern auch in einer HTML5-Klasse eingesetzt, denn es ergibt wenig Sinn, mehrere Ausgabe-Objekte parallel zu haben. Alle Objekte, die dieses HTML5-Objekt nutzen, schreiben ihre Ausgabe in eine "body"-Eigentschaft des Singletons.

Im nächsten Teil sparen wir uns viel Tipparbeit und vererben das Singleton-Pattern einfach.

PHP Resource Forum

Sehr gut besuchtes Forum welches sich nicht nur um php sondern um alle Aspekte der Web-/Internetentwicklung kümmert.

SelfPHP

Das php-Pendant zu SelfHTML, nicht immer topaktuell.

php Manual online

Hier gibt es ausführliche Hilfestellung zu jeder php-Funktion und allen anderen Aspekten der php-Entwicklung. Wenn man die deutsche Version bevorzugt, findet man diese hier: PHP Handbuch.
Sehr hilfreich sind die dortigen Userkommentare zu den einzelnen Handbuchseiten oder Funktionsbeschreibungen. Oftmals werden hier für die komplexesten Probleme Lösungswege oder komplette Lösungen angeboten.

MongoDB und php5 - in 3 Schritten zu Datenbankperformance

Bereich:

php

Nachdem ich die Ergebnisse einiger Performancetests veröffentlicht habe, zeige ich in diesem Artikel mal, wie schnell und einfach man mongoDB einrichten und nutzen kann. Ich versichte absichtlich hier auf die Einrichtung der Datenbank mit Benutzeranmeldung, der REST-API und der Replikation, un konzentriere mich auf den einfachsten Fall und den schnellsten Weg.

1. Installation

Die Binärpakete für fast alle Betriebssysteme findet man unter [1], Linux und Mac-User werden wohl besser ihr eingebautes (oder im Falle Mac "nachinstalliertes") Distributions-Paketsystem nutzen. Unter gentoo genügt ein "emerge mongodb".

Um die Datenbank in php5 nutzen zu können braucht man die PECL-Extension für php. Unter [2] finden sich die Binärpakete, eine gute Installationsanweisung findet ihr im php-Manual unter [3].

2. Der Server

Den Server startet man über das Programm mongod[.exe] in der Konsole. Eventuell muss man diverse Parameter mitgeben, vor allem den Speicherort der Datenbanken. Da mongodb die Datenbankfiles und die Indexfiles im Vorfeld exponentiell wachsen lässt, sollte man für ausreichend Speicherplatz sorgen und unter den Unix-/Linux-Systemen ein performantes Dateisystem wählen (ext4, btrfs, zfs, ...).

Die meisten Linuxe werden mongodb jedoch mit mehr oder weniger sinnvollen Stnadardeinstellungen installiert und konfiguriert haben, so dass ein "/etc/init.d/mongodb start" oder Ähnliches genügen.

Danach kann man auf der Konsole mit dem Clientprogramm testen, ob der Server läuft: mongo[.exe] eingeben und man ist mit dem server verbunden.

3. MongoDB in php5 nutzen

Das php5-pecl-Modul ist erfrischend objektorientiert und die Daten welche man in der DB speichert und ausliesst werden als assoziative Arrays übergeben, so dass die ersten Schritte recht schnell nachvollziehen kann:

```
// Wir instanzieren ein Mongo-Objekt:
```
```
$myMongoObject = new Mongo();
```
```
 
```

// Und wählen unsere Datenbank "dataBase" und die Collection "myCollection" aus.

// "Collection" -> Entspricht den Tabellen in relationalen DBs

$myCollection = $myMongoObject->dataBase->collectionEins;

```
 
```

// Wir fuegen jetzt ein Array in die Collection ein:

```
$myArray = array (
```
```
  'name' => 'Test123',
```
```
  'wert' => 123,
```
```
  'nocheinwert' => TRUE
```
```
); 
```
```
$myCollection->insert($myArray);
```
```
 
```

// Jetzt lesen wir unser Array wieder aus

// als Rueckgabewert erhalten wir einen MongoCursor.

$myCursor = $myCollection->find(array('name' => 'Test123'));

```
 
```

// diesen Cursor wandeln wir in ein Array

$retArray = iterator_to_array($myCursor)

Wir sehen, die ersten Schritte in MongoDB sind wirklich einfach und das php-Manual unter [4] oder die mongodb-Homepage unter [5] sind sehr ausführlich.

Ich hoffe, Euer Interesse geweckt zu haben und ihr erhebt Euch von der Couch ;-)

echo vs. print

Bereich:

php

Oft belächelt, aber immer noch wahr: echo ist schneller als print!

Um das ganze unter realistischen Bedingungen zu testen, wurden alle Caches (APC, ...) deaktiviert und das Outputbuffering in der CLI-Version von php deaktiviert.

Folgender Code dient als Test:

```
<?php
```
```
// Ergebnisse im Array speichern...
```
```
$arrRes = array();
```
```
 
```
```
$time = microtime(true);
```
```
for ($i=0; $i<100000; $i++) {
```
```
        echo $i;
```
```
}
```

$arrRes['echo'] = microtime(true) - $time;

```
 
```
```
$time = microtime(true);
```
```
for ($i=0; $i<100000; $i++) {
```
```
        print $i;
```
```
}
```

$arrRes['print'] = microtime(true) - $time;

```
 
```
```
$time = microtime(true);
```
```
for ($i=0; $i<100000; $i++) {
```
```
        echo ($i);
```
```
}
```

$arrRes['echo()'] = microtime(true) - $time;

```
 
```
```
$time = microtime(true);
```
```
for ($i=0; $i<100000; $i++) {
```
```
        print ($i);
```
```
}
```

$arrRes['print()'] = microtime(true) - $time;

```
 
```
```
print_r($arrRes);
```
```
?>
```

Diese Testläufe führen im aktuellen Lauf zu folgenden Werten:

```
(
```
```
    [echo] => 9.266254901886
```
```
    [print] => 13.399059057236
```
```
    [echo()] => 14.875532150269
```
```
    [print()] => 13.882831096649
```
```
)
```

Die Werte variieren je nach sonstiger Auslastung des Testsystems, aber es gibt immer einen klaren Sieger: echo. Die beiden Varianten mit den Klammern sind immer - logischerweise - langsamer als ihre Pendants ohne Klammerung.

Oft als Mythos verschrien, zeigt sich alleine bei der Ausgabe von den wenigen Zahlen eine klare Überlegenheit. Mancher Entwickler sollte im Kleinen beginnen zu optimieren!

In der nächsten Folge testen wir die Geschwindigkeit von Anführungszeichen vs. Hochkommas.

Seiten

Neuestes HowTo

Anti-Post-Privacy Teil 2: OpenVPN-Zugang für Android

Willkommen zum zweiten Teil meiner kleinen HowTo-Serie. Heute werde ich Euch zeigen, wie man einem Android-Handy zu einem Zugang zum OpenVPN-Server aus dem ersten Teil der HowTo-Reihe verhilft.

Von Haus aus kommt Android (auch ICS) leider nur mit PTPP-Verbindungen klar, aber es ist einfach möglich, dem Smartphone OpenVPN beizubringen.

Bereich:

Alle HowTos anzeigen