Anwendungsbeispiel Datenbankklasse

Denken wir uns einfach mal eine recht umfangreiche Webseite, die auf einem komplexen Content Management System aufbaut. Meistens steckt dahinter nur eine einzige Datenbank, die dem CMS die entsprechenden Inhaltsdaten und weiterführende Metadaten (z.B. Reihenfolge der Navigation) liefert. Natürlich wurde auf Seiten des CMS eine Klasse implementiert, um Datenbankverbindungen und Abfragen zu behandeln.

Diese Datenbankklasse könnte jetzt (natürlich enorm vereinfacht) so aussehen:

class myDatabase {

	private static 	$_aryConData = array(),
			$_intCounter = 0;

	private  	$_strStatus = 'disconnected',
			$_intID;
	// ... weitere Eigenschaften

	public function __construct($aryConData = array()) {
		if (!empty($aryConData))
			self::$_aryConData = $aryConData;
		$this->_intID = ++self::$_intCounter;
		$this->connect();
	}

	public function connect() {
		// Connect to your database
		$this->_strStatus = 'connected';
	}

	public function getStatus() {
		return '['.$this->_intID.'] '
			.$this->_strStatus.': '
			.self::$_aryConData[1]
			.':***@'.self::$_aryConData[0]
			.'/'.self::$_aryConData[3];
	}
	// ... weitere Methoden
}

Wir können sie ganz einfach mit den folgenden Codezeilen testen:

$aryConData = array('myhost', 'myuser', 'mypassword', 'mydb');
$objDatabase = new myDatabase($aryConData);
echo $objDatabase->getStatus();

Daraus resultiert die folgende Ausgabe:

[1] connected: myuser:***@myhost/mydb

Um ein wenig die Übersicht zu behalten, befindet sich in der Klasse die Eigenschaft $_intID und die statische Variable $_intCounter. $_intCounter macht nichts anderes, als die aus der Klasse erzeugten Objekte zu zählen, und ist für alle Objekte gleich. $_intID enthält hingegen die dem jeweiligen Objekt zugehörige Nummer, also 1 für das erste Objekt, 2 für das zweite Objekt und so weiter.

Unnötige Instanzen

Jetzt stellen wir uns vor, dass an einer ganz anderen Stelle wieder auf die Datenbank zugegriffen werden soll. Dummerweise geschieht das aber innerhalb einer Funktion oder Klasse, weshalb nicht auf das ursprüngliche $objDatabase zurückgegriffen werden kann. Also wird ein neues Objekt erzeugt und da die Verbindungsdaten auch in einer statischen Variable gespeichert wurden, geht das ganz einfach. Der Testcode dazu sieht jetzt so aus:

$aryConData = array('myhost', 'myuser', 'mypassword', 'mydb');
$objDatabase = new myDatabase($aryConData);
echo $objDatabase->getStatus().'';
// Ganz viel Magie
$objDatabase = new myDatabase();
echo $objDatabase->getStatus();

Nun die Ausgabe dazu:

[1] connected: myuser:***@myhost/mydb
[2] connected: myuser:***@myhost/mydb

Obwohl das neue Objekt eigentlich dem Vorherigen entspricht, wird eine gänzlich neue Instanz (Nr. 2) geschaffen. Geschieht das recht häufig innerhalb des komplexen Systems, dann kommt auf Dauer doch einiges an Speicher zusammen.

Nun kann man natürlich das $objDatabase global verfügbar machen oder via Parameter und Referenzen durch die gesamte Codegeschichte reichen. Ersteres halte ich (mit bestem Gruß an WordPress) für ganz schlechten Stil, letzteres ist unnötig aufwendig. Beide Varianten werden schnell unübersichtlich und damit fehleranfällig, zudem schützen sie nicht davor, dass z.B. ein Plugin-Entwickler aus Unwissenheit doch neue Objekte erzeugt.

Singleton als Lösung

