Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.mule.util
Class ClassUtils

    java.lang.Object
      org.apache.commons.lang.ClassUtils
          org.mule.util.ClassUtils

    public class ClassUtils

extends ClassUtils

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
`static Object[]` | `NO_ARGS`
`static Class<?>[]` | `NO_ARGS_TYPE`

Fields inherited from class org.apache.commons.lang.ClassUtils
`INNER_CLASS_SEPARATOR, INNER_CLASS_SEPARATOR_CHAR, PACKAGE_SEPARATOR, PACKAGE_SEPARATOR_CHAR`

Constructor Summary
`ClassUtils()`

Method Summary
`static void` | `addLibrariesToClasspath(List urls)`
`static boolean` | `compare(Class[] c1, Class[] c2, boolean matchOnObject)`
`static boolean` | `equal(Object a, Object b)` Simple helper for writing object equalities.
`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 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 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)`
`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 List<Method>` | `getSatisfiableMethodsWithReturnType(Class implementation, Class returnType, boolean matchOnObject, Set<String> ignoredMethodNames)` Match all method son a class with a defined return 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`
` | `instanciateClass(Class<? extends T> clazz, Object... constructorArgs)`
`static Object` | `instanciateClass(String name, Object... constructorArgs)`
`static Object` | `instanciateClass(String name, Object[] constructorArgs, Class<?> callingClass)`
`static Object` | `instanciateClass(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 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[]` | `wrappersToPrimitives(Class[] wrappers)`
`static Class` | `wrapperToPrimitive(Class wrapper)`

Methods inherited from class org.apache.commons.lang.ClassUtils
`convertClassesToClassNames, convertClassNamesToClasses, getAllInterfaces, getAllSuperclasses, getClass, getClass, getClass, getClass, getPackageCanonicalName, getPackageCanonicalName, getPackageCanonicalName, getPackageName, getPackageName, getPackageName, getPublicMethod, getShortCanonicalName, getShortCanonicalName, getShortCanonicalName, getShortClassName, getShortClassName, getShortClassName, isAssignable, isAssignable, isInnerClass, primitivesToWrappers, primitiveToWrapper, toClass`

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

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

### 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

### 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

### instanciateClass

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

  Throws:
    `SecurityException`
    `NoSuchMethodException`
    `IllegalArgumentException`
    `InstantiationException`
    `IllegalAccessException`
    `InvocationTargetException`

### instanciateClass

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

  Throws:
    `ClassNotFoundException`
    `SecurityException`
    `NoSuchMethodException`
    `IllegalArgumentException`
    `InstantiationException`
    `IllegalAccessException`
    `InvocationTargetException`

### instanciateClass

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

  Throws:
    `ClassNotFoundException`
    `SecurityException`
    `NoSuchMethodException`
    `IllegalArgumentException`
    `InstantiationException`
    `IllegalAccessException`
    `InvocationTargetException`

### instanciateClass

    public static Object instanciateClass(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

### 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

### getSatisfiableMethodsWithReturnType

    public static List<Method> getSatisfiableMethodsWithReturnType(Class implementation,
                                                                   Class returnType,
                                                                   boolean matchOnObject,
                                                                   Set<String> ignoredMethodNames)

  Match all method son a class with a defined return type

  Parameters:
    `implementation` - the class to search
    `returnType` - the return type to match
    `matchOnObject` - whether `Object` methods should be matched
    `ignoredMethodNames` - a set of method names to ignore
  Returns:
    the list of methods that matched the return type and criteria. If none are found an empty result 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)

### wrapperToPrimitive

    public static Class wrapperToPrimitive(Class wrapper)

### 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)

### addLibrariesToClasspath

    public static void addLibrariesToClasspath(List urls)
                                        throws NoSuchMethodException,
                                               IllegalAccessException,
                                               InvocationTargetException

  Throws:
    `NoSuchMethodException`
    `IllegalAccessException`
    `InvocationTargetException`

### getClassPathRoot

    public static URL getClassPathRoot(Class clazz)

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2010 MuleSoft, Inc.. All Rights Reserved.