1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.bcel.util;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/**
* Java interpreter replacement, i.e., wrapper that uses its own ClassLoader
* to modify/generate classes as they're requested. You can take this as a template
* for your own applications.<br>
* Call this wrapper with:
*
* <pre>java org.apache.bcel.util.JavaWrapper <real.class.name> [arguments]</pre>
*
* <p>To use your own class loader you can set the "bcel.classloader" system property<p>
* <pre>java org.apache.bcel.util.JavaWrapper -Dbcel.classloader=foo.MyLoader <real.class.name> [arguments]</pre>
*
* @version $Id$
* @see ClassLoader
*/
public class JavaWrapper {
private final java.lang.ClassLoader loader;
private static java.lang.ClassLoader getClassLoader() {
final String s = System.getProperty("bcel.classloader");
if ((s == null) || "".equals(s)) {
throw new IllegalArgumentException("The property 'bcel.classloader' must be defined");
}
try {
return (java.lang.ClassLoader) Class.forName(s).newInstance();
} catch (final Exception e) {
throw new RuntimeException(e.toString(), e);
}
}
public JavaWrapper(final java.lang.ClassLoader loader) {
this.loader = loader;
}
public JavaWrapper() {
this(getClassLoader());
}
/** Runs the main method of the given class with the arguments passed in argv
*
* @param class_name the fully qualified class name
* @param argv the arguments just as you would pass them directly
*/
public void runMain( final String class_name, final String[] argv ) throws ClassNotFoundException {
final Class<?> cl = loader.loadClass(class_name);
Method method = null;
try {
method = cl.getMethod("main", new Class[] {
argv.getClass()
});
/* Method main is sane ?
*/
final int m = method.getModifiers();
final Class<?> r = method.getReturnType();
if (!(Modifier.isPublic(m) && Modifier.isStatic(m)) || Modifier.isAbstract(m)
|| (r != Void.TYPE)) {
throw new NoSuchMethodException();
}
} catch (final NoSuchMethodException no) {
System.out.println("In class " + class_name
+ ": public static void main(String[] argv) is not defined");
return;
}
try {
method.invoke(null, new Object[] {
argv
});
} catch (final Exception ex) {
ex.printStackTrace();
}
}
/** Default main method used as wrapper, expects the fully qualified class name
* of the real class as the first argument.
*/
public static void main( final String[] argv ) throws Exception {
/* Expects class name as first argument, other arguments are by-passed.
*/
if (argv.length == 0) {
System.out.println("Missing class name.");
return;
}
final String class_name = argv[0];
final String[] new_argv = new String[argv.length - 1];
System.arraycopy(argv, 1, new_argv, 0, new_argv.length);
final JavaWrapper wrapper = new JavaWrapper();
wrapper.runMain(class_name, new_argv);
}
}
|
