Overview | Package | Class | Use | Tree | Deprecated | Index
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javassist
Class Loader

    java.lang.Object
      |
      +--java.lang.ClassLoader
            |
            +--javassist.Loader

Direct Known Subclasses:
  Loader

public class Loader
extends java.lang.ClassLoader

The class loader for Javassist (JDK 1.2 or later only).

This is a sample class loader using `ClassPool`. Unlike a regular class loader, this class loader obtains bytecode from a `ClassPool`.

Note that Javassist can be used without this class loader; programmers can define their own versions of class loader. They can run a program even without any user-defined class loader if that program is statically translated with Javassist. This class loader is just provided as a utility class.

Suppose that an instance of `MyTranslator` implementing the interface `Translator` is responsible for modifying class files. The startup program of an application using `MyTranslator` should be something like this:

     import javassist.*;

     public class Main {
       public static void main(String[] args) throws Throwable {
         MyTranslator myTrans = new MyTranslator();
         ClassPool cp = ClassPool.getDefault(myTrans);
         Loader cl = new Loader(cp);
         cl.run("MyApp", args);
       }
     }

Class `MyApp` is the main program of the application.

This program should be executed as follows:

     % java Main arg1 arg2...

It modifies the class `MyApp` with a `MyTranslator` object before loading it into the JVM. Then it calls `main()` in `MyApp` with arguments arg1, arg2, ...

This program execution is equivalent to:

     % java MyApp arg1 arg2...

except that classes are translated by `MyTranslator` at load time.

If only a particular class is modified when it is loaded, a program like the following can be used:

    ClassPool cp = ClassPool.getDefault();
     Loader cl = new Loader(cp);

     CtClass ct = cp.get("test.Rectangle");
     ct.setSuperclass(cp.get("test.Point"));

     Class c = cl.loadClass("test.Rectangle");
     Object rect = c.newInstance();

This program modifies the super class of the `Rectangle` class and loads it into the JVM with a class loader `cl`.

Note 1:

This class loader does not allow the users to intercept the loading of `java.*` and `javax.*` classes unless `Loader.doDelegation` is `false`. Also see Note 2.

Note 2:

If classes are loaded with different class loaders, they belong to separate name spaces. If class `C` is loaded by a class loader `CL`, all classes that the class `C` refers to are also loaded by `CL`. However, if `CL` delegates the loading of the class `C` to `CL'`, then those classes that the class `C` refers to are loaded by a parent class loader `CL'` instead of `CL`.

If an object of class `C` is assigned to a variable of class `C` belonging to a different name space, then a `ClassCastException` is thrown.

Because of the fact above, this loader delegates only the loading of `javassist.Loader` and classes included in package `java.*` and `javax.*` to the parent class loader. Other classes are directly loaded by this loader.

For example, suppose that `java.lang.String` would be loaded by this loader while `java.io.File` is loaded by the parent class loader. If the constructor of `java.io.File` is called with an instance of `java.lang.String`, then it may throw an exception since it accepts an instance of only the `java.lang.String` loaded by the parent class loader.

See Also:
  `ClassPool`, `Translator`

Field Summary
`boolean` | `doDelegation` Specifies the algorithm of class loading.

Constructor Summary
`Loader()` Creates a new class loader.
`Loader(java.lang.ClassLoader parent, ClassPool cp)` Creates a new class loader using the specified parent class loader for delegation.
`Loader(ClassPool cp)` Creates a new class loader.

Method Summary
`void` | `delegateLoadingOf(java.lang.String classname)` Records a class so that the loading of that class is delegated to the parent class loader.
`static void` | `main(java.lang.String[] args)` Loads a class with an instance of `Loader` and calls `main()` of that class.
`void` | `run(java.lang.String[] args)` Loads a class and calls `main()` in that class.
`void` | `run(java.lang.String classname, java.lang.String[] args)` Loads a class and calls `main()` in that class.
`void` | `setClassPool(ClassPool cp)` Sets the soruce `ClassPool`.

Methods inherited from class java.lang.ClassLoader
`clearAssertionStatus, getParent, getResource, getResourceAsStream, getResources, getSystemClassLoader, getSystemResource, getSystemResourceAsStream, getSystemResources, loadClass, setClassAssertionStatus, setDefaultAssertionStatus, setPackageAssertionStatus`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### doDelegation

    public boolean doDelegation

  Specifies the algorithm of class loading.

  This class loader uses the parent class loader for `java.*` and `javax.*` classes. If this variable `doDelegation` is `false`, this class loader does not delegate those classes to the parent class loader.

  The default value is `true`.

Constructor Detail

### Loader

    public Loader()

  Creates a new class loader.

### Loader

    public Loader(ClassPool cp)

  Creates a new class loader.

Parameters:
  `cp` - the source of class files.

### Loader

    public Loader(java.lang.ClassLoader parent,
                  ClassPool cp)

  Creates a new class loader using the specified parent class loader for delegation.

Parameters:
  `parent` - the parent class loader.
  `cp` - the source of class files.

Method Detail

### delegateLoadingOf

    public void delegateLoadingOf(java.lang.String classname)

  Records a class so that the loading of that class is delegated to the parent class loader.

  If the given class name ends with `.` (dot), then that name is interpreted as a package name. All the classes in that package and the sub packages are delegated.

### setClassPool

    public void setClassPool(ClassPool cp)

  Sets the soruce `ClassPool`.

### main

    public static void main(java.lang.String[] args)
                     throws java.lang.Throwable

  Loads a class with an instance of `Loader` and calls `main()` of that class.

  This method calls `run()`.

    `java.lang.Throwable`
  See Also:
    `run(String[])`

### run

    public void run(java.lang.String[] args)
             throws java.lang.Throwable

  Loads a class and calls `main()` in that class.

    `java.lang.Throwable`

### run

    public void run(java.lang.String classname,
                    java.lang.String[] args)
             throws java.lang.Throwable

  Loads a class and calls `main()` in that class.

  Parameters:
    `classname` - the loaded class.
    `args` - parameters passed to `main()`.
    `java.lang.Throwable`

Overview | Package | Class | Use | Tree | Deprecated | Index
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Javassist, a Java-bytecode translator toolkit. Copyright (C) 1999-2003 Shigeru Chiba. All Rights Reserved.