| Package | Description | 
|---|---|
| javassist | The Javassist Core API. | 
| javassist.bytecode | Bytecode-level API. | 
| javassist.compiler | |
| javassist.convert | |
| javassist.expr | This package contains the classes for modifying a method body. | 
| javassist.scopedpool | A custom class pool for several JBoss products. | 
| javassist.tools | Covenient tools. | 
| javassist.tools.reflect | Runtime Behavioral Reflection. | 
| javassist.tools.rmi | Sample implementation of remote method invocation. | 
| javassist.tools.web | Simple web server for running sample code. | 
| javassist.util.proxy | Dynamic proxy (similar to  Enhancerof cglib). | 
| Modifier and Type | Method and Description | 
|---|---|
| void | CtBehavior. addCatch(String src,
        CtClass exceptionType)Adds a catch clause that handles an exception thrown in the
 body. | 
| void | CtBehavior. addCatch(String src,
        CtClass exceptionType,
        String exceptionName)Adds a catch clause that handles an exception thrown in the
 body. | 
| void | CtClass. addConstructor(CtConstructor c)Adds a constructor. | 
| void | CtClass. addField(CtField f)Adds a field. | 
| void | CtClass. addField(CtField f,
        CtField.Initializer init)Adds a field with an initial value. | 
| void | CtClass. addField(CtField f,
        String init)Adds a field with an initial value. | 
| void | CtBehavior. addLocalVariable(String name,
                CtClass type)Declares a new local variable. | 
| void | CtClass. addMethod(CtMethod m)Adds a method. | 
| void | CtBehavior. addParameter(CtClass type)Appends a new parameter, which becomes the last parameter. | 
| void | Loader. addTranslator(ClassPool cp,
             Translator t)Adds a translator, which is called whenever a class is loaded. | 
| static long | SerialVersionUID. calculateDefault(CtClass clazz)Calculate default value. | 
| boolean | CtConstructor. callsSuper()Returns true if this constructor calls a constructor
 of the super class. | 
| static CtConstructor | CtNewConstructor. copy(CtConstructor c,
    CtClass declaring,
    ClassMap map)Creates a copy of a constructor. | 
| static CtMethod | CtNewMethod. copy(CtMethod src,
    CtClass declaring,
    ClassMap map)Creates a copy of a method. | 
| static CtMethod | CtNewMethod. copy(CtMethod src,
    String name,
    CtClass declaring,
    ClassMap map)Creates a copy of a method with a new name. | 
| static CtConstructor | CtNewConstructor. defaultConstructor(CtClass declaring)Creates a default (public) constructor. | 
| static CtMethod | CtNewMethod. delegator(CtMethod delegate,
         CtClass declaring)Creates a method forwarding to a delegate in
 a super class. | 
| protected void | CodeConverter. doit(CtClass clazz,
    MethodInfo minfo,
    ConstPool cp)Performs code conversion. | 
| static CtMethod | CtNewMethod. getter(String methodName,
      CtField field)Creates a public getter method. | 
| void | CtBehavior. insertAfter(String src)Inserts bytecode at the end of the body. | 
| void | CtBehavior. insertAfter(String src,
           boolean asFinally)Inserts bytecode at the end of the body. | 
| void | CodeConverter. insertAfterMethod(CtMethod origMethod,
                 CtMethod afterMethod)Inserts a call to another method after an existing method call. | 
| int | CtBehavior. insertAt(int lineNum,
        boolean modify,
        String src)Inserts bytecode at the specified line in the body. | 
| int | CtBehavior. insertAt(int lineNum,
        String src)Inserts bytecode at the specified line in the body. | 
| void | CtBehavior. insertBefore(String src)Inserts bytecode at the beginning of the body. | 
| void | CtConstructor. insertBeforeBody(String src)Inserts bytecode just after another constructor in the super class
 or this class is called. | 
| void | CodeConverter. insertBeforeMethod(CtMethod origMethod,
                  CtMethod beforeMethod)Insert a call to another method before an existing method call. | 
| void | CtBehavior. insertParameter(CtClass type)Inserts a new parameter, which becomes the first parameter. | 
| void | CtClass. instrument(CodeConverter converter)Applies the given converter to all methods and constructors
 declared in the class. | 
