Class Loading Revisited

M¨ogliche Untertitel
Was ist eine Klasse?
Wie kommt sie in die VM?
Kann ich sie ¨andern?
2/56

— oder —
Class-Transformer
Eines der bestgeh¨uteten Java-Geheimnisse
2/56

— oder —
Class-Transformer
Eines der bestgeh¨uteten Java-Geheimnisse
— oder —
Wie Sie immer alle Unit-Tests bestehen ;-)
2/56

Referent
Vorstellung Referent
Prof. Informatik (Ostfalia, HS Braunschweig/Wolfenbüttel)
Buchautor (JSF, Seam, JPA, ...)
Mitglied EGs JSR 344 (JSF 2.2) und JSR 338 (JPA 2.1)
Geschäftsführer PMST GmbH
. . .
3/56

Agenda
Agenda
Class Loader
Class Transformer
Redeﬁnition
Retransformation
4/56

Motivation
Motivation
Die schlechte Nachricht:
F¨ur Anwendungsentwickler wenig direkt Verwendbares
Framework-Entwickler kennen das schon ;-)
6/56

Motivation
Motivation
Die schlechte Nachricht:
F¨ur Anwendungsentwickler wenig direkt Verwendbares
Framework-Entwickler kennen das schon ;-)
Die gute Nachricht:
Als interessierter Java-Entwickler lohnt es sich, hinter die
Kulissen zu schauen
Man versteht einiges besser und wird damit besser
Eventuell k¨onnten Sie etwas Spaß haben (siehe Unit-Tests)
6/56

Class-Loader
Class-Loader
oder
Wie kommen die Klassen in die VM?
7/56

Class-Loader
Motivation: Ein Blick hinter die Kulissen
Class-Loader arbeiten im Hintergrund, daher f¨ur
Hello-World-Niveau vernachl¨assigbar
8/56

Class-Loader
F¨ur Java 1.1 gezeigt, dass der FQN nicht reicht: Java is not
type-safe, Vijay Saraswat, AT&T Research, 1997
8/56

Class-Loader
In Java 1.2 neue Class-Loader-Architektur, die seither Bestand
hat
8/56

Class-Loader
hat
Einige Methoden von SDK-Klassen haben Parameter vom Typ
ClassLoader und es gibt Implementierungen der Klasse
ClassLoader
8/56

Class-Loader
hat
Einige Methoden von SDK-Klassen haben Parameter vom Typ
ClassLoader und es gibt Implementierungen der Klasse
ClassLoader
Class-Loader wichtig in Java-EE. Was sagt die Speziﬁkation?
8/56

Class-Loader
Java EE 6 (JSR 316)
EE.8.3 Class Loading Requirements
The Java EE specification purposely does not define the exact
types and arrangements of class loaders that must be used by
a Java EE product. Instead, the specification defines
requirements in terms of what classes must or must not be
visible to components. A Java EE product is free to use
whatever class loaders it chooses to meet these requirements.
Portable applications must not depend on the types of class
loaders used or the hierarchical arrangement of class loaders,
if any. Applications should use the techniques described in
Section EE.8.2.5, “Dynamic Class Loading” if they need to
load classes dynamically.
9/56

Class-Loader
Class-Loader Basics
Die VM
l¨adt
linkt
und initialisiert
Klassen und Interfaces dynamisch
10/56

Class-Loader
Class-Loader Basics
Die VM
lädt
linkt
und initialisiert
Laden: Finden einer Binärdarstellung eines Klassen- oder
Interface-Typs eines bestimmten Namen und Erzeugen der
Klasse/Interface aus dieser Binärdarstellung
10/56

Class-Loader
Class-Loader Basics
Die VM
l¨adt
linkt
und initialisiert
Linking: Einf¨ugen der Klasse/Interface in den aktuellen
Laufzeitzustand der VM, so dass sie verwendet werden kann
10/56

