http://www.javassist.org/: Javassist (JAVA programming ASSISTant) makes Java bytecode manipulation simple. It is a class library for editing bytecodes in Java. (Shigeru Chiba, www.javassist.org) 
/*
 * Javassist, a Java-bytecode translator toolkit.
 * Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License.  Alternatively, the contents of this file may be used under
 * the terms of the GNU Lesser General Public License Version 2.1 or later,
 * or the Apache License Version 2.0.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 */

package javassist;

import javassist.CtMethod.ConstParameter;
import javassist.bytecode.AccessFlag;
import javassist.bytecode.Bytecode;
import javassist.bytecode.ConstPool;
import javassist.bytecode.ExceptionsAttribute;
import javassist.bytecode.FieldInfo;
import javassist.bytecode.MethodInfo;
import javassist.compiler.CompileError;
import javassist.compiler.Javac;


A collection of static methods for creating a CtMethod.
An instance of this class does not make any sense.

See Also:
  • addMethod.addMethod(CtMethod)
/**
 * A collection of static methods for creating a <code>CtMethod</code>.
 * An instance of this class does not make any sense.
 *
 * @see CtClass#addMethod(CtMethod)
 */
public class CtNewMethod {

    
Compiles the given source code and creates a method.
The source code must include not only the method body
but the whole declaration, for example,

"public Object id(Object obj) { return obj; }"


Params:
  • src –               the source text.
  • declaring –    the class to which the created method is added.
/**
     * Compiles the given source code and creates a method.
     * The source code must include not only the method body
     * but the whole declaration, for example,
     *
     * <pre>"public Object id(Object obj) { return obj; }"</pre>
     *
     * @param src               the source text. 
     * @param declaring    the class to which the created method is added.
     */
    public static CtMethod make(String src, CtClass declaring)
        throws CannotCompileException
    {
        return make(src, declaring, null, null);
    }

    
Compiles the given source code and creates a method.
The source code must include not only the method body
but the whole declaration, for example,

"public Object id(Object obj) { return obj; }"


If the source code includes $proceed(), then
it is compiled into a method call on the specified object.

Params:
  • src –               the source text.
  • declaring –    the class to which the created method is added.
  • delegateObj –       the source text specifying the object
                         that is called on by $proceed().
  • delegateMethod –    the name of the method
                         that is called by $proceed().
/**
     * Compiles the given source code and creates a method.
     * The source code must include not only the method body
     * but the whole declaration, for example,
     *
     * <pre>"public Object id(Object obj) { return obj; }"</pre>
     *
     * <p>If the source code includes <code>$proceed()</code>, then
     * it is compiled into a method call on the specified object.
     *
     * @param src               the source text. 
     * @param declaring    the class to which the created method is added.
     * @param delegateObj       the source text specifying the object
     *                          that is called on by <code>$proceed()</code>.
     * @param delegateMethod    the name of the method
     *                          that is called by <code>$proceed()</code>.
     */
    public static CtMethod make(String src, CtClass declaring,
                                String delegateObj, String delegateMethod)
        throws CannotCompileException
    {
        Javac compiler = new Javac(declaring);
        try {
            if (delegateMethod != null)
                compiler.recordProceed(delegateObj, delegateMethod);

            CtMember obj = compiler.compile(src);
            if (obj instanceof CtMethod)
                return (CtMethod)obj;
        }
        catch (CompileError e) {
            throw new CannotCompileException(e);
        }

        throw new CannotCompileException("not a method");
    }

    
Creates a public (non-static) method.  The created method cannot
be changed to a static method later.

Params:
  • returnType –        the type of the returned value.
  • mname –             the method name.
  • parameters –        a list of the parameter types.
  • exceptions –        a list of the exception types.
  • body –              the source text of the method body.
                 It must be a block surrounded by {}.
                 If it is null, the created method
                 does nothing except returning zero or null.
  • declaring –    the class to which the created method is added.
See Also:
/**
     * Creates a public (non-static) method.  The created method cannot
     * be changed to a static method later.
     *
     * @param returnType        the type of the returned value.
     * @param mname             the method name.
     * @param parameters        a list of the parameter types.
     * @param exceptions        a list of the exception types.
     * @param body              the source text of the method body.
     *                  It must be a block surrounded by <code>{}</code>.
     *                  If it is <code>null</code>, the created method
     *                  does nothing except returning zero or null.
     * @param declaring    the class to which the created method is added.
     * @see #make(int, CtClass, String, CtClass[], CtClass[], String, CtClass)
     */
    public static CtMethod make(CtClass returnType,
                                String mname, CtClass[] parameters,
                                CtClass[] exceptions,
                                String body, CtClass declaring)
        throws CannotCompileException
    {
        return make(Modifier.PUBLIC, returnType, mname, parameters, exceptions,
                    body, declaring);
    }

    
Creates a method.  modifiers can contain
Modifier.STATIC.

Params:
  • modifiers –         access modifiers.
  • returnType –        the type of the returned value.
  • mname –             the method name.
  • parameters –        a list of the parameter types.
  • exceptions –        a list of the exception types.
  • body –              the source text of the method body.
                 It must be a block surrounded by {}.
                 If it is null, the created method
                 does nothing except returning zero or null.
  • declaring –    the class to which the created method is added.
See Also:
/**
     * Creates a method.  <code>modifiers</code> can contain
     * <code>Modifier.STATIC</code>.
     *
     * @param modifiers         access modifiers.
     * @param returnType        the type of the returned value.
     * @param mname             the method name.
     * @param parameters        a list of the parameter types.
     * @param exceptions        a list of the exception types.
     * @param body              the source text of the method body.
     *                  It must be a block surrounded by <code>{}</code>.
     *                  If it is <code>null</code>, the created method
     *                  does nothing except returning zero or null.
     * @param declaring    the class to which the created method is added.
     *
     * @see Modifier
     */
    public static CtMethod make(int modifiers, CtClass returnType,
                                String mname, CtClass[] parameters,
                                CtClass[] exceptions,
                                String body, CtClass declaring)
        throws CannotCompileException
    {
        try {
            CtMethod cm
                = new CtMethod(returnType, mname, parameters, declaring);
            cm.setModifiers(modifiers);
            cm.setExceptionTypes(exceptions);
            cm.setBody(body);
            return cm;
        }
        catch (NotFoundException e) {
            throw new CannotCompileException(e);
        }
    }

    
Creates a copy of a method. This method is provided for creating a new method based on an existing method. This is a convenience method for calling this constructor. See the description of the constructor for particular behavior of the copying. 
Params:
  • src –       the source method.
  • declaring –    the class to which the created method is added.
  • map –       the hash table associating original class names
                 with substituted names.
                 It can be null.
See Also:
/**
     * Creates a copy of a method.  This method is provided for creating
     * a new method based on an existing method.
     * This is a convenience method for calling
     * {@link CtMethod#CtMethod(CtMethod, CtClass, ClassMap) this constructor}.
     * See the description of the constructor for particular behavior of the copying.
     *
     * @param src       the source method.
     * @param declaring    the class to which the created method is added.
     * @param map       the hash table associating original class names
     *                  with substituted names.
     *                  It can be <code>null</code>.
     *
     * @see CtMethod#CtMethod(CtMethod,CtClass,ClassMap)
     */
    public static CtMethod copy(CtMethod src, CtClass declaring,
                                ClassMap map) throws CannotCompileException {
        return new CtMethod(src, declaring, map);
    }

    
Creates a copy of a method with a new name. This method is provided for creating a new method based on an existing method. This is a convenience method for calling this constructor. See the description of the constructor for particular behavior of the copying. 
Params:
  • src –       the source method.
  • name –      the name of the created method.
  • declaring –    the class to which the created method is added.
  • map –       the hash table associating original class names
                 with substituted names.
                 It can be null.
See Also:
/**
     * Creates a copy of a method with a new name.
     * This method is provided for creating
     * a new method based on an existing method.
     * This is a convenience method for calling
     * {@link CtMethod#CtMethod(CtMethod, CtClass, ClassMap) this constructor}.
     * See the description of the constructor for particular behavior of the copying.
     *
     * @param src       the source method.
     * @param name      the name of the created method.
     * @param declaring    the class to which the created method is added.
     * @param map       the hash table associating original class names
     *                  with substituted names.
     *                  It can be <code>null</code>.
     *
     * @see CtMethod#CtMethod(CtMethod,CtClass,ClassMap)
     */
    public static CtMethod copy(CtMethod src, String name, CtClass declaring,
                                ClassMap map) throws CannotCompileException {
        CtMethod cm = new CtMethod(src, declaring, map);
        cm.setName(name);
        return cm;
    }

    
Creates a public abstract method.

Params:
  • returnType –        the type of the returned value
  • mname –             the method name
  • parameters –        a list of the parameter types
  • exceptions –        a list of the exception types
  • declaring –    the class to which the created method is added.
See Also:
/**
     * Creates a public abstract method.
     *
     * @param returnType        the type of the returned value
     * @param mname             the method name
     * @param parameters        a list of the parameter types
     * @param exceptions        a list of the exception types
     * @param declaring    the class to which the created method is added.
     *
     * @see CtMethod#CtMethod(CtClass,String,CtClass[],CtClass)
     */
    public static CtMethod abstractMethod(CtClass returnType,
                                          String mname,
                                          CtClass[] parameters,
                                          CtClass[] exceptions,
                                          CtClass declaring)
        throws NotFoundException
    {
        CtMethod cm = new CtMethod(returnType, mname, parameters, declaring);
        cm.setExceptionTypes(exceptions);
        return cm;
    }

    
Creates a public getter method.  The getter method returns the value
of the specified field in the class to which this method is added.
The created method is initially not static even if the field is
static.  Change the modifiers if the method should be static.

Params:
  • methodName –        the name of the getter
  • field –             the field accessed.
/**
     * Creates a public getter method.  The getter method returns the value
     * of the specified field in the class to which this method is added.
     * The created method is initially not static even if the field is
     * static.  Change the modifiers if the method should be static.
     *
     * @param methodName        the name of the getter
     * @param field             the field accessed.
     */
    public static CtMethod getter(String methodName, CtField field)
        throws CannotCompileException
    {
        FieldInfo finfo = field.getFieldInfo2();
        String fieldType = finfo.getDescriptor();
        String desc = "()" + fieldType;
        ConstPool cp = finfo.getConstPool();
        MethodInfo minfo = new MethodInfo(cp, methodName, desc);
        minfo.setAccessFlags(AccessFlag.PUBLIC);

        Bytecode code = new Bytecode(cp, 2, 1);
        try {
            String fieldName = finfo.getName();
            if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) {
                code.addAload(0);
                code.addGetfield(Bytecode.THIS, fieldName, fieldType);
            }
            else
                code.addGetstatic(Bytecode.THIS, fieldName, fieldType);

            code.addReturn(field.getType());
        }
        catch (NotFoundException e) {
            throw new CannotCompileException(e);
        }

