public class Loader extends Loader
To run a program, say MyApp,
 including a reflective class,
 you must write a start-up program as follows:
 
 public class Main {
   public static void main(String[] args) throws Throwable {
     javassist.tools.reflect.Loader cl
         = (javassist.tools.reflect.Loader)Main.class.getClassLoader();
     cl.makeReflective("Person", "MyMetaobject",
                       "javassist.tools.reflect.ClassMetaobject");
     cl.run("MyApp", args);
   }
 }
 
 Then run this program as follows:
% java javassist.tools.reflect.Loader Main arg1, ...
This command runs Main.main() with arg1, ...
 and Main.main() runs MyApp.main() with
 arg1, ...
 The Person class is modified
 to be a reflective class.  Method calls on a Person
 object are intercepted by an instance of MyMetaobject.
 
Also, you can run MyApp in a slightly different way:
 
 public class Main2 {
   public static void main(String[] args) throws Throwable {
     javassist.tools.reflect.Loader cl = new javassist.tools.reflect.Loader();
     cl.makeReflective("Person", "MyMetaobject",
                       "javassist.tools.reflect.ClassMetaobject");
     cl.run("MyApp", args);
   }
 }
 
 This program is run as follows:
% java Main2 arg1, ...
The difference from the former one is that the class Main
 is loaded by javassist.tools.reflect.Loader whereas the class
 Main2 is not.  Thus, Main belongs
 to the same name space (security domain) as MyApp
 whereas Main2 does not; Main2 belongs
 to the same name space as javassist.tools.reflect.Loader.
 For more details,
 see the notes in the manual page of javassist.Loader.
 
The class Main2 is equivalent to this class:
 
 public class Main3 {
   public static void main(String[] args) throws Throwable {
     Reflection reflection = new Reflection();
     javassist.Loader cl
         = new javassist.Loader(ClassPool.getDefault(reflection));
     reflection.makeReflective("Person", "MyMetaobject",
                               "javassist.tools.reflect.ClassMetaobject");
     cl.run("MyApp", args);
   }
 }
 
 Note:
javassist.tools.reflect.Loader does not make a class reflective
 if that class is in a java.* or
 javax.* pacakge because of the specifications
 on the class loading algorithm of Java.  The JVM does not allow to
 load such a system class with a user class loader.
 
To avoid this limitation, those classes should be statically
 modified with javassist.tools.reflect.Compiler and the original
 class files should be replaced.
Reflection, 
Compiler, 
Loader| Modifier and Type | Field and Description | 
|---|---|
| protected Reflection | reflection | 
doDelegation| Constructor and Description | 
|---|
| Loader()Constructs a new class loader. | 
| Modifier and Type | Method and Description | 
|---|---|
| static void | main(String[] args)Loads a class with an instance of  Loaderand callsmain()in that class. | 
| boolean | makeReflective(String clazz,
              String metaobject,
              String metaclass)Produces a reflective class. | 
addTranslator, delegateLoadingOf, delegateToParent, findClass, loadClass, loadClassByDelegation, run, run, setClassPool, setDomainclearAssertionStatus, defineClass, defineClass, defineClass, defineClass, definePackage, findLibrary, findLoadedClass, findResource, findResources, findSystemClass, getClassLoadingLock, getPackage, getPackages, getParent, getResource, getResourceAsStream, getResources, getSystemClassLoader, getSystemResource, getSystemResourceAsStream, getSystemResources, loadClass, registerAsParallelCapable, resolveClass, setClassAssertionStatus, setDefaultAssertionStatus, setPackageAssertionStatus, setSignersprotected Reflection reflection
public Loader()
       throws CannotCompileException,
              NotFoundException
public static void main(String[] args) throws Throwable
Loader
 and calls main() in that class.args - command line parameters.
 args[0] is the class name to be loaded.
 args[1..n] are parameters passed
                      to the target main().Throwablepublic boolean makeReflective(String clazz, String metaobject, String metaclass) throws CannotCompileException, NotFoundException
clazz - the reflective class.metaobject - the class of metaobjects.
                          It must be a subclass of
                          Metaobject.metaclass - the class of the class metaobject.
                          It must be a subclass of
                          ClassMetaobject.false       if the class is already reflective.CannotCompileExceptionNotFoundExceptionMetaobject, 
ClassMetaobjectCopyright © 2016 Shigeru Chiba, www.javassist.org. All Rights Reserved.