Class-Loader
Class-Loader Basics
Die VM
lädt
linkt
und initialisiert
Linking: Einfügen der Klasse/Interface in den aktuellen
Laufzeitzustand der VM, so dass sie verwendet werden kann
Initialisierung: Ausführen der Initialisierungsmethode
<clinit>
10/56

Class-Loader
Laden und Linken
Laden erzeugt (mit ein paar grundlegenden Pr¨ufungen) ein
Class-Objekt, das aber noch nicht verwendet werden kann
11/56

Class-Loader
Laden und Linken
Laden erzeugt (mit ein paar grundlegenden Pr¨ufungen) ein
Class-Objekt, das aber noch nicht verwendet werden kann
Linken besteht aus weiteren einzelnen Schritten:
Veriﬁcation
Preparation
Resolution
11/56

Class-Loader
Verification
Die Verifikation bestätigt, dass sich die Klasse
”
gutmütig“
verhält und keine Laufzeitprobleme verursacht
12/56

Class-Loader
Verification
”
gutmütig“
Einige dieser Prüfungen:
Constant Pool konsistent
Keine final-Methoden überschrieben
Methoden respektieren Access-Control
Methoden werden mit korrekter Anzahl und Typ von
Parametern aufgerufen
Byte-Code manipuliert Stack nicht
Variablen sind vor Verwendung initialisiert
Variablen werden nur Werte passender Typen zugewiesen
Aufruf des Oberklassenkonstruktors ist erste Anweisung im
Konstruktor
. . .
12/56

Class-Loader
Verification
”
gutmütig“
Einige dieser Prüfungen:
Constant Pool konsistent
Keine final-Methoden überschrieben
Methoden respektieren Access-Control
Methoden werden mit korrekter Anzahl und Typ von
Parametern aufgerufen
Byte-Code manipuliert Stack nicht
Variablen sind vor Verwendung initialisiert
Variablen werden nur Werte passender Typen zugewiesen
Aufruf des Oberklassenkonstruktors ist erste Anweisung im
Konstruktor
. . .
Bei Verletzung wird VerifyError geworfen
12/56

Verﬁcation: K¨urzlich bekannt geworden

Class-Loader
Preparation und Resolution
Preparation:
Vorbereitung, dass Speicher für Klasse alloziert und
Klassenvariablen initialisiert werden können. Initalisierung wird
aber nicht durchgeführt und es wird kein Byte-Code
ausgeführt
14/56

Class-Loader
Preparation:
ausgef¨uhrt
Resolution:
Pr¨uft, dass alle von der Klasse referenzierten Klassen geladen
sind. Falls nicht, werden diese geladen
14/56

Class-Loader
Preparation:
ausgeführt
Resolution:
Wenn alle Klassen geladen sind, wird Initialisierung
(Klassenvariablen und Static-Initializer-Blöcke) durchgeführt
14/56

Class-Loader
Preparation:
ausgeführt
Resolution:
Wenn alle Klassen geladen sind, wird Initialisierung
(Klassenvariablen und Static-Initializer-Blöcke) durchgeführt
Wenn das abgeschlossen ist, steht die Klasse zur Verwendung
bereit
14/56

Class-Loader
API-Doc ClassLoader
public abstract class ClassLoader extends Object
A class loader is an object that is responsible for loading classes.
The class ClassLoader is an abstract class. . . .
Every Class object contains a reference to the ClassLoader that
deﬁned it. . . .
Applications implement subclasses of ClassLoader in order to
extend the manner in which the Java virtual machine dynamically
loads classes.
Class loaders may typically be used by security managers to
indicate security domains.
15/56