An dieser Stelle kommt jetzt das Entwurfs- bzw. Erzeugungsmuster Singleton in’s Spiel. Damit wird der Klasse sozusagen beigebracht, auf sich selbst aufzupassen. Statt über den Constructor, also mit new Klassenname, eine neue Instanz zu erzeugen, wird die statische Singleton-Methode verwendet. Diese überprüft, ob bereits eine Instanz erzeugt wurde. Ist dies der Fall, so wird die bestehende Instanz geliefert, ansonsten eine neue erzeugt. Schauen wir uns das mal an unserer Pseudo-Datenbankklasse an:

class myDatabase {

	private static 	$_objInstance = NULL,
			$_aryConData = array(),
			$_intCounter = 0;

	private  	$_strStatus = 'disconnected',
			$_intID;
	// ... weitere Eigenschaften

	static function singleton($aryConData = array()) {
		if (self::$_objInstance === NULL)
			self::$_objInstance = new self($aryConData);
		return self::$_objInstance;
	}

	public function __construct($aryConData = array()) {
		if (!empty($aryConData))
			self::$_aryConData = $aryConData;
		$this->_intID = ++self::$_intCounter;
		$this->connect();
	}

	public function connect() {
		// Connect to your database
		$this->_strStatus = 'connected';
	}

	public function getStatus() {
		return '['.$this->_intID.'] '
			.$this->_strStatus.': '
			.self::$_aryConData[1]
			.':***@'.self::$_aryConData[0]
			.'/'.self::$_aryConData[3];
	}
	// ... weitere Methoden
}

Wir haben eine neue statische Variable $_objInstance eingefügt, die das einzige aus der Klasse erzeugte Objekt speichern soll und die zuvor beschriebene Methode singleton ergänzt. Nun passen wir natürlich auch unseren Testcode entsprechend an:

$aryConData = array('myhost', 'myuser', 'mypassword', 'mydb');
$objDatabase = myDatabase::singleton($aryConData);
echo $objDatabase->getStatus().'';
// Ganz viel Magie
$objDatabase = myDatabase::singleton();
echo $objDatabase->getStatus();

Werfen wir wieder einen Blick auf die Ausgabe:

[1] connected: myuser:***@myhost/mydb
[1] connected: myuser:***@myhost/mydb

Siehe da: Es existiert nur noch eine einzige Klasseninstanz, d.h. wir müssen uns keine Sorgen mehr um unnötige Duplikate machen. Umständliche Lösung wie global sind damit unnötig.

Erzeugung ohne Singleton unterbinden

