public interface ClassFileTransformer
An agent provides an implementation of this interface in order to transform class files. The transformation occurs before the class is defined by the JVM.
Note the term class file is used as defined in the chapter The class File Format of The Java Virtual Machine Specification , to mean a sequence of bytes in class file format, whether or not they reside in a file.
Method Summary | |
---|---|
byte[] |
transform
(
ClassLoader
loader,
String
className,
Class
<?> classBeingRedefined,
ProtectionDomain
protectionDomain, byte[] classfileBuffer) The implementation of this method may transform the supplied class file and return a new replacement class file. |
Method Detail |
---|
byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException
There are two kinds of transformers, determined by the canRetransform parameter of
Instrumentation.addTransformer(ClassFileTransformer,boolean)
Once a transformer has been registered with
Instrumentation.addTransformer
:
Once a transformer has been registered with
addTransformer
, the transformer will be called for every new class definition and every class redefinition.
Retransformation capable transformers will also be called on every class retransformation.
The request for a new class definition is made with
ClassLoader.defineClass
or its native equivalents.
.
The request for a class redefinition is made with
Instrumentation.redefineClasses
Instrumentation.redefineClasses
or its native equivalents.
The request for a class retransformation is made with
Instrumentation.retransformClasses
or its native equivalents.
The transformer is called during the processing of the request, before the class file bytes have been verified or applied.
When there are multiple transformers, transformations are composed by chaining the transform calls. That is, the byte array returned by one call to transform becomes the input (via the classfileBuffer parameter) to the next call.
Transformations are applied in the following order:
For retransformations, the retransformation incapable transformers are not called, instead the result of the previous transformation is reused. In all other cases, this method is called. Within each of these groupings, transformers are called in the order registered. Native transformers are provided by the ClassFileLoadHook event in the Java Virtual Machine Tool Interface).
The input (via the classfileBuffer parameter) to the first transformer is:
If the implementing method determines that no transformations are needed, it should return null. Otherwise, it should create a new byte[] array, copy the input classfileBuffer into it, along with all desired transformations, and return the new array. The input classfileBuffer must not be modified.
In the
retransform and
redefine
cases,
case,
the transformer must support the redefinition
semantics: if
semantics. If
a class that the transformer changed during initial definition is later
retransformed or
redefined, the transformer must insure that the second class output class file is a legal redefinition of the first output class file.
If the transformer believes the classFileBuffer does not represent a validly formatted class file, it should throw an IllegalClassFormatException. Subsequent transformers will still be called and the load or redefine will still be attempted. Throwing an IllegalClassFormatException thus has the same effect as returning null but facilitates the logging or debugging of format corruptions.