| void | CtBehavior. instrument(CodeConverter converter)Modifies the method/constructor body. | 
| void | CtClass. instrument(ExprEditor editor)Modifies the bodies of all methods and constructors
 declared in the class. | 
| void | CtBehavior. instrument(ExprEditor editor)Modifies the method/constructor body. | 
| static CtConstructor | CtNewConstructor. make(CtClass[] parameters,
    CtClass[] exceptions,
    CtClass declaring)Creates a public constructor that only calls a constructor
 in the super class. | 
| static CtConstructor | CtNewConstructor. make(CtClass[] parameters,
    CtClass[] exceptions,
    int howto,
    CtMethod body,
    CtMethod.ConstParameter cparam,
    CtClass declaring)Creates a public constructor. | 
| static CtConstructor | CtNewConstructor. make(CtClass[] parameters,
    CtClass[] exceptions,
    String body,
    CtClass declaring)Creates a public constructor. | 
| static CtMethod | CtNewMethod. make(CtClass returnType,
    String mname,
    CtClass[] parameters,
    CtClass[] exceptions,
    String body,
    CtClass declaring)Creates a public (non-static) method. | 
| static CtMethod | CtNewMethod. make(int modifiers,
    CtClass returnType,
    String mname,
    CtClass[] parameters,
    CtClass[] exceptions,
    String body,
    CtClass declaring)Creates a method. | 
| static CtMethod | CtMethod. make(MethodInfo minfo,
    CtClass declaring)Creates a method from a  MethodInfoobject. | 
| static CtMethod | CtMethod. make(String src,
    CtClass declaring)Compiles the given source code and creates a method. | 
| static CtMethod | CtNewMethod. make(String src,
    CtClass declaring)Compiles the given source code and creates a method. | 
| static CtConstructor | CtNewConstructor. make(String src,
    CtClass declaring)Compiles the given source code and creates a constructor. | 
| static CtField | CtField. make(String src,
    CtClass declaring)Compiles the given source code and creates a field. | 
| static CtMethod | CtNewMethod. make(String src,
    CtClass declaring,
    String delegateObj,
    String delegateMethod)Compiles the given source code and creates a method. | 
| CtConstructor | CtClass. makeClassInitializer()Makes an empty class initializer (static constructor). | 
| void | ClassPool. makePackage(ClassLoader loader,
           String name)Defines a new package. | 
| void | Translator. onLoad(ClassPool pool,
      String classname)Is invoked by a  Loaderfor notifying that
 a class is loaded. | 
| void | CodeConverter. redirectMethodCall(CtMethod origMethod,
                  CtMethod substMethod)Modify method invocations in a method body so that a different
 method will be invoked. | 
| void | CodeConverter. redirectMethodCall(String oldMethodName,
                  CtMethod newMethod)Correct invocations to a method that has been renamed. | 
| void | CtConstructor. setBody(CtConstructor src,
       ClassMap map)Copies a constructor body from another constructor. | 
| void | CtMethod. setBody(CtMethod src,
       ClassMap map)Copies a method body from another method. | 
| void | CtConstructor. setBody(String src)Sets a constructor body. | 
| void | CtBehavior. setBody(String src)Sets a method/constructor body. | 
| void | CtBehavior. setBody(String src,
       String delegateObj,
       String delegateMethod)Sets a method/constructor body. | 
| static void | SerialVersionUID. setSerialVersionUID(CtClass clazz)Adds serialVersionUID if one does not already exist. | 
| void | CtClass. setSuperclass(CtClass clazz)Changes a super class unless this object represents an interface. | 
| static CtMethod | CtNewMethod. setter(String methodName,
      CtField field)Creates a public setter method. | 
| void | CtMethod. setWrappedBody(CtMethod mbody,
              CtMethod.ConstParameter constParam)Replace a method body with a new method body wrapping the
 given method. | 
| static CtConstructor | CtNewConstructor. skeleton(CtClass[] parameters,
        CtClass[] exceptions,
        CtClass declaring)Creates a public constructor that only calls a constructor
 in the super class. | 
| void | Translator. start(ClassPool pool)Is invoked by a  Loaderfor initialization
 when the object is attached to theLoaderobject. | 
| byte[] | CtClass. toBytecode()Converts this class to a class file. | 
| void | CtClass. toBytecode(DataOutputStream out)Converts this class to a class file. | 
| Class | CtClass. toClass()Converts this class to a  java.lang.Classobject. | 
| Class | CtClass. toClass(ClassLoader loader)Deprecated. 
 Replaced by  CtClass.toClass(ClassLoader,ProtectionDomain) | 