API-Doc ClassLoader (cont’d)
The ClassLoader class uses a delegation model to search for classes
and resources. Each instance of ClassLoader has an associated
parent class loader. When requested to ﬁnd a class or resource, a
ClassLoader instance will delegate the search for the class or
resource to its parent class loader before attempting to ﬁnd the
class or resource itself. The virtual machine’s built-in class loader,
called the ”bootstrap class loader”, does not itself have a parent
but may serve as the parent of a ClassLoader instance.
Class loaders that support concurrent loading of classes are known
as parallel capable class loaders and are required to register
themselves at their class initialization time by invoking the
ClassLoader.registerAsParallelCapable method. Note that the
ClassLoader class is registered as parallel capable by default.
However, its subclasses still need to register themselves if they are
parallel capable. In environments in which the delegation model is
not strictly hierarchical, class loaders need to be parallel capable,
. . .

Class-Loader
Class-Loader-Basics zum Zweiten
Henne-Ei-Problem: Erzeugung einer Class-Loader-Instanz
setzt voraus, dass dieser Class-Loader bereits geladen wurde.
Von wem?
17/56

Class-Loader
Von wem?
Der Class-Loader ist eine normale Klasse und leitet von
java.lang.Object ab. Object muss also geladen worden
sein. Von wem?
17/56

Class-Loader
Von wem?
sein. Von wem?
Im API-Doc schon genannt: der Bootstrap-Class-Loader auch
Primordinal Class-Loader genannt
17/56

Class-Loader
Von wem?
sein. Von wem?
Im API-Doc schon genannt: der Bootstrap-Class-Loader auch
Primordinal Class-Loader genannt
Und durch das Delegationsmodell ergibt sich eine Hierarchie:
Alle Class-Loader haben einen Parent außer
Bootstrap-Class-Loader
17/56

Class-Loader
Class-Loader-Hierarchie
Sehr früh bei VM-Start instanziiert
Meist nativ implementiert
Gehört praktisch zur VM
Lädt System-JARs, z.B. rt.jar
Verifiziert nicht
Path-Property: sun.boot.class.path
18/56

Class-Loader
Class-Loader-Hierarchie
Sehr früh bei VM-Start instanziiert
Meist nativ implementiert
Gehört praktisch zur VM
Lädt System-JARs, z.B. rt.jar
Verifiziert nicht
Path-Property: sun.boot.class.path
Extension-Class-Loader
Lädt Standarderweiterungen
Path-Property: java.ext.dirs
Klasse: sun.misc.Launcher$ExtClassLoader
18/56

Class-Loader
Class-Loader-Hierarchie (cont’d)
Application-Class-Loader
L¨adt Anwendungsklassen
In SE der Class-Loader, der die meisten Klassen l¨adt
Path-Property: java.class.path
Klasse: sun.misc.Launcher$AppClassLoader
19/56

Class-Loader
Custom-Class-Loader
Wird in Java-EE ben¨otigt, um Spec zu erf¨ullen
Jeder (Sie?) kann eigenen Class-Loader schreiben
Bekanntes Beispiel: JBoss Modules
19/56

Class-Loader
Custom-Class-Loader
Wird in Java-EE ben¨otigt, um Spec zu erf¨ullen
Jeder (Sie?) kann eigenen Class-Loader schreiben
Bekanntes Beispiel: JBoss Modules
Bootstrap
Extension
Application
Custom: EE Custom: XY
Plattform
Custom
19/56

