universal.adapter

Analyse, Generierung oder auch Manipulation von Java-Programmen zur Laufzeit sind nützliche Technologien in der Java-Softwareentwicklung. Durch diese Funktionen können beispielsweise Programmier-Paradigmen wie die Aspekt-orientierte Programmierung (AOP) realisiert werden. Der Vorgang des Veränderns von Bytecode wird in der Softwaretechnologie auch als Bytecode-Engineering oder Instrumentierung bezeichnet. Eine sinnvolle Erweiterung in Java 5 stellt das Package java.lang.instrument dar, welches eine einfache Integration von Bytecode-Engineering-Mechanismen ermöglicht.

Der Vorteil der Bytecode-Manipulation besteht darin, dass kein erneutes Compilieren des Quellcodes notwendig ist. Ebenso vorteilhaft ist, dass der Quellcode eines Programmes nicht zwangsläufig zur Manipulation vorhanden sein muss. Je nach Lizenz eines Softwareproduktes ist ein Zugang zum Quellcode zuweilen gar nicht möglich. Neben der Veränderung von Java Bytecode ist es genauso auch möglich, mittels Bytecode-Engineering Klassen komplett neu zu generieren. In diesem Fall würde man die Notwendigkeit eines Compilers komplett umgehen.

Durch Analysieren und Modifizieren des Bytecodes können spezielle Punkte im Programm mit zusätzlicher Funktionalität versehen oder verändert werden. Ein einfaches Beispiel dafür ist das Einfügen von Zeitstempel-Ausgaben an bestimmten Programmpunkten zur Zeitmessung.

Zur Einbindung von Bytecode-Engineering in ein System stellen sich zwei gegensätzliche Ansätze heraus:

Bei der statischen Instrumentierung wird eine class-Datei lediglich einmal instrumentiert und anschließend gespeichert. Diese Variante ist jedoch nicht immer möglich bzw. auch nicht in jedem Falle ausreichend, da sich gegebenenfalls auch die Art der Instrumentierung ändern könnte. Weiterhin ist es sinnvoller, statische Veränderungen am Quellcode direkt vorzunehmen.

Die dynamische Instrumentierung ist das Bearbeiten vorhandenen Bytecodes jeweils zur Ladezeit einer Klasse. Da Bytecode-Engineering im Gegensatz zur Verwendung eines Compilers erhebliche Vorteile bei der Performanz bietet, ist eine sinnvolle Verwendung des dynamischen Instrumentierens zur Laufzeit eines Programmes durchaus möglich.
Die Einbindung eines Instrumentierungs-Mechanismus, welcher beispielsweise mittels eines der im Artikel über Bytecode-Engineering vorgestellten Frameworks realisiert werden kann, ist am einfachsten mit dem seit Java 5 vorhandenen Package java.lang.instrumentmöglich.

Der erste notwendige Schritt ist die Implementierung einer so genannten premain()-Methode. Wie der Name vermuten lässt, wird diese noch vor der eigentlichen main()-Methode aufgerufen. Die Klasse, die diese Methode enthält, wird auch als Agentenklasse oder als Agent bezeichnet. Die premain()-Methode hat zwei Argumente: einen String mit den Parametern für die Agentenklasse und eine Instanz der Klasse Instrumentation. Dieser Instanz können nun Objekte vom Typ ClassFileTransformer mittels addTransformer() übergeben werden:

public static void premain(String agentArgs, Instrumentation inst)
{
    inst.addTransformer( new MyClassFileTransformer() );
}

Eine Klasse, welche das Interface ClassFileTransformer implementiert, muss die abstrakte Methode transform() implementieren. Dieser Methode wird unter anderem das ursprüngliche Byte-Array der zu ladenden Klasse übergeben. Nun kann dieses Byte-Array nach eigenem Bedarf verändert werden. Hier sei wieder auf die bereits vorgestellten Frameworks zur Bytecode-Manipulation verwiesen. Der Rückgabewert der transform()-Methode ist letztendlich wieder ein Byte-Array, welches den instrumentierten Bytecode enthält:

public byte[] transform(ClassLoader loader,
                        String className,
                        Class<?> classBeingRedefined,
                        ProtectionDomain protectionDomain,
                        byte[] classfileBuffer )
                        throws IllegalClassFormatException
{
    byte[] result = modify(classfileBuffer);
    return result;
}

Um den Instrumentierungsmechanismus mittels des Agenten und der darin implementierten premain()-Methode überhaupt nutzen zu können, bedarf es weiterer Schritte. Die erste Notwendigkeit besteht darin, die AgentClassund die instrumentierenden Klassen in eine jar-Datei zu packen. Diesem Archiv ist in seiner Manifest-Datei der folgende Parameter hinzuzufügen:

Premain-Class: <agentpackage.AgentClass>

Dieser Parameter zeigt auf die Agenten-Klasse, welche die premain()-Methode implementiert.

Für die Einbindung der Instrumentierung mittels des erstellten Archivs ist dieses Archiv der JVM als Agenten-Argument mitzuteilen. Dies geschieht über das JVM-Argument

-javaagent:<agentarchive>.jar

Damit werden alle Klassen vor ihrer Initialisierung dem ClassFileTransformer übergeben, der dann die Instrumentierung durchführen kann.

Der Instrumentierungsmechanismus des Packages java.lang.instrument setzt am ClassLoader der Applikation, also direkt nach dem System-ClassLoader an. Daraus resultiert, dass viele Klassen beim Laden in der transform()-Methode der Instrumentierung unterworfen werden. Dazu zählen teilweise auch Klassen aus den Packages java.utilund java.lang. Es ist somit sinnvoll, an geeigneter Stelle, wie etwa in einem Property-File, festzulegen, welche Klassen instrumentiert werden dürfen und welche nicht.

Um gleich loslegen zu können, ist hier eine Beispiel-Klasse zu finden, in der das Grundgerüst für eine Instrumentierung bereitgestellt ist. Die modify(byte[])-Methode ist nun der Ansatzpunkt für eigene Implementierungen.