Als ich mich vor ein paar Jahren auf meine Java-Zertifizierung vorbereitet habe, ist mir ein Satz immer wieder begegnet: “Programm to an interface, not to an implementation!”. Klingt einfach, ist es auch.

Im Prinzip sagt das nur aus, dass man sich beim Entwickeln nur darauf verlassen sollte, was die jeweilig implementierten Interfaces an Funktionalität anbieten. Wie das ganze dann im Hintergrund implementiert ist, interessiert dann nicht mehr.

Ein kleines Beispiel aus der Praxis: In einem Shop (in dem Fall Magento) werden Bestellungen (Orders) gespeichert. Nun soll ein ERP-System angebunden werden. Für beide Systeme gibt es entsprechende Models, mit denen die Daten verarbeitet werden können.

Soweit, so gut. Jetzt kommt der unbequeme Teil der Aufgabe. Das Magento-Order-Model erbt einfach nur von verschiedenen anderen Klassen, aber es existiert kein Interface, das dem Entwickler bestimmte Methoden garantiert. An vielen Stellen werden zudem die Parameter mit Type-Hinting überprüft, ob sie eine Magento-Order enthalten.

Das Model für die Anbindung an das ERP-System hat unter Umständen andere Elternklassen und somit auch erstmal keine Gemeinsamkeiten. Das bedeutet, dass wir theoretisch die Objekte gleich behandeln könnten, aber wir sie für das Type-Hinting doch wieder in Wrapper verpacken oder auf Magento-Order-Objekte mappen müssen.

Diese Arbeit könnte man sich komplett sparen, wenn man sich von Anfang an auf ein Interface verlassen hätte. Leider existiert dieses meines Wissens nicht und es für eigene Projekte zu nutzen würde Änderungen in den Magento-Core-Dateien fordern.

<?php
interface Mage_Sales_Model_Order_Interface
{
  /**
   * Retrieve customer model
   *
   * @return Mage_Customer_Model_Customer_Interface
   */
  public function getCustomer();

  // ...
}

Damit könnte man sich auf verschiedene Methoden verlassen die der Typ Mage_Sales_Model_Order_Interface (!) zusagt.

<?php
class Mage_Sales_Model_Order
  extends Mage_Sales_Model_Abstract
  implements Mage_Sales_Model_Order_Interface
{
  // ...
}

Die Klasse Mage_Sales_Model_Order könnte sich an diesen “Vertrag” halten,

<?php
class Erp_Sales_Model_Order
  extends Erp_Was_Auch_Immer_Model_Abstract
  implements Mage_Sales_Model_Order_Interface
{
  // ...
}

sowie auch jede andere Klasse.

<?php
// ...
public function getEmailFromOrder(Mage_Sales_Model_Order_Interface $order)
{
  return $order->getCustomer()->getEmail();
}
// ...

So können wir jede beliebige Klasse mit bestehenden Code weiterhin verarbeiten, ohne dass uns das Type-Hinting dabei im Weg steht. Was die Methode getCustomer() nun intern macht, ist uns egal, solange ein Objekt vom Typ Mage_Customer_Model_Customer_Interface zurückgegeben wird.

Es ist vielleicht auf den ersten Blick etwas umständlicher, für jeden Typ ein Interface zu schreiben, aber das spart man danach wieder locker ein und bleibt dazu auch in der weiteren Entwicklung seiner Anwendung flexibel.

Aber nach mir geht es nicht, das Leben ist kein Ponyhof und ich habe mich so entschieden mein Geld mit PHP- und nicht mit Java-Programmierung zu verdienen. Genug gejammert, worum geht es?

In den letzten Tagen, Urlaub sei Dank, hatte ich etwas mehr Zeit mich durch die Blogwelt zu klicken und habe dabei einen älteren Artikel von Benjamin entdeckt, in dem er seine PHP-Stringklasse vorstellt. Etwas schmunzeln musste ich bei der Lizenz für die wenigen Zeilen Code, aber Ordnung muss sein.