        minfo.setCodeAttribute(code.toCodeAttribute());
        CtClass cc = field.getDeclaringClass();
        // a stack map is not needed.
        return new CtMethod(minfo, cc);
    }

    
Creates a public setter method.  The setter method assigns the
value of the first parameter to the specified field
in the class to which this method is added.
The created method is not static even if the field is
static.  You may not change it to be static
by setModifiers() in CtBehavior.

Params:
  • methodName –        the name of the setter
  • field –             the field accessed.
/**
     * Creates a public setter method.  The setter method assigns the
     * value of the first parameter to the specified field
     * in the class to which this method is added.
     * The created method is not static even if the field is
     * static.  You may not change it to be static
     * by <code>setModifiers()</code> in <code>CtBehavior</code>.
     *
     * @param methodName        the name of the setter
     * @param field             the field accessed.
     */
    public static CtMethod setter(String methodName, CtField field)
        throws CannotCompileException
    {
        FieldInfo finfo = field.getFieldInfo2();
        String fieldType = finfo.getDescriptor();
        String desc = "(" + fieldType + ")V";
        ConstPool cp = finfo.getConstPool();
        MethodInfo minfo = new MethodInfo(cp, methodName, desc);
        minfo.setAccessFlags(AccessFlag.PUBLIC);

        Bytecode code = new Bytecode(cp, 3, 3);
        try {
            String fieldName = finfo.getName();
            if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) {
                code.addAload(0);
                code.addLoad(1, field.getType());
                code.addPutfield(Bytecode.THIS, fieldName, fieldType);
            }
            else {
                code.addLoad(1, field.getType());
                code.addPutstatic(Bytecode.THIS, fieldName, fieldType);
            }

            code.addReturn(null);
        }
        catch (NotFoundException e) {
            throw new CannotCompileException(e);
        }

        minfo.setCodeAttribute(code.toCodeAttribute());
        CtClass cc = field.getDeclaringClass();
        // a stack map is not needed.
        return new CtMethod(minfo, cc);
    }

    
