/* * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.lang.instrument; import java.security.ProtectionDomain; /* * Copyright 2003 Wily Technology, Inc. */ /** * A transformer of class files. An agent registers an implementation of this * interface using the {@link Instrumentation#addTransformer addTransformer} * method so that the transformer's {@link * ClassFileTransformer#transform(Module,ClassLoader,String,Class,ProtectionDomain,byte[]) * transform} method is invoked when classes are loaded, * {@link Instrumentation#redefineClasses redefined}, or * {@link Instrumentation#retransformClasses retransformed}. The implementation * should override one of the {@code transform} methods defined here. * Transformers are invoked before the class is defined by the Java virtual * machine. * *
* There are two kinds of transformers, determined by the canRetransform
* parameter of
* {@link java.lang.instrument.Instrumentation#addTransformer(ClassFileTransformer,boolean)}:
*
canRetransform
as true
* canRetransform
as false or where added with
* {@link java.lang.instrument.Instrumentation#addTransformer(ClassFileTransformer)}
*
* Once a transformer has been registered with
* {@link java.lang.instrument.Instrumentation#addTransformer(ClassFileTransformer,boolean)
* 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
* {@link java.lang.ClassLoader#defineClass ClassLoader.defineClass}
* or its native equivalents.
* The request for a class redefinition is made with
* {@link java.lang.instrument.Instrumentation#redefineClasses Instrumentation.redefineClasses}
* or its native equivalents.
* The request for a class retransformation is made with
* {@link java.lang.instrument.Instrumentation#retransformClasses 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:
*
ClassLoader.defineClass
* definitions.getDefinitionClassFile()
where
* definitions
is the parameter to
* {@link java.lang.instrument.Instrumentation#redefineClasses
* Instrumentation.redefineClasses}
*
* 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, * the transformer must support the redefinition 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. * *
* The transformers can define additional classes when a class is * being transformed via {@link ClassDefiner#defineClass(byte[]) * ClassDefiner.defineClass}. They will be defined to the same class loader and * the same protection domain as the class being transformed. * *
* If the transformer throws an exception (which it doesn't catch),
* subsequent transformers will still be called and the load, redefine
* or retransform will still be attempted.
* Thus, throwing an exception has the same effect as returning {@code null}.
* To prevent unexpected behavior when unchecked exceptions are generated
* in transformer code, a transformer can catch Throwable
.
* If the transformer believes the classFileBuffer
does not
* represent a validly formatted class file, it should throw
* an IllegalClassFormatException
;
* while this has the same effect as returning {@code null}, it facilitates the
* logging or debugging of format corruptions.
*
*
* Note the term class file is used as defined in section 3.1 of * The Java™ Virtual Machine Specification, to mean a * sequence of bytes in class file format, whether or not they reside in a * file. * * @see java.lang.instrument.Instrumentation * @since 1.5 */ public interface ClassFileTransformer { /** * A {@code ClassDefiner} provides the mechanism for {@code ClassFileTransformer} * to define additional classes during the * {@linkplain ClassFileTransformer#transform(ClassDefiner, Module, ClassLoader, String, Class, ProtectionDomain, byte[]) * transformation process} of a class. * *
When a {@linkplain ClassFileTransformer#transform(ClassDefiner, Module, ClassLoader, String, Class, ProtectionDomain, byte[]) * transformer} is called to retransform a class, the transformer can call * {@link ClassDefiner#defineClass(byte[])} to define additional classes. * If it is called after {@link ClassFileTransformer#transform(ClassDefiner, Module, ClassLoader, String, Class, ProtectionDomain, byte[]) * ClassFileTransformer.tranform} method returns or called by another * thread, {@code IllegalStateException} will be thrown. * * @since 11 */ static interface ClassDefiner { /** * Defines a class of the given bytes to the runtime. * The given bytes will be defined to the same class loader and in the * same runtime package and * {@linkplain java.security.ProtectionDomain protection domain} as * the class being transformed. * *
No transformation is applied to the bytes passed to this
* {@code ClassDefiner.defineClass} method.
* {@link Instrumentation#retransformClasses(Class[])} can be called
* later to retransform the {@code Class} returned by this method
* if desired.
*
* @param bytes the class bytes
* @return the {@code Class} object for the class
*
* @throws IllegalArgumentException
* the bytes are for a class of a different package than
* the class being transformed
* @throws LinkageError if the class is malformed ({@code ClassFormatError}),
* cannot be verified ({@code VerifyError}), is already defined,
* or another linkage error occurs
* @throws IllegalStateException if this {@code ClassDefiner} is called
* by a thread other than the thread doing the transformation,
* or after all transformers are called.
*/
Class> defineClass(byte[] bytes);
}
/**
* Transforms the given class file and returns a new replacement class file.
* This method is invoked when the {@link Module Module} bearing {@link
* ClassFileTransformer#transform(Module,ClassLoader,String,Class,ProtectionDomain,byte[])
* transform} is not overridden.
*
* @implSpec The default implementation returns null.
*
* @param loader the defining loader of the class to be transformed,
* may be {@code null} if the bootstrap loader
* @param className the name of the class in the internal form of fully
* qualified class and interface names as defined in
* The Java Virtual Machine Specification.
* For example, "java/util/List"
.
* @param classBeingRedefined if this is triggered by a redefine or retransform,
* the class being redefined or retransformed;
* if this is a class load, {@code null}
* @param protectionDomain the protection domain of the class being defined or redefined
* @param classfileBuffer the input byte buffer in class file format - must not be modified
*
* @throws IllegalClassFormatException
* if the input does not represent a well-formed class file
* @return a well-formed class file buffer (the result of the transform),
* or {@code null} if no transform is performed
*
* @revised 9
* @spec JPMS
*/
default byte[]
transform( ClassLoader loader,
String className,
Class> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer)
throws IllegalClassFormatException {
return null;
}
/**
* Transforms the given class file and returns a new replacement class file.
*
* @implSpec The default implementation of this method invokes the
* {@link #transform(ClassLoader,String,Class,ProtectionDomain,byte[]) transform}
* method.
*
* @param module the module of the class to be transformed
* @param loader the defining loader of the class to be transformed,
* may be {@code null} if the bootstrap loader
* @param className the name of the class in the internal form of fully
* qualified class and interface names as defined in
* The Java Virtual Machine Specification.
* For example, "java/util/List"
.
* @param classBeingRedefined if this is triggered by a redefine or retransform,
* the class being redefined or retransformed;
* if this is a class load, {@code null}
* @param protectionDomain the protection domain of the class being defined or redefined
* @param classfileBuffer the input byte buffer in class file format - must not be modified
*
* @throws IllegalClassFormatException
* if the input does not represent a well-formed class file
* @return a well-formed class file buffer (the result of the transform),
* or {@code null} if no transform is performed
*
* @since 9
* @spec JPMS
*/
default byte[]
transform( Module module,
ClassLoader loader,
String className,
Class> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer)
throws IllegalClassFormatException {
// invoke the legacy transform method
return transform(loader,
className,
classBeingRedefined,
protectionDomain,
classfileBuffer);
}
/**
* Transforms the given class file and returns a new replacement class file.
*
*
A {@code ClassFileTransformer} may define additional classes
* to the same class loader and the same runtime package as the class being
* transformed by calling {@link ClassDefiner#defineClass(byte[])}
* classDefiner.defineClass} method. If an attempt to use {@code classDefiner}
* is made after this {@code transform} method returns,
* {@code IllegalStateException} will be thrown.
*
* @implSpec The default implementation of this method invokes the
* {@link #transform(Module,ClassLoader,String,Class,ProtectionDomain,byte[]) transform}
* method.
*
* @param classDefiner a {@code ClassDefiner} that this class transformer
* can define additional classes
* @param module the module of the class to be transformed
* @param loader the defining loader of the class to be transformed,
* may be {@code null} if the bootstrap loader
* @param className the name of the class in the internal form of fully
* qualified class and interface names as defined in
* The Java Virtual Machine Specification.
* For example, "java/util/List"
.
* @param classBeingRedefined if this is triggered by a redefine or retransform,
* the class being redefined or retransformed;
* if this is a class load, {@code null}
* @param protectionDomain the protection domain of the class being defined or redefined
* @param classfileBuffer the input byte buffer in class file format - must not be modified
*
* @throws IllegalClassFormatException
* if the input does not represent a well-formed class file
* @return a well-formed class file buffer (the result of the transform),
* or {@code null} if no transform is performed
*
* @since 11
*/
default byte[]
transform( ClassFileTransformer.ClassDefiner classDefiner,
Module module,
ClassLoader loader,
String className,
Class> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer)
throws IllegalClassFormatException {
// invoke the transform method
return transform(module,
loader,
className,
classBeingRedefined,
protectionDomain,
classfileBuffer);
}
}