Einziger Haken: Natürlich könnte immer noch ein Entwickler aus Unwissenheit neue Objekte erzeugen. Hier können wir mit einer kleinen Anpassung an der Definition des Constructors Abhilfe schaffen:

	private function __construct($aryConData = array()) {

Da der Constructor jetzt private ist, kann er nur noch aus dem Klassenkontext heraus verwendet werden, d.h. singleton kann nach wie vor darauf zugreifen, aber eine Instanzerzeugung von außerhalb via new ist jetzt ausgeschlossen.

Verwendung für mehrere Datenbankverbindungen

Oft kommt natürlich immer alles vollkommen anders, als man zu Beginn denkt. Kaum wurde das Entwurfsmuster Singleton umgesetzt, schon muss man feststellen, dass aus irgendwelchen Gründen doch eine Verbindung zu einer zweiten, unabhängigen Datenbank notwendig ist. Nun muss aber nicht die bisherige Klasse vollständig kopiert und als Alternativklasse angeboten werden. Stattdessen machen wir unser singleton etwas flexibler, um mehrere Instanzen für verschiedene Datenbanken verwalten zu können.

Hier der angepasste Code:

class myDatabase {

	private static 	$_aryInstances = array(),
			$_intCounter = 0;

	private 	$_strStatus = 'disconnected',
			$_aryConData = array(),
			$_intID;

	// ... weitere Eigenschaften

	static function singleton($aryConData = array()) {
		$strFingerprint = serialize($aryConData);
		if (!isset(self::$_aryInstances[$strFingerprint]))
			self::$_aryInstances[$strFingerprint] = new self($aryConData);
		return self::$_aryInstances[$strFingerprint];
	}

	private function __construct($aryConData = array()) {
		if (!empty($aryConData))
			$this->_aryConData = $aryConData;
		$this->_intID = ++self::$_intCounter;
		$this->connect();
	}

	public function connect() {
		// Connect to your database
		$this->_strStatus = 'connected';
	}

	public function getStatus() {
		return '['.$this->_intID.'] '
			.$this->_strStatus.': '
			.$this->_aryConData[1]
			.':***@'.$this->_aryConData[0]
			.'/'.$this->_aryConData[3];
	}
	// ... weitere Methoden
}

Folgende Änderungen wurden vorgenommen:

1. Die statische Instanz-Variable ist nun ein Array, um mehrere Instanzen beinhalten zu können.
2. Die statische Variable für die Verbindungsdaten ist nun eine normale Eigenschaft, da diese sich ja in jeder Instanz ändern soll.
3. singleton bildet einen “Fingerabdruck” aus den Verbindungsdaten, um einzelne Instanzen über den Key des Instanz-Arrays unterscheiden zu können.

Auch hierzu nochmal ein Testcode:

$aryConData = array('myhost', 'myuser', 'mypassword', 'mydb');
$aryConData2 = array('yourhost', 'youruser', 'yourpassword', 'yourdb');
$objDatabase = myDatabase::singleton($aryConData);
echo $objDatabase->getStatus().'';
// Ganz viel Magie
$objDatabase = myDatabase::singleton($aryConData2);
echo $objDatabase->getStatus().'';
// Noch mehr Mage
$objDatabase = myDatabase::singleton($aryConData);
echo $objDatabase->getStatus();

Zwischen den beiden Verwendungen der identischen Verbindung, wird eine weitere Verbindung geöffnet. Das Resultat in der Ausgabe:

[1] connected: myuser:***@myhost/mydb
[2] connected: youruser:***@yourhost/yourdb
[1] connected: myuser:***@myhost/mydb

Wir haben zwei unterschiedliche Instanzen – für jeden Verwendungszweck genau eine. Viel Erfolg beim Schonen der Ressourcen!

Literatur

Mehr zum Thema Entwurfsmuster findet ihr im Softwaretechnik-Standardwerk der sogenannten “Gang of Four” (Gamma, Helm, Johnson und Vlissides): Design Patterns. Elements of Reusable Object-Oriented Software.*

• Web-Entwicklung 1: Die Grundgedanken (0)
• Wusstest Du schon… (0)
• WP-Plugin Bee5 API Entwicklerversion 0.2.0 (0)
• WordPress: Empfehlungen auf der 404-Seite (0)
• Web-Entwicklung 3: Tabellen (HTML) (0)

Bei iPoint handelt es sich um ein gestengesteuertes System, das wie der Gesture Cube keine Berührungen erfordert. Dadurch ist auch die Küchen-Demo naheliegend: Ohne den Bildschirm mit fettigen Händen berühren zu müssen, kann z.B. durch Rezepte geblättert oder einfach nur andere Musik ausgewählt werden. Technisch erinnert das System entfernt an Microsofts Project Natal. Während der Gesture Cube die Gesten durch ein elektrisches Feld erkennt, arbeitet die Fraunhofer Technik mit zwei Infrarot-Kameras. Mit diesen wird die Position der Hand ermittelt und durch Identifikation der Finger können selbst komplexere Gesten (Faust, Finger spreizen, zeigen) erkannt werden.

Das erste Video zeigt die Technik im Detail:

Das nächste Filmchen präsentiert das System im Einsatz, u.a. um eine 3D-Pong-Variante zu spielen:

Auch andere Einsatzgebiete sind denkbar. Der iPoint Presenter bildet zum Beispiel ein komplettes, tragbares System aus Gestensteuerung und Projektor, so dass interaktive Präsentationen ohne Fernbedienungen oder ähnliche Hardware durchgeführt werden können:

In der Bayerischen StaatsBibliothek wird iPoint als gestengesteuertes Interface verwendet, um intuitiv durch digitalisierte Bücher zu blättern:

Erinnert alles ein wenig an Minority Report, oder? Der Schweizer Radiosender DRS3 hat sich das System auf der CeBIT 2010 auch einmal live angesehen, jedoch zeigt das Video meiner Meinung nach im Gegensatz zu den HHI-Videos, dass das System noch nicht ganz ausgereift ist und weiteres Feintuning benötigt. Aber das ist sicherlich nichts, was sich nicht in den Griff bekommen lassen sollte. Ich bin gespannt

• Natural User Interfaces (0)
• Gesture Cube – Gestensteuerung ohne Berührung (0)
• Microsoft Surface in Deutschland angekommen (1)
• Microsoft Courier: User Interface in Aktion (0)
• Dynamo: Shared interactive surface (0)

• Mal kurz rundgeschaut… #15 (0)
• Mal kurz rundgeschaut… #8 (0)
• Mal kurz rundgeschaut… #6 (0)
• Mal kurz rundgeschaut… #9 (0)
• Mal kurz rundgeschaut… #7 (0)

Leider kann ich nichts zur Echtheit dieser Videos sagen. Im Endgadget-Artikel ist die Rede von einer extremely trusted source, zu den Videos steht dort nur we’ve gotten. Meine Skepsis rührt daher, dass Microsoft sich selbst vollständig in Schweigen hüllt… quasi nach bestem Apple-Vorbild. Falls irgendwer weitere Informationen hat: Nur her damit!

Gefunden habe ich die folgenden Videos, die das vermeintliche User Interface des Courier zeigen, bei werbeblogger.

Jetzt aber zu den Eindrücken:

Was denkt ihr? Ich finde, dass es wirklich Lust auf mehr macht.

• Natural User Interfaces (0)
• Microsoft Surface in Deutschland angekommen (1)
• [Video] Weltraumschwaben und virales Marketing (2)
• Microsoft-Boygroup feiert PDC & Windows 7 (0)
• Mal kurz rundgeschaut… #15 (0)

HTML5 bringt insbesondere viele Neuerungen, die die Entwicklung von Web-Applikationen erleichtern sollen. Aus diesem Grund will Google die Arbeiten an Gears zurückfahren, um stattdessen verstärkt auf HTML5 zu setzen. Da der neue Standard zudem erlaubt, Video und Audio nativ einzubinden, findet er auch in den laufenden Diskussionen über das drohende Ende des Flash-Zeitalters entsprechende Beachtung. Besonders interessant sind außerdem die zusätzlichen Formular-Elemente (z.B. für Datumseingaben), das Canvas-Element, das dynamische Grafiken via HTML erlaubt, und die zusätzlichen Tags zur Strukturierung eines Dokumentes (z.B. article oder nav).

Folgende Dokumente finde ich persönlich insbesondere für den Einstieg in HTML5 sehr interessant:

HTML5 – A vocabulary and associated APIs for HTML and XHTML

Abstract: This specification defines the 5th major revision of the core language of the World Wide Web: the Hypertext Markup Language (HTML). In this version, new features are introduced to help Web application authors, new elements are introduced based on research into prevailing authoring practices, and special attention has been given to defining clear conformance criteria for user agents in an effort to improve interoperability.

Zur zuletzt veröffentlichten Version des Dokumentes.

HTML: The Markup Language

Abstract: This document describes the HTML markup language and provides details necessary for producers of HTML content to create documents that conform to the language. By design, it does not define related APIs, nor attempt to specify how consumers of HTML content are meant to process documents, nor attempt to be a tutorial or “how to” authoring guide.

Zur zuletzt veröffentlichten Version des Dokumentes.

HTML5 differences from HTML4

Abstract: HTML5 defines the fifth major revision of the core language of the World Wide Web, HTML. “HTML5 differences from HTML4″ describes the differences between HTML4 and HTML5 and provides some of the rationale for the changes. This document may not provide accurate information as the HTML5 specification is still actively in development. When in doubt, always check the HTML5 specification itself.

Zur zuletzt veröffentlichten Version des Dokumentes.

Viel Spaß beim Stöbern… und nicht vergessen: Es handelt sich nach wie vor um Entwürfe. Die Links führen übrigens nicht direkt auf die gerade veröffentlichten Dokumente vom 4. März, sondern auf die jeweils zuletzt veröffentlichte Version, d.h. sie eignen sich als Bookmarks, wenn ihr immer auf dem neusten Stand sein wollt.

• Teleskoptext – Die etwas andere Klickstrecke (1)
• Sketching und Wireframing – Noch mehr Vorlagen (0)
• Praktisch: Webseiten mit Browsershots testen (0)
• MAMA wacht über Webstandards (1)
• Mal kurz rundgeschaut… #11 (0)

Anatomy of Apple Design from Transparent House on Vimeo.

• Steve Jobs Biografie: From Garage to Grandeur (0)
• [Video] Weltraumschwaben und virales Marketing (2)
• W&W der Geschichte #1: Apple (0)
• Rundgugg zum Sonntach 52/08 (0)
• [Video] Turing Maschine aus Lego (1)

Die klassischen Graphical User Interfaces (GUIs) sollten die vorherigen Command Line Interfaces (CLIs) zugänglicher machen, d.h. “Interna” des Systems wurden z.B. mit der mittlerweile üblichen Desktop-Metapher vermittelt. Nutzer verwalten dadurch Dokumente innerhalb von Ordnern, statt Dateien innerhalb von Verzeichnissen. NUIs sollen noch einen Schritt weitergehen und den Computer weitgehend unsichtbar machen. Das System soll also möglichst intuitiv bedient werden, ohne das seine einzelnen Elemente in Erscheinung treten.

Microsofts Forscher setzen dazu auf sogenanntes Body Computing. Das bedeutet, dass der Körper selbst zum Eingabegerät wird. Ein erstes Beispiel sind physiologische Sensoren, die an den Arm angebracht werden und einzelne Fingerbewegungen registrieren können. Im folgenden Demo-Video nutzt Desney Tan diese Technik, um ohne Gitarren-Controller eine Partie Guitar Hero zu spielen. Anschließend zeigt Dan Morris, wie der menschliche Arm mit Hilfe des Systems zu einem Eingabegerät wird. Er steuert den Computer einfach dadurch, dass er mit den Fingern der linken Hand auf den rechten Arm tippt.

Hier das bei Golem.de gehostete Demo-Video:

In eine andere Richtung geht zumindest auf den ersten Blick das Konzept des Mobile Surface. Man kann es sich als eine Art tragbaren Mini-Surface vorstellen, der quasi überall ein Touch-System verfügbar macht. Dazu besteht es aus einem Mobile Device, einem Projektor zur Darstellung des Bildes und einer Kamera, die die Bewegungen des Nutzers registriert. Das zugehörige Beispielvideo zeigt Chunhui Zhang, wie er die Tischplatte als Schlagzeug verwendet. Zusätzlich zeigt er eine weitere Möglichkeit dieser Technik: Indem man eine einfache “Fläche” über eine projezierte Karte bewegt, kann das System auf diese Fläche Detailinformationen zum darunterliegenden Kartenteil projizieren.

Auch dieses Microsoft-Video hat Golem.de gehosted:

Kombiniert man beide Techniken, so kann man z.B. Bedienelemente direkt auf den Arm projizieren und damit einen Computer vollkommen ohne zusätzliche Eingabemedien bedienen. Weitere Details und auch ein Bild von auf den Arm “geworfenen” Bedienelementen findet ihr auf der Microsoft Research Webseite. Außerdem erfahrt ihr dort auch noch etwas über das Project Gustav, das realisitisches Malen am Computer ermöglichen soll.

• Microsoft Surface in Deutschland angekommen (1)
• Microsoft Courier: User Interface in Aktion (0)
• Gesture Cube – Gestensteuerung ohne Berührung (0)
• iPoint Control – Neue Videos (0)
• Tangible User Interfaces (0)

• Mal kurz rundgeschaut… #6 (0)
• Mal kurz rundgeschaut… #16 (0)
• Mal kurz rundgeschaut… #13 (0)
• Mal kurz rundgeschaut… #12 (0)
• Mal kurz rundgeschaut… #8 (0)

Ermöglicht wird dies durch die GestIC-Technologie, die ursprünglich vor einigen Jahren von der Ident Technology AG zur Absicherung von Cabriodächern entwickelt wurde: Der Einfahrprozess des Daches sollte automatisch stoppen, sobald sich eine Hand nähert. Registriert wird die Hand, weil sie ein elektrisches Feld stört, das vom Gerät ausgesendet wird.

Durch diese Technik kann zudem die Position der Hand ermittelt werden, womit folglich Gesten erkannt werden können. Man kann also sagen, dass der Gesture Cube wie moderne Touchscreens (z.B. iPhone, Microsoft Surface) gesteuert wird, aber ohne wirklich den Bildschirm zu berühren. Damit sollten die Zeiten schmieriger Fingerabdrücke vorbei sein.

Im Demo-Video wird der Einsatz der Würfels als ein Multimedia-System präsentiert. Beispielsweise kann eine eingehende Nachricht mit einer einfachen Wisch-Bewegung gelöscht werden, Photos werden wie durch Telekinese verschoben und durch das Hinabfahren an einer Kante wird die Lautstärke des gerade gespielten Musiktitels gesenkt. Insgesamt scheint die Bedienung sehr intuitiv zu sein, jedoch stelle ich mir die Frage, ob im Einsatz, z.B. beim Verschieben von Reglern, nicht irgendwie die Haptik fehlen könnte.

Da das gute Stück nicht allzu groß sein soll, kann es problemlos durch die Wohnung getragen werden. Greift man den Wunderwürfel dazu, friert das User Interface ein und ist wieder verwendbar, sobald man ihn wieder absetzt.

Schaut euch einfach mal das untenstehende Video und die Gesture Cube Webseite an. Dort findet ihr auch viele weitere Bilder. Es ist auf jeden Fall eine sehr interessante Idee und ich bin auf erste Prototypen aus diesem Konzept gespannt. Was haltet ihr davon?

• Natural User Interfaces (0)
• 3D Desktop Concept – Eine neue UI-Dimension (1)
• Microsoft Surface in Deutschland angekommen (1)
• iPoint Control – Neue Videos (0)
• Microsoft Courier: User Interface in Aktion (0)

Aber zukünftig ist die Bastelei im Piwik-Code, die deutsche Benutzer offenbar durchführen müssen, wohl vorbei, denn gerade schrieb Martin:

Das Konzept meines NoIP-Plugins ist offensichtlich angenommen worden und wird als Plugin in der Version 0.55 von Piwik vorhanden sein. Mit dem Unterschied, dass man per Konfigurationsparameter die Anzahl der zu löschenden Oktette einstellen kann.

Wer will, kann es sich schon mal aus dem SVN holen.

Zukünftig müssen wir also nur noch das Plugin aktivieren. Damit ein großes Dankeschön an Martin für die Mühe!

• Mal wieder: Piwik und anonymisierte IPs (13)
• Piwik: Keine IP-Adressen speichern (19)
• WP-Piwik – WPMU-Piwik (19)
• Piwik – Lokale Analytics-Alternative (2)
• Neues WordPress-Plugin: WP-Piwik (15)