217 lines
8.4 KiB
Java
217 lines
8.4 KiB
Java
/*
|
|
* 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.catalina.tribes.demos;
|
|
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.net.InetAddress;
|
|
import java.net.UnknownHostException;
|
|
import java.util.Hashtable;
|
|
|
|
import org.apache.juli.logging.Log;
|
|
import org.apache.juli.logging.LogFactory;
|
|
|
|
/**
|
|
* Utils for introspection and reflection
|
|
*/
|
|
public final class IntrospectionUtils {
|
|
|
|
|
|
private static final Log log = LogFactory.getLog(IntrospectionUtils.class);
|
|
|
|
/*
|
|
* 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).
|
|
*/
|
|
@SuppressWarnings("null")
|
|
public static boolean setProperty(Object o, String name, String value) {
|
|
if (log.isDebugEnabled())
|
|
log.debug("IntrospectionUtils: setProperty(" +
|
|
o.getClass() + " " + name + "=" + value + ")");
|
|
|
|
String setter = "set" + capitalize(name);
|
|
|
|
try {
|
|
Method methods[] = findMethods(o.getClass());
|
|
Method setPropertyMethodVoid = null;
|
|
Method setPropertyMethodBool = 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 true;
|
|
}
|
|
}
|
|
|
|
// 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] = Integer.valueOf(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] = Long.valueOf(value);
|
|
} catch (NumberFormatException ex) {
|
|
ok = false;
|
|
}
|
|
|
|
// Try a setFoo ( boolean )
|
|
} else if ("java.lang.Boolean".equals(paramType.getName())
|
|
|| "boolean".equals(paramType.getName())) {
|
|
params[0] = Boolean.valueOf(value);
|
|
|
|
// Try a setFoo ( InetAddress )
|
|
} else if ("java.net.InetAddress".equals(paramType
|
|
.getName())) {
|
|
try {
|
|
params[0] = InetAddress.getByName(value);
|
|
} catch (UnknownHostException exc) {
|
|
if (log.isDebugEnabled())
|
|
log.debug("IntrospectionUtils: Unable to resolve host name:" + value);
|
|
ok = false;
|
|
}
|
|
|
|
// Unknown type
|
|
} else {
|
|
if (log.isDebugEnabled())
|
|
log.debug("IntrospectionUtils: Unknown type " +
|
|
paramType.getName());
|
|
}
|
|
|
|
if (ok) {
|
|
methods[i].invoke(o, params);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// save "setProperty" for later
|
|
if ("setProperty".equals(methods[i].getName())) {
|
|
if (methods[i].getReturnType()==Boolean.TYPE){
|
|
setPropertyMethodBool = methods[i];
|
|
}else {
|
|
setPropertyMethodVoid = methods[i];
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// Ok, no setXXX found, try a setProperty("name", "value")
|
|
if (setPropertyMethodBool != null || setPropertyMethodVoid != null) {
|
|
Object params[] = new Object[2];
|
|
params[0] = name;
|
|
params[1] = value;
|
|
if (setPropertyMethodBool != null) {
|
|
try {
|
|
return ((Boolean) setPropertyMethodBool.invoke(o,
|
|
params)).booleanValue();
|
|
}catch (IllegalArgumentException biae) {
|
|
//the boolean method had the wrong
|
|
//parameter types. lets try the other
|
|
if (setPropertyMethodVoid!=null) {
|
|
setPropertyMethodVoid.invoke(o, params);
|
|
return true;
|
|
}else {
|
|
throw biae;
|
|
}
|
|
}
|
|
} else {
|
|
setPropertyMethodVoid.invoke(o, params);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
} catch (IllegalArgumentException ex2) {
|
|
log.warn("IAE " + o + " " + name + " " + value, ex2);
|
|
} catch (SecurityException ex1) {
|
|
if (log.isDebugEnabled())
|
|
log.debug("IntrospectionUtils: SecurityException for " +
|
|
o.getClass() + " " + name + "=" + value + ")", ex1);
|
|
} catch (IllegalAccessException iae) {
|
|
if (log.isDebugEnabled())
|
|
log.debug("IntrospectionUtils: IllegalAccessException for " +
|
|
o.getClass() + " " + name + "=" + value + ")", iae);
|
|
} catch (InvocationTargetException ie) {
|
|
Throwable cause = ie.getCause();
|
|
if (cause instanceof ThreadDeath) {
|
|
throw (ThreadDeath) cause;
|
|
}
|
|
if (cause instanceof VirtualMachineError) {
|
|
throw (VirtualMachineError) cause;
|
|
}
|
|
if (log.isDebugEnabled())
|
|
log.debug("IntrospectionUtils: InvocationTargetException for " +
|
|
o.getClass() + " " + name + "=" + value + ")", ie);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
}
|
|
|
|
// -------------------- other utils --------------------
|
|
/**
|
|
* @deprecated Not used, but code must be updated to call it
|
|
*/
|
|
@Deprecated
|
|
public static void clear() {
|
|
objectMethods.clear();
|
|
}
|
|
|
|
static Hashtable<Class<?>,Method[]> objectMethods = new Hashtable<>();
|
|
|
|
public static Method[] findMethods(Class<?> c) {
|
|
Method methods[] = objectMethods.get(c);
|
|
if (methods != null)
|
|
return methods;
|
|
|
|
methods = c.getMethods();
|
|
objectMethods.put(c, methods);
|
|
return methods;
|
|
}
|
|
|
|
}
|