org.mule.runtime.core.api.util

Class ClassUtils

java.lang.Object

org.mule.runtime.core.api.util.ClassUtils

public class ClassUtils
extends Object

Extend the Apache Commons ClassUtils to provide additional functionality.

This class is useful for loading resources and classes in a fault tolerant manner that works across different applications servers. The resource and classloading methods are SecurityManager friendly.

Field Summary

Fields

Modifier and Type	Field and Description
static Object[]	NO_ARGS
static Class<?>[]	NO_ARGS_TYPE

Constructor Summary

Constructors

Constructor and Description
ClassUtils()

Method Summary

Modifier and Type	Method and Description
static boolean	compare(Class[] c1, Class[] c2, boolean matchOnObject)
static boolean	compare(Class[] c1, Class[] c2, boolean matchOnObject, boolean acceptNulls) Returns true if the types from array c2 are assignable to the types from c1 and the arrays are the same size.
static boolean	equal(Object a, Object b) Simple helper for writing object equalities.
static Class<?>[]	findImplementedInterfaces(Class<?> aClass) Returns the list of interfaces implemented in a given class.
static String	getClassName(Class clazz)
static URL	getClassPathRoot(Class clazz)
static Class<?>[]	getClassTypes(Object object) Used for creating an array of class types for an array or single object
static Constructor	getConstructor(Class clazz, Class[] paramTypes)
static Constructor	getConstructor(Class clazz, Class[] paramTypes, boolean exactMatch) Returns available constructor in the target class that as the parameters specified.
static <T> T	getFieldValue(Object target, String fieldName, boolean recursive)
static Method	getMethod(Class<?> clazz, String name, Class<?>[] parameterTypes) Returns a matching method for the given name and parameters on the given class If the parameterTypes arguments is null it will return the first matching method on the class.
static Method	getMethod(Class clazz, String name, Class[] parameterTypes, boolean acceptNulls)
static Class<?>[]	getParameterTypes(Object bean, String methodName)
static URL	getResource(String resourceName, Class<?> callingClass) Load a given resource.
static Enumeration<URL>	getResources(String resourceName, Class<?> callingClass) Deprecated.
static Enumeration<URL>	getResources(String resourceName, ClassLoader fallbackClassLoader) Find resources with a given name.
static List<Method>	getSatisfiableMethods(Class<?> implementation, Class<?>[] parameterTypes, boolean voidOk, boolean matchOnObject, Collection<String> ignoredMethodNames, WildcardFilter filter) A helper method that will find all matching methods on a class with the given parameter type
static List<Method>	getSatisfiableMethods(Class<?> implementation, Class<?>[] parameterTypes, boolean voidOk, boolean matchOnObject, Set<String> ignoredMethodNames) A helper method that will find all matching methods on a class with the given parameter type
static String	getSimpleName(Class clazz) Provide a simple-to-understand class name (with access to only Java 1.4 API).
static int	hash(Object[] state)
static Class<?>	initializeClass(Class<?> clazz) Ensure that the given class is properly initialized when the argument is passed in as .class literal.
static <T> T	instantiateClass(Class<? extends T> clazz, Object... constructorArgs)
static Object	instantiateClass(String name, Object... constructorArgs)
static Object	instantiateClass(String name, Object[] constructorArgs, Class<?> callingClass)
static Object	instantiateClass(String name, Object[] constructorArgs, ClassLoader classLoader)
static boolean	isClassOnPath(String className, Class currentClass) Can be used by serice endpoints to select which service to use based on what's loaded on the classpath
static boolean	isConcrete(Class<?> clazz)
static <T> boolean	isInstance(Class<T> type, Object value) Checks that value is an instance of type.
static Class	loadClass(String className, Class<?> callingClass) Load a class with a given name.
static <T extends Class> T	loadClass(String className, Class<?> callingClass, T type) Load a class with a given name.
static Class	loadClass(String className, ClassLoader classLoader) Load a class with a given name from the given classloader.
static Class<? extends Annotation>	resolveAnnotationClass(Annotation annotation)
static void	setFieldValue(Object target, String fieldName, Object value, boolean recursive)
static <T> T	withContextClassLoader(ClassLoader classLoader, Callable<T> callable) Executes the given callable using the given classLoader as the current Thread's context classloader.
static <T,E extends Exception> T	withContextClassLoader(ClassLoader classLoader, Callable<T> callable, Class<E> expectedExceptionType, ExceptionHandler<T,E> exceptionHandler) Executes the given callable using the given classLoader as the current Thread's context classloader.
static void	withContextClassLoader(ClassLoader classLoader, Runnable runnable) Executes the given runnable using the given classLoader as the current Thread's context classloader.
static Class[]	wrappersToPrimitives(Class[] wrappers)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