| Class | CtClass. toClass(ClassLoader loader,
       ProtectionDomain domain)Converts this class to a  java.lang.Classobject. | 
| Class | ClassPool. toClass(CtClass clazz)Converts the given class to a  java.lang.Classobject. | 
| Class | ClassPool. toClass(CtClass ct,
       ClassLoader loader)Deprecated. 
 Replaced by  ClassPool.toClass(CtClass,ClassLoader,ProtectionDomain).
 A subclass ofClassPoolthat has been
 overriding this method should be modified.  It should overrideClassPool.toClass(CtClass,ClassLoader,ProtectionDomain). | 
| Class | ClassPool. toClass(CtClass ct,
       ClassLoader loader,
       ProtectionDomain domain)Converts the class to a  java.lang.Classobject. | 
| CtMethod | CtConstructor. toMethod(String name,
        CtClass declaring)Makes a copy of this constructor and converts it into a method. | 
| CtMethod | CtConstructor. toMethod(String name,
        CtClass declaring,
        ClassMap map)Makes a copy of this constructor and converts it into a method. | 
| void | CtBehavior. useCflow(String name)Declares to use  $cflowfor this method/constructor. | 
| static CtMethod | CtNewMethod. wrapped(CtClass returnType,
       String mname,
       CtClass[] parameterTypes,
       CtClass[] exceptionTypes,
       CtMethod body,
       CtMethod.ConstParameter constParam,
       CtClass declaring)Creates a wrapped method. | 
| void | CtClass. writeFile()Writes a class file represented by this  CtClassobject in the current directory. | 
| void | CtClass. writeFile(String directoryName)Writes a class file represented by this  CtClassobject on a local disk. | 
| Constructor and Description | 
|---|
| CtConstructor(CtConstructor src,
             CtClass declaring,
             ClassMap map)Creates a copy of a  CtConstructorobject. | 
| CtField(CtClass type,
       String name,
       CtClass declaring)Creates a  CtFieldobject. | 
| CtField(CtField src,
       CtClass declaring)Creates a copy of the given field. | 
| CtMethod(CtMethod src,
        CtClass declaring,
        ClassMap map)Creates a copy of a  CtMethodobject. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | DuplicateMemberExceptionAn exception thrown when adding a duplicate member is requested. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | StackMap. removeNew(int where)Undocumented method. | 
| void | StackMapTable. removeNew(int where)Undocumented method. | 
| void | ClassFile. setSuperclass(String superclass)Sets the super class. | 
| Constructor and Description | 
|---|
| CompileError(CannotCompileException e) | 
| Modifier and Type | Method and Description | 
|---|---|
| void | Transformer. initialize(ConstPool cp,
          CtClass clazz,
          MethodInfo minfo) | 
| void | TransformAccessArrayField. initialize(ConstPool cp,
          CtClass clazz,
          MethodInfo minfo) | 
| abstract int | Transformer. transform(CtClass clazz,
         int pos,
         CodeIterator it,
         ConstPool cp) | 
| int | TransformNew. transform(CtClass clazz,
         int pos,
         CodeIterator iterator,
         ConstPool cp)Replace a sequence of
    NEW classname
    DUP
    ... | 
| int | TransformNewClass. transform(CtClass clazz,
         int pos,
         CodeIterator iterator,
         ConstPool cp)Modifies a sequence of
    NEW classname
    DUP
    ... | 
| Modifier and Type | Method and Description | 
|---|---|
| boolean | ExprEditor. doit(CtClass clazz,
    MethodInfo minfo)Undocumented method. | 
| void | ExprEditor. edit(Cast c)Edits an expression for explicit type casting (overridable). | 
| void | ExprEditor. edit(ConstructorCall c)Edits a constructor call (overridable). | 
| void | ExprEditor. edit(FieldAccess f)Edits a field-access expression (overridable). | 
| void | ExprEditor. edit(Handler h)Edits a catch clause (overridable). | 
| void | ExprEditor. edit(Instanceof i)Edits an instanceof expression (overridable). | 
| void | ExprEditor. edit(MethodCall m)Edits a method call (overridable). | 
| void | ExprEditor. edit(NewArray a)Edits an expression for array creation (overridable). | 
| void | ExprEditor. edit(NewExpr e)Edits a new expression (overridable). | 
| void | Handler. insertBefore(String src)Inserts bytecode at the beginning of the catch clause. | 
| abstract void | Expr. replace(String statement)Replaces this expression with the bytecode derived from
 the given source text. | 
