public class Reflection extends Object implements Translator
If a class is reflective, then all the method invocations on every instance of that class are intercepted by the runtime metaobject controlling that instance. The methods inherited from the super classes are also intercepted except final methods. To intercept a final method in a super class, that super class must be also reflective.
To do this, the original class file representing a reflective class:
 class Person {
   public int f(int i) { return i + 1; }
   public int value;
 }
 
 is modified so that it represents a class:
 class Person implements Metalevel {
   public int _original_f(int i) { return i + 1; }
   public int f(int i) { delegate to the metaobject }
   public int value;
   public int _r_value() { read "value" }
   public void _w_value(int v) { write "value" }
   public ClassMetaobject _getClass() { return a class metaobject }
   public Metaobject _getMetaobject() { return a metaobject }
   public void _setMetaobject(Metaobject m) { change a metaobject }
 }
 ClassMetaobject, 
Metaobject, 
Loader, 
Compiler| Modifier and Type | Field and Description | 
|---|---|
| protected ClassPool | classPool | 
| protected CodeConverter | converter | 
| protected CtClass[] | readParam | 
| protected CtMethod | trapMethod | 
| protected CtMethod | trapRead | 
| protected CtMethod | trapStaticMethod | 
| protected CtMethod | trapWrite | 
| Constructor and Description | 
|---|
| Reflection()Constructs a new  Reflectionobject. | 
| Modifier and Type | Method and Description | 
|---|---|
| boolean | makeReflective(Class clazz,
              Class metaobject,
              Class metaclass)Produces a reflective class. | 
| boolean | makeReflective(CtClass clazz,
              CtClass metaobject,
              CtClass metaclass)Produces a reflective class. | 
| boolean | makeReflective(String classname,
              String metaobject,
              String metaclass)Produces a reflective class. | 
| void | onLoad(ClassPool pool,
      String classname)Inserts hooks for intercepting accesses to the fields declared
 in reflective classes. | 
| void | rebuildClassFile(ClassFile cf) | 
| void | start(ClassPool pool)Initializes the object. | 
protected CtMethod trapMethod
protected CtMethod trapStaticMethod
protected CtMethod trapRead
protected CtMethod trapWrite
protected CtClass[] readParam
protected ClassPool classPool
protected CodeConverter converter
public void start(ClassPool pool) throws NotFoundException
start in interface Translatorpool - the ClassPool that this translator
                          should use.NotFoundException - if a CtClass cannot be found.Loaderpublic void onLoad(ClassPool pool, String classname) throws CannotCompileException, NotFoundException
onLoad in interface Translatorpool - the ClassPool that this translator
                          should use.classname - the name of the class being loaded.CannotCompileException - if the code transformation
                                  by this method fails.NotFoundException - if a CtClass cannot be found.Loaderpublic boolean makeReflective(String classname, String metaobject, String metaclass) throws CannotCompileException, NotFoundException
classname - the name of the reflective classmetaobject - the class name of metaobjects.metaclass - the class name of the class metaobject.false       if the class is already reflective.CannotCompileExceptionNotFoundExceptionMetaobject, 
ClassMetaobjectpublic boolean makeReflective(Class clazz, Class metaobject, Class 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, 
ClassMetaobjectpublic boolean makeReflective(CtClass clazz, CtClass metaobject, CtClass metaclass) throws CannotCompileException, CannotReflectException, NotFoundException
CtClass object and makes it reflective.
 If the super class is also made reflective, it must be done
 before the sub class.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.CannotCompileExceptionCannotReflectExceptionNotFoundExceptionMetaobject, 
ClassMetaobjectpublic void rebuildClassFile(ClassFile cf) throws BadBytecode
BadBytecodeCopyright © 2016 Shigeru Chiba, www.javassist.org. All Rights Reserved.