Creates a method forwarding to a delegate in
a super class.  The created method calls a method specified
by delegate with all the parameters passed to the
created method.  If the delegate method returns a value,
the created method returns that value to the caller.
The delegate method must be declared in a super class.

The following method is an example of the created method.

int f(int p, int q) {
    return super.f(p, q);
}


The name of the created method can be changed by
setName().

Params:
  • delegate –    the method that the created method forwards to.
  • declaring –         the class to which the created method is
                         added.
/**
     * Creates a method forwarding to a delegate in
     * a super class.  The created method calls a method specified
     * by <code>delegate</code> with all the parameters passed to the
     * created method.  If the delegate method returns a value,
     * the created method returns that value to the caller.
     * The delegate method must be declared in a super class.
     *
     * <p>The following method is an example of the created method.
     *
     * <pre>
     * int f(int p, int q) {
     *     return super.f(p, q);
     * }</pre>
     *
     * <p>The name of the created method can be changed by
     * <code>setName()</code>.
     *
     * @param delegate    the method that the created method forwards to.
     * @param declaring         the class to which the created method is
     *                          added.
     */
    public static CtMethod delegator(CtMethod delegate, CtClass declaring)
        throws CannotCompileException
    {
        try {
            return delegator0(delegate, declaring);
        }
        catch (NotFoundException e) {
            throw new CannotCompileException(e);
        }
    }

    private static CtMethod delegator0(CtMethod delegate, CtClass declaring)
        throws CannotCompileException, NotFoundException
    {
        MethodInfo deleInfo = delegate.getMethodInfo2();
        String methodName = deleInfo.getName();
        String desc = deleInfo.getDescriptor();
        ConstPool cp = declaring.getClassFile2().getConstPool();
        MethodInfo minfo = new MethodInfo(cp, methodName, desc);
        minfo.setAccessFlags(deleInfo.getAccessFlags());

        ExceptionsAttribute eattr = deleInfo.getExceptionsAttribute();
        if (eattr != null)
            minfo.setExceptionsAttribute(
                                (ExceptionsAttribute)eattr.copy(cp, null));

        Bytecode code = new Bytecode(cp, 0, 0);
        boolean isStatic = Modifier.isStatic(delegate.getModifiers());
        CtClass deleClass = delegate.getDeclaringClass();
        CtClass[] params = delegate.getParameterTypes();
        int s;
        if (isStatic) {
            s = code.addLoadParameters(params, 0);
            code.addInvokestatic(deleClass, methodName, desc);
        }
        else {
            code.addLoad(0, deleClass);
            s = code.addLoadParameters(params, 1);
            code.addInvokespecial(deleClass, methodName, desc);
        }

        code.addReturn(delegate.getReturnType());
        code.setMaxLocals(++s);
        code.setMaxStack(s < 2 ? 2 : s); // for a 2-word return value
        minfo.setCodeAttribute(code.toCodeAttribute());
        // a stack map is not needed. 
        return new CtMethod(minfo, declaring);
    }

    