Die Idee gefällt mir sehr gut keine primitiven Datentypen, sondern echte Objekte zu verwenden.

Inspiriert von der Idee, habe ich ein paar Minuten gebastelt und habe nun meine Custom_String-Klasse. Sie ist einfach umgesetzt, handlich und hat alles was ich brauche.

An der Stelle fiel mir dann auch gleich wieder ein, warum ich das bisher nicht umgesetzt habe.

Wer sich etwas mit Java auskennt, der weiß, dass sämtliche Objekte in gewisser Weise nach bestimmten Mustern funktionieren. Will ich meine Objekte sortieren können, dann implementiere ich einfach das Interface Comparable und gut ist.

An dem Beispiel mit den Strings sollte das Problem klar werden. Benjamin hat eine Klasse für Strings geschrieben, wie er sie gerne hätte, ich habe das getan und viele andere vielleicht auch.

Jede für sich mag gut sein, aber auch etwas anders funktionieren und eine andere Schnittstelle bieten.

In großen Systemen kommen nun die Arbeiten vieler Entwickler zusammen, teilweise sogar aus verschiedenen Teams oder auch Firmen.

Um nun einheitlich mit allen Objekten arbeiten zu können, brauchen wir zwangsläufig Adapter-Klassen und haben damit weitere potentielle Schwachstellen im System. Wir müssten jedes Objekt an den Schnittstellen richtig verpacken und bauschen dadurch den Code auf und wir haben die Adapter-Klassen, die wir ebenfalls mit jeder Änderung der Originalklassen anpassen müssen.

Ich denke, solange PHP nicht im Kern ähnlich wie Java die entsprechenden Schnittstellen vorgibt, macht man sich das Entwicklerleben damit nicht wirklich leichter. Wie denkt ihr darüber?

Gleichzeitig wollen wir aber zu jeder Zeit sicherstellen, dass wir das Model wie gewohnt vollständig abfragen und verwenden können. An dieser Stelle kommt eine Technik namens LazyLoading (lazy = engl. faul, träge) zum Einsatz.

Nun konstruiere ich einfach ein Beispiel, um den Ablauf besser erklären zu können. In unserer Anwendung brauchen wir ein Model “Person”, das Informationen wie Name, Geburtstag und diverse andere speichern kann. Den Namen und den Geburtstag brauchen wir immer (z.B. in der Listenansicht) und die restlichen Felder nur wenn wir eine Detailansicht erstellen.

Wie kommt unser Model nun an die Daten? In der Regel wird sicherlich load() auf dem Modelobjekt aufgerufen oder eine vergleichbare Methode auf der jeweiligen Collection, dann werden die Daten über ein Resourcemodel geladen und letztendlich komplett auf die einzelnen Modelobjekte kopiert.

Um unser Vorhaben umzusetzen müssen wir das etwas abändern. Die Methode load() des Models funktioniert wie gewohnt und lädt alle Daten und die Collection nur die Nötigsten. Um nun sicherzustellen, dass wir trotzdem immer alles abrufen können, muss das Model etwas intelligenter werden.

Die Entwicklung des Custom_Models hat der eine oder andere ja vielleicht mitbekommen und kennt den grundlegenden Aufbau. Relativ neu ist die Klasse Custom_Model_Persistent, durch die eine weitere Unterscheidung zwischen einfachen Datencontainern und speicherbaren Models möglich wird.

Für das automatische Nachladen muss die Modelklasse nun erweitert werden.

<?php
class Custom_Model_Persistent extends Custom_Model
{
  private $_isLoaded;

  // ...

  public function load($value = null, $field = 'id')
  {
    if (null === $value && $this->_isset($field)) {
      $value = $this->_get($field);
    }

    $this->getResource()
         ->loadModel($this, $value, $this->_mapKey($field))
         ->markLoaded();

    return $this;
  }

  public function isLoaded()
  {
    return $this->_isLoaded;
  }