Kann man das ¨uberpr¨ufen?
Class-Loader-Option der VM: -verbose:class
1: [Opened /usr/lib/jvm/.../jre/lib/rt.jar]
2: [Loaded java.lang.Object from /usr/lib/jvm/.../jre/lib/rt.jar]
3: [Loaded java.io.Serializable from /usr/lib/jvm/.../jre/lib/rt.jar]
12: [Loaded java.lang.ClassLoader from /usr/lib/jvm/.../jre/lib/rt.jar]
55: [Loaded sun.reflect.DelegatingClassLoader from /usr/lib/jvm/.../jre
223: [Loaded java.lang.ClassLoader$3 from /usr/lib/jvm/.../jre/lib/rt.ja
228: [Loaded java.lang.ClassLoader$NativeLibrary from /usr/lib/jvm/.../j
243: [Loaded java.security.SecureClassLoader from /usr/lib/jvm/.../jre/l
244: [Loaded java.net.URLClassLoader from /usr/lib/jvm/.../jre/lib/rt.ja
245: [Loaded sun.misc.Launcher$ExtClassLoader from /usr/lib/jvm/.../jre/
247: [Loaded java.lang.ClassLoader$ParallelLoaders from /usr/lib/jvm/jav
256: [Loaded java.net.URLClassLoader$7 from /usr/lib/jvm/java-1.7.0-open
259: [Loaded sun.misc.Launcher$ExtClassLoader$1 from /usr/lib/jvm/java-1
317: [Loaded sun.misc.Launcher$AppClassLoader from /usr/lib/jvm/java-1.7
318: [Loaded sun.misc.Launcher$AppClassLoader$1 from /usr/lib/jvm/java-1
319: [Loaded java.lang.SystemClassLoaderAction from /usr/lib/jvm/java-1.
321: [Loaded java.net.URLClassLoader$1 from /usr/lib/jvm/java-1.7.0-open
383: [Loaded de.pdbm.simple.Main from file:/home/bernd/lehre/skripte/cla
384: [Loaded java.lang.Void from /usr/lib/jvm/java-1.7.0-openjdk-1.7.0.6
385: Hello World

Class-Loader
Class-Loader-Delegation
ClassLoader ist Oberklasse aller Class-Loader
21/56

Class-Loader
ClassLoader enth¨alt:
private final ClassLoader parent;
21/56

Class-Loader
Ganz nett: Kommentar aus src.zip:
// The parent class loader for delegation
// Note: VM hardcoded the offset of this field, thus all
// new fields must be added *after* it.
21/56

Class-Loader
Und Konstruktor f¨ur Delegation an Parent:
protected ClassLoader(ClassLoader parent)
21/56

Class-Loader
Und Methode
protected Class<?> loadClass(String name,
boolean resolve)
21/56

Class-Loader
Und Methode
protected Class<?> loadClass(String name,
boolean resolve)
Falls Parent null Bootstrap-Class-Loader
21/56

Class-Loader
API-Doc der Methode loadClass()
Loads the class with the specified binary name. The default
implementation of this method searches for classes in the following
order:
1. Invoke findLoadedClass(String) to check if the class has
already been loaded.
2. Invoke the loadClass method on the parent class loader. If the
parent is null the class loader built-in to the virtual machine is
used, instead.
3. Invoke the findClass(String) method to find the class.
If the class was found using the above steps, and the resolve flag is
true, this method will then invoke the resolveClass(Class) method
on the resulting Class object.
22/56

Class-Loader
API-Doc der Methode loadClass()
Loads the class with the specified binary name. The default
implementation of this method searches for classes in the following
order:
1. Invoke findLoadedClass(String) to check if the class has
already been loaded.
2. Invoke the loadClass method on the parent class loader. If the
parent is null the class loader built-in to the virtual machine is
used, instead.
3. Invoke the findClass(String) method to find the class.
If the class was found using the above steps, and the resolve flag is
true, this method will then invoke the resolveClass(Class) method
on the resulting Class object.
Nennt man Parent-First-Strategie
22/56

Class-Loader
Delegation an AppClassLoader
public class Different { main (){
URL url = new URL("file ://.");
URLClassLoader loader1 = new URLClassLoader (new URL []{ url });
URLClassLoader loader2 = new URLClassLoader (new URL []{ url });
System.out.println(loader1.equals(loader2 )); // false
System.out.println(loader1.getParent ()); // AppClassLoader
System.out.println(loader2.getParent ()); // AppClassLoader
Class <?> class1 = loader1.loadClass(CLASS );
System.out.println(Different.class.equals(class1 )); //false
Class <?> class2 = loader2.loadClass(CLASS );
System.out.println(class2.equals(class1 )); // true
System.out.println(class1. getClassLoader ()); // AppClassLoader
System.out.println(class2. getClassLoader ()); // AppClassLoader
23/56

Pre-Main
Pre-Main
oder
Gibt es ein Leben vor main() ?
24/56

Pre-Main Instrumentierung in Java 5
Das Package java.lang.instrument
Das Package java.lang.instrument wurde mit Java 5
eingef¨uhrt
25/56

eingef¨uhrt
Aus dem API-Doc:
”
Provides services that allow Java programming language
agents to instrument programs running on the JVM. The
mechanism for instrumentation is modiﬁcation of the
byte-codes of methods.“
25/56

eingef¨uhrt
Aus dem API-Doc:
”
Wikipedia Instrumentation (computer programming):
”
. . . instrumentation refers to an ability to monitor or measure
the level of a product’s performance, to diagnose errors and to
write trace information. . . .“
25/56

eingef¨uhrt
Aus dem API-Doc:
”
”
Also (nach Wikipedia) gedacht f¨ur’s Monitoring
25/56

eingeführt
Aus dem API-Doc:
”
”
Also (nach Wikipedia) gedacht für’s Monitoring
Lässt sich aber für beliebiges nutzen (z.B. von JPA-Providern)
25/56

Package Specification java.lang.instrument
”
An agent is deployed as a JAR file. An attribute in the JAR file
manifest specifies the agent class which will be loaded to start the
agent. For implementations that support a command-line interface,
an agent is started by specifying an option on the command-line.
Implementations may also support a mechanism to start agents
some time after the VM has started. For example, an
implementation may provide a mechanism that allows a tool to
attach to a running application, and initiate the loading of the
tool’s agent into the running application. The details as to how the
load is initiated, is implementation dependent.“
Zentral: der Agent
26/56

Der Agent
Deployed als Jar-File
27/56

Der Agent
Attribut im Manifest deﬁniert die Agent-Klasse
27/56

Der Agent
Alternativen, um Agent zu starten
27/56

Der Agent
Auf Kommandozeile bei VM-Start (zwingend erforderlich f¨ur
Kommandozeilenimplementierungen)
27/56

Der Agent
Auf Kommandozeile bei VM-Start (zwingend erforderlich für
Kommandozeilenimplementierungen)
Nach VM-Start, z.B. durch nicht näher spezifiziertes Binden
(optional und implementation dependent)
27/56

Pre-Main Agentenstart ¨uber Kommandozeile
Agentenstart ¨uber Kommandozeile
Syntax: -javaagent:jarpath[=options]
28/56

Option mehrfach verwendbar, damit mehrere Agenten
28/56

Manifest des Agenten-Jars muss Attribut Premain-Class
enthalten
28/56

enthalten
Diese Agentenklasse muss premain()-Methode enthalten
28/56

enthalten
Nachdem VM initialisiert ist, werden alle
premain()-Methoden in der Reihenfolge der Optionen
aufgerufen, dann die main()-Methode
28/56

enthalten
Nachdem VM initialisiert ist, werden alle
premain()-Methoden in der Reihenfolge der Optionen
aufgerufen, dann die main()-Methode
Zwei m¨ogliche Signaturen:
public static void premain(String agentArgs ,
Instrumentation inst );
public static void premain(String agentArgs );
Aufruf der zweiten Alternative nur, falls erste nicht existiert
28/56

Agentenstart ¨uber Kommandozeile (cont’d)
Optional agentmain()-Methode zur Verwendung nach
VM-Start
29/56

VM-Start
Falls Start ¨uber Kommandozeile, wird agentmain() nicht
aufgerufen
29/56

VM-Start
aufgerufen
Agent wird ¨uber System-Class-Loader geladen
29/56

VM-Start
aufgerufen
Jeder Agent bekommt seine Parameter ¨uber
agentArgs-Parameter als ein String, d.h. Agent muss selbst
parsen
29/56

VM-Start
aufgerufen
parsen
Falls Agent nicht geladen werden kann oder
premain()-Methode nicht existert, wird VM beendet
29/56

VM-Start
aufgerufen
parsen
Falls Agent nicht geladen werden kann oder
premain()-Methode nicht existert, wird VM beendet
Exceptions der premain()-Methode f¨uhren ebenfalls zum
Beenden der VM
29/56

Was kann man damit machen?
Wie bereits erw¨ahnt: Instrumentieren
30/56

Z.B. um
30/56

Z.B. um
Zu monitoren
30/56

Z.B. um
Zu monitoren
Proxies zu bauen (JPA: Assoziationen, Automatic Dirty
Checking,. . . )
30/56

Z.B. um
Zu monitoren
Checking,. . . )
final Modiﬁer entfernen
30/56

Z.B. um
Zu monitoren
Checking,. . . )
. . .
30/56

Z.B. um
Zu monitoren
Checking,. . . )
. . .
Allgemein: Sinnvolles Verhalten, das nicht im Code steht,
nachtr¨aglich und nur bei Bedarf einbauen
30/56

Beispiel Monitoring: Aufrufhäufigkeit der Methode
public class ClassToMonitor {
public void foo() {
// beliebig
}
}
Aufrufhäufigkeit der Methode foo() soll (auf einfache Art)
gezählt werden
31/56

Beispiel Monitoring: Z¨ahler und Main
public class Monitor {
public static int counter = 0;
}
public class Main {
public static void main(String [] args)
throws Exception {
System.out.println("Zaehler vor Schleife: "
+ Monitor.counter );
ClassToMonitor classToMonitor = new ClassToMonitor ();
for (int i = 0; i < 1000; i++) {
classToMonitor.foo ();
}
System.out.println("Zaehler nach Schleife: "
+ Monitor.counter );
}
}
32/56

Beispiel Monitoring: Der Agent
public class MonitorAgent {
public static void premain(String agentArgs ,
Instrumentation instrumentation ) {
instrumentation
.addTransformer (new MonitorTransformer ());
}
}
Und die MANIFEST.MF
Premain -Class: de.pdbm.MonitorAgent
33/56

Beispiel Monitoring: Instrumentierung mit Javassist
public class MonitorTransformer
implements ClassFileTransformer {
public byte [] transform(ClassLoader loader , String classNa
Class <?> classBeingRedefined , ProtectionDomain protect
byte [] classfileBuffer) throws IllegalClassFormatExcep
if (className.equals("de/pdbm/ ClassToMonitor")) {
ClassPool pool = ClassPool.getDefault ();
try {
CtClass cc = pool.get("de.pdbm. ClassToMonitor");
CtMethod method = cc. getDeclaredMethod ("foo");
method.insertBefore("de.pdbm.Monitor.counter ++;");
return cc.toBytecode ();
} catch ( NotFoundException | CannotCompileException |
...
}
}
return classfileBuffer ; // andere Klassen unveraendert
}
}

Attach-API
Das Attach-API
oder
Wie rede ich mit einer VM ?
35/56

Attach-API Redeﬁnition
Wiederholung Instrumentation-Package
”
. . . Implementations may also support a mechanism to start
agents some time after the VM has started. For example, an
implementation may provide a mechanism that allows a tool to
attach to a running application, and initiate the loading of the
tool’s agent into the running application. The details as to how the
load is initiated, is implementation dependent.“
Achtung: implementierungsabh¨angig
Aber: in HotSpot, JRockit, IBM SDK, SAP SDK vorhanden
Schnittstelle ist die abstrakte Klasse VirtualMachine im
Package com.sun.tools.attach, enthalten in tools.jar
36/56

API-Doc Klasse VirtualMachine
”
A VirtualMachine represents a Java virtual machine to which this
Java virtual machine has attached. The Java virtual machine to
which it is attached is sometimes called the target virtual machine,
or target VM. An application (typically a tool such as a
managemet console or profiler) uses a VirtualMachine to load an
agent into the target VM. For example, a profiler tool written in
the Java Language might attach to a running application and load
its profiler agent to profile the running application. “
Methode attach(<pid>) Fabrikmethode, um angebundene
Instanz zu bekommen
Methode loadAgent(<agent>,<args>), um Agent zu laden
und zu starten (Methode agentmain())
37/56

Agent mit agentmain()
Der Agent
public static void agentmain(String agentArgs ,
Instrumentation inst );
public static void agentmain(String agentArgs );
Im Manifest Attribut Agent-Class auf Klassennamen des
Agenten setzten
Attribut Can-Redefine-Classes auf true, falls redeﬁniert
(neue Klassendeﬁnition)
Attribut Can-Retransform-Classes auf true, falls
transformiert (Byte-Code-Enhancer)
38/56

Beispiel ¨Andern einer Methode und Neuladen
public class ClassToBeRedefined {
public void saySomething () {
System.out.println("foo");
// System.out.println ("bar ");
}
}
39/56

Beispiel ¨Andern einer Methode und Neuladen (cont’d)
public class Agent {
private static Instrumentation instrumentation = null;
public static void agentmain(String agentArgument ,
Instrumentation instrumentation ) {
Agent. instrumentation = instrumentation ;
}
public static void redefineClasses ( ClassDefinition ...
definitions) throws Exc
if (Agent.instrumentation == null) {
throw new RuntimeException ("Agent nicht gestartet. Ins
}
Agent. instrumentation . redefineClasses (definitions );
}
}
40/56

public class Main {
public static void main(String [] args) throws Exception {
ClassToBeRedefined ctbr = new ClassToBeRedefined ();
ctbr.saySomething ();
InputStream is = ctbr.getClass (). getClassLoader ()
// class ClassToBeRedefined
. getResourceAsStream ("dummy");
byte [] classBytes = classInputStreamToByteArray (is);
ClassDefinition classDefinition =
new ClassDefinition (ctbr.getClass (), classBytes );
loadAgent ();
Agent. redefineClasses ( classDefinition );
ctbr.saySomething ();
}
...
41/56

private static void loadAgent () {
String nameOfRunningVM = ManagementFactory
. getRuntimeMXBean (). getName ();
int p = nameOfRunningVM .indexOf(’@’);
String pid = nameOfRunningVM .substring (0, p);
try {
VirtualMachine vm = VirtualMachine.attach(pid);
vm.loadAgent(JAR_FILE_PATH , "");
vm.detach ();
} catch (Exception e) {
throw new RuntimeException (e);
}
}
42/56

Seeing is believing . . .
Demo
43/56

Auszug aus API-Doc für redefineClasses() I
This method is used to replace the definition of a class
without reference to the existing class file bytes, as one might
do when recompiling from source for fix-and-continue
debugging. Where the existing class file bytes are to be
transformed (for example in bytecode instrumentation)
retransformClasses should be used.
This method operates on a set in order to allow
interdependent changes to more than one class at the same
time (a redefinition of class A can require a redefinition of
class B).
44/56

Auszug aus API-Doc für redefineClasses() II
If a redefined method has active stack frames, those active
frames continue to run the bytecodes of the original method.
The redefined method will be used on new invokes.
This method does not cause any initialization except that
which would occur under the customary JVM semantics. In
other words, redefining a class does not cause its initializers to
be run. The values of static variables will remain as they were
prior to the call.
Instances of the redefined class are not affected.
45/56

Auszug aus API-Doc für redefineClasses() III
The redefinition may change method bodies, the constant
pool and attributes. The redefinition must not add, remove or
rename fields or methods, change the signatures of methods,
or change inheritance. These restrictions maybe be lifted in
future versions. The class file bytes are not checked, verified
and installed until after the transformations have been
applied, if the resultant bytes are in error this method will
throw an exception.
46/56

Attach-API Retransformation
Retransformation
Retransformation auch m¨oglich
47/56

Retransformation
Dazu Can-Retransform-Classes im Manifest auf true
setzen
47/56

Retransformation
setzen
Transformer registrieren:
Instrumentation.addTransformer(ClassFileTransformer
transformer)
47/56

Retransformation
setzen
transformer)
Und entsprechende Methode aufrufen:
Instrumentation.retransformClasses(Class<?>...
classes)
47/56

Retransformation
setzen
transformer)
Und entsprechende Methode aufrufen:
Instrumentation.retransformClasses(Class<?>...
classes)
Ja, so einfach ist es wirklich ;-)
47/56

Beispiel
”
Alle JUnit-Tests bestehen“
public class ClassToTest {
public String getTheCanonicalClassName () {
return "Falscher Name";
//return this.getClass().getCanonicalName();
}
public int add(int a, int b) {
return a * b;
//return a + b;
}
}
48/56

Die JUnit-Tests
public class JunitTests {
@Test
public void testClassName () {
ClassToTest ctt = new ClassToTest ();
Assert.assertEquals("Falscher Klassenname",
ClassToTest.class. getCanonicalName (),
ctt. getTheCanonicalClassName ());
}
@Test
public void testAdd () {
ClassToTest ctt = new ClassToTest ();
Assert.assertEquals("Falsche Summe", (3 + 4),
ctt.add(3, 4));
}
}
49/56

Der Transformer
public class JunitTransformer implements ClassFileTransforme
@Override
public byte [] transform(ClassLoader loader , String classNa
Class <?> classBeingRedefined , ProtectionDomain protectionD
byte [] classfileBuffer) throws IllegalClassFormatException
if (className.equals("org/junit/Assert")) {
return transformAssert (); // ohne Exception-Handling
}
// alle anderen Klassen unveraendert zurueckgeben
return classfileBuffer ;
}
...
}
50/56

Der Transformer
private byte [] transformAssert () throws Exception {
ClassPool pool = ClassPool.getDefault ();
CtClass cc = pool.get("org.junit.Assert");
for (CtMethod ctMethod : cc.getMethods ()) {
if (ctMethod.getName (). startsWith("assert")) {
ctMethod.setBody("return;");
} else {
// die anderen (equals(), clone(), wait(), ...)
}
}
return cc.toBytecode ();
}
51/56

Der Agent
public class TransformerAgent {
public static void agentmain(String agentArgs , Instrumenta
instrumentation . addTransformer(new JunitTransformer (), t
Class <?>[] classes = instrumentation . getAllLoadedClasses
for (Class <?> c : classes) {
if (c.getName (). equals("org.junit.Assert")) {
try {
instrumentation . retransformClasses (c);
} catch ( UnmodifiableClassException e) {
e. printStackTrace ();
System.err.println(c + " laesst sich nicht modifiz
}
}
}
}
}
52/56

Und wie besteht man alle Unit-Tests?
public class ClassToTest {
static {
AgentLoader.loadAgent ();
}
public String getTheCanonicalClassName () {
return "Falscher Name";
//return this.getClass().getCanonicalName();
}
public int add(int a, int b) {
return a * b;
//return a + b;
}
}
53/56

Seeing is believing . . .
Demo
54/56

Wozu ?
Erstens: zum Spaß
55/56

Wozu ?
Erstens: zum Spaß
Zweitens: um in Gehaltsverhandlungen einzusteigen ;-)
55/56

Wozu ?
Erstens: zum Spaß
Drittens: um zu lernen
55/56

Wozu ?
Erstens: zum Spaß
Drittens: um zu lernen
Viertens: . . .
55/56

Fragen und Anmerkungen
Fragen und Anmerkungen
56/56

Class Loading Revisited

Weitere ähnliche Inhalte

Mehr von berndmueller (6)

Class Loading Revisited