| void | NewExpr. replace(String statement)Replaces the new expression with the bytecode derived from
 the given source text. | 
| void | MethodCall. replace(String statement)Replaces the method call with the bytecode derived from
 the given source text. | 
| void | NewArray. replace(String statement)Replaces the array creation with the bytecode derived from
 the given source text. | 
| void | Cast. replace(String statement)Replaces the explicit cast operator with the bytecode derived from
 the given source text. | 
| void | Handler. replace(String statement)This method has not been implemented yet. | 
| void | Instanceof. replace(String statement)Replaces the instanceof operator with the bytecode derived from
 the given source text. | 
| void | FieldAccess. replace(String statement)Replaces the method call with the bytecode derived from
 the given source text. | 
| void | Expr. replace(String statement,
       ExprEditor recursive)Replaces this expression with the bytecode derived from
 the given source text and  ExprEditor. | 
| protected void | Expr. runEditor(ExprEditor ed,
         CodeIterator oldIterator) | 
| Modifier and Type | Method and Description | 
|---|---|
| Class | ScopedClassPool. toClass(CtClass ct,
       ClassLoader loader,
       ProtectionDomain domain)Convert a javassist class to a java class | 
| Modifier and Type | Method and Description | 
|---|---|
| static void | Callback. insertAfter(CtBehavior behavior,
           Callback callback)Utility method to inserts callback at the end of the body. | 
| static void | Callback. insertAfter(CtBehavior behavior,
           Callback callback,
           boolean asFinally)Utility method to inserts callback at the end of the body. | 
| static int | Callback. insertAt(CtBehavior behavior,
        Callback callback,
        int lineNum)Utility method to inserts callback at the specified line in the body. | 
| static void | Callback. insertBefore(CtBehavior behavior,
            Callback callback)Utility method to insert callback at the beginning of the body. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | CannotReflectExceptionThrown by  makeReflective()inReflectionwhen there is an attempt to reflect
 a class that is either an interface or a subclass of
 either ClassMetaobject or Metaobject. | 
| Modifier and Type | Method and Description | 
|---|---|
| boolean | Reflection. makeReflective(Class clazz,
              Class metaobject,
              Class metaclass)Produces a reflective class. | 
| boolean | Reflection. makeReflective(CtClass clazz,
              CtClass metaobject,
              CtClass metaclass)Produces a reflective class. | 
| boolean | Reflection. makeReflective(String classname,
              String metaobject,
              String metaclass)Produces a reflective class. | 
| boolean | Loader. makeReflective(String clazz,
              String metaobject,
              String metaclass)Produces a reflective class. | 
| void | Reflection. onLoad(ClassPool pool,
      String classname)Inserts hooks for intercepting accesses to the fields declared
 in reflective classes. | 
| Constructor and Description | 
|---|
| Loader()Constructs a new class loader. | 
| Modifier and Type | Method and Description | 
|---|---|
| int | AppletServer. exportObject(String name,
            Object obj)Exports an object. | 
| boolean | StubGenerator. makeProxyClass(Class clazz)Makes a proxy class. | 
| Constructor and Description | 
|---|
| AppletServer(int port)Constructs a web server. | 
| AppletServer(int port,
            ClassPool src)Constructs a web server. | 
| AppletServer(String port)Constructs a web server. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | Webserver. addTranslator(ClassPool cp,
             Translator t)Adds a translator, which is called whenever a client requests
 a class file. | 
| Modifier and Type | Method and Description | 
|---|---|
| static Class | FactoryHelper. toClass(ClassFile cf,
       ClassLoader loader)Loads a class file by a given class loader. | 
| static Class | FactoryHelper. toClass(ClassFile cf,
       ClassLoader loader,
       ProtectionDomain domain)Loads a class file by a given class loader. | 
| static void | FactoryHelper. writeFile(ClassFile cf,
         String directoryName)Writes a class file. | 
Copyright © 2016 Shigeru Chiba, www.javassist.org. All Rights Reserved.