  public function markLoaded()
  {
    $this->_isLoaded = true;
    return $this;
  }

  protected function _get($key, $default = null)
  {
    if (!$this->_isset($key) && !$this->isLoaded()) {
      $this->load();
    }
    return parent::_get($key, $default);
  }
}

Die entscheidenen Stellen sind hier der überschriebene zentrale Getter, der ein das “Default-Load()” auslöst, wenn der Wert nicht gesetzt ist und die Daten auch noch nicht vollständig geladen wurden und die Methode load() mit optionalen Parameter $value.

Im Beispiel verlasse ich mich darauf, dass das Standardfeld schon gesetzt ist. Eine ordentliche Fehlerbehandlung muss aber unbedingt her, wenn wir das ganze produktiv einsetzen wollen.

Die Methoden isLoaded() bzw markLoaded() sind absichtlich public, damit sie z.B. aus einer Collection aufgerufen werden können, wenn das Model komplett geladen wurde. Eine weitere Möglichkeit wäre ein Vergleich mit einer Liste die gesetzt sein sollten.

Im Moment ist das noch etwas im Entwurf und sogar ungetestet. Wenn euch nun noch was dazu einfällt, dann schreibt einen Kommentar. Wo seht ihr für euch die Vor- oder evtl. auch die Nachteile?

Ganz klar, es handelt sich um die Interfaces Iterator und IteratorAggregate. Was aber unterscheidet die beiden?

Um den Aufbau der beiden Klassen gegenüberzustellen habe ich zwei einfache Beispiel-Klassen geschrieben, mit denen wir ein Array in einer foreach-Schleife auslesen können.

Iterator

Das Interface Iterator schreibt fünf Methoden vor, die zur Verarbeitung des Objektes in einer Schleife benötigt werden: current(), next(), key(), valid() und rewind().

<?php
class TestA implements Iterator
{
  private $_items;

  public function __construct(array $items = array())
  {
    $this->_items = $items;
  }

  public function current()
  {
    return current($this->_items);
  }

  public function next()
  {
    next($this->_items);
  }

  public function key()
  {
    return key($this->_items);
  }

  public function valid()
  {
    return false !== current($this->_items);
  }

  public function rewind()
  {
    reset($this->_items);
  }
}

Auf den ersten Blick lässt sich erkennen, dass relativ viel Code benötigt benötigt wird und dieser starr am Objekt hängt. Ok, für diesen Zweck hätte man auch den ArrayIterator nehmen können, aber dann gäbe es weniger zu gucken.

IteratorAggregate

Das zweite Iterface ist dagegen wesentlich schlanker, denn es kommt mit der einzigen Methode getIterator() aus.

<?php
class TestB implements IteratorAggregate
{
  private $_items;

  public function __construct(array $items = array())
  {
    $this->_items = $items;
  }

  public function getIterator()
  {
    return new ArrayIterator($this->_items);
  }
}

Die Methode erzeugt einen externen Iterator und lagert damit die Funktionalität in eine andere Klasse aus. Dadurch bleibt unsere Klasse übersichtlich und das Iterator-Verhalten lässt sich einfach austauschen.

Fazit

Für einfache Strukturen würde ich das IteratorAggregate-Interface vorziehen, da es sehr einfach aufgebaut ist und unseren Code schlank und übersichtlich hält. Die Funktionalität ist zudem durch verschiedene externe Klassen variabel und viele Standardfälle können mit den SPL-Klassen abgedeckt werden.

Lässt sich eine Struktur aus irgendeinem Grund nicht an einen externen Iterator übergeben, bzw. will man für diesen speziellen Fall schreiben, dann kommt das Iterator-Interface zum Einsatz.

Genaugenommen lässt sich das mit den beiden Beispielklassen schon gut testen. Einfach in der Klasse TestB

public function getIterator()
{
  return new ArrayIterator($this->_items);
}

gegen

public function getIterator()
{
  return new TestA($this->_items);
}