NO_ARGS

public static final Object[] NO_ARGS

NO_ARGS_TYPE

public static final Class<?>[] NO_ARGS_TYPE

Constructor Detail

ClassUtils

public ClassUtils()

Method Detail

isConcrete

public static boolean isConcrete(Class<?> clazz)

getResource

public static URL getResource(String resourceName,
                              Class<?> callingClass)

Load a given resource.

This method will try to load the resource using the following methods (in order):

• From Thread.currentThread().getContextClassLoader()
• From ClassUtils.class.getClassLoader()
• From the callingClass.getClassLoader()

Parameters:

resourceName - The name of the resource to load

callingClass - The Class object of the calling object

Returns:

A URL pointing to the resource to load or null if the resource is not found

getResources

@Deprecated
public static Enumeration<URL> getResources(String resourceName,
                                                        Class<?> callingClass)

Deprecated.

getResources

public static Enumeration<URL> getResources(String resourceName,
                                            ClassLoader fallbackClassLoader)

Find resources with a given name.

Resources are searched in the following order:

• current thread's context classLoader
• ClassUtilss class classLoader
• fallbackClassLoader passed on the parameter

Search stops as soon as any of the mentioned classLoaders has found a matching resource.

Parameters:

resourceName - resource being searched. Non empty.

fallbackClassLoader - classloader used to fallback the search. Non null.

Returns:

a non null Enumeration containing the found resources. Can be empty.

loadClass

public static Class loadClass(String className,
                              Class<?> callingClass)
                       throws ClassNotFoundException

Load a class with a given name.

It will try to load the class in the following order:

• From Thread.currentThread().getContextClassLoader()
• Using the basic Class.forName(java.lang.String)
• From ClassLoaderUtil.class.getClassLoader()
• From the callingClass.getClassLoader()

Parameters:

className - The name of the class to load

callingClass - The Class object of the calling object

Returns:

The Class instance

Throws:

ClassNotFoundException - If the class cannot be found anywhere.

loadClass

public static <T extends Class> T loadClass(String className,
                                            Class<?> callingClass,
                                            T type)
                                     throws ClassNotFoundException

Load a class with a given name.

It will try to load the class in the following order:

• From Thread.currentThread().getContextClassLoader()
• Using the basic Class.forName(java.lang.String)
• From ClassLoaderUtil.class.getClassLoader()
• From the callingClass.getClassLoader()

Parameters:

className - The name of the class to load

callingClass - The Class object of the calling object

type - the class type to expect to load

Returns:

The Class instance

Throws:

ClassNotFoundException - If the class cannot be found anywhere.

loadClass

public static Class loadClass(String className,
                              ClassLoader classLoader)
                       throws ClassNotFoundException

Load a class with a given name from the given classloader.

Parameters:

className - the name of the class to load

classLoader - the loader to load it from

Returns:

the instance of the class

Throws:

ClassNotFoundException - if the class is not available in the class loader

getFieldValue

public static <T> T getFieldValue(Object target,
                                  String fieldName,
                                  boolean recursive)
                           throws IllegalAccessException,
                                  NoSuchFieldException

Throws:

IllegalAccessException

NoSuchFieldException

setFieldValue

public static void setFieldValue(Object target,
                                 String fieldName,
                                 Object value,
                                 boolean recursive)
                          throws IllegalAccessException,
                                 NoSuchFieldException

Throws:

IllegalAccessException

NoSuchFieldException

initializeClass

public static Class<?> initializeClass(Class<?> clazz)

Ensure that the given class is properly initialized when the argument is passed in as .class literal. This method can never fail unless the bytecode is corrupted or the VM is otherwise seriously confused.

Parameters:

clazz - the Class to be initialized

Returns:

the same class but initialized

instantiateClass

public static <T> T instantiateClass(Class<? extends T> clazz,
                                     Object... constructorArgs)
                              throws SecurityException,
                                     NoSuchMethodException,
                                     IllegalArgumentException,
                                     InstantiationException,
                                     IllegalAccessException,
                                     InvocationTargetException

Throws:

SecurityException

NoSuchMethodException

IllegalArgumentException

InstantiationException

IllegalAccessException

InvocationTargetException

instantiateClass

