Nach etwas Suchen fand ich eine Möglichkeit in der Symfony Dokumentation.

Ab Version 2.1 kann ein Parameter in der Konfigurations-Datei gespeichert werden.

# app/config/config.yml
parameters:
    backend_prefix: admin

Dieser Parameter kann dann z.B. in der Route-Annotation oder der Routing Konfiguration verwendet werden.

/**
 * @Route("/%backend_prefix%/user")
 */
class UserBackendController extends Controller {
    /**
     * @Route("/")
     */
    public function indexAction() {
        /* do something */
    }
}

Durch das Prefix ist dieser Bereich nicht nur optisch im URL abgehoben, sondern kann durch die Security Konfiguration auch leicht nur für einzelne Nutzergruppen freigegeben werden.

Nun habe ich in der Vergangenheit ja schon das eine oder andere über Closures in PHP und Java Comparatoren für PHP geschrieben und wollte das nun mal zusammenbringen.

Einige PHP-Sortierfunktionen erlauben Callbacks, um die Reihenfolge zu bestimmen. Da ich das Ganze aber gerne in gut testbaren OOP-Einheiten hätte, müssen wir einen kleinen Umweg gehen.

Zunächst das obligatorische Interface.

namespace E7;

interface Comparator {
  public function compare($a, $b);
}

Diese Schnittstelle implementieren wir mit einer abstrakten Klasse.

namespace E7;

class BaseComparator implements Comparator {
  public function compare($a, $b) {
    if ($a == $b) { return 0; }
    return $a < $b ? -1 : 1;
  }

  public function __invoke() {
    return call_user_func_array(array($this, 'compare'), func_get_args());
  }
}

Und schon haben wir einen einfachen, und zugegebenermaßen nicht typsicheren, Comparator.

Durch die magische Methode __invoke() kann ein Objekt nun wie eine Callbackfunktion verwendet werden.

Für die Sortierung von Objekten kann das dann einfach erweitert werden.

class PersonComparator extends BaseComparator {
  public function compare($a, $b) {
    // hier Prüfung auf Typ etc.
    return parent::compare($a->getId(), $b->getId());
  }    
}

Um die Sortierreihenfolge negieren zu können, können wir einen einfachen Wrapper nutzen.