austauschen und etwas damit rumspielen.

In der Anwendung sind beide später identisch:

<?php
$a = new TestA(array('A','B','C','D','E'));

foreach ($a as $k => $v) {
  echo "$k = $v <br/>";
}

$b = new TestB(array('A','B','C','D','E'));

foreach ($b as $k => $v) {
  echo "$k = $v <br/>";
}

Viel Spaß damit! Eure Erkenntnisse zu dem Thema könnt ihr wie immer gerne in den Kommentaren verewigen…

Ein Grund mehr mal über den PHP-Tellerrand zu spicken und einen kleine Ausflug in die Java-Welt zu machen.

PHP bietet zwar mit diversen Array-Funktionen schon einige Möglichkeiten der Sortierung an, diese sind aber doch recht starr und man stößt schnell an gewisse Grenzen, wenn man mehr als nur einfache Datentypen sortieren will, da sowohl die Sortierlogik, wie auch der Vergleich der Objekte sind nach außen in einer Funktion zusammengefasst sind.

Wie funktioniert das denn nun in der Java-Welt? In Java müssen Objekte durch das Interface “Comparable” als sortierbar gekennzeichnet werden. Die meisten Standardklassen implementieren das bereits.

Das Interface schreibt die Methode ‘compareTo” vor, die es dem Objekt erlaubt, sich mit anderen Objekten zu vergleichen. Der Rückgabewert kann 1, 0 oder -1 sein.

Dazu ein kleines Beispiel:

Leider gibt ist in der SPL noch kein derartiges Interface vorhanden, also schreibe ich es einfach mal selbst.

<?php
interface Custom_Compareable
{
  public function compareTo($object);
}

Dann brauchen wir noch ein Objekt zum Vergleichen.

<?php
class Person implements Custom_Comparable
{
  private $_id;
  private $_vorname;
  private $_nachname;
  private $_geburtsdatum;

  public function __construct($id)
  {
    $this->_id = $id;
  }

  //  Getter und Setter...

  public function compareTo($object)
  {
    if (!$object instanceof Person) {
      throw new InvalidArgumentException();
    }

    if ($this->_id < $object->_id) {
      return -1;
    } else if ($this->_id == $object->_id) {
      return 0;
    } else {
      return 1;
    }
  }
}

Damit können nun Objekte vom Typ Person standardmäßig nach ihrer Id unabhängig vom Suchalgorithmus sortiert werden.

<?php
$p1 = new Person(3);
$p2 = new Person(2);

if ($p1->compareTo($p2) < 0) {
  // swap($p1, $p2)
}

Bis jetzt haben wir zwar schon die Sortierlogik vom Vergleich der Objekte lösen können, aber trotzdem noch nicht viel gewonnen, da nur die Ids verglichen werden. Für abweichende Sortierungen lässt sich der Vergleich nun auch noch vom Personen-Objekt lösen. Dafür bietet Java das Interface “Comparator” an, bei uns wird es nun das Custom_Comparator-Interface.

<?php
interface Custom_Comparator
{
  public function compare($object1, $object2);
}

Die Methode “compare()” hat die gleichen Rückgabewerte wie “compareTo()” und kann dadurch genauso verwendet werden.

<?php
class PersonComparatorVorname implements Custom_Comparator
{
  public function compare($object1, $object2)
  {
    if (!$object1 instanceof Person || !$object2 instanceof Person) {
      throw new InvalidArgumentException();
    }

    if ($object1->getVorname() < $object2->getVorname()) {
      return -1;
    } else if ($object1->getVorname() == $object2->getVorname()) {
      return 0;
    } else {
      return 1;
    }
  }
}

Durch diese beiden Interfaces haben wir nun die Möglichkeit, unsere Objekte beliebig sortieren zu lassen. Über die Wertigkeit der Objekte entscheidet nun das Objekt selbst, bzw. ein passender Comparartor. Wie die Objekte letztendlich sortiert werden ist egal, da die Logik an einer anderen Stelle implementiert wird und nun für alle Objekte gleich funktioniert, wenn diese “Comparable” sind.

