|
/***
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Project: www.simpledbm.org
* Author : Dibyendu Majumdar
* Email : dibyendu@mazumdar.demon.co.uk
*/
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* Various Class Loader utilities.
* @author Dibyendu Majumdar
* @since 14.Jan.2005
*/
public final class ClassUtils {
private static final String LOG_CLASS_NAME = ClassUtils.class.getName();
/**
* Get the ClassLoader to use. We always use the current Thread's
* Context ClassLoader. Assumption is that all threads within the
* application share the same ClassLoader.
*/
private static ClassLoader getClassLoader() {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (cl == null) {
throw new NullPointerException();
}
return cl;
}
/**
* A wrapper for Class.forName() so that we can change the behaviour
* globally without changing the rest of the code.
*
* @param name Name of the class to be loaded
* @throws ClassNotFoundException
*/
public static Class forName(String name) throws ClassNotFoundException {
ClassLoader cl = getClassLoader();
Class clazz = null;
clazz = Class.forName(name, true, cl);
return clazz;
}
/**
* Load a properties file from the classpath.
*
* @param name Name of the properties file
* @throws IOException If the properties file could not be loaded
*/
public static InputStream getResourceAsStream(String name) throws IOException {
ClassLoader cl = getClassLoader();
InputStream is = null;
is = cl.getResourceAsStream(name);
if (is == null) {
throw new IOException("Unable to load "+ " " + name);
}
return is;
}
/**
* Load a properties file from the classpath.
*
* @param name Name of the properties file
* @throws IOException If the properties file could not be loaded
*/
public static Properties getResourceAsProperties(String name) throws IOException {
ClassLoader cl = getClassLoader();
InputStream is = null;
is = cl.getResourceAsStream(name);
if (is == null) {
throw new IOException("Unable to load "+ " " + name);
}
Properties props = new Properties();
props.load(is);
return props;
}
/**
* Helper for invoking an instance method that takes a single parameter.
* This method also handles parameters of primitive type.
*
* @param cl
* The class that the instance belongs to
* @param instance
* The object on which we will invoke the method
* @param methodName
* The method name
* @param param
* The parameter
* @throws Throwable
*/
public static Object invokeMethod(Class cl, Object instance,
String methodName, Object param) throws Throwable {
Class paramClass;
if (param instanceof Integer)
paramClass = Integer.TYPE;
else if (param instanceof Long)
paramClass = Long.TYPE;
else if (param instanceof Short)
paramClass = Short.TYPE;
else if (param instanceof Boolean)
paramClass = Boolean.TYPE;
else if (param instanceof Double)
paramClass = Double.TYPE;
else if (param instanceof Float)
paramClass = Float.TYPE;
else if (param instanceof Character)
paramClass = Character.TYPE;
else if (param instanceof Byte)
paramClass = Byte.TYPE;
else
paramClass = param.getClass();
Method method = cl.getMethod(methodName,
new Class[] { paramClass });
try {
return method.invoke(instance, new Object[] { param });
} catch (InvocationTargetException e) {
throw e.getCause();
}
}
/**
* Helper for invoking a static method that takes one parameter.
*
* @param cl
* The class that implements the static method
* @param methodName
* The method name
* @param param
* A parameter
* @param paramClass
* Class of the parameter
* @throws Throwable
*/
public static Object invokeStaticMethod(Class cl, String methodName,
Object param, Class paramClass) throws Throwable {
Method method = cl.getMethod(methodName, new Class[] { paramClass });
try {
return method.invoke(null, new Object[] { param });
} catch (InvocationTargetException e) {
throw e.getCause();
}
}
/**
* Helper for invoking a constructor with one parameter.
*
* @param className Class of which an instance is to be allocated
* @param param Parameter
* @param paramClass Type of the parameter
* @throws ClassNotFoundException
* @throws SecurityException
* @throws NoSuchMethodException
* @throws IllegalArgumentException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static Object createObject(String className, Object param, Class paramClass)
throws ClassNotFoundException, SecurityException,
NoSuchMethodException, IllegalArgumentException,
InstantiationException, IllegalAccessException,
InvocationTargetException {
Class clazzImpl = ClassUtils.forName(className);
Constructor ctor = clazzImpl
.getConstructor(new Class[] { paramClass });
Object instance = ctor.newInstance(new Object[] { param });
return instance;
}
}
|