class ReverseOrder implements Comparator {
  private $_comparator;

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

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

Beispiel…

//--
$people = array();
for ($i = 0; $i < 10; $i ++) {
  $people[] = new Person();
}

echo 'BEFORE<br/>';
foreach($people as $person) {
  echo "$person<br/>";
}

$comparator = new ReverseOrder( new PersonComparator() );

uasort($people, function($a, $b) use ($comparator) {
    return $comparator->compare($a, $b);
});

// oder

uasort($people, $comparator);

echo 'AFTER<br/>';
foreach($people as $person) {
  echo "$person<br/>";
}

Damit ist dann zumindest der eine Teil, die Datenstruktur, für sich gekapselt. Was ist aber mit dem Teil, den wir wahrscheinlich häufiger verwenden werden? Wir nutzen Iteratoren in Schleifen und machen irgendwas mit den Elementen.

<?php
foreach($list as $key => $item) {
  $item->doSomething();
}

// oder
$values = array();
foreach($list as $key => $item) {
  $values[] = $item->getSomething();
}

In verschiedenen anderen Sprachen, Java, JavaScript etc., sieht man häufig, dass dort auch die Scheifen gekapselt sind. Warum probieren wir das nicht auch mal in PHP?

Ich werde das Beipiel bewusst einfach halten und wie gewohnt auf einige Fehlerbehandlungen verzichten, um den Code übersichtlich zu halten.

Als erstes erstellen wir eine Klasse “WalkableIterator” und lassen diese von ArrayIterator erben. Die beiden Methoden “each” und “walk” bilden später unsere beiden Beispiele ab.

<?php
class WalkableIterator extends ArrayIterator {
  public function each($method) {}
  public function walk($callback) {}
}

Mit each() können wir eine bestimmte Methode auf jedem Element in unserem Iterator aufrufen. Dafür müssten hier natürlich diverse Fehlerbehandlungen rein was passieren soll, wenn das Element kein Objekt ist oder die Methode nicht existiert oder diese gar eine Exception wirft.

<?php
class WalkableIterator extends ArrayIterator {
  public function each($method) {
    $args = func_get_args();
    $method = array_shift($args);
    foreach($this as $item) {
      call_user_func_array( array($item, $method), $args );
    }
  }
  // ...
}

Das ganze ist denkbar einfach: Die Methode nimmt als ersten Pflichtparameter den Methodennamen entgegen, die auf allen Elementen aufgerufen werden soll und der Rest bleibt flexibel und wird einfach nur durchgereicht.

Die Implementierung von walk() wird sogar noch einfacher, da hier keine Parameter weitergegeben werden müssen. Im produktiven Einsatz müssten auch hier noch die üblichen Fehlerbehandlungen rein.

<?php
class WalkableIterator extends ArrayIterator {
  // ...
  public function walk($callback) {
    foreach($this as $item) {
      call_user_func( $callback, $item );
    }
  }
}

Soweit, so einfach… Was können wir jetzt damit machen? Bauen wir ein kleines Beispiel.

<?php
// Testklasse
class Person {
  private $name;
  public function __construct($name = 'unnamed') {
    $this->setName($name);
  }
  public function getName() {
    return $this->name;
  }
  public function setName($name) {
    $this->name = $name;
  }
}

// Testarray mit Objekten befüllen
$a = array();
for($i=1; $i <= 10; $i++) {
  $a[] = new Person('Person ' . $i);
}

// Iterator erstellen und Namen ausgeben
$it = new WalkableIterator($a);

foreach($it as $item) {
  echo $item->getName() . '<br/>';
}

// Person 1
// ...
// Person 10

Wollten wir nun allen Personenobjekten einen Namen geben, so könnten wir dafür each() verwenden.

<?php
$it->each('setName', 'PHP-Nerd');

// PHP-Nerd
// ...
// PHP-Nerd

Wollen wir unsere Personen dann vielleicht doch wieder individueller benennen, so könnten wird das mit walk() und einem Callback machen.

$callback = function(Person $person) {
  static $count = 1;
  $person->setName( $person->getName() . ' ' . $count++ );
};

$it->walk($callback);

// PHP-Nerd 1
// ...
// PHP-Nerd 10

“Was bringt uns das und warum so kompliziert?”, ist in dem Zusammenhang eine oft gehörte Frage.

Zunächst ist die Implementierung, wie das Beispiel sicher beweist, nicht kompliziert.

Die Vorteile sind kürzere Aufrufe im Code, weil wir keine Schleifen mehr schreiben müssen und durch die Kapselung verbessert sich auch die Wart- und Testbarkeit. Der Code existiert nur an einer Stelle und funktioniert überall nach dem selben Muster.

Bislang musste man Callback-Funktionen gewöhnlich definieren, bevor man sie verwenden konnte.

<?php
function myCallback($output) {
  return '##' . $output . '##';
}

echo call_user_func('myCallback', 'Hallo Welt');

// Ausgabe:
##Hallo Welt##

Als Closure geschrieben sähe das dann so aus:

<?php
echo call_user_func(
  function($output) { return '##' . $output . '##'; },
  'Hallo Welt');

// Ausgabe:
##Hallo Welt##

Zugegeben, dieses Beispiel hätte man durch einfache Stringverkettung wesentlich einfacher schreiben können und eigentlich war das mit create_function() auch schon unter PHP4 möglich.

Wir können die Funktion natürlich wie früher auch schon in einer Variablen speichern und dann weiter verwenden.

<?php
$myFunction = function($output) {
  return '##' . $output . '##';
};

echo call_user_func($myFunction, 'Hallo Welt') . '<br/>';
echo $myFunction('Hallo Welt') . '<br/>';

//Ausgabe:
##Hallo Welt##
##Hallo Welt##

Und auch das ist ja noch nichts Neues. Mit Closures haben wir nun aber auch die Möglichkeit, teile unserer “Umgebung” zum Zeitpunkt der Funktionsdefinition zu konservieren.

Dazu müssen wir nur die Definition etwas erweitern.

<?php
$before = '>';
$after = '<';

$myFunction = function($output) use ($before, $after) {
    return $before . $output . $after;
};

echo $myFunction('Hallo Welt') . '<br/>';

//Ausgabe:
>Hallo Welt<

An dieser Stelle frieren wir mit “use” sozusagen die Werte für $before und $after innerhalb unserer Funktion ein. Spätere Änderungen der beiden Variablen haben keine Auswirkungen auf die Funktion.

$before = 'foo';
$after = 'bar';
echo $myFunction('Hallo Welt') . '<br/>';

//Ausgabe:
>Hallo Welt<

In PHP wir mittlerweile sehr viel mit Standardinterfaces und -klassen (SPL) abgedeckt und so ist es auch in diesem Fall. In der Variablen $myFunction ist ein Objekt vom Typ “Closure” gespeichert.

<?php
echo '<pre>' . print_r($myFunction, true) . '</pre>';

//Ausgabe:
Closure Object
(
  [static] => Array
    (
      [before] => >
      [after] => <
    )
  [parameter] => Array
    (
      [$output] =>
    )
)

Will man eigene Objekte wie Funktionen aufrufen, dann geht das mit der magischen Methode __invoke(), die auch hier verwendet wird.

Anfangs erwähnte ich, dass Closure-Callbacks zur Filterung, aber auch zur Manipulation von Array verwendet werden können.

Wenn nur der Inhalt interessant ist, dann kommen wir mit array_map() und einem Parameter aus.

<?php
$values = array(
  array(
    'a' => array(
      'b' => 'foo'
    )
  ),
  array(
    'a' => array(
      'b' => 'bar'
    )
  ),
);

$filtered = array_map(
  function ($item) { return $item['a']['b']; },
  $values
);
echo '<pre>' . print_r($filtered, true) . '</pre>';

// Ausgabe:
Array
(
  [0] => foo
  [1] => bar
)

Wollen wir aber Werte im Array in Abhängigkeit zum Key/Index verändern, dann geht das mit array_walk und einem zweiten Parameter im Callback. Bei beiden kann natürlich auch “use” verwendet werden. Der Parameter $value wird dabei als Referenz übernommen.

$values = array(
  'a' => 100,
  'b' => 200,
  'c' => 300,
);

array_walk(
  $values,
  function (&$value, $key) {
    if ('b' == $key) {
      $value = 42;
    }
  }
);

echo '<pre>' . print_r($values, true) . '</pre>';

// Ausgabe:
Array
(
  [a] => 100
  [b] => 42
  [c] => 300
)

Ich hoffe, dass ich ein wenig Licht ins Dunkel bringen konnte und “Closure” nun kein geheimnisvolles Zauberwort mehr ist.

Wenn ihr noch gute Ergänzungen oder Anwendungbeispiele habt, dann immer her damit und bitte fleissig kommentieren.

Das Prinzip ist einfach: in der (abstrakten) Basisklasse wird eine leere Methode definiert, die durch eine konkrete Klasse überschrieben werden kann.

Der Vorteil ist recht offensichtlich. Die Methode kann ohne vorherige Prüfung verwendet werden und das spart an vielen Stellen unnötigen Code. Aus meinem ästhetischem Empfinden der richtige Weg.

Aber auch den anderen Weg habe ich auch schon desöfteren gesehen und mein Bauchgefühl hat ja auch nicht immer recht. Vielleicht ist der schöne Weg ja auch der langsamere?

Gefühl ist gut, Zahlen sind besser! Also habe ich schnell drei Testklassen geschrieben und probiere die verschiedenen Möglichkeiten durch.

Variante 1: Wir verlassen uns darauf, dass die Methode aufgerufen werden kann.

<?php
class Test1 {
    public function machWas() {
        $this->machWasAnderes();
    }

