Java tutorial
/* * Copyright 2002-2006 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. */ package org.springframework.util; import java.beans.Introspector; import java.lang.reflect.Array; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.Collections; import java.util.HashSet; import java.util.Set; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * Miscellaneous class utility methods. Mainly for internal use within the * framework; consider Jakarta's Commons Lang for a more comprehensive suite * of class utilities. * * @author Keith Donald * @author Rob Harrop * @author Juergen Hoeller * @since 1.1 */ public abstract class ClassUtils { /** Suffix for array class names */ public static final String ARRAY_SUFFIX = "[]"; /** All primitive classes */ private static Class[] PRIMITIVE_CLASSES = { boolean.class, byte.class, char.class, short.class, int.class, long.class, float.class, double.class }; /** 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 "$$" */ private static final String CGLIB_CLASS_SEPARATOR = "$$"; private static final Log logger = LogFactory.getLog(ClassUtils.class); /** * Return a default ClassLoader to use (never <code>null</code>). * Returns 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). * @see java.lang.Thread#getContextClassLoader() */ public static ClassLoader getDefaultClassLoader() { ClassLoader cl = null; try { cl = Thread.currentThread().getContextClassLoader(); } catch (Throwable ex) { logger.debug("Cannot access thread context ClassLoader - falling back to system class loader", ex); } if (cl == null) { // No thread context class loader -> use class loader of this class. cl = ClassUtils.class.getClassLoader(); } return cl; } /** * 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() */ public static Class forName(String name) throws ClassNotFoundException, LinkageError { return forName(name, getDefaultClassLoader()); } /** * Replacement for <code>Class.forName()</code> that also returns Class instances * for primitives (like "int") and array class names (like "String[]"). * @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(String name, ClassLoader classLoader) throws ClassNotFoundException, LinkageError { Assert.notNull(name, "Name must not be null"); Class clazz = resolvePrimitiveClassName(name); if (clazz != null) { return clazz; } if (name.endsWith(ARRAY_SUFFIX)) { // special handling for array class names String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length()); Class elementClass = forName(elementClassName, classLoader); return Array.newInstance(elementClass, 0).getClass(); } return Class.forName(name, true, classLoader); } /** * Resolve the given class name as primitive class, if appropriate. * @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 */ public static Class resolvePrimitiveClassName(String name) { // Most class names will be quite long, considering that they // SHOULD sit in a package, so a length check is worthwhile. if (name.length() <= 8) { // could be a primitive - likely for (int i = 0; i < PRIMITIVE_CLASSES.length; i++) { Class clazz = PRIMITIVE_CLASSES[i]; if (clazz.getName().equals(name)) { return clazz; } } } return null; } /** * 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(String className) { Assert.hasLength(className, "Class name must not be empty"); 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(Class clazz) { return getShortName(getQualifiedName(clazz)); } /** * Return the short string name of a Java class in decapitalized * JavaBeans property format. * @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(Class clazz) { return Introspector.decapitalize(getShortName(clazz)); } /** * 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(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) { StringBuffer buffer = new StringBuffer(); while (clazz.isArray()) { clazz = clazz.getComponentType(); buffer.append(ClassUtils.ARRAY_SUFFIX); } buffer.insert(0, clazz.getName()); return buffer.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(Method method) { Assert.notNull(method, "Method must not be null"); return method.getDeclaringClass().getName() + "." + method.getName(); } /** * 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 paramTypes the parameter types of the method * @see java.lang.Class#getMethod */ public static boolean hasMethod(Class clazz, String methodName, Class[] paramTypes) { return (getMethodIfAvailable(clazz, methodName, paramTypes) != 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 paramTypes 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(Class clazz, String methodName, Class[] paramTypes) { Assert.notNull(clazz, "Class must not be null"); Assert.notNull(methodName, "Method name must not be null"); try { return clazz.getMethod(methodName, paramTypes); } catch (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(Class clazz, String methodName) { Assert.notNull(clazz, "Class must not be null"); Assert.notNull(methodName, "Method name must not be null"); int count = 0; for (int i = 0; i < clazz.getDeclaredMethods().length; i++) { Method method = clazz.getDeclaredMethods()[i]; if (methodName.equals(method.getName())) { count++; } } Class[] ifcs = clazz.getInterfaces(); for (int i = 0; i < ifcs.length; i++) { count += getMethodCountForName(ifcs[i], methodName); } if (clazz.getSuperclass() != null) { count += getMethodCountForName(clazz.getSuperclass(), methodName); } return count; } /** * Does the given class and/or its superclasses at least have one or more * methods (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(Class clazz, String methodName) { Assert.notNull(clazz, "Class must not be null"); Assert.notNull(methodName, "Method name must not be null"); for (int i = 0; i < clazz.getDeclaredMethods().length; i++) { Method method = clazz.getDeclaredMethods()[i]; if (method.getName().equals(methodName)) { return true; } } Class[] ifcs = clazz.getInterfaces(); for (int i = 0; i < ifcs.length; i++) { if (hasAtLeastOneMethodWithName(ifcs[i], methodName)) { return true; } } if (clazz.getSuperclass() != null) { return hasAtLeastOneMethodWithName(clazz.getSuperclass(), methodName); } return false; } /** * Return a 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(Class clazz, String methodName, Class[] args) { Assert.notNull(clazz, "Class must not be null"); Assert.notNull(methodName, "Method name must not be null"); try { Method method = clazz.getDeclaredMethod(methodName, args); if ((method.getModifiers() & Modifier.STATIC) != 0) { return method; } } catch (NoSuchMethodException ex) { } return null; } /** * 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 necesssary, 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 org.springframework.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(Class clazz, 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 ClassLoader.getResource(). For it to be fed to Class.getResource, * a leading slash would also have to be prepended to the return value. * @param clazz the input class. A null 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(Class clazz) { if (clazz == null || clazz.getPackage() == null) { return ""; } return clazz.getPackage().getName().replace('.', '/'); } /** * Return all interfaces that the given object implements as array, * including ones implemented by superclasses. * @param object the object to analyse for interfaces * @return all interfaces that the given object implements as array */ public static Class[] getAllInterfaces(Object object) { Set interfaces = getAllInterfacesAsSet(object); return (Class[]) interfaces.toArray(new Class[interfaces.size()]); } /** * 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 analyse for interfaces * @return all interfaces that the given object implements as array */ public static Class[] getAllInterfacesForClass(Class clazz) { Set interfaces = getAllInterfacesForClassAsSet(clazz); return (Class[]) interfaces.toArray(new Class[interfaces.size()]); } /** * Return all interfaces that the given object implements as List, * including ones implemented by superclasses. * @param object the object to analyse for interfaces * @return all interfaces that the given object implements as List */ public static Set getAllInterfacesAsSet(Object object) { Assert.notNull(object, "Object must not be null"); return getAllInterfacesForClassAsSet(object.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 analyse for interfaces * @return all interfaces that the given object implements as Set */ public static Set getAllInterfacesForClassAsSet(Class clazz) { Assert.notNull(clazz, "Class must not be null"); if (clazz.isInterface()) { return Collections.singleton(clazz); } Set interfaces = new HashSet(); while (clazz != null) { for (int i = 0; i < clazz.getInterfaces().length; i++) { Class ifc = clazz.getInterfaces()[i]; interfaces.add(ifc); } clazz = clazz.getSuperclass(); } return interfaces; } }