classUtils.javassist.reflect
Class Loader

java.lang.Object
  java.lang.ClassLoader
      classUtils.javassist.Loader
          classUtils.javassist.reflect.Loader

public class Loader
extends Loader

A class loader for reflection.

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.reflect.Loader cl
         = (javassist.reflect.Loader)Main.class.getClassLoader();
     cl.makeReflective("Person", "MyMetaobject",
                       "javassist.reflect.ClassMetaobject");
     cl.run("MyApp", args);
   }
 }
 

Then run this program as follows:

% java javassist.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.reflect.Loader cl = new javassist.reflect.Loader();
     cl.makeReflective("Person", "MyMetaobject",
                       "javassist.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.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.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.reflect.ClassMetaobject");
     cl.run("MyApp", args);
   }
 }
 

 
Note:

 
javassist.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.reflect.Compiler and the original
 class files should be replaced.




See Also:
Reflection, 
Compiler, 
Loader






Field Summary

 
Fields inherited from class classUtils.javassist.Loader
doDelegation
 



Constructor Summary
Loader()



          Constructs a new class loader.
 



Method Summary




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



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



 boolean
makeReflective(java.lang.String clazz,
               java.lang.String metaobject,
               java.lang.String metaclass)



          Produces a reflective class.


 
Methods inherited from class classUtils.javassist.Loader
delegateLoadingOf, run, run, setClassPool
 
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
 





Constructor Detail



Loader
public Loader()

Constructs a new class loader.






Method Detail



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

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

  args[0]           class name to be loaded.
  args[1-n]         parameters passed to main().



Throws:
java.lang.Throwable





makeReflective
public boolean makeReflective(java.lang.String clazz,
                              java.lang.String metaobject,
                              java.lang.String metaclass)
                       throws CannotCompileException,
                              NotFoundException

Produces a reflective class.
 If the super class is also made reflective, it must be done
 before the sub class.


Parameters:
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.
Returns:
false       if the class is already reflective.
Throws:
CannotCompileException
NotFoundException
See Also:
Metaobject, 
ClassMetaobject