scouter.javassist.tools.reflect.Loader Maven / Gradle / Ivy
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. Alternatively, the contents of this file may be used under
* the terms of the GNU Lesser General Public License Version 2.1 or later,
* or the Apache License Version 2.0.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*/
package scouter.javassist.tools.reflect;
import scouter.javassist.CannotCompileException;
import scouter.javassist.NotFoundException;
import scouter.javassist.ClassPool;
/**
* 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 {
* Loader cl
* = (Loader)Main.class.getClassLoader();
* cl.makeReflective("Person", "MyMetaobject",
* "ClassMetaobject");
* cl.run("MyApp", args);
* }
* }
*
*
* Then run this program as follows:
*
*
% java 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 {
* Loader cl = new Loader();
* cl.makeReflective("Person", "MyMetaobject",
* "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 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 Loader.
* For more details,
* see the notes in the manual page of Loader.
*
*
The class Main2 is equivalent to this class:
*
*
* public class Main3 {
* public static void main(String[] args) throws Throwable {
* Reflection reflection = new Reflection();
* Loader cl
* = new Loader(ClassPool.getDefault(reflection));
* reflection.makeReflective("Person", "MyMetaobject",
* "ClassMetaobject");
* cl.run("MyApp", args);
* }
* }
*
*
* Note:
*
*
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 Compiler and the original
* class files should be replaced.
*
* @see Reflection
* @see Compiler
* @see scouter.javassist.Loader
*/
public class Loader extends scouter.javassist.Loader {
protected Reflection reflection;
/**
* Loads a class with an instance of Loader
* and calls main() in that class.
*
* @param args command line parameters.
*
args[0] is the class name to be loaded.
*
args[1..n] are parameters passed
* to the target main().
*/
public static void main(String[] args) throws Throwable {
Loader cl = new Loader();
cl.run(args);
}
/**
* Constructs a new class loader.
*/
public Loader() throws CannotCompileException, NotFoundException {
super();
delegateLoadingOf("Loader");
reflection = new Reflection();
ClassPool pool = ClassPool.getDefault();
addTranslator(pool, reflection);
}
/**
* Produces a reflective class.
* If the super class is also made reflective, it must be done
* before the sub class.
*
* @param clazz the reflective class.
* @param metaobject the class of metaobjects.
* It must be a subclass of
* Metaobject.
* @param metaclass the class of the class metaobject.
* It must be a subclass of
* ClassMetaobject.
* @return false if the class is already reflective.
*
* @see Metaobject
* @see ClassMetaobject
*/
public boolean makeReflective(String clazz,
String metaobject, String metaclass)
throws CannotCompileException, NotFoundException
{
return reflection.makeReflective(clazz, metaobject, metaclass);
}
}