The implementation of this method may transform the supplied class file and
return a new replacement class file.
Once a transformer has been registered with
{@link java.lang.instrument.Instrumentation#addTransformer Instrumentation.addTransformer},
the transformer will be called for every new class definition and every class redefinition.
The request for a new class definition is made with
{@link java.lang.ClassLoader#defineClass ClassLoader.defineClass}.
The request for a class redefinition is made with
{@link java.lang.instrument.Instrumentation#redefineClasses Instrumentation.redefineClasses}
or its native equivalents.
The transformer is called during the processing of the request, before the class file bytes
have been verified or applied.
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 redefine case, the transformer must support the redefinition semantics.
If a class that the transformer changed during initial definition is later 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.