public static Object instantiateClass(String name,
                                      Object... constructorArgs)
                               throws ClassNotFoundException,
                                      SecurityException,
                                      NoSuchMethodException,
                                      IllegalArgumentException,
                                      InstantiationException,
                                      IllegalAccessException,
                                      InvocationTargetException

Throws:

ClassNotFoundException

SecurityException

NoSuchMethodException

IllegalArgumentException

InstantiationException

IllegalAccessException

InvocationTargetException

instantiateClass

public static Object instantiateClass(String name,
                                      Object[] constructorArgs,
                                      Class<?> callingClass)
                               throws ClassNotFoundException,
                                      SecurityException,
                                      NoSuchMethodException,
                                      IllegalArgumentException,
                                      InstantiationException,
                                      IllegalAccessException,
                                      InvocationTargetException

Throws:

ClassNotFoundException

SecurityException

NoSuchMethodException

IllegalArgumentException

InstantiationException

IllegalAccessException

InvocationTargetException

instantiateClass

public static Object instantiateClass(String name,
                                      Object[] constructorArgs,
                                      ClassLoader classLoader)
                               throws ClassNotFoundException,
                                      SecurityException,
                                      NoSuchMethodException,
                                      IllegalArgumentException,
                                      InstantiationException,
                                      IllegalAccessException,
                                      InvocationTargetException

Throws:

ClassNotFoundException

SecurityException

NoSuchMethodException

IllegalArgumentException

InstantiationException

IllegalAccessException

InvocationTargetException

getParameterTypes

public static Class<?>[] getParameterTypes(Object bean,
                                           String methodName)

getMethod

public static Method getMethod(Class<?> clazz,
                               String name,
                               Class<?>[] parameterTypes)

Returns a matching method for the given name and parameters on the given class If the parameterTypes arguments is null it will return the first matching method on the class.

Parameters:

clazz - the class to find the method on

name - the method name to find

parameterTypes - an array of argument types or null

Returns:

the Method object or null if none was found

getMethod

public static Method getMethod(Class clazz,
                               String name,
                               Class[] parameterTypes,
                               boolean acceptNulls)

getConstructor

public static Constructor getConstructor(Class clazz,
                                         Class[] paramTypes)

getConstructor

public static Constructor getConstructor(Class clazz,
                                         Class[] paramTypes,
                                         boolean exactMatch)

Returns available constructor in the target class that as the parameters specified.

Parameters:

clazz - the class to search

paramTypes - the param types to match against

exactMatch - should exact types be used (i.e. equals rather than isAssignableFrom.)

Returns:

The matching constructor or null if no matching constructor is found

getSatisfiableMethods

public static List<Method> getSatisfiableMethods(Class<?> implementation,
                                                 Class<?>[] parameterTypes,
                                                 boolean voidOk,
                                                 boolean matchOnObject,
                                                 Set<String> ignoredMethodNames)

A helper method that will find all matching methods on a class with the given parameter type

Parameters:

implementation - the class to build methods on

parameterTypes - the argument param types to look for

voidOk - whether void methods shouldbe included in the found list

matchOnObject - determines whether parameters of Object type are matched when they are of Object.class type

ignoredMethodNames - a Set of method names to ignore. Often 'equals' is not a desired match. This argument can be null.

Returns:

a List of methods on the class that match the criteria. If there are none, an empty list is returned

getSatisfiableMethods

public static List<Method> getSatisfiableMethods(Class<?> implementation,
                                                 Class<?>[] parameterTypes,
                                                 boolean voidOk,
                                                 boolean matchOnObject,
                                                 Collection<String> ignoredMethodNames,
                                                 WildcardFilter filter)

A helper method that will find all matching methods on a class with the given parameter type

Parameters:

implementation - the class to build methods on

parameterTypes - the argument param types to look for

voidOk - whether void methods shouldbe included in the found list

matchOnObject - determines whether parameters of Object type are matched when they are of Object.class type

ignoredMethodNames - a Set of method names to ignore. Often 'equals' is not a desired match. This argument can be null.

filter - Wildcard expression filter that allows methods to be matched using wildcards i.e. 'get*'

Returns:

a List of methods on the class that match the criteria. If there are none, an empty list is returned

isClassOnPath

public static boolean isClassOnPath(String className,
                                    Class currentClass)

Can be used by serice endpoints to select which service to use based on what's loaded on the classpath

Parameters:

className - The class name to look for

currentClass - the calling class

Returns:

true if the class is on the path

getClassTypes

public static Class<?>[] getClassTypes(Object object)