<?php
$listeMitPersonen = array(new Person(1), new Person(2));
$comparator = new PersonComparatorVorname();

// die Funktionen stehen als Pseudocode
bubblesort($listeMitPersonen);
bubblesort($listeMitPersonen, $comparator);

quicksort($listeMitPersonen);
quicksort($listeMitPersonen, $comparator);

Und auch die Logik für auf- oder absteigende Reihenfolge lässt sich komplett getrennt dank Dekorator-Pattern auslagern.

<?php
class ReverseComparator implements Custom_Comparator
{
  private $_comparator;

  public function __construct(Custom_Comparator $comparator)
  {
    $this->_comparator = $comparator;
  }

  public function compare($object1, $object2)
  {
    return $this->_comparator->compare($object1, $object2) * (-1);
  }
}

Wirklich störend war aus meiner Sicht bislang nur, dass sich das Singleton nicht vererben ließ. Dank Late Static Binding seit PHP Version 5.3 ist nun auch das möglich.

Dazu habe ich vor ein paar Tagen einen guten Artikel von Julian gefunden und auch noch einen englischsprachigen im Blog von Brandon.

Alle, die bislang nur wenig oder keine Erfahrung mit MVC-Anwendungen gesammelt haben, werden sich vielleicht nun fragen, wofür dieses Objekt gut ist. Das Response-Objekt kontrolliert die komplette Ausgabe der Anwendung an den Client (z.B. einen Browser).

Während der kompletten Laufzeit können mit dem Objekt Ausgaben gesammelt und auch nachträglich verändert werden und auch die Reihenfolge spielt keine Rolle. So kann nun zuerst die Ausgabe gemacht werden und dann die Header gesetzt werden.

So müsste es klassisch mit PHP geschrieben werden:

<?php header('Content-type: text/xml'); echo $xml;

Wenn wir nun die Reihenfolge vertauschen würden, hätte das eine Warning zur Folge.

<?php echo $xml; header('Content-type: text/xml');

Warning: Cannot modify header information - headers already sent by (output started at ####) in #### on line 3

Wenn wir uns in einer MVC-Umgebung befinden, stellt diese Reihenfolge kein Problem dar, denn das Objekt verwaltet die Ausgabe und schickt alles zur rechten Zeit raus.

So könnte es dann z.B. in einer Action des Kontrollers aussehen:

<?php public function indexAction() { // ... $this->getResponse()->appendBody($xml); $this->getResponse()->setHeader('Content-type', 'text/xml'); } 

Neben den relativ harmlosen direkten Ausgaben mit echo oder print habe ich in den vergangenen Jahren auch Ausgaben mit die() gefunden. Die offensichtliche Arbeit verrichtet die Anwendung zwar in den Actions der Kontroller, aber es passiert unter Umständen auch vor- und nachher eine Menge. Letzteres würde dann unterbunden werden und evtl. wichtige Aufgaben nicht mehr abgearbeitet werden.

Ein Beispiel sah etwa so aus:

<?php
public function jsonAction()
{
  // ...
  header('Content-type: text/json');
  die($json);
  // ...
}

Die Anwendung verliert so die Kontrolle über die Ausgabe und wird an der falschen Stelle beendet. Der richtige Weg führt auch hier zum Response-Objekt.

<?php
public function jsonAction()
{
  // ...
  $this->getResponse()->setHeader('COntent-type', 'text/json');
  $this->getResponse()->appendBody($json);
  return;  // <== falls die Bearbeitung hier enden soll
  // ...
}

So, nun gibt es in Zukunft keine Ausreden mehr, wenn irgendwo ein echo im Kontroller steht. Ich würde mich natürlich wie immer freuen eure Erfahrungen in den Kommentaren zu lesen.

Nebenbei bemerkt ist das mein 50. Artikel, also schon fast ein kleiner Grund zum Feiern.