/*
* 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
*
* https://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;
import org.apache.commons.lang3.StringUtils;
/**
* Java interpreter replacement, that is, 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.
* <p>
* Call this wrapper with:
* </p>
*
* <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>
*
* @see ClassLoader
*/
public class JavaWrapper {
private static java.lang.ClassLoader getClassLoader() {
final String s = System.getProperty("bcel.classloader"); if (StringUtils.isEmpty(s)) { throw new IllegalStateException("The property 'bcel.classloader' must be defined");
}
try {
return (java.lang.ClassLoader) Class.forName(s).getConstructor().newInstance(); } catch (final Exception e) { throw new IllegalStateException(e.toString(), e);
}
}
/**
* Default main method used as wrapper, expects the fully qualified class name of the real class as the first argument.
*
* @param argv command line arguments where first argument is the class name.
* @throws Exception Thrown if an error occurs during execution.
*/
public static void main(final String[] argv) throws Exception {
/*
* Expects class name as first argument, other arguments are bypassed.
*/
if (argv.length == 0) { System.out.println("Missing class name."); return;
}
final String className = argv[0]; final String[] newArgv = new String[argv.length - 1]; System.arraycopy(argv, 1, newArgv, 0, newArgv.length); new JavaWrapper().runMain(className, newArgv); }
private final java.lang.ClassLoader loader;
/**
* Constructs a JavaWrapper with the default class loader.
*/
public JavaWrapper() {
this(getClassLoader()); }
/**
* Constructs a JavaWrapper with the specified class loader.
*
* @param loader The class loader to use.
*/
public JavaWrapper(final java.lang.ClassLoader loader) { this.loader = loader; }
/**
* Runs the main method of the given class with the arguments passed in argv
*
* @param className The fully qualified class name.
* @param argv The arguments just as you would pass them directly.
* @throws ClassNotFoundException Thrown if {@code className} can't be found.
*/
public void runMain(final String className, final String[] argv) throws ClassNotFoundException {
final Class<?> cl = loader.loadClass(className); Method method = null;
try {
method = cl.getMethod("main", 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 " + className + ": public static void main(String[] argv) is not defined"); return; }
try {
method.invoke(null, (Object[]) argv); } catch (final Exception ex) { ex.printStackTrace(); } }
}