/* | |
* Copyright 1999-2004 The Apache Software Foundation | |
* | |
* Licensed 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.catalina.tribes.demos; | |
import java.io.File; | |
import java.io.FilenameFilter; | |
import java.io.IOException; | |
import java.lang.reflect.InvocationTargetException; | |
import java.lang.reflect.Method; | |
import java.net.InetAddress; | |
import java.net.MalformedURLException; | |
import java.net.URL; | |
import java.net.UnknownHostException; | |
import java.util.Hashtable; | |
import java.util.StringTokenizer; | |
import java.util.Vector; | |
// Depends: JDK1.1 | |
/** | |
* Utils for introspection and reflection | |
*/ | |
public final class IntrospectionUtils { | |
private static org.apache.commons.logging.Log log= | |
org.apache.commons.logging.LogFactory.getLog( IntrospectionUtils.class ); | |
/** | |
* Call execute() - any ant-like task should work | |
*/ | |
public static void execute(Object proxy, String method) throws Exception { | |
Method executeM = null; | |
Class c = proxy.getClass(); | |
Class params[] = new Class[0]; | |
// params[0]=args.getClass(); | |
executeM = findMethod(c, method, params); | |
if (executeM == null) { | |
throw new RuntimeException("No execute in " + proxy.getClass()); | |
} | |
executeM.invoke(proxy, (Object[]) null);//new Object[] { args }); | |
} | |
/** | |
* Call void setAttribute( String ,Object ) | |
*/ | |
public static void setAttribute(Object proxy, String n, Object v) | |
throws Exception { | |
if (proxy instanceof AttributeHolder) { | |
((AttributeHolder) proxy).setAttribute(n, v); | |
return; | |
} | |
Method executeM = null; | |
Class c = proxy.getClass(); | |
Class params[] = new Class[2]; | |
params[0] = String.class; | |
params[1] = Object.class; | |
executeM = findMethod(c, "setAttribute", params); | |
if (executeM == null) { | |
if (log.isDebugEnabled()) | |
log.debug("No setAttribute in " + proxy.getClass()); | |
return; | |
} | |
if (false) | |
if (log.isDebugEnabled()) | |
log.debug("Setting " + n + "=" + v + " in " + proxy); | |
executeM.invoke(proxy, new Object[] { n, v }); | |
return; | |
} | |
/** | |
* Call void getAttribute( String ) | |
*/ | |
public static Object getAttribute(Object proxy, String n) throws Exception { | |
Method executeM = null; | |
Class c = proxy.getClass(); | |
Class params[] = new Class[1]; | |
params[0] = String.class; | |
executeM = findMethod(c, "getAttribute", params); | |
if (executeM == null) { | |
if (log.isDebugEnabled()) | |
log.debug("No getAttribute in " + proxy.getClass()); | |
return null; | |
} | |
return executeM.invoke(proxy, new Object[] { n }); | |
} | |
/** | |
* Construct a URLClassLoader. Will compile and work in JDK1.1 too. | |
*/ | |
public static ClassLoader getURLClassLoader(URL urls[], ClassLoader parent) { | |
try { | |
Class urlCL = Class.forName("java.net.URLClassLoader"); | |
Class paramT[] = new Class[2]; | |
paramT[0] = urls.getClass(); | |
paramT[1] = ClassLoader.class; | |
Method m = findMethod(urlCL, "newInstance", paramT); | |
if (m == null) | |
return null; | |
ClassLoader cl = (ClassLoader) m.invoke(urlCL, new Object[] { urls, | |
parent }); | |
return cl; | |
} catch (ClassNotFoundException ex) { | |
// jdk1.1 | |
return null; | |
} catch (Exception ex) { | |
ex.printStackTrace(); | |
return null; | |
} | |
} | |
public static String guessInstall(String installSysProp, | |
String homeSysProp, String jarName) { | |
return guessInstall(installSysProp, homeSysProp, jarName, null); | |
} | |
/** | |
* Guess a product install/home by analyzing the class path. It works for | |
* product using the pattern: lib/executable.jar or if executable.jar is | |
* included in classpath by a shell script. ( java -jar also works ) | |
* | |
* Insures both "install" and "home" System properties are set. If either or | |
* both System properties are unset, "install" and "home" will be set to the | |
* same value. This value will be the other System property that is set, or | |
* the guessed value if neither is set. | |
*/ | |
public static String guessInstall(String installSysProp, | |
String homeSysProp, String jarName, String classFile) { | |
String install = null; | |
String home = null; | |
if (installSysProp != null) | |
install = System.getProperty(installSysProp); | |
if (homeSysProp != null) | |
home = System.getProperty(homeSysProp); | |
if (install != null) { | |
if (home == null) | |
System.getProperties().put(homeSysProp, install); | |
return install; | |
} | |
// Find the directory where jarName.jar is located | |
String cpath = System.getProperty("java.class.path"); | |
String pathSep = System.getProperty("path.separator"); | |
StringTokenizer st = new StringTokenizer(cpath, pathSep); | |
while (st.hasMoreTokens()) { | |
String path = st.nextToken(); | |
// log( "path " + path ); | |
if (path.endsWith(jarName)) { | |
home = path.substring(0, path.length() - jarName.length()); | |
try { | |
if ("".equals(home)) { | |
home = new File("./").getCanonicalPath(); | |
} else if (home.endsWith(File.separator)) { | |
home = home.substring(0, home.length() - 1); | |
} | |
File f = new File(home); | |
String parentDir = f.getParent(); | |
if (parentDir == null) | |
parentDir = home; // unix style | |
File f1 = new File(parentDir); | |
install = f1.getCanonicalPath(); | |
if (installSysProp != null) | |
System.getProperties().put(installSysProp, install); | |
if (home == null && homeSysProp != null) | |
System.getProperties().put(homeSysProp, install); | |
return install; | |
} catch (Exception ex) { | |
ex.printStackTrace(); | |
} | |
} else { | |
String fname = path + (path.endsWith("/") ? "" : "/") | |
+ classFile; | |
if (new File(fname).exists()) { | |
try { | |
File f = new File(path); | |
String parentDir = f.getParent(); | |
if (parentDir == null) | |
parentDir = path; // unix style | |
File f1 = new File(parentDir); | |
install = f1.getCanonicalPath(); | |
if (installSysProp != null) | |
System.getProperties().put(installSysProp, install); | |
if (home == null && homeSysProp != null) | |
System.getProperties().put(homeSysProp, install); | |
return install; | |
} catch (Exception ex) { | |
ex.printStackTrace(); | |
} | |
} | |
} | |
} | |
// if install directory can't be found, use home as the default | |
if (home != null) { | |
System.getProperties().put(installSysProp, home); | |
return home; | |
} | |
return null; | |
} | |
/** | |
* Debug method, display the classpath | |
*/ | |
public static void displayClassPath(String msg, URL[] cp) { | |
if (log.isDebugEnabled()) { | |
log.debug(msg); | |
for (int i = 0; i < cp.length; i++) { | |
log.debug(cp[i].getFile()); | |
} | |
} | |
} | |
public static String PATH_SEPARATOR = System.getProperty("path.separator"); | |
/** | |
* Adds classpath entries from a vector of URL's to the "tc_path_add" System | |
* property. This System property lists the classpath entries common to web | |
* applications. This System property is currently used by Jasper when its | |
* JSP servlet compiles the Java file for a JSP. | |
*/ | |
public static String classPathAdd(URL urls[], String cp) { | |
if (urls == null) | |
return cp; | |
for (int i = 0; i < urls.length; i++) { | |
if (cp != null) | |
cp += PATH_SEPARATOR + urls[i].getFile(); | |
else | |
cp = urls[i].getFile(); | |
} | |
return cp; | |
} | |
/** | |
* Find a method with the right name If found, call the method ( if param is | |
* int or boolean we'll convert value to the right type before) - that means | |
* you can have setDebug(1). | |
*/ | |
public static void setProperty(Object o, String name, String value) { | |
if (dbg > 1) | |
d("setProperty(" + o.getClass() + " " + name + "=" + value + ")"); | |
String setter = "set" + capitalize(name); | |
try { | |
Method methods[] = findMethods(o.getClass()); | |
Method setPropertyMethod = null; | |
// First, the ideal case - a setFoo( String ) method | |
for (int i = 0; i < methods.length; i++) { | |
Class paramT[] = methods[i].getParameterTypes(); | |
if (setter.equals(methods[i].getName()) && paramT.length == 1 | |
&& "java.lang.String".equals(paramT[0].getName())) { | |
methods[i].invoke(o, new Object[] { value }); | |
return; | |
} | |
} | |
// Try a setFoo ( int ) or ( boolean ) | |
for (int i = 0; i < methods.length; i++) { | |
boolean ok = true; | |
if (setter.equals(methods[i].getName()) | |
&& methods[i].getParameterTypes().length == 1) { | |
// match - find the type and invoke it | |
Class paramType = methods[i].getParameterTypes()[0]; | |
Object params[] = new Object[1]; | |
// Try a setFoo ( int ) | |
if ("java.lang.Integer".equals(paramType.getName()) | |
|| "int".equals(paramType.getName())) { | |
try { | |
params[0] = new Integer(value); | |
} catch (NumberFormatException ex) { | |
ok = false; | |
} | |
// Try a setFoo ( long ) | |
}else if ("java.lang.Long".equals(paramType.getName()) | |
|| "long".equals(paramType.getName())) { | |
try { | |
params[0] = new Long(value); | |
} catch (NumberFormatException ex) { | |
ok = false; | |
} | |
// Try a setFoo ( boolean ) | |
} else if ("java.lang.Boolean".equals(paramType.getName()) | |
|| "boolean".equals(paramType.getName())) { | |
params[0] = new Boolean(value); | |
// Try a setFoo ( InetAddress ) | |
} else if ("java.net.InetAddress".equals(paramType | |
.getName())) { | |
try { | |
params[0] = InetAddress.getByName(value); | |
} catch (UnknownHostException exc) { | |
d("Unable to resolve host name:" + value); | |
ok = false; | |
} | |
// Unknown type | |
} else { | |
d("Unknown type " + paramType.getName()); | |
} | |
if (ok) { | |
methods[i].invoke(o, params); | |
return; | |
} | |
} | |
// save "setProperty" for later | |
if ("setProperty".equals(methods[i].getName())) { | |
setPropertyMethod = methods[i]; | |
} | |
} | |
// Ok, no setXXX found, try a setProperty("name", "value") | |
if (setPropertyMethod != null) { | |
Object params[] = new Object[2]; | |
params[0] = name; | |
params[1] = value; | |
setPropertyMethod.invoke(o, params); | |
} | |
} catch (IllegalArgumentException ex2) { | |
log.warn("IAE " + o + " " + name + " " + value, ex2); | |
} catch (SecurityException ex1) { | |
if (dbg > 0) | |
d("SecurityException for " + o.getClass() + " " + name + "=" | |
+ value + ")"); | |
if (dbg > 1) | |
ex1.printStackTrace(); | |
} catch (IllegalAccessException iae) { | |
if (dbg > 0) | |
d("IllegalAccessException for " + o.getClass() + " " + name | |
+ "=" + value + ")"); | |
if (dbg > 1) | |
iae.printStackTrace(); | |
} catch (InvocationTargetException ie) { | |
if (dbg > 0) | |
d("InvocationTargetException for " + o.getClass() + " " + name | |
+ "=" + value + ")"); | |
if (dbg > 1) | |
ie.printStackTrace(); | |
} | |
} | |
public static Object getProperty(Object o, String name) { | |
String getter = "get" + capitalize(name); | |
String isGetter = "is" + capitalize(name); | |
try { | |
Method methods[] = findMethods(o.getClass()); | |
Method getPropertyMethod = null; | |
// First, the ideal case - a getFoo() method | |
for (int i = 0; i < methods.length; i++) { | |
Class paramT[] = methods[i].getParameterTypes(); | |
if (getter.equals(methods[i].getName()) && paramT.length == 0) { | |
return methods[i].invoke(o, (Object[]) null); | |
} | |
if (isGetter.equals(methods[i].getName()) && paramT.length == 0) { | |
return methods[i].invoke(o, (Object[]) null); | |
} | |
if ("getProperty".equals(methods[i].getName())) { | |
getPropertyMethod = methods[i]; | |
} | |
} | |
// Ok, no setXXX found, try a getProperty("name") | |
if (getPropertyMethod != null) { | |
Object params[] = new Object[1]; | |
params[0] = name; | |
return getPropertyMethod.invoke(o, params); | |
} | |
} catch (IllegalArgumentException ex2) { | |
log.warn("IAE " + o + " " + name, ex2); | |
} catch (SecurityException ex1) { | |
if (dbg > 0) | |
d("SecurityException for " + o.getClass() + " " + name + ")"); | |
if (dbg > 1) | |
ex1.printStackTrace(); | |
} catch (IllegalAccessException iae) { | |
if (dbg > 0) | |
d("IllegalAccessException for " + o.getClass() + " " + name | |
+ ")"); | |
if (dbg > 1) | |
iae.printStackTrace(); | |
} catch (InvocationTargetException ie) { | |
if (dbg > 0) | |
d("InvocationTargetException for " + o.getClass() + " " + name | |
+ ")"); | |
if (dbg > 1) | |
ie.printStackTrace(); | |
} | |
return null; | |
} | |
/** | |
*/ | |
public static void setProperty(Object o, String name) { | |
String setter = "set" + capitalize(name); | |
try { | |
Method methods[] = findMethods(o.getClass()); | |
Method setPropertyMethod = null; | |
// find setFoo() method | |
for (int i = 0; i < methods.length; i++) { | |
Class paramT[] = methods[i].getParameterTypes(); | |
if (setter.equals(methods[i].getName()) && paramT.length == 0) { | |
methods[i].invoke(o, new Object[] {}); | |
return; | |
} | |
} | |
} catch (Exception ex1) { | |
if (dbg > 0) | |
d("Exception for " + o.getClass() + " " + name); | |
if (dbg > 1) | |
ex1.printStackTrace(); | |
} | |
} | |
/** | |
* Replace ${NAME} with the property value | |
* | |
* @deprecated Use the explicit method | |
*/ | |
public static String replaceProperties(String value, Object getter) { | |
if (getter instanceof Hashtable) | |
return replaceProperties(value, (Hashtable) getter, null); | |
if (getter instanceof PropertySource) { | |
PropertySource src[] = new PropertySource[] { (PropertySource) getter }; | |
return replaceProperties(value, null, src); | |
} | |
return value; | |
} | |
/** | |
* Replace ${NAME} with the property value | |
*/ | |
public static String replaceProperties(String value, Hashtable staticProp, | |
PropertySource dynamicProp[]) { | |
StringBuffer sb = new StringBuffer(); | |
int prev = 0; | |
// assert value!=nil | |
int pos; | |
while ((pos = value.indexOf("$", prev)) >= 0) { | |
if (pos > 0) { | |
sb.append(value.substring(prev, pos)); | |
} | |
if (pos == (value.length() - 1)) { | |
sb.append('$'); | |
prev = pos + 1; | |
} else if (value.charAt(pos + 1) != '{') { | |
sb.append('$'); | |
prev = pos + 1; // XXX | |
} else { | |
int endName = value.indexOf('}', pos); | |
if (endName < 0) { | |
sb.append(value.substring(pos)); | |
prev = value.length(); | |
continue; | |
} | |
String n = value.substring(pos + 2, endName); | |
String v = null; | |
if (staticProp != null) { | |
v = (String) ((Hashtable) staticProp).get(n); | |
} | |
if (v == null && dynamicProp != null) { | |
for (int i = 0; i < dynamicProp.length; i++) { | |
v = dynamicProp[i].getProperty(n); | |
if (v != null) { | |
break; | |
} | |
} | |
} | |
if (v == null) | |
v = "${" + n + "}"; | |
sb.append(v); | |
prev = endName + 1; | |
} | |
} | |
if (prev < value.length()) | |
sb.append(value.substring(prev)); | |
return sb.toString(); | |
} | |
/** | |
* Reverse of Introspector.decapitalize | |
*/ | |
public static String capitalize(String name) { | |
if (name == null || name.length() == 0) { | |
return name; | |
} | |
char chars[] = name.toCharArray(); | |
chars[0] = Character.toUpperCase(chars[0]); | |
return new String(chars); | |
} | |
public static String unCapitalize(String name) { | |
if (name == null || name.length() == 0) { | |
return name; | |
} | |
char chars[] = name.toCharArray(); | |
chars[0] = Character.toLowerCase(chars[0]); | |
return new String(chars); | |
} | |
// -------------------- Class path tools -------------------- | |
/** | |
* Add all the jar files in a dir to the classpath, represented as a Vector | |
* of URLs. | |
*/ | |
public static void addToClassPath(Vector cpV, String dir) { | |
try { | |
String cpComp[] = getFilesByExt(dir, ".jar"); | |
if (cpComp != null) { | |
int jarCount = cpComp.length; | |
for (int i = 0; i < jarCount; i++) { | |
URL url = getURL(dir, cpComp[i]); | |
if (url != null) | |
cpV.addElement(url); | |
} | |
} | |
} catch (Exception ex) { | |
ex.printStackTrace(); | |
} | |
} | |
public static void addToolsJar(Vector v) { | |
try { | |
// Add tools.jar in any case | |
File f = new File(System.getProperty("java.home") | |
+ "/../lib/tools.jar"); | |
if (!f.exists()) { | |
// On some systems java.home gets set to the root of jdk. | |
// That's a bug, but we can work around and be nice. | |
f = new File(System.getProperty("java.home") + "/lib/tools.jar"); | |
if (f.exists()) { | |
if (log.isDebugEnabled()) | |
log.debug("Detected strange java.home value " | |
+ System.getProperty("java.home") | |
+ ", it should point to jre"); | |
} | |
} | |
URL url = new URL("file", "", f.getAbsolutePath()); | |
v.addElement(url); | |
} catch (MalformedURLException ex) { | |
ex.printStackTrace(); | |
} | |
} | |
/** | |
* Return all files with a given extension in a dir | |
*/ | |
public static String[] getFilesByExt(String ld, String ext) { | |
File dir = new File(ld); | |
String[] names = null; | |
final String lext = ext; | |
if (dir.isDirectory()) { | |
names = dir.list(new FilenameFilter() { | |
public boolean accept(File d, String name) { | |
if (name.endsWith(lext)) { | |
return true; | |
} | |
return false; | |
} | |
}); | |
} | |
return names; | |
} | |
/** | |
* Construct a file url from a file, using a base dir | |
*/ | |
public static URL getURL(String base, String file) { | |
try { | |
File baseF = new File(base); | |
File f = new File(baseF, file); | |
String path = f.getCanonicalPath(); | |
if (f.isDirectory()) { | |
path += "/"; | |
} | |
if (!f.exists()) | |
return null; | |
return new URL("file", "", path); | |
} catch (Exception ex) { | |
ex.printStackTrace(); | |
return null; | |
} | |
} | |
/** | |
* Add elements from the classpath <i>cp </i> to a Vector <i>jars </i> as | |
* file URLs (We use Vector for JDK 1.1 compat). | |
* <p> | |
* | |
* @param jars The jar list | |
* @param cp a String classpath of directory or jar file elements | |
* separated by path.separator delimiters. | |
* @throws IOException If an I/O error occurs | |
* @throws MalformedURLException Doh ;) | |
*/ | |
public static void addJarsFromClassPath(Vector jars, String cp) | |
throws IOException, MalformedURLException { | |
String sep = System.getProperty("path.separator"); | |
String token; | |
StringTokenizer st; | |
if (cp != null) { | |
st = new StringTokenizer(cp, sep); | |
while (st.hasMoreTokens()) { | |
File f = new File(st.nextToken()); | |
String path = f.getCanonicalPath(); | |
if (f.isDirectory()) { | |
path += "/"; | |
} | |
URL url = new URL("file", "", path); | |
if (!jars.contains(url)) { | |
jars.addElement(url); | |
} | |
} | |
} | |
} | |
/** | |
* Return a URL[] that can be used to construct a class loader | |
*/ | |
public static URL[] getClassPath(Vector v) { | |
URL[] urls = new URL[v.size()]; | |
for (int i = 0; i < v.size(); i++) { | |
urls[i] = (URL) v.elementAt(i); | |
} | |
return urls; | |
} | |
/** | |
* Construct a URL classpath from files in a directory, a cpath property, | |
* and tools.jar. | |
*/ | |
public static URL[] getClassPath(String dir, String cpath, | |
String cpathProp, boolean addTools) throws IOException, | |
MalformedURLException { | |
Vector jarsV = new Vector(); | |
if (dir != null) { | |
// Add dir/classes first, if it exists | |
URL url = getURL(dir, "classes"); | |
if (url != null) | |
jarsV.addElement(url); | |
addToClassPath(jarsV, dir); | |
} | |
if (cpath != null) | |
addJarsFromClassPath(jarsV, cpath); | |
if (cpathProp != null) { | |
String cpath1 = System.getProperty(cpathProp); | |
addJarsFromClassPath(jarsV, cpath1); | |
} | |
if (addTools) | |
addToolsJar(jarsV); | |
return getClassPath(jarsV); | |
} | |
// -------------------- Mapping command line params to setters | |
public static boolean processArgs(Object proxy, String args[]) | |
throws Exception { | |
String args0[] = null; | |
if (null != findMethod(proxy.getClass(), "getOptions1", new Class[] {})) { | |
args0 = (String[]) callMethod0(proxy, "getOptions1"); | |
} | |
if (args0 == null) { | |
//args0=findVoidSetters(proxy.getClass()); | |
args0 = findBooleanSetters(proxy.getClass()); | |
} | |
Hashtable h = null; | |
if (null != findMethod(proxy.getClass(), "getOptionAliases", | |
new Class[] {})) { | |
h = (Hashtable) callMethod0(proxy, "getOptionAliases"); | |
} | |
return processArgs(proxy, args, args0, null, h); | |
} | |
public static boolean processArgs(Object proxy, String args[], | |
String args0[], String args1[], Hashtable aliases) throws Exception { | |
for (int i = 0; i < args.length; i++) { | |
String arg = args[i]; | |
if (arg.startsWith("-")) | |
arg = arg.substring(1); | |
if (aliases != null && aliases.get(arg) != null) | |
arg = (String) aliases.get(arg); | |
if (args0 != null) { | |
boolean set = false; | |
for (int j = 0; j < args0.length; j++) { | |
if (args0[j].equalsIgnoreCase(arg)) { | |
setProperty(proxy, args0[j], "true"); | |
set = true; | |
break; | |
} | |
} | |
if (set) | |
continue; | |
} | |
if (args1 != null) { | |
for (int j = 0; j < args1.length; j++) { | |
if (args1[j].equalsIgnoreCase(arg)) { | |
i++; | |
if (i >= args.length) | |
return false; | |
setProperty(proxy, arg, args[i]); | |
break; | |
} | |
} | |
} else { | |
// if args1 is not specified,assume all other options have param | |
i++; | |
if (i >= args.length) | |
return false; | |
setProperty(proxy, arg, args[i]); | |
} | |
} | |
return true; | |
} | |
// -------------------- other utils -------------------- | |
public static void clear() { | |
objectMethods.clear(); | |
} | |
public static String[] findVoidSetters(Class c) { | |
Method m[] = findMethods(c); | |
if (m == null) | |
return null; | |
Vector v = new Vector(); | |
for (int i = 0; i < m.length; i++) { | |
if (m[i].getName().startsWith("set") | |
&& m[i].getParameterTypes().length == 0) { | |
String arg = m[i].getName().substring(3); | |
v.addElement(unCapitalize(arg)); | |
} | |
} | |
String s[] = new String[v.size()]; | |
for (int i = 0; i < s.length; i++) { | |
s[i] = (String) v.elementAt(i); | |
} | |
return s; | |
} | |
public static String[] findBooleanSetters(Class c) { | |
Method m[] = findMethods(c); | |
if (m == null) | |
return null; | |
Vector v = new Vector(); | |
for (int i = 0; i < m.length; i++) { | |
if (m[i].getName().startsWith("set") | |
&& m[i].getParameterTypes().length == 1 | |
&& "boolean".equalsIgnoreCase(m[i].getParameterTypes()[0] | |
.getName())) { | |
String arg = m[i].getName().substring(3); | |
v.addElement(unCapitalize(arg)); | |
} | |
} | |
String s[] = new String[v.size()]; | |
for (int i = 0; i < s.length; i++) { | |
s[i] = (String) v.elementAt(i); | |
} | |
return s; | |
} | |
static Hashtable objectMethods = new Hashtable(); | |
public static Method[] findMethods(Class c) { | |
Method methods[] = (Method[]) objectMethods.get(c); | |
if (methods != null) | |
return methods; | |
methods = c.getMethods(); | |
objectMethods.put(c, methods); | |
return methods; | |
} | |
public static Method findMethod(Class c, String name, Class params[]) { | |
Method methods[] = findMethods(c); | |
if (methods == null) | |
return null; | |
for (int i = 0; i < methods.length; i++) { | |
if (methods[i].getName().equals(name)) { | |
Class methodParams[] = methods[i].getParameterTypes(); | |
if (methodParams == null) | |
if (params == null || params.length == 0) | |
return methods[i]; | |
if (params == null) | |
if (methodParams == null || methodParams.length == 0) | |
return methods[i]; | |
if (params.length != methodParams.length) | |
continue; | |
boolean found = true; | |
for (int j = 0; j < params.length; j++) { | |
if (params[j] != methodParams[j]) { | |
found = false; | |
break; | |
} | |
} | |
if (found) | |
return methods[i]; | |
} | |
} | |
return null; | |
} | |
/** Test if the object implements a particular | |
* method | |
*/ | |
public static boolean hasHook(Object obj, String methodN) { | |
try { | |
Method myMethods[] = findMethods(obj.getClass()); | |
for (int i = 0; i < myMethods.length; i++) { | |
if (methodN.equals(myMethods[i].getName())) { | |
// check if it's overriden | |
Class declaring = myMethods[i].getDeclaringClass(); | |
Class parentOfDeclaring = declaring.getSuperclass(); | |
// this works only if the base class doesn't extend | |
// another class. | |
// if the method is declared in a top level class | |
// like BaseInterceptor parent is Object, otherwise | |
// parent is BaseInterceptor or an intermediate class | |
if (!"java.lang.Object".equals(parentOfDeclaring.getName())) { | |
return true; | |
} | |
} | |
} | |
} catch (Exception ex) { | |
ex.printStackTrace(); | |
} | |
return false; | |
} | |
public static void callMain(Class c, String args[]) throws Exception { | |
Class p[] = new Class[1]; | |
p[0] = args.getClass(); | |
Method m = c.getMethod("main", p); | |
m.invoke(c, new Object[] { args }); | |
} | |
public static Object callMethod1(Object target, String methodN, | |
Object param1, String typeParam1, ClassLoader cl) throws Exception { | |
if (target == null || param1 == null) { | |
d("Assert: Illegal params " + target + " " + param1); | |
} | |
if (dbg > 0) | |
d("callMethod1 " + target.getClass().getName() + " " | |
+ param1.getClass().getName() + " " + typeParam1); | |
Class params[] = new Class[1]; | |
if (typeParam1 == null) | |
params[0] = param1.getClass(); | |
else | |
params[0] = cl.loadClass(typeParam1); | |
Method m = findMethod(target.getClass(), methodN, params); | |
if (m == null) | |
throw new NoSuchMethodException(target.getClass().getName() + " " | |
+ methodN); | |
return m.invoke(target, new Object[] { param1 }); | |
} | |
public static Object callMethod0(Object target, String methodN) | |
throws Exception { | |
if (target == null) { | |
d("Assert: Illegal params " + target); | |
return null; | |
} | |
if (dbg > 0) | |
d("callMethod0 " + target.getClass().getName() + "." + methodN); | |
Class params[] = new Class[0]; | |
Method m = findMethod(target.getClass(), methodN, params); | |
if (m == null) | |
throw new NoSuchMethodException(target.getClass().getName() + " " | |
+ methodN); | |
return m.invoke(target, emptyArray); | |
} | |
static Object[] emptyArray = new Object[] {}; | |
public static Object callMethodN(Object target, String methodN, | |
Object params[], Class typeParams[]) throws Exception { | |
Method m = null; | |
m = findMethod(target.getClass(), methodN, typeParams); | |
if (m == null) { | |
d("Can't find method " + methodN + " in " + target + " CLASS " | |
+ target.getClass()); | |
return null; | |
} | |
Object o = m.invoke(target, params); | |
if (dbg > 0) { | |
// debug | |
StringBuffer sb = new StringBuffer(); | |
sb.append("" + target.getClass().getName() + "." + methodN + "( "); | |
for (int i = 0; i < params.length; i++) { | |
if (i > 0) | |
sb.append(", "); | |
sb.append(params[i]); | |
} | |
sb.append(")"); | |
d(sb.toString()); | |
} | |
return o; | |
} | |
public static Object convert(String object, Class paramType) { | |
Object result = null; | |
if ("java.lang.String".equals(paramType.getName())) { | |
result = object; | |
} else if ("java.lang.Integer".equals(paramType.getName()) | |
|| "int".equals(paramType.getName())) { | |
try { | |
result = new Integer(object); | |
} catch (NumberFormatException ex) { | |
} | |
// Try a setFoo ( boolean ) | |
} else if ("java.lang.Boolean".equals(paramType.getName()) | |
|| "boolean".equals(paramType.getName())) { | |
result = new Boolean(object); | |
// Try a setFoo ( InetAddress ) | |
} else if ("java.net.InetAddress".equals(paramType | |
.getName())) { | |
try { | |
result = InetAddress.getByName(object); | |
} catch (UnknownHostException exc) { | |
d("Unable to resolve host name:" + object); | |
} | |
// Unknown type | |
} else { | |
d("Unknown type " + paramType.getName()); | |
} | |
if (result == null) { | |
throw new IllegalArgumentException("Can't convert argument: " + object); | |
} | |
return result; | |
} | |
// -------------------- Get property -------------------- | |
// This provides a layer of abstraction | |
public static interface PropertySource { | |
public String getProperty(String key); | |
} | |
public static interface AttributeHolder { | |
public void setAttribute(String key, Object o); | |
} | |
// debug -------------------- | |
static final int dbg = 0; | |
static void d(String s) { | |
if (log.isDebugEnabled()) | |
log.debug("IntrospectionUtils: " + s); | |
} | |
} |