package vnet.sms.common.shell.springshell.internal.util;
/*
* Copyright 2002-2010 the original author or authors.
*
* 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.
*/
import java.beans.Introspector;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
/**
* Miscellaneous class utility methods. Mainly for internal use within the
* framework; consider <a href="http://commons.apache.org/lang/"
* target="_blank">Apache Commons Lang</a> for a more comprehensive suite of
* class utilities.
*
* @author Juergen Hoeller
* @author Keith Donald
* @author Rob Harrop
* @author Sam Brannen
* @since 1.1
* @see vnet.sms.common.util.TypeUtils
* @see ReflectionUtils
*/
@SuppressWarnings("all")
public abstract class ClassUtils {
/** Suffix for array class names: "[]" */
public static final String ARRAY_SUFFIX = "[]";
/** Prefix for internal array class names: "[" */
private static final String INTERNAL_ARRAY_PREFIX = "[";
/** Prefix for internal non-primitive array class names: "[L" */
private static final String NON_PRIMITIVE_ARRAY_PREFIX = "[L";
/** The package separator character '.' */
private static final char PACKAGE_SEPARATOR = '.';
/** The inner class separator character '$' */
private static final char INNER_CLASS_SEPARATOR = '$';
/** The CGLIB class separator character "$$" */
public static final String CGLIB_CLASS_SEPARATOR = "$$";
/** The ".class" file suffix */
public static final String CLASS_FILE_SUFFIX = ".class";
/**
* Map with primitive wrapper type as key and corresponding primitive type
* as value, for example: Integer.class -> int.class.
*/
private static final Map<Class<?>, Class<?>> primitiveWrapperTypeMap = new HashMap<Class<?>, Class<?>>(
8);
/**
* Map with primitive type as key and corresponding wrapper type as value,
* for example: int.class -> Integer.class.
*/
private static final Map<Class<?>, Class<?>> primitiveTypeToWrapperMap = new HashMap<Class<?>, Class<?>>(
8);
/**
* Map with primitive type name as key and corresponding primitive type as
* value, for example: "int" -> "int.class".
*/
private static final Map<String, Class<?>> primitiveTypeNameMap = new HashMap<String, Class<?>>(
32);
/**
* Map with common "java.lang" class name as key and corresponding Class as
* value. Primarily for efficient deserialization of remote invocations.
*/
private static final Map<String, Class<?>> commonClassCache = new HashMap<String, Class<?>>(
32);
static {
primitiveWrapperTypeMap.put(Boolean.class, boolean.class);
primitiveWrapperTypeMap.put(Byte.class, byte.class);
primitiveWrapperTypeMap.put(Character.class, char.class);
primitiveWrapperTypeMap.put(Double.class, double.class);
primitiveWrapperTypeMap.put(Float.class, float.class);
primitiveWrapperTypeMap.put(Integer.class, int.class);
primitiveWrapperTypeMap.put(Long.class, long.class);
primitiveWrapperTypeMap.put(Short.class, short.class);
for (final Map.Entry<Class<?>, Class<?>> entry : primitiveWrapperTypeMap
.entrySet()) {
primitiveTypeToWrapperMap.put(entry.getValue(), entry.getKey());
registerCommonClasses(entry.getKey());
}
final Set<Class<?>> primitiveTypes = new HashSet<Class<?>>(32);
primitiveTypes.addAll(primitiveWrapperTypeMap.values());
primitiveTypes.addAll(Arrays.asList(boolean[].class, byte[].class,
char[].class, double[].class, float[].class, int[].class,
long[].class, short[].class));
primitiveTypes.add(void.class);
for (final Class<?> primitiveType : primitiveTypes) {
primitiveTypeNameMap.put(primitiveType.getName(), primitiveType);
}
registerCommonClasses(Boolean[].class, Byte[].class, Character[].class,
Double[].class, Float[].class, Integer[].class, Long[].class,
Short[].class);
registerCommonClasses(Number.class, Number[].class, String.class,
String[].class, Object.class, Object[].class, Class.class,
Class[].class);
registerCommonClasses(Throwable.class, Exception.class,
RuntimeException.class, Error.class, StackTraceElement.class,
StackTraceElement[].class);
}
/**
* Register the given common classes with the ClassUtils cache.
*/
private static void registerCommonClasses(final Class<?>... commonClasses) {
for (final Class<?> clazz : commonClasses) {
commonClassCache.put(clazz.getName(), clazz);
}
}
/**
* Return the default ClassLoader to use: typically the thread context
* ClassLoader, if available; the ClassLoader that loaded the ClassUtils
* class will be used as fallback.
* <p>
* Call this method if you intend to use the thread context ClassLoader in a
* scenario where you absolutely need a non-null ClassLoader reference: for
* example, for class path resource loading (but not necessarily for
* <code>Class.forName</code>, which accepts a <code>null</code> ClassLoader
* reference as well).
*
* @return the default ClassLoader (never <code>null</code>)
* @see java.lang.Thread#getContextClassLoader()
*/
public static ClassLoader getDefaultClassLoader() {
ClassLoader cl = null;
try {
cl = Thread.currentThread().getContextClassLoader();
} catch (final Throwable ex) {
// Cannot access thread context ClassLoader - falling back to system
// class loader...
}
if (cl == null) {
// No thread context class loader -> use class loader of this class.
cl = ClassUtils.class.getClassLoader();
}
return cl;
}
/**
* Override the thread context ClassLoader with the environment's bean
* ClassLoader if necessary, i.e. if the bean ClassLoader is not equivalent
* to the thread context ClassLoader already.
*
* @param classLoaderToUse
* the actual ClassLoader to use for the thread context
* @return the original thread context ClassLoader, or <code>null</code> if
* not overridden
*/
public static ClassLoader overrideThreadContextClassLoader(
final ClassLoader classLoaderToUse) {
final Thread currentThread = Thread.currentThread();
final ClassLoader threadContextClassLoader = currentThread
.getContextClassLoader();
if ((classLoaderToUse != null)
&& !classLoaderToUse.equals(threadContextClassLoader)) {
currentThread.setContextClassLoader(classLoaderToUse);
return threadContextClassLoader;
}
return null;
}
/**
* Replacement for <code>Class.forName()</code> that also returns Class
* instances for primitives (like "int") and array class names (like
* "String[]").
* <p>
* Always uses the default class loader: that is, preferably the thread
* context class loader, or the ClassLoader that loaded the ClassUtils class
* as fallback.
*
* @param name
* the name of the Class
* @return Class instance for the supplied name
* @throws ClassNotFoundException
* if the class was not found
* @throws LinkageError
* if the class file could not be loaded
* @see Class#forName(String, boolean, ClassLoader)
* @see #getDefaultClassLoader()
* @deprecated as of Spring 3.0, in favor of specifying a ClassLoader
* explicitly: see {@link #forName(String, ClassLoader)}
*/
@Deprecated
public static Class<?> forName(final String name)
throws ClassNotFoundException, LinkageError {
return forName(name, getDefaultClassLoader());
}
/**
* Replacement for <code>Class.forName()</code> that also returns Class
* instances for primitives (e.g."int") and array class names (e.g.
* "String[]"). Furthermore, it is also capable of resolving inner class
* names in Java source style (e.g. "java.lang.Thread.State" instead of
* "java.lang.Thread$State").
*
* @param name
* the name of the Class
* @param classLoader
* the class loader to use (may be <code>null</code>, which
* indicates the default class loader)
* @return Class instance for the supplied name
* @throws ClassNotFoundException
* if the class was not found
* @throws LinkageError
* if the class file could not be loaded
* @see Class#forName(String, boolean, ClassLoader)
*/
public static Class<?> forName(final String name,
final ClassLoader classLoader) throws ClassNotFoundException,
LinkageError {
Assert.notNull(name, "Name must not be null");
Class<?> clazz = resolvePrimitiveClassName(name);
if (clazz == null) {
clazz = commonClassCache.get(name);
}
if (clazz != null) {
return clazz;
}
// "java.lang.String[]" style arrays
if (name.endsWith(ARRAY_SUFFIX)) {
final String elementClassName = name.substring(0, name.length()
- ARRAY_SUFFIX.length());
final Class<?> elementClass = forName(elementClassName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
}
// "[Ljava.lang.String;" style arrays
if (name.startsWith(NON_PRIMITIVE_ARRAY_PREFIX) && name.endsWith(";")) {
final String elementName = name.substring(
NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1);
final Class<?> elementClass = forName(elementName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
}
// "[[I" or "[[Ljava.lang.String;" style arrays
if (name.startsWith(INTERNAL_ARRAY_PREFIX)) {
final String elementName = name.substring(INTERNAL_ARRAY_PREFIX
.length());
final Class<?> elementClass = forName(elementName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
}
ClassLoader classLoaderToUse = classLoader;
if (classLoaderToUse == null) {
classLoaderToUse = getDefaultClassLoader();
}
try {
return classLoaderToUse.loadClass(name);
} catch (final ClassNotFoundException ex) {
final int lastDotIndex = name.lastIndexOf('.');
if (lastDotIndex != -1) {
final String innerClassName = name.substring(0, lastDotIndex)
+ '$' + name.substring(lastDotIndex + 1);
try {
return classLoaderToUse.loadClass(innerClassName);
} catch (final ClassNotFoundException ex2) {
// swallow - let original exception get through
}
}
throw ex;
}
}
/**
* Resolve the given class name into a Class instance. Supports primitives
* (like "int") and array class names (like "String[]").
* <p>
* This is effectively equivalent to the <code>forName</code> method with
* the same arguments, with the only difference being the exceptions thrown
* in case of class loading failure.
*
* @param className
* the name of the Class
* @param classLoader
* the class loader to use (may be <code>null</code>, which
* indicates the default class loader)
* @return Class instance for the supplied name
* @throws IllegalArgumentException
* if the class name was not resolvable (that is, the class
* could not be found or the class file could not be loaded)
* @see #forName(String, ClassLoader)
*/
public static Class<?> resolveClassName(final String className,
final ClassLoader classLoader) throws IllegalArgumentException {
try {
return forName(className, classLoader);
} catch (final ClassNotFoundException ex) {
throw new IllegalArgumentException("Cannot find class ["
+ className + "]", ex);
} catch (final LinkageError ex) {
throw new IllegalArgumentException("Error loading class ["
+ className
+ "]: problem with class file or dependent class.", ex);
}
}
/**
* Resolve the given class name as primitive class, if appropriate,
* according to the JVM's naming rules for primitive classes.
* <p>
* Also supports the JVM's internal class names for primitive arrays. Does
* <i>not</i> support the "[]" suffix notation for primitive arrays; this is
* only supported by {@link #forName(String, ClassLoader)}.
*
* @param name
* the name of the potentially primitive class
* @return the primitive class, or <code>null</code> if the name does not
* denote a primitive class or primitive array class
*/
public static Class<?> resolvePrimitiveClassName(final String name) {
Class<?> result = null;
// Most class names will be quite long, considering that they
// SHOULD sit in a package, so a length check is worthwhile.
if ((name != null) && (name.length() <= 8)) {
// Could be a primitive - likely.
result = primitiveTypeNameMap.get(name);
}
return result;
}
/**
* Determine whether the {@link Class} identified by the supplied name is
* present and can be loaded. Will return <code>false</code> if either the
* class or one of its dependencies is not present or cannot be loaded.
*
* @param className
* the name of the class to check
* @return whether the specified class is present
* @deprecated as of Spring 2.5, in favor of
* {@link #isPresent(String, ClassLoader)}
*/
@Deprecated
public static boolean isPresent(final String className) {
return isPresent(className, getDefaultClassLoader());
}
/**
* Determine whether the {@link Class} identified by the supplied name is
* present and can be loaded. Will return <code>false</code> if either the
* class or one of its dependencies is not present or cannot be loaded.
*
* @param className
* the name of the class to check
* @param classLoader
* the class loader to use (may be <code>null</code>, which
* indicates the default class loader)
* @return whether the specified class is present
*/
public static boolean isPresent(final String className,
final ClassLoader classLoader) {
try {
forName(className, classLoader);
return true;
} catch (final Throwable ex) {
// Class or one of its dependencies is not present...
return false;
}
}
/**
* Return the user-defined class for the given instance: usually simply the
* class of the given instance, but the original class in case of a
* CGLIB-generated subclass.
*
* @param instance
* the instance to check
* @return the user-defined class
*/
public static Class<?> getUserClass(final Object instance) {
Assert.notNull(instance, "Instance must not be null");
return getUserClass(instance.getClass());
}
/**
* Return the user-defined class for the given class: usually simply the
* given class, but the original class in case of a CGLIB-generated
* subclass.
*
* @param clazz
* the class to check
* @return the user-defined class
*/
public static Class<?> getUserClass(final Class<?> clazz) {
if ((clazz != null) && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
final Class<?> superClass = clazz.getSuperclass();
if ((superClass != null) && !Object.class.equals(superClass)) {
return superClass;
}
}
return clazz;
}
/**
* Check whether the given class is cache-safe in the given context, i.e.
* whether it is loaded by the given ClassLoader or a parent of it.
*
* @param clazz
* the class to analyze
* @param classLoader
* the ClassLoader to potentially cache metadata in
*/
public static boolean isCacheSafe(final Class<?> clazz,
final ClassLoader classLoader) {
Assert.notNull(clazz, "Class must not be null");
final ClassLoader target = clazz.getClassLoader();
if (target == null) {
return false;
}
ClassLoader cur = classLoader;
if (cur == target) {
return true;
}
while (cur != null) {
cur = cur.getParent();
if (cur == target) {
return true;
}
}
return false;
}
/**
* Get the class name without the qualified package name.
*
* @param className
* the className to get the short name for
* @return the class name of the class without the package name
* @throws IllegalArgumentException
* if the className is empty
*/
public static String getShortName(final String className) {
Assert.hasLength(className, "Class name must not be empty");
final int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
int nameEndIndex = className.indexOf(CGLIB_CLASS_SEPARATOR);
if (nameEndIndex == -1) {
nameEndIndex = className.length();
}
String shortName = className.substring(lastDotIndex + 1, nameEndIndex);
shortName = shortName.replace(INNER_CLASS_SEPARATOR, PACKAGE_SEPARATOR);
return shortName;
}
/**
* Get the class name without the qualified package name.
*
* @param clazz
* the class to get the short name for
* @return the class name of the class without the package name
*/
public static String getShortName(final Class<?> clazz) {
return getShortName(getQualifiedName(clazz));
}
/**
* Return the short string name of a Java class in uncapitalized JavaBeans
* property format. Strips the outer class name in case of an inner class.
*
* @param clazz
* the class
* @return the short name rendered in a standard JavaBeans property format
* @see java.beans.Introspector#decapitalize(String)
*/
public static String getShortNameAsProperty(final Class<?> clazz) {
String shortName = ClassUtils.getShortName(clazz);
final int dotIndex = shortName.lastIndexOf('.');
shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1)
: shortName);
return Introspector.decapitalize(shortName);
}
/**
* Determine the name of the class file, relative to the containing package:
* e.g. "String.class"
*
* @param clazz
* the class
* @return the file name of the ".class" file
*/
public static String getClassFileName(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
final String className = clazz.getName();
final int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
return className.substring(lastDotIndex + 1) + CLASS_FILE_SUFFIX;
}
/**
* Determine the name of the package of the given class: e.g. "java.lang"
* for the <code>java.lang.String</code> class.
*
* @param clazz
* the class
* @return the package name, or the empty String if the class is defined in
* the default package
*/
public static String getPackageName(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
final String className = clazz.getName();
final int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
return (lastDotIndex != -1 ? className.substring(0, lastDotIndex) : "");
}
/**
* Return the qualified name of the given class: usually simply the class
* name, but component type class name + "[]" for arrays.
*
* @param clazz
* the class
* @return the qualified name of the class
*/
public static String getQualifiedName(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
if (clazz.isArray()) {
return getQualifiedNameForArray(clazz);
} else {
return clazz.getName();
}
}
/**
* Build a nice qualified name for an array: component type class name +
* "[]".
*
* @param clazz
* the array class
* @return a qualified name for the array class
*/
private static String getQualifiedNameForArray(Class<?> clazz) {
final StringBuilder result = new StringBuilder();
while (clazz.isArray()) {
clazz = clazz.getComponentType();
result.append(ClassUtils.ARRAY_SUFFIX);
}
result.insert(0, clazz.getName());
return result.toString();
}
/**
* Return the qualified name of the given method, consisting of fully
* qualified interface/class name + "." + method name.
*
* @param method
* the method
* @return the qualified name of the method
*/
public static String getQualifiedMethodName(final Method method) {
Assert.notNull(method, "Method must not be null");
return method.getDeclaringClass().getName() + "." + method.getName();
}
/**
* Return a descriptive name for the given object's type: usually simply the
* class name, but component type class name + "[]" for arrays, and an
* appended list of implemented interfaces for JDK proxies.
*
* @param value
* the value to introspect
* @return the qualified name of the class
*/
public static String getDescriptiveType(final Object value) {
if (value == null) {
return null;
}
final Class<?> clazz = value.getClass();
if (Proxy.isProxyClass(clazz)) {
final StringBuilder result = new StringBuilder(clazz.getName());
result.append(" implementing ");
final Class<?>[] ifcs = clazz.getInterfaces();
for (int i = 0; i < ifcs.length; i++) {
result.append(ifcs[i].getName());
if (i < ifcs.length - 1) {
result.append(',');
}
}
return result.toString();
} else if (clazz.isArray()) {
return getQualifiedNameForArray(clazz);
} else {
return clazz.getName();
}
}
/**
* Check whether the given class matches the user-specified type name.
*
* @param clazz
* the class to check
* @param typeName
* the type name to match
*/
public static boolean matchesTypeName(final Class<?> clazz,
final String typeName) {
return ((typeName != null) && (typeName.equals(clazz.getName())
|| typeName.equals(clazz.getSimpleName()) || (clazz.isArray() && typeName
.equals(getQualifiedNameForArray(clazz)))));
}
/**
* Determine whether the given class has a public constructor with the given
* signature.
* <p>
* Essentially translates <code>NoSuchMethodException</code> to "false".
*
* @param clazz
* the clazz to analyze
* @param parameterTypes
* the parameter types of the method
* @return whether the class has a corresponding constructor
* @see java.lang.Class#getMethod
*/
public static boolean hasConstructor(final Class<?> clazz,
final Class<?>... parameterTypes) {
return (getConstructorIfAvailable(clazz, parameterTypes) != null);
}
/**
* Determine whether the given class has a public constructor with the given
* signature, and return it if available (else return <code>null</code>).
* <p>
* Essentially translates <code>NoSuchMethodException</code> to
* <code>null</code>.
*
* @param clazz
* the clazz to analyze
* @param parameterTypes
* the parameter types of the method
* @return the constructor, or <code>null</code> if not found
* @see java.lang.Class#getConstructor
*/
public static <T> Constructor<T> getConstructorIfAvailable(
final Class<T> clazz, final Class<?>... parameterTypes) {
Assert.notNull(clazz, "Class must not be null");
try {
return clazz.getConstructor(parameterTypes);
} catch (final NoSuchMethodException ex) {
return null;
}
}
/**
* Determine whether the given class has a method with the given signature.
* <p>
* Essentially translates <code>NoSuchMethodException</code> to "false".
*
* @param clazz
* the clazz to analyze
* @param methodName
* the name of the method
* @param parameterTypes
* the parameter types of the method
* @return whether the class has a corresponding method
* @see java.lang.Class#getMethod
*/
public static boolean hasMethod(final Class<?> clazz,
final String methodName, final Class<?>... parameterTypes) {
return (getMethodIfAvailable(clazz, methodName, parameterTypes) != null);
}
/**
* Determine whether the given class has a method with the given signature,
* and return it if available (else return <code>null</code>).
* <p>
* Essentially translates <code>NoSuchMethodException</code> to
* <code>null</code>.
*
* @param clazz
* the clazz to analyze
* @param methodName
* the name of the method
* @param parameterTypes
* the parameter types of the method
* @return the method, or <code>null</code> if not found
* @see java.lang.Class#getMethod
*/
public static Method getMethodIfAvailable(final Class<?> clazz,
final String methodName, final Class<?>... parameterTypes) {
Assert.notNull(clazz, "Class must not be null");
Assert.notNull(methodName, "Method name must not be null");
try {
return clazz.getMethod(methodName, parameterTypes);
} catch (final NoSuchMethodException ex) {
return null;
}
}
/**
* Return the number of methods with a given name (with any argument types),
* for the given class and/or its superclasses. Includes non-public methods.
*
* @param clazz
* the clazz to check
* @param methodName
* the name of the method
* @return the number of methods with the given name
*/
public static int getMethodCountForName(final Class<?> clazz,
final String methodName) {
Assert.notNull(clazz, "Class must not be null");
Assert.notNull(methodName, "Method name must not be null");
int count = 0;
final Method[] declaredMethods = clazz.getDeclaredMethods();
for (final Method method : declaredMethods) {
if (methodName.equals(method.getName())) {
count++;
}
}
final Class<?>[] ifcs = clazz.getInterfaces();
for (final Class<?> ifc : ifcs) {
count += getMethodCountForName(ifc, methodName);
}
if (clazz.getSuperclass() != null) {
count += getMethodCountForName(clazz.getSuperclass(), methodName);
}
return count;
}
/**
* Does the given class or one of its superclasses at least have one or more
* methods with the supplied name (with any argument types)? Includes
* non-public methods.
*
* @param clazz
* the clazz to check
* @param methodName
* the name of the method
* @return whether there is at least one method with the given name
*/
public static boolean hasAtLeastOneMethodWithName(final Class<?> clazz,
final String methodName) {
Assert.notNull(clazz, "Class must not be null");
Assert.notNull(methodName, "Method name must not be null");
final Method[] declaredMethods = clazz.getDeclaredMethods();
for (final Method method : declaredMethods) {
if (method.getName().equals(methodName)) {
return true;
}
}
final Class<?>[] ifcs = clazz.getInterfaces();
for (final Class<?> ifc : ifcs) {
if (hasAtLeastOneMethodWithName(ifc, methodName)) {
return true;
}
}
return ((clazz.getSuperclass() != null) && hasAtLeastOneMethodWithName(
clazz.getSuperclass(), methodName));
}
/**
* Given a method, which may come from an interface, and a target class used
* in the current reflective invocation, find the corresponding target
* method if there is one. E.g. the method may be <code>IFoo.bar()</code>
* and the target class may be <code>DefaultFoo</code>. In this case, the
* method may be <code>DefaultFoo.bar()</code>. This enables attributes on
* that method to be found.
* <p>
* <b>NOTE:</b> In contrast to
* {@link vnet.sms.common.aop.support.AopUtils#getMostSpecificMethod}, this
* method does <i>not</i> resolve Java 5 bridge methods automatically. Call
* {@link vnet.sms.common.core.BridgeMethodResolver#findBridgedMethod} if
* bridge method resolution is desirable (e.g. for obtaining metadata from
* the original method definition).
*
* @param method
* the method to be invoked, which may come from an interface
* @param targetClass
* the target class for the current invocation. May be
* <code>null</code> or may not even implement the method.
* @return the specific target method, or the original method if the
* <code>targetClass</code> doesn't implement it or is
* <code>null</code>
*/
public static Method getMostSpecificMethod(final Method method,
final Class<?> targetClass) {
Method specificMethod = null;
if ((method != null) && isOverridable(method, targetClass)
&& (targetClass != null)
&& !targetClass.equals(method.getDeclaringClass())) {
specificMethod = ReflectionUtils.findMethod(targetClass,
method.getName(), method.getParameterTypes());
}
return (specificMethod != null ? specificMethod : method);
}
/**
* Determine whether the given method is overridable in the given target
* class.
*
* @param method
* the method to check
* @param targetClass
* the target class to check against
*/
private static boolean isOverridable(final Method method,
final Class<?> targetClass) {
if (Modifier.isPrivate(method.getModifiers())) {
return false;
}
if (Modifier.isPublic(method.getModifiers())
|| Modifier.isProtected(method.getModifiers())) {
return true;
}
return getPackageName(method.getDeclaringClass()).equals(
getPackageName(targetClass));
}
/**
* Return a public static method of a class.
*
* @param methodName
* the static method name
* @param clazz
* the class which defines the method
* @param args
* the parameter types to the method
* @return the static method, or <code>null</code> if no static method was
* found
* @throws IllegalArgumentException
* if the method name is blank or the clazz is null
*/
public static Method getStaticMethod(final Class<?> clazz,
final String methodName, final Class<?>... args) {
Assert.notNull(clazz, "Class must not be null");
Assert.notNull(methodName, "Method name must not be null");
try {
final Method method = clazz.getMethod(methodName, args);
return Modifier.isStatic(method.getModifiers()) ? method : null;
} catch (final NoSuchMethodException ex) {
return null;
}
}
/**
* Check if the given class represents a primitive wrapper, i.e. Boolean,
* Byte, Character, Short, Integer, Long, Float, or Double.
*
* @param clazz
* the class to check
* @return whether the given class is a primitive wrapper class
*/
public static boolean isPrimitiveWrapper(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
return primitiveWrapperTypeMap.containsKey(clazz);
}
/**
* Check if the given class represents a primitive (i.e. boolean, byte,
* char, short, int, long, float, or double) or a primitive wrapper (i.e.
* Boolean, Byte, Character, Short, Integer, Long, Float, or Double).
*
* @param clazz
* the class to check
* @return whether the given class is a primitive or primitive wrapper class
*/
public static boolean isPrimitiveOrWrapper(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
return (clazz.isPrimitive() || isPrimitiveWrapper(clazz));
}
/**
* Check if the given class represents an array of primitives, i.e. boolean,
* byte, char, short, int, long, float, or double.
*
* @param clazz
* the class to check
* @return whether the given class is a primitive array class
*/
public static boolean isPrimitiveArray(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
return (clazz.isArray() && clazz.getComponentType().isPrimitive());
}
/**
* Check if the given class represents an array of primitive wrappers, i.e.
* Boolean, Byte, Character, Short, Integer, Long, Float, or Double.
*
* @param clazz
* the class to check
* @return whether the given class is a primitive wrapper array class
*/
public static boolean isPrimitiveWrapperArray(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
return (clazz.isArray() && isPrimitiveWrapper(clazz.getComponentType()));
}
/**
* Resolve the given class if it is a primitive class, returning the
* corresponding primitive wrapper type instead.
*
* @param clazz
* the class to check
* @return the original class, or a primitive wrapper for the original
* primitive type
*/
public static Class<?> resolvePrimitiveIfNecessary(final Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
return (clazz.isPrimitive() && (clazz != void.class) ? primitiveTypeToWrapperMap
.get(clazz) : clazz);
}
/**
* Check if the right-hand side type may be assigned to the left-hand side
* type, assuming setting by reflection. Considers primitive wrapper classes
* as assignable to the corresponding primitive types.
*
* @param lhsType
* the target type
* @param rhsType
* the value type that should be assigned to the target type
* @return if the target type is assignable from the value type
* @see vnet.sms.common.util.TypeUtils#isAssignable
*/
public static boolean isAssignable(final Class<?> lhsType,
final Class<?> rhsType) {
Assert.notNull(lhsType, "Left-hand side type must not be null");
Assert.notNull(rhsType, "Right-hand side type must not be null");
return (lhsType.isAssignableFrom(rhsType) || lhsType
.equals(primitiveWrapperTypeMap.get(rhsType)));
}
/**
* Determine if the given type is assignable from the given value, assuming
* setting by reflection. Considers primitive wrapper classes as assignable
* to the corresponding primitive types.
*
* @param type
* the target type
* @param value
* the value that should be assigned to the type
* @return if the type is assignable from the value
*/
public static boolean isAssignableValue(final Class<?> type,
final Object value) {
Assert.notNull(type, "Type must not be null");
return (value != null ? isAssignable(type, value.getClass()) : !type
.isPrimitive());
}
/**
* Convert a "/"-based resource path to a "."-based fully qualified class
* name.
*
* @param resourcePath
* the resource path pointing to a class
* @return the corresponding fully qualified class name
*/
public static String convertResourcePathToClassName(
final String resourcePath) {
Assert.notNull(resourcePath, "Resource path must not be null");
return resourcePath.replace('/', '.');
}
/**
* Convert a "."-based fully qualified class name to a "/"-based resource
* path.
*
* @param className
* the fully qualified class name
* @return the corresponding resource path, pointing to the class
*/
public static String convertClassNameToResourcePath(final String className) {
Assert.notNull(className, "Class name must not be null");
return className.replace('.', '/');
}
/**
* Return a path suitable for use with <code>ClassLoader.getResource</code>
* (also suitable for use with <code>Class.getResource</code> by prepending
* a slash ('/') to the return value). Built by taking the package of the
* specified class file, converting all dots ('.') to slashes ('/'), adding
* a trailing slash if necessary, and concatenating the specified resource
* name to this. <br/>
* As such, this function may be used to build a path suitable for loading a
* resource file that is in the same package as a class file, although
* {@link vnet.sms.common.core.io.ClassPathResource} is usually even more
* convenient.
*
* @param clazz
* the Class whose package will be used as the base
* @param resourceName
* the resource name to append. A leading slash is optional.
* @return the built-up resource path
* @see java.lang.ClassLoader#getResource
* @see java.lang.Class#getResource
*/
public static String addResourcePathToPackagePath(final Class<?> clazz,
final String resourceName) {
Assert.notNull(resourceName, "Resource name must not be null");
if (!resourceName.startsWith("/")) {
return classPackageAsResourcePath(clazz) + "/" + resourceName;
}
return classPackageAsResourcePath(clazz) + resourceName;
}
/**
* Given an input class object, return a string which consists of the
* class's package name as a pathname, i.e., all dots ('.') are replaced by
* slashes ('/'). Neither a leading nor trailing slash is added. The result
* could be concatenated with a slash and the name of a resource and fed
* directly to <code>ClassLoader.getResource()</code>. For it to be fed to
* <code>Class.getResource</code> instead, a leading slash would also have
* to be prepended to the returned value.
*
* @param clazz
* the input class. A <code>null</code> value or the default
* (empty) package will result in an empty string ("") being
* returned.
* @return a path which represents the package name
* @see ClassLoader#getResource
* @see Class#getResource
*/
public static String classPackageAsResourcePath(final Class<?> clazz) {
if (clazz == null) {
return "";
}
final String className = clazz.getName();
final int packageEndIndex = className.lastIndexOf('.');
if (packageEndIndex == -1) {
return "";
}
final String packageName = className.substring(0, packageEndIndex);
return packageName.replace('.', '/');
}
/**
* Build a String that consists of the names of the classes/interfaces in
* the given array.
* <p>
* Basically like <code>AbstractCollection.toString()</code>, but stripping
* the "class "/"interface " prefix before every class name.
*
* @param classes
* a Collection of Class objects (may be <code>null</code>)
* @return a String of form "[com.foo.Bar, com.foo.Baz]"
* @see java.util.AbstractCollection#toString()
*/
public static String classNamesToString(final Class<?>... classes) {
return classNamesToString(Arrays.asList(classes));
}
/**
* Build a String that consists of the names of the classes/interfaces in
* the given collection.
* <p>
* Basically like <code>AbstractCollection.toString()</code>, but stripping
* the "class "/"interface " prefix before every class name.
*
* @param classes
* a Collection of Class objects (may be <code>null</code>)
* @return a String of form "[com.foo.Bar, com.foo.Baz]"
* @see java.util.AbstractCollection#toString()
*/
public static String classNamesToString(final Collection<Class<?>> classes) {
if (CollectionUtils.isEmpty(classes)) {
return "[]";
}
final StringBuilder sb = new StringBuilder("[");
for (final Iterator<Class<?>> it = classes.iterator(); it.hasNext();) {
final Class<?> clazz = it.next();
sb.append(clazz.getName());
if (it.hasNext()) {
sb.append(", ");
}
}
sb.append("]");
return sb.toString();
}
/**
* Return all interfaces that the given instance implements as array,
* including ones implemented by superclasses.
*
* @param instance
* the instance to analyze for interfaces
* @return all interfaces that the given instance implements as array
*/
public static Class[] getAllInterfaces(final Object instance) {
Assert.notNull(instance, "Instance must not be null");
return getAllInterfacesForClass(instance.getClass());
}
/**
* Return all interfaces that the given class implements as array, including
* ones implemented by superclasses.
* <p>
* If the class itself is an interface, it gets returned as sole interface.
*
* @param clazz
* the class to analyze for interfaces
* @return all interfaces that the given object implements as array
*/
public static Class<?>[] getAllInterfacesForClass(final Class<?> clazz) {
return getAllInterfacesForClass(clazz, null);
}
/**
* Return all interfaces that the given class implements as array, including
* ones implemented by superclasses.
* <p>
* If the class itself is an interface, it gets returned as sole interface.
*
* @param clazz
* the class to analyze for interfaces
* @param classLoader
* the ClassLoader that the interfaces need to be visible in (may
* be <code>null</code> when accepting all declared interfaces)
* @return all interfaces that the given object implements as array
*/
public static Class<?>[] getAllInterfacesForClass(final Class<?> clazz,
final ClassLoader classLoader) {
final Set<Class> ifcs = getAllInterfacesForClassAsSet(clazz,
classLoader);
return ifcs.toArray(new Class[ifcs.size()]);
}
/**
* Return all interfaces that the given instance implements as Set,
* including ones implemented by superclasses.
*
* @param instance
* the instance to analyze for interfaces
* @return all interfaces that the given instance implements as Set
*/
public static Set<Class> getAllInterfacesAsSet(final Object instance) {
Assert.notNull(instance, "Instance must not be null");
return getAllInterfacesForClassAsSet(instance.getClass());
}
/**
* Return all interfaces that the given class implements as Set, including
* ones implemented by superclasses.
* <p>
* If the class itself is an interface, it gets returned as sole interface.
*
* @param clazz
* the class to analyze for interfaces
* @return all interfaces that the given object implements as Set
*/
public static Set<Class> getAllInterfacesForClassAsSet(final Class clazz) {
return getAllInterfacesForClassAsSet(clazz, null);
}
/**
* Return all interfaces that the given class implements as Set, including
* ones implemented by superclasses.
* <p>
* If the class itself is an interface, it gets returned as sole interface.
*
* @param clazz
* the class to analyze for interfaces
* @param classLoader
* the ClassLoader that the interfaces need to be visible in (may
* be <code>null</code> when accepting all declared interfaces)
* @return all interfaces that the given object implements as Set
*/
public static Set<Class> getAllInterfacesForClassAsSet(Class clazz,
final ClassLoader classLoader) {
Assert.notNull(clazz, "Class must not be null");
if (clazz.isInterface() && isVisible(clazz, classLoader)) {
return Collections.singleton(clazz);
}
final Set<Class> interfaces = new LinkedHashSet<Class>();
while (clazz != null) {
final Class<?>[] ifcs = clazz.getInterfaces();
for (final Class<?> ifc : ifcs) {
interfaces.addAll(getAllInterfacesForClassAsSet(ifc,
classLoader));
}
clazz = clazz.getSuperclass();
}
return interfaces;
}
/**
* Create a composite interface Class for the given interfaces, implementing
* the given interfaces in one single Class.
* <p>
* This implementation builds a JDK proxy class for the given interfaces.
*
* @param interfaces
* the interfaces to merge
* @param classLoader
* the ClassLoader to create the composite Class in
* @return the merged interface as Class
* @see java.lang.reflect.Proxy#getProxyClass
*/
public static Class<?> createCompositeInterface(
final Class<?>[] interfaces, final ClassLoader classLoader) {
Assert.notEmpty(interfaces, "Interfaces must not be empty");
Assert.notNull(classLoader, "ClassLoader must not be null");
return Proxy.getProxyClass(classLoader, interfaces);
}
/**
* Check whether the given class is visible in the given ClassLoader.
*
* @param clazz
* the class to check (typically an interface)
* @param classLoader
* the ClassLoader to check against (may be <code>null</code>, in
* which case this method will always return <code>true</code>)
*/
public static boolean isVisible(final Class<?> clazz,
final ClassLoader classLoader) {
if (classLoader == null) {
return true;
}
try {
final Class<?> actualClass = classLoader.loadClass(clazz.getName());
return (clazz == actualClass);
// Else: different interface class found...
} catch (final ClassNotFoundException ex) {
// No interface class found...
return false;
}
}
}