Used for creating an array of class types for an array or single object

Parameters:

object - single object or array. If this parameter is null or a zero length array then NO_ARGS_TYPE is returned

Returns:

an array of class types for the object

getClassName

public static String getClassName(Class clazz)

compare

public static boolean compare(Class[] c1,
                              Class[] c2,
                              boolean matchOnObject)

compare

public static boolean compare(Class[] c1,
                              Class[] c2,
                              boolean matchOnObject,
                              boolean acceptNulls)

Returns true if the types from array c2 are assignable to the types from c1 and the arrays are the same size. If matchOnObject argument is true and there is a parameter of type Object in c1 then the method returns false. If acceptNulls argument is true, null values are accepted in c2.

Parameters:

c1 - parameter types array

c2 - parameter types array

matchOnObject - return false if there is a parameter of type Object in c1

acceptNulls - allows null parameter types in c2

Returns:

true if arrays are the same size and the types assignable from c2 to c1

wrappersToPrimitives

public static Class[] wrappersToPrimitives(Class[] wrappers)

getSimpleName

public static String getSimpleName(Class clazz)

Provide a simple-to-understand class name (with access to only Java 1.4 API).

Parameters:

clazz - The class whose name we will generate

Returns:

A readable name for the class

equal

public static boolean equal(Object a,
                            Object b)

Simple helper for writing object equalities.

TODO Is there a better place for this?

Parameters:

a - object to compare

b - object to be compared to

Returns:

true if the objects are equal (value or reference), false otherwise

hash

public static int hash(Object[] state)

getClassPathRoot

public static URL getClassPathRoot(Class clazz)

resolveAnnotationClass

public static Class<? extends Annotation> resolveAnnotationClass(Annotation annotation)

isInstance

public static <T> boolean isInstance(Class<T> type,
                                     Object value)

Checks that value is an instance of type.

The value that this method adds over something like Class.isInstance(Object) is that it also considers the case in which type and value are evaluate by isWrapperAndPrimitivePair(Class, Class) as true

Type Parameters:

T - the generic type of type

Parameters:

type - the Class you want to check the value against

value - an instance you want to verify is instance of type

Returns:

true if value is an instance of type or if they are a wrapper-primitive pair. false otherwise

withContextClassLoader

public static void withContextClassLoader(ClassLoader classLoader,
                                          Runnable runnable)

Executes the given runnable using the given classLoader as the current Thread's context classloader.

This method guarantees that whatever the outcome, the thread's context classloader is set back to the value that it had before executing this method

Parameters:

classLoader - the context ClassLoader on which the runnable should be executed

runnable - a closure

withContextClassLoader

public static <T> T withContextClassLoader(ClassLoader classLoader,
                                           Callable<T> callable)

Executes the given callable using the given classLoader as the current Thread's context classloader.

This method guarantees that whatever the outcome, the thread's context classloader is set back to the value that it had before executing this method

Parameters:

classLoader - the context ClassLoader on which the runnable should be executed

callable - a Callable

Returns:

the value that the callable produced

withContextClassLoader

public static <T,E extends Exception> T withContextClassLoader(ClassLoader classLoader,
                                                               Callable<T> callable,
                                                               Class<E> expectedExceptionType,
                                                               ExceptionHandler<T,E> exceptionHandler)
                                                        throws E extends Exception

Executes the given callable using the given classLoader as the current Thread's context classloader.

This method guarantees that whatever the outcome, the thread's context classloader is set back to the value that it had before executing this method.

This method also accounts for the possibility of the callable to throw and exception of type expectedExceptionType. If that happens, then the exception is re-thrown. If the callable throws a RuntimeException of a different type, it is also re-thrown. Finally, if an exception of any other type is found, then it is handled delegating into the exceptionHandler which might in turn throw another exception of expectedExceptionType or return a value

Type Parameters:

T - the generic type of the return value

E - the generic type of the expected exception

Parameters:

classLoader - the context ClassLoader on which the runnable should be executed

callable - a Callable

expectedExceptionType - the type of exception which is expected to be thrown

exceptionHandler - a ExceptionHandler in case an unexpected exception is found instead

Returns:

a value returned by either the callable or the exceptionHandler

Throws:

E - if the expected exception is actually thrown

E extends Exception

findImplementedInterfaces

public static Class<?>[] findImplementedInterfaces(Class<?> aClass)

Returns the list of interfaces implemented in a given class.

Parameters:

aClass - class to analyze. Non null.

Returns:

the list of interfaces implemented in the provided class and all its super classes.