    public function machWasAnderes() {
    }
}

Variante 2: Wir prüfen, ob die Methode existiert und finden nichts.

<?php
class Test2 {
    public function machWas() {
        if (method_exists($this, 'machWasAnderes')) {
            $this->machWasAnderes();
        }
    }
}

Variante 3: Wir prüfen, ob die Methode existiert und rufen sie auf.

<?php
class Test3 {
    public function machWas() {
        if (method_exists($this, 'machWasAnderes')) {
            $this->machWasAnderes();
        }
    }

    public function machWasAnderes() {
    }
}

Zum Vergleich habe ich das folgende Script verwendet.

<?php
foreach (array('Test1', 'Test2', 'Test3') as $class) {
    $object = new $class();
    $start = microtime(true);

    for($i=0; $i<100000; $i++) {
        $object->machWas();
    }
    echo $class . ' = ' . round(microtime(true) - $start, 5) . '<br/>';
}

Ausgabe:

Test1 = 0.44767
Test2 = 0.48588
Test3 = 0.70881

In mehreren Durchläufen waren “Test1″ und “Test2″ immer fast gleich auf, nur “Test3″ brauchte etwas länger, weil in der Klasse die Prüfung und die Ausführung der Methode stattfindet.

Fazit: Der Einsatz von Schablonenmethoden lohnt sich doppelt, da der Code übersichtlich bleibt und auch die Geschwindigkeit etwas besser ist.

Der eine oder andere kennt die Funktion vielleicht schon, aber für mich ist sie neu. Daher habe ich damit einfach mal etwas rumprobiert und einen kleinen Codeschipsel dazu gebastelt. Die Apache-Logs können für vielfältige Auswertungen verwendet werden.

Zum Beispiel welche Seiten besucht oder nicht gefunden werden können, zum Tracken von Werbemitteln oder in dem Fall auch zum Protokollieren weiterer PHP-Werte.

In einem früheren Projekt haben wir mal die Zeit und den Speicherverbrauch gemessen die ein PHP-Script braucht, um die Seite auszuliefern. Dazu hatten wir eine einfache Klasse, ähnlich der folgenden (im dem Beispiel wird nur die Zeit gemessen):

class PageBenchmark
{
  private $_startTime;
  private static $_instance;

