Ein Profiler kann bei vielen komplexen Entwicklungen helfen, rechenintensive Schwachstellen aufzuspüren. Dazu protokolliert er die Zeit zwischen Ausführungsbeginn und Ausführungsende eines Funktionsaufrufs. Um nun eine spezifische Komponente einem solchen Profiling zu unterziehen, wäre es nötig an Ort und Stelle entsprechende Codezeilen zur Zeitberechnung zu hinterlegen, bestenfalls durch den Aufruf einer ausgelagerten Methode. Der Code der Komponente ist damit jedoch unweigerlich mit Programmzeilen verstrickt, die nicht zur Kernlogik der Komponente beitragen. Durch den Einsatz eines Programmierparadigmas, wie dem der Aspektorientierten Programmierung [1], ist es möglich, diesen Umstand zu umgehen und eine klare Aufteilung aller Komponenten in ihre jeweiligen Dömanen vorzunehmen. Fremdartige Aspekte wie das Profiling werden der Komponente dann zur Laufzeit hinzugefügt.

Im Sinne von AOP werden Aspekte, die nicht unmittelbar zur Domäne des Programms gehören, auch als „cross-cutting concerns“ bezeichnet. Die Klasse, auf die diese concerns angewandt werden, heißt „target-class“.

Der Begriff „Advice“ lässt sich darüber hinaus nach seinem Ausführungszeitpunkt unterteilen:

Ein Aspekt wie Profiling wird in FLOW3 durch eine reguläre PHP-Klasse beschrieben, die eine beliebige Anzahl an Pointcuts, Introductions und Advices beinhaltet. Sie muss in ihrem Kommentar lediglich mittels „@aspect“ als Aspekt getagged werden. Zuvor sollte jedoch der seit PHP 5.3.0 eingeführte Namensraum für die Klasse gesetzt werden. Dieser entspricht in der Regel dem Namensraum für das Paket, dem der Aspekt angehört (hier: SomePackage).

namespace F3::SomePackage;
/**
 * Profiling Aspect
 * @aspect
 */
class ProfilingAspect{}

Da der Profiler in diesem Beispiel darauf basieren wird, die Zeit vor und nach einem Methodenaufruf der target-class zu messen, sollte zunächst ein Schnittpunkt definiert werden, der für diese Aufrufe zutrifft. Um einen solchen Pointcut zu definieren, wird eine leere Methode angelegt, die in ihrem Kommentar die entsprechende Pointcut-Expression enthält. Diese Expression nutzt ebenfalls die neue Namespace-Syntax und besteht jeweils aus einem Bezeichner und seinen Parametern, die reguläre Ausdrücke beinhalten können. Derzeit sind die folgenden fünf Bezeichner verfügbar:

Ein geeigneter Pointcut für den Profiler aus diesem Beispiel stellt einen Schnittpunkt für alle Methodenaufrufe dar, die innerhalb des Pakets „SomePackage“ stattfinden:

/**
* @pointcut method(F3::SomePackage::.*->.*())
*/
public function allMethodsInPackagePointcut() {}

Ein weiterer Pointcut für alle Methoden desselben Pakets, die mit „find“ beginnen und der Klasse „SomeClass“ angehören, könnte so aussehen:

/**
 * @pointcut method(F3::SomePackage::SomeClass->find.*())
 */
public function someClassFindMethodsPointcut() {}

Die soeben definierten Pointcuts lassen sich nun dazu nutzen, Advices wie die Zeitmessung darin einzuhängen. Diese werden ähnlich wie Pointcuts definiert. Sie bestehen wieder aus einer Pointcut-Expression im Kommentar und einer Methode. Jedoch kann diese nun mit Kommandos befüllt werden. In ihrer Pointcut-Expression wird dabei auf die zuvor definierten Pointcuts verwiesen. Anstelle eines Pointcuts kann hier auch eine direkte Referenz auf einen Methodenaufruf beschrieben werden. Der Methode eines Advices kann ein Join Point des Typs „F3::FLOW3::AOPJoinPointInterface“ übergeben werden, der automatisch von FLOW3 bereitgestellt wird. Dieses Interface stellt nun neun Methoden zur Verfügung, mit denen Informationen über die Zielklasse und die Methode, die es zu beeinflussen gilt, eingeholt werden können:

• getProxy()
• getClassName()
• getMethodName()
• getMethodArguments()
• getMethodArgument($argumentName)
• isMethodArgument($argumentName)
• getAdviceChain()
• getException()
• getResult()

Im Falle des Profilers bietet es sich an, einen Around advice zu definieren, der das Ergebnis seiner Zeitmessung in ein Logfile schreibt. Zuvor muss jedoch erst ein geeigneter Logger eingebunden werden – idealerweise im Konstruktor des Aspekts:

/**
 * @var F3::FLOW3::Log::LoggerInterface Instanz des Loggers
 */
protected $logger;
/**
 * Konstruktor-Methode des Aspekts
 * 
 * @param F3::FLOW3::Log::LoggerInterface $logger: Instanz eines Loggers
 * @return void 
*/
public function __construct(F3::FLOW3::Log::LoggerInterface $logger) {
	$this->logger = $logger;
}

FLOW3 erkennt hierbei die Typendeklaration „F3::FLOW3::Log::LoggerInterface“ des Parameters „$logger“ und versucht automatisch eine Instanz dieses Typs zu übergeben. Letztendlich kann nun der Advice definiert werden:

/**
 * @around F3::SomePackage::ProfilingAspect->allMethodsInPackagePointcut
 */
public function profileMethods(F3::FLOW3::AOPJoinPointInterface $joinPoint) {
	$beforeTime = microtime(true);
	$result = $joinPoint->getAdviceChain()->proceed($joinPoint);
	$proceedTime = microtime(true) - $beforeTime;
	$this->logger->log('Method Execution Time: ' . $joinPoint->getMethodName() . ' of Class '.$joinPoint->getClassName().' took '.$proceedTime.'ms');
	return $result;
}

FLOW3 verwendet für sein AOP-Framework [2] weder PHP-Extensions, die zusätzlich installiert werden müssen, noch einen Pre-Processor, sondern ausschließlich reines PHP. Dabei wird intensiv auf die Reflection-Klasse zurückgegriffen, um Aspekte, Pointcuts und Advices zu erkennen. FLOW3 erzeugt dann eine Unterklasse der Zielklasse in Form eines dynamischen Proxys. Dieser implementiert eine Methode zum Abfangen von Funktionsaufrufen, auf die ein bestimmter Advice angewandt werden soll. Diese Proxyklasse wird automatisch vom Framework erzeugt und gecached.

Der Autor

Alexander Buch realisiert seit einigen Jahren als Webentwickler bei der S2 INTERMEDIA GmbH zahlreiche TYPO3-Anwendungen. In diesem Umfeld und im Rahmen seiner Facharbeit (TechInsight FLOW3, 90 Seiten, über Softlink abrufbar) am SAE Institute beschäftigt er sich umfassend mit dem Thema PHP und verfolgt aufmerksam die Entwicklung von FLOW3.