Creates a wrapped method.  The wrapped method receives parameters
in the form of an array of Object.

The body of the created method is a copy of the body of the method
specified by body.  However, it is wrapped in
parameter-conversion code.

The method specified by body must have this singature:

Object method(Object[] params, <type> cvalue)


The type of the cvalue depends on
constParam.
If constParam is null, the signature
must be:

Object method(Object[] params)


The method body copied from body is wrapped in
parameter-conversion code, which converts parameters specified by
parameterTypes into an array of Object.
The returned value is also converted from the Object
type to the type specified by returnType.  Thus,
the resulting method body is as follows:

Object[] params = new Object[] { p0, p1, ... };
<type> cvalue = <constant-value>;
 ... copied method body ...
Object result = <returned value>
return (<returnType>)result;



The variables p0, p2, ... represent
formal parameters of the created method.
The value of cvalue is specified by
constParam.

If the type of a parameter or a returned value is a primitive
type, then the value is converted into a wrapper object such as
java.lang.Integer.  If the type of the returned value
is void, the returned value is discarded.

Example:

ClassPool pool = ... ;
CtClass vec = pool.makeClass("intVector");
vec.setSuperclass(pool.get("java.util.Vector"));
CtMethod addMethod = pool.getMethod("Sample", "add0");
CtClass[] argTypes = { CtClass.intType };
CtMethod m = CtNewMethod.wrapped(CtClass.voidType, "add", argTypes,
                                 null, addMethod, null, vec);
vec.addMethod(m);


where the class Sample is as follows:

public class Sample extends java.util.Vector {
    public Object add0(Object[] args) {
        super.addElement(args[0]);
        return null;
    }
}


This program produces a class intVector:

public class intVector extends java.util.Vector {
    public void add(int p0) {
        Object[] args = new Object[] { p0 };
        // begin of the copied body
        super.addElement(args[0]);
        Object result = null;
        // end
    }
}


Note that the type of the parameter to add() depends
only on the value of argTypes passed to
CtNewMethod.wrapped().  Thus, it is easy to
modify this program to produce a
StringVector class, which is a vector containing
only String objects, and other vector classes.