  protected function __construct()
  {
    register_shutdown_function(array(self::$_instance, 'stop'));
    $this->start();
  }

  protected function __clone() {}

  public function getInstance()
  {
    if (null === self::$_instance) {
      self::$_instance = new self();
    }
    return self::$_instance;
  }

  public function start()
  {
    $this->_startTime = microtime(true);
  }

  public function stop()
  {
    $time = microtime() - $this->_startTime;
    apache_note('worktime', $time);
  }
}

PageBenchmark::getInstance();

Die Klasse ist bewusst einfach gehalten und sollte möglichst ohne weitere Abhängigkeiten funktionieren. Die Verwendung ist dabei recht einfach. Das Script an einer zentralen Stelle möglichst früh einbinden. Durch den Aufruf von getInstance() wird ein Objekt instanziiert und die Methode stop() als Callback registriert.

Wird das Script nun abgearbeitet, wird diese Methode zum Ende aufgerufen und die verbrauchte Zeit wird errechnet und an Apache übergeben.

Damit das ganze dann einen Sinn bekommt, muss die Konfiguration des Webservers noch etwas angepasst werden. Für unser Beispiel schreiben wir die Zeit an das Ende jeder Zeile.

LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" [%{worktime}n]" mylogformat
CustomLog /var/www/sandkasten/logs/access.log mylogformat

Danach natürlich den Webserver neu starten, bzw. ein Reload machen. Ab jetzt sollte zu jedem Logeintrag die verbrauchte Zeit mitgeschrieben werden. Die verwendeten Kürzel werden in der Doku zu mod_log_config erklärt.

Viel Spaß beim Probieren!

Was ist aber eigentlich passiert? Für eine bestimmte Aufgabe musste ich Daten in der SimpleDB (Amazon Webservices) zwischengespeichern und dann an anderer Stelle weiter verarbeitet. Nun passiert es hin und wieder, dass meine Weiterleitung schneller als die Datenbank war und ich die Daten (noch) nicht lesen konnte.

Was macht man in diesem Fall? Abwarten, Tee trinken und nochmal probieren. In dem Fall kamen ein paar Zeilen Code dazu und alles lief wie gewünscht. Wirklich schick ist das jedoch so noch nicht.

Erstmal eine einfach Beipielklasse im PHP-Pseudocode zum besseren Verständnis:

<?php
class SomeWebResource
{
  public function load($key)
  {
    // do something
    return $data;
  }