Params:
  • returnType –        the type of the returned value.
  • mname –             the method name.
  • parameterTypes –    a list of the parameter types.
  • exceptionTypes –    a list of the exception types.
  • body –              the method body
                         (must not be a static method).
  • constParam –        the constant parameter
                         (maybe null).
  • declaring –         the class to which the created method is
                         added.
/**
     * Creates a wrapped method.  The wrapped method receives parameters
     * in the form of an array of <code>Object</code>.
     *
     * <p>The body of the created method is a copy of the body of the method
     * specified by <code>body</code>.  However, it is wrapped in
     * parameter-conversion code.
     *
     * <p>The method specified by <code>body</code> must have this singature:
     *
     * <pre>Object method(Object[] params, &lt;type&gt; cvalue)</pre>
     *
     * <p>The type of the <code>cvalue</code> depends on
     * <code>constParam</code>.
     * If <code>constParam</code> is <code>null</code>, the signature
     * must be:
     *
     * <pre>Object method(Object[] params)</pre>
     *
     * <p>The method body copied from <code>body</code> is wrapped in
     * parameter-conversion code, which converts parameters specified by
     * <code>parameterTypes</code> into an array of <code>Object</code>.
     * The returned value is also converted from the <code>Object</code>
     * type to the type specified by <code>returnType</code>.  Thus,
     * the resulting method body is as follows:
     *
     * <pre>
     * Object[] params = new Object[] { p0, p1, ... };
     * &lt;<i>type</i>&gt; cvalue = &lt;<i>constant-value</i>&gt;;
     *  <i>... copied method body ...</i>
     * Object result = &lt;<i>returned value</i>&gt;
     * return (<i>&lt;returnType&gt;</i>)result;
     * </pre>
     *
     * <p>The variables <code>p0</code>, <code>p2</code>, ... represent
     * formal parameters of the created method.
     * The value of <code>cvalue</code> is specified by
     * <code>constParam</code>.
     *
     * <p>If the type of a parameter or a returned value is a primitive
     * type, then the value is converted into a wrapper object such as
     * <code>java.lang.Integer</code>.  If the type of the returned value
     * is <code>void</code>, the returned value is discarded.
     *
     * <p><i>Example:</i>
     *
     * <pre>
     * ClassPool pool = ... ;
     * CtClass vec = pool.makeClass("intVector");
     * vec.setSuperclass(pool.get("java.util.Vector"));
     * CtMethod addMethod = pool.getMethod("Sample", "add0");
     *
     * CtClass[] argTypes = { CtClass.intType };
     * CtMethod m = CtNewMethod.wrapped(CtClass.voidType, "add", argTypes,
     *                                  null, addMethod, null, vec);
     * vec.addMethod(m);</pre>
     *
     * <p>where the class <code>Sample</code> is as follows:
     *
     * <pre>public class Sample extends java.util.Vector {
     *     public Object add0(Object[] args) {
     *         super.addElement(args[0]);
     *         return null;
     *     }
     * }</pre>
     *
     * <p>This program produces a class <code>intVector</code>:
     *
     * <pre>public class intVector extends java.util.Vector {
     *     public void add(int p0) {
     *         Object[] args = new Object[] { p0 };
     *         // begin of the copied body
     *         super.addElement(args[0]);
     *         Object result = null;
     *         // end
     *     }
     * }</pre>
     *
     * <p>Note that the type of the parameter to <code>add()</code> depends
     * only on the value of <code>argTypes</code> passed to
     * <code>CtNewMethod.wrapped()</code>.  Thus, it is easy to
     * modify this program to produce a
     * <code>StringVector</code> class, which is a vector containing
     * only <code>String</code> objects, and other vector classes.
     *
     * @param returnType        the type of the returned value.
     * @param mname             the method name.
     * @param parameterTypes    a list of the parameter types.
     * @param exceptionTypes    a list of the exception types.
     * @param body              the method body
     *                          (must not be a static method).
     * @param constParam        the constant parameter
     *                          (maybe <code>null</code>).
     * @param declaring         the class to which the created method is
     *                          added.
     */
    public static CtMethod wrapped(CtClass returnType,
                                   String mname,
                                   CtClass[] parameterTypes,
                                   CtClass[] exceptionTypes,
                                   CtMethod body, ConstParameter constParam,
                                   CtClass declaring)
        throws CannotCompileException
    {
        return CtNewWrappedMethod.wrapped(returnType, mname, parameterTypes,
                        exceptionTypes, body, constParam, declaring);
    }
}