  public function save($key, $data)
  {
    // do something
    return $flag;
  }

  public function delete($key)
  {
    // do something
    return $flag;
  }
}

In diesem Beispiel hat unsere Klasse drei Methoden, in denen die selben oder zumindest ähnliche Probleme auftreten können. Die Daten haben das falsche Format, der Webservice ist nicht erreichbar oder was auch immer.

Für diesen Fall bauen wir dann nun die Wiederholung ein.

<?php
class SomeWebResource
{
  public function load($key)
  {
    $count = 0;
    do {
      try {
        // do something
        return $data;
      } catch (Exception $e) {
        sleep(1);
      }
    } while (3 > $count++);
  }

  public function save($key, $data)
  {
    $count = 0;
    do {
      try {
        // do something
        return $flag;
      } catch (Exception $e) {
        sleep(1);
      }
    } while (3 > $count++);
  }

  public function delete($key)
  {
    $count = 0;
    do {
      try {
        // do something
        return $flag;
      } catch (Exception $e) {
        sleep(1);
      }
    } while (3 > $count++);
  }
}

Spontan sollten nun jedem mindestens drei Dinge auffallen. Der Code ist gleich um etliche Zeilen länger und wiederholt sich, man könnte fast ein Muster (Pattern) erkennen. Der Code ist nicht wirklich flexibel, wenn es darum geht die Wartezeit oder die Anzahl der Versuche zu konfigurieren. Der Code ist immer da und lässt sich so nicht mehr ohne die Wiederholung ausführen und es ist nicht die Aufgabe dieser Klasse die Wiederholungen zu kontrollieren.

In dem Fall schreit es doch gerade danach, diesen Code recyclebar auszulagern, findet ihr nicht?

Dafür brauchen wir nur eine einfache Proxy-Klasse. Ok, bevor jetzt jemand protestiert, dass sei doch garnicht das Proxy-Pattern, stimmt! Wir leiten die Proxy-Klasse nicht von der Klasse “SomeWebResource” ab und haben dadurch eine andere Schnittstelle. In diesem Fall ist das aber egal, denn wir leiten ja auch nur den Methodenaufruf weiter.

Nun aber erstmal die RetryProxy-Klasse:

<?php
class E7_Tools_RetryProxy
{
  // some other methods

  public function call($callback)
  {
    $exception = null;
    $count = 0;
    $args = func_get_args();
    array_shift($args);

    do {
      try {
        return call_user_func_array($callback, $args);
      } catch (Exception $e) {
        $exception = $e;
        sleep($this->getDelay());
      }
    } while ($this->getRepititions() > $count++);

    if ($exception instanceof Exception) {
      throw $exception;
    }
  }
}

Auch hier lässt sich natürlich das selbe Muster erkennen, aber wir haben es von jeder weitern Logik entkoppelt und die gewünschten Werte lassen sich nun einfach über die Setter einstellen.

Die Verwendung ist später ebenfalls einfach.

<?php
$proxy = new E7_Tools_RetryProxy();
$swr   = new SomeWebResource();
$data  = $proxy->call(array($swr, 'load'), 42);

Wer damit etwas experimentieren will, findet die komplette Klasse hier. Wie immer freue ich mich natürlich über möglichst zahlreiche Kommentare.