org.tinygroup.commons.tools.ClassUtil Maven / Gradle / Ivy
/**
* Copyright (c) 1997-2013, www.tinygroup.org ([email protected]).
*
* Licensed under the GPL, Version 3.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.gnu.org/licenses/gpl.html
*
* 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.tinygroup.commons.tools;
import static org.tinygroup.commons.tools.ArrayUtil.isArraySameLength;
import static org.tinygroup.commons.tools.ArrayUtil.isEmptyArray;
import static org.tinygroup.commons.tools.Assert.assertNotNull;
import static org.tinygroup.commons.tools.Assert.assertTrue;
import static org.tinygroup.commons.tools.BasicConstant.EMPTY_CLASS_ARRAY;
import static org.tinygroup.commons.tools.BasicConstant.EMPTY_STRING;
import static org.tinygroup.commons.tools.CollectionUtil.createHashMap;
import static org.tinygroup.commons.tools.CollectionUtil.createHashSet;
import static org.tinygroup.commons.tools.StringUtil.trimToNull;
import java.beans.Introspector;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
/**
* 有关 Class 处理的工具类。
*
* 这个类中的每个方法都可以“安全”地处理 null ，而不会抛出
* NullPointerException。
*
* @author renhui
*
*/
public class ClassUtil {
/** Suffix for array class names: "[]" */
public static final String ARRAY_SUFFIX = "[]";
/** 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";
/**
* 从接口端计算深度
* @param pInterface
* @param targetClass
* @return
*/
public static int checkInterfaceDeepth(Class pInterface,
Class targetClass) {
if (targetClass.isAssignableFrom(pInterface))
return 0;
int min = -1;
for (Class c : targetClass.getInterfaces()) {
if (pInterface.isAssignableFrom(c)) {
int i = checkInterfaceDeepth(pInterface, c) + 1;
if (min == -1 || min > i) {
min = i;
}
}
}
return min;
}
/**
* @param supperClass
* @param targetClass
* @return
*/
public static int checkSupperClassDeepth(Class supperClass,
Class targetClass) {
if (!supperClass.isAssignableFrom(targetClass)) {
return -1;
}
if (targetClass.isAssignableFrom(supperClass))
return 0;
int supperDeepth = checkSupperClassDeepth(supperClass,
targetClass.getSuperclass()) + 1;
int interfaceDeepth = checkInterfaceDeepth(supperClass,
targetClass.getSuperclass()) + 1;
if (supperDeepth < interfaceDeepth)
return supperDeepth;
return interfaceDeepth;
}
/**
* 采取驼峰规则
*
* @param simpleName
* @return
*/
public static String humpString(Class clazz) {
String simpleName = clazz.getSimpleName();
String first = simpleName.charAt(0) + "";
return first.toLowerCase() + simpleName.substring(1);
}
// ==========================================================================
// 取得友好类名和package名的方法。
// ==========================================================================
/**
* 取得对象所属的类的友好类名。
*
* 类似object.getClass().getName()，但不同的是，该方法用更友好的方式显示数组类型。 例如：
*
*
*
* int[].class.getName() = "[I"
* ClassUtil.getFriendlyClassName(int[].class) = "int[]"
*
* Integer[][].class.getName() = "[[Ljava.lang.Integer;"
* ClassUtil.getFriendlyClassName(Integer[][].class) = "java.lang.Integer[][]"
*
*
* 对于非数组的类型，该方法等效于 Class.getName() 方法。
*
*
* 注意，该方法所返回的数组类名只能用于显示给人看，不能用于 Class.forName 操作。
*
*
* @param object 要显示类名的对象
* @return 用于显示的友好类名，如果对象为空，则返回null
*/
public static String getFriendlyClassNameForObject(Object object) {
if (object == null) {
return null;
}
String javaClassName = object.getClass().getName();
return toFriendlyClassName(javaClassName, true, javaClassName);
}
/**
* 取得友好的类名。
*
* 类似clazz.getName()，但不同的是，该方法用更友好的方式显示数组类型。 例如：
*
*
*
* int[].class.getName() = "[I"
* ClassUtil.getFriendlyClassName(int[].class) = "int[]"
*
* Integer[][].class.getName() = "[[Ljava.lang.Integer;"
* ClassUtil.getFriendlyClassName(Integer[][].class) = "java.lang.Integer[][]"
*
*
* 对于非数组的类型，该方法等效于 Class.getName() 方法。
*
*
* 注意，该方法所返回的数组类名只能用于显示给人看，不能用于 Class.forName 操作。
*
*
* @param object 要显示类名的对象
* @return 用于显示的友好类名，如果类对象为空，则返回null
*/
public static String getFriendlyClassName(Class clazz) {
if (clazz == null) {
return null;
}
String javaClassName = clazz.getName();
return toFriendlyClassName(javaClassName, true, javaClassName);
}
/**
* 取得友好的类名。
*
* className 必须是从 clazz.getName()
* 所返回的合法类名。该方法用更友好的方式显示数组类型。 例如：
*
*
*
* int[].class.getName() = "[I"
* ClassUtil.getFriendlyClassName(int[].class) = "int[]"
*
* Integer[][].class.getName() = "[[Ljava.lang.Integer;"
* ClassUtil.getFriendlyClassName(Integer[][].class) = "java.lang.Integer[][]"
*
*
* 对于非数组的类型，该方法等效于 Class.getName() 方法。
*
*
* 注意，该方法所返回的数组类名只能用于显示给人看，不能用于 Class.forName 操作。
*
*
* @param javaClassName 要转换的类名
* @return 用于显示的友好类名，如果原类名为空，则返回 null ，如果原类名是非法的，则返回原类名
*/
public static String getFriendlyClassName(String javaClassName) {
return toFriendlyClassName(javaClassName, true, javaClassName);
}
/**
* 将Java类名转换成友好类名。
*
* @param javaClassName Java类名
* @param processInnerClass 是否将内联类分隔符 '$' 转换成 '.'
* @return 友好的类名。如果参数非法或空，则返回null。
*/
private static String toFriendlyClassName(String javaClassName, boolean processInnerClass, String defaultIfInvalid) {
String name = StringUtil.trimToNull(javaClassName);
if (name == null) {
return defaultIfInvalid;
}
if (processInnerClass) {
name = name.replace('$', '.');
}
int length = name.length();
int dimension = 0;
// 取得数组的维数，如果不是数组，维数为0
for (int i = 0; i < length; i++, dimension++) {
if (name.charAt(i) != '[') {
break;
}
}
// 如果不是数组，则直接返回
if (dimension == 0) {
return name;
}
// 确保类名合法
if (length <= dimension) {
return defaultIfInvalid; // 非法类名
}
// 处理数组
StringBuilder componentTypeName = new StringBuilder();
switch (name.charAt(dimension)) {
case 'Z':
componentTypeName.append("boolean");
break;
case 'B':
componentTypeName.append("byte");
break;
case 'C':
componentTypeName.append("char");
break;
case 'D':
componentTypeName.append("double");
break;
case 'F':
componentTypeName.append("float");
break;
case 'I':
componentTypeName.append("int");
break;
case 'J':
componentTypeName.append("long");
break;
case 'S':
componentTypeName.append("short");
break;
case 'L':
if (name.charAt(length - 1) != ';' || length <= dimension + 2) {
return defaultIfInvalid; // 非法类名
}
componentTypeName.append(name.substring(dimension + 1, length - 1));
break;
default:
return defaultIfInvalid; // 非法类名
}
for (int i = 0; i < dimension; i++) {
componentTypeName.append("[]");
}
return componentTypeName.toString();
}
/**
* 取得指定对象所属的类的简单类名，不包括package名。
*
* 此方法可以正确显示数组和内联类的名称。 例如：
*
*
* ClassUtil.getSimpleClassNameForObject(Boolean.TRUE) = "Boolean"
* ClassUtil.getSimpleClassNameForObject(new Boolean[10]) = "Boolean[]"
* ClassUtil.getSimpleClassNameForObject(new int[1][2]) = "int[][]"
*
*
* 本方法和Class.getSimpleName()的区别在于，本方法会保留inner类的外层类名称。
*
*
* @param object 要查看的对象
* @return 简单类名，如果对象为 null ，则返回 null
*/
public static String getSimpleClassNameForObject(Object object) {
if (object == null) {
return null;
}
return getSimpleClassName(object.getClass().getName());
}
/**
* 取得指定对象所属的类的简单类名，不包括package名。
*
* 此方法可以正确显示数组和内联类的名称。 例如：
*
*
* ClassUtil.getSimpleClassNameForObject(Boolean.TRUE) = "Boolean"
* ClassUtil.getSimpleClassNameForObject(new Boolean[10]) = "Boolean[]"
* ClassUtil.getSimpleClassNameForObject(new int[1][2]) = "int[][]"
*
*
* 本方法和Class.getSimpleName()的区别在于，本方法会保留inner类的外层类名称。
*
*
* @param object 要查看的对象
* @return 简单类名，如果对象为 null ，则返回 null
*/
public static String getSimpleClassNameForObject(Object object, boolean processInnerClass) {
if (object == null) {
return null;
}
return getSimpleClassName(object.getClass().getName(), processInnerClass);
}
/**
* 取得简单类名，不包括package名。
*
* 此方法可以正确显示数组和内联类的名称。 例如：
*
*
* ClassUtil.getSimpleClassName(Boolean.class) = "Boolean"
* ClassUtil.getSimpleClassName(Boolean[].class) = "Boolean[]"
* ClassUtil.getSimpleClassName(int[][].class) = "int[][]"
* ClassUtil.getSimpleClassName(Map.Entry.class) = "Map.Entry"
*
*
* 本方法和Class.getSimpleName()的区别在于，本方法会保留inner类的外层类名称。
*
*
* @param clazz 要查看的类
* @return 简单类名，如果类为 null ，则返回 null
*/
public static String getSimpleClassName(Class clazz) {
if (clazz == null) {
return null;
}
return getSimpleClassName(clazz.getName());
}
/**
* 取得简单类名，不包括package名。
*
* 此方法可以正确显示数组和内联类的名称。 例如：
*
*
* ClassUtil.getSimpleClassName(Boolean.class) = "Boolean"
* ClassUtil.getSimpleClassName(Boolean[].class) = "Boolean[]"
* ClassUtil.getSimpleClassName(int[][].class) = "int[][]"
* ClassUtil.getSimpleClassName(Map.Entry.class) = "Map.Entry"
*
*
* 本方法和Class.getSimpleName()的区别在于，本方法会保留inner类的外层类名称。
*
*
* @param clazz 要查看的类
* @return 简单类名，如果类为 null ，则返回 null
*/
public static String getSimpleClassName(Class clazz, boolean proccessInnerClass) {
if (clazz == null) {
return null;
}
return getSimpleClassName(clazz.getName(), proccessInnerClass);
}
/**
* 取得类名，不包括package名。
*
* 此方法可以正确显示数组和内联类的名称。 例如：
*
*
* ClassUtil.getSimpleClassName(Boolean.class.getName()) = "Boolean"
* ClassUtil.getSimpleClassName(Boolean[].class.getName()) = "Boolean[]"
* ClassUtil.getSimpleClassName(int[][].class.getName()) = "int[][]"
* ClassUtil.getSimpleClassName(Map.Entry.class.getName()) = "Map.Entry"
*
*
* 本方法和Class.getSimpleName()的区别在于，本方法会保留inner类的外层类名称。
*
*
* @param javaClassName 要查看的类名
* @return 简单类名，如果类名为空，则返回 null
*/
public static String getSimpleClassName(String javaClassName) {
return getSimpleClassName(javaClassName, true);
}
/**
* 取得类名，不包括package名。
*
* 此方法可以正确显示数组和内联类的名称。 例如：
*
*
* ClassUtil.getSimpleClassName(Boolean.class.getName()) = "Boolean"
* ClassUtil.getSimpleClassName(Boolean[].class.getName()) = "Boolean[]"
* ClassUtil.getSimpleClassName(int[][].class.getName()) = "int[][]"
* ClassUtil.getSimpleClassName(Map.Entry.class.getName()) = "Map.Entry"
*
*
* 本方法和Class.getSimpleName()的区别在于，本方法会保留inner类的外层类名称。
*
*
* @param javaClassName 要查看的类名
* @return 简单类名，如果类名为空，则返回 null
*/
public static String getSimpleClassName(String javaClassName, boolean proccesInnerClass) {
String friendlyClassName = toFriendlyClassName(javaClassName, false, null);
if (friendlyClassName == null) {
return javaClassName;
}
if (proccesInnerClass) {
char[] chars = friendlyClassName.toCharArray();
int beginIndex = 0;
for (int i = chars.length - 1; i >= 0; i--) {
if (chars[i] == '.') {
beginIndex = i + 1;
break;
} else if (chars[i] == '$') {
chars[i] = '.';
}
}
return new String(chars, beginIndex, chars.length - beginIndex);
} else {
return friendlyClassName.substring(friendlyClassName.lastIndexOf(".") + 1);
}
}
/** 取得简洁的method描述。 */
public static String getSimpleMethodSignature(Method method) {
return getSimpleMethodSignature(method, false, false, false, false);
}
/** 取得简洁的method描述。 */
public static String getSimpleMethodSignature(Method method, boolean withClassName) {
return getSimpleMethodSignature(method, false, false, withClassName, false);
}
/** 取得简洁的method描述。 */
public static String getSimpleMethodSignature(Method method, boolean withModifiers, boolean withReturnType,
boolean withClassName, boolean withExceptionType) {
if (method == null) {
return null;
}
StringBuilder buf = new StringBuilder();
if (withModifiers) {
buf.append(Modifier.toString(method.getModifiers())).append(' ');
}
if (withReturnType) {
buf.append(getSimpleClassName(method.getReturnType())).append(' ');
}
if (withClassName) {
buf.append(getSimpleClassName(method.getDeclaringClass())).append('.');
}
buf.append(method.getName()).append('(');
Class[] paramTypes = method.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) {
Class paramType = paramTypes[i];
buf.append(getSimpleClassName(paramType));
if (i < paramTypes.length - 1) {
buf.append(", ");
}
}
buf.append(')');
if (withExceptionType) {
Class[] exceptionTypes = method.getExceptionTypes();
if (!isEmptyArray(exceptionTypes)) {
buf.append(" throws ");
for (int i = 0; i < exceptionTypes.length; i++) {
Class exceptionType = exceptionTypes[i];
buf.append(getSimpleClassName(exceptionType));
if (i < exceptionTypes.length - 1) {
buf.append(", ");
}
}
}
}
return buf.toString();
}
/**
* 取得指定对象所属的类的package名。
*
* 对于数组，此方法返回的是数组元素类型的package名。
*
*
* @param object 要查看的对象
* @return package名，如果对象为 null ，则返回""
*/
public static String getPackageNameForObject(Object object) {
if (object == null) {
return EMPTY_STRING;
}
return getPackageName(object.getClass().getName());
}
/**
* 取得指定类的package名。
*
* 对于数组，此方法返回的是数组元素类型的package名。
*
*
* @param clazz 要查看的类
* @return package名，如果类为 null ，则返回""
*/
public static String getPackageName(Class clazz) {
if (clazz == null) {
return EMPTY_STRING;
}
return getPackageName(clazz.getName());
}
/**
* 取得指定类名的package名。
*
* 对于数组，此方法返回的是数组元素类型的package名。
*
*
* @param javaClassName 要查看的类名
* @return package名，如果类名为空，则返回 null
*/
public static String getPackageName(String javaClassName) {
String friendlyClassName = toFriendlyClassName(javaClassName, false, null);
if (friendlyClassName == null) {
return EMPTY_STRING;
}
int i = friendlyClassName.lastIndexOf('.');
if (i == -1) {
return EMPTY_STRING;
}
return friendlyClassName.substring(0, i);
}
// ==========================================================================
// 取得类名和package名的resource名的方法。
//
// 和类名、package名不同的是，resource名符合文件名命名规范，例如：
// java/lang/String.class
// com/alibaba/commons/lang
// etc.
// ==========================================================================
/**
* 取得对象所属的类的资源名。
*
* 例如：
*
*
*
* ClassUtil.getResourceNameForObjectClass("This is a string") = "java/lang/String.class"
*
*
* @param object 要显示类名的对象
* @return 指定对象所属类的资源名，如果对象为空，则返回null
*/
public static String getResourceNameForObjectClass(Object object) {
if (object == null) {
return null;
}
return object.getClass().getName().replace('.', '/') + ".class";
}
/**
* 取得指定类的资源名。
*
* 例如：
*
*
*
* ClassUtil.getResourceNameForClass(String.class) = "java/lang/String.class"
*
*
* @param clazz 要显示类名的类
* @return 指定类的资源名，如果指定类为空，则返回null
*/
public static String getResourceNameForClass(Class clazz) {
if (clazz == null) {
return null;
}
return clazz.getName().replace('.', '/') + ".class";
}
/**
* 取得指定类的资源名。
*
* 例如：
*
*
*
* ClassUtil.getResourceNameForClass("java.lang.String") = "java/lang/String.class"
*
*
* @param className 要显示的类名
* @return 指定类名对应的资源名，如果指定类名为空，则返回null
*/
public static String getResourceNameForClass(String className) {
if (className == null) {
return null;
}
return className.replace('.', '/') + ".class";
}
/**
* 取得指定对象所属的类的package名的资源名。
*
* 对于数组，此方法返回的是数组元素类型的package名。
*
*
* @param object 要查看的对象
* @return package名，如果对象为 null ，则返回 null
*/
public static String getResourceNameForObjectPackage(Object object) {
if (object == null) {
return null;
}
return getPackageNameForObject(object).replace('.', '/');
}
/**
* 取得指定类的package名的资源名。
*
* 对于数组，此方法返回的是数组元素类型的package名。
*
*
* @param clazz 要查看的类
* @return package名，如果类为 null ，则返回 null
*/
public static String getResourceNameForPackage(Class clazz) {
if (clazz == null) {
return null;
}
return getPackageName(clazz).replace('.', '/');
}
/**
* 取得指定类名的package名的资源名。
*
* 对于数组，此方法返回的是数组元素类型的package名。
*
*
* @param className 要查看的类名
* @return package名，如果类名为空，则返回 null
*/
public static String getResourceNameForPackage(String className) {
if (className == null) {
return null;
}
return getPackageName(className).replace('.', '/');
}
// ==========================================================================
// 取得数组类。
// ==========================================================================
/**
* 取得指定一维数组类.
*
* @param componentType 数组的基础类
* @return 数组类，如果数组的基类为 null ，则返回 null
*/
public static Class getArrayClass(Class componentType) {
return getArrayClass(componentType, 1);
}
/**
* 取得指定维数的 Array类.
*
* @param componentType 数组的基类
* @param dimension 维数，如果小于 0 则看作 0
* @return 如果维数为0, 则返回基类本身, 否则返回数组类，如果数组的基类为 null ，则返回
* null
*/
public static Class getArrayClass(Class componentClass, int dimension) {
if (componentClass == null) {
return null;
}
switch (dimension) {
case 1:
return Array.newInstance(componentClass, 0).getClass();
case 0:
return componentClass;
default:
assertTrue(dimension > 0, "wrong dimension: %d", dimension);
return Array.newInstance(componentClass, new int[dimension]).getClass();
}
}
// ==========================================================================
// 取得原子类型或者其wrapper类。
// ==========================================================================
/**
* 取得primitive类。
*
* 例如：
*
*
* ClassUtil.getPrimitiveType("int") = int.class;
* ClassUtil.getPrimitiveType("long") = long.class;
*
*
*
*/
public static Class getPrimitiveType(String name) {
PrimitiveInfo info = PRIMITIVES.get(name);
if (info != null) {
return info.type;
}
return null;
}
/**
* 取得primitive类。
*
* 例如：
*
*
* ClassUtil.getPrimitiveType(Integer.class) = int.class;
* ClassUtil.getPrimitiveType(Long.class) = long.class;
*
*
*
*/
public static Class getPrimitiveType(Class type) {
return getPrimitiveType(type.getName());
}
/**
* 取得primitive类型的wrapper。如果不是primitive，则原样返回。
*
* 例如：
*
*
* ClassUtil.getPrimitiveWrapperType(int.class) = Integer.class;
* ClassUtil.getPrimitiveWrapperType(int[].class) = int[].class;
* ClassUtil.getPrimitiveWrapperType(int[][].class) = int[][].class;
* ClassUtil.getPrimitiveWrapperType(String[][].class) = String[][].class;
*
*
*
*/
@SuppressWarnings("unchecked")
public static Class getWrapperTypeIfPrimitive(Class type) {
if (type.isPrimitive()) {
return ((PrimitiveInfo) PRIMITIVES.get(type.getName())).wrapperType;
}
return type;
}
/**
* 取得primitive类型的默认值。如果不是primitive，则返回null。
*
* 例如：
*
*
* ClassUtil.getPrimitiveDefaultValue(int.class) = 0;
* ClassUtil.getPrimitiveDefaultValue(boolean.class) = false;
* ClassUtil.getPrimitiveDefaultValue(char.class) = '\0';
*
*
*
*/
@SuppressWarnings("unchecked")
public static T getPrimitiveDefaultValue(Class type) {
PrimitiveInfo info = (PrimitiveInfo) PRIMITIVES.get(type.getName());
if (info != null) {
return info.defaultValue;
}
return null;
}
private static final Map> PRIMITIVES = createHashMap();
static {
addPrimitive(boolean.class, "Z", Boolean.class, "booleanValue", false);
addPrimitive(short.class, "S", Short.class, "shortValue", (short) 0);
addPrimitive(int.class, "I", Integer.class, "intValue", 0);
addPrimitive(long.class, "J", Long.class, "longValue", 0L);
addPrimitive(float.class, "F", Float.class, "floatValue", 0F);
addPrimitive(double.class, "D", Double.class, "doubleValue", 0D);
addPrimitive(char.class, "C", Character.class, "charValue", '\0');
addPrimitive(byte.class, "B", Byte.class, "byteValue", (byte) 0);
addPrimitive(void.class, "V", Void.class, null, null);
}
private static void addPrimitive(Class type, String typeCode, Class wrapperType, String unwrapMethod,
T defaultValue) {
PrimitiveInfo info = new PrimitiveInfo(type, typeCode, wrapperType, unwrapMethod, defaultValue);
PRIMITIVES.put(type.getName(), info);
PRIMITIVES.put(wrapperType.getName(), info);
}
/** 代表一个primitive类型的信息。 */
@SuppressWarnings("unused")
private static class PrimitiveInfo {
final Class type;
final String typeCode;
final Class wrapperType;
final String unwrapMethod;
final T defaultValue;
public PrimitiveInfo(Class type, String typeCode, Class wrapperType, String unwrapMethod, T defaultValue) {
this.type = type;
this.typeCode = typeCode;
this.wrapperType = wrapperType;
this.unwrapMethod = unwrapMethod;
this.defaultValue = defaultValue;
}
}
// ==========================================================================
// 类型匹配。
// ==========================================================================
/**
* 检查一组指定类型 fromClasses 的对象是否可以赋值给另一组类型 classes。
*
* 此方法可以用来确定指定类型的参数 object1, object2, ... 是否可以用来调用确定参数类型为
* class1, class2,
* ... 的方法。
*
*
* 对于 fromClasses 的每个元素 fromClass 和
* classes 的每个元素 clazz， 按照如下规则：
*
* - 如果目标类
clazz 为 null ，总是返回 false
* 。
* - 如果参数类型
fromClass 为 null ，并且目标类型
* clazz 为非原子类型，则返回 true。 因为 null
* 可以被赋给任何引用类型。
* - 调用
Class.isAssignableFrom 方法来确定目标类 clazz
* 是否和参数类 fromClass 相同或是其父类、接口，如果是，则返回 true。
* - 如果目标类型
clazz 为原子类型，那么根据 The Java Language
* Specification ，sections 5.1.1, 5.1.2, 5.1.4定义的Widening Primitive
* Conversion规则，参数类型 fromClass 可以是任何能扩展成该目标类型的原子类型及其包装类。 例如，
* clazz 为 long ，那么参数类型可以是 byte、
* short、int、long、char
* 及其包装类 java.lang.Byte、java.lang.Short、
* java.lang.Integer、 java.lang.Long 和
* java.lang.Character 。如果满足这个条件，则返回 true。
* - 不满足上述所有条件，则返回
false。
*
*
*
* @param classes 目标类型列表，如果是 null 总是返回 false
* @param fromClasses 参数类型列表， null 表示可赋值给任意非原子类型
* @return 如果可以被赋值，则返回 true
*/
public static boolean isAssignable(Class[] classes, Class[] fromClasses) {
if (!isArraySameLength(fromClasses, classes)) {
return false;
}
if (fromClasses == null) {
fromClasses = EMPTY_CLASS_ARRAY;
}
if (classes == null) {
classes = EMPTY_CLASS_ARRAY;
}
for (int i = 0; i < fromClasses.length; i++) {
if (isAssignable(classes[i], fromClasses[i]) == false) {
return false;
}
}
return true;
}
/**
* 检查指定类型 fromClass 的对象是否可以赋值给另一种类型 clazz。
*
* 此方法可以用来确定指定类型的参数 object1, object2, ... 是否可以用来调用确定参数类型
* class1, class2,
* ... 的方法。
*
*
* 按照如下规则：
*
* - 如果目标类
clazz 为 null ，总是返回 false
* 。
* - 如果参数类型
fromClass 为 null ，并且目标类型
* clazz 为非原子类型，则返回 true。 因为 null
* 可以被赋给任何引用类型。
* - 调用
Class.isAssignableFrom 方法来确定目标类 clazz
* 是否和参数类 fromClass 相同或是其父类、接口，如果是，则返回 true。
* - 如果目标类型
clazz 为原子类型，那么根据 The Java Language
* Specification ，sections 5.1.1, 5.1.2, 5.1.4定义的Widening Primitive
* Conversion规则，参数类型 fromClass 可以是任何能扩展成该目标类型的原子类型及其包装类。 例如，
* clazz 为 long ，那么参数类型可以是 byte、
* short、int、long、char
* 及其包装类 java.lang.Byte、java.lang.Short、
* java.lang.Integer、 java.lang.Long 和
* java.lang.Character 。如果满足这个条件，则返回 true。
* - 不满足上述所有条件，则返回
false。
*
*
*
* @param clazz 目标类型，如果是 null 总是返回 false
* @param fromClass 参数类型， null 表示可赋值给任意非原子类型
* @return 如果可以被赋值，则返回 null
*/
public static boolean isAssignable(Class clazz, Class fromClass) {
if (clazz == null) {
return false;
}
// 如果fromClass是null，只要clazz不是原子类型如int，就一定可以赋值
if (fromClass == null) {
return !clazz.isPrimitive();
}
// 如果类相同或有父子关系，当然可以赋值
if (clazz.isAssignableFrom(fromClass)) {
return true;
}
// 对于原子类型，根据JLS的规则进行扩展
// 目标class为原子类型时，fromClass可以为原子类型和原子类型的包装类型。
if (clazz.isPrimitive()) {
return assignmentTable.get(clazz).contains(fromClass);
}
return false;
}
private final static Map, Set>> assignmentTable = createHashMap();
static {
// boolean可以接受：boolean
assignmentTable.put(boolean.class, assignableSet(boolean.class));
// byte可以接受：byte
assignmentTable.put(byte.class, assignableSet(byte.class));
// char可以接受：char
assignmentTable.put(char.class, assignableSet(char.class));
// short可以接受：short, byte
assignmentTable.put(short.class, assignableSet(short.class, byte.class));
// int可以接受：int、byte、short、char
assignmentTable.put(int.class, assignableSet(int.class, byte.class, short.class, char.class));
// long可以接受：long、int、byte、short、char
assignmentTable.put(long.class, assignableSet(long.class, int.class, byte.class, short.class, char.class));
// float可以接受：float, long, int, byte, short, char
assignmentTable.put(float.class,
assignableSet(float.class, long.class, int.class, byte.class, short.class, char.class));
// double可以接受：double, float, long, int, byte, short, char
assignmentTable.put(double.class,
assignableSet(double.class, float.class, long.class, int.class, byte.class, short.class, char.class));
assertTrue(assignmentTable.size() == 8);
}
private static Set> assignableSet(Class... types) {
Set> assignableSet = createHashSet();
for (Class type : types) {
assignableSet.add(getPrimitiveType(type));
assignableSet.add(getWrapperTypeIfPrimitive(type));
}
return assignableSet;
}
// ==========================================================================
// 定位class的位置。
// ==========================================================================
/** 在class loader中查找class的位置。 */
public static String locateClass(Class clazz) {
return locateClass(clazz.getName(), clazz.getClassLoader());
}
/** 在class loader中查找class的位置。 */
public static String locateClass(String className) {
return locateClass(className, null);
}
/** 在class loader中查找class的位置。 */
public static String locateClass(String className, ClassLoader loader) {
className = assertNotNull(trimToNull(className), "className");
if (loader == null) {
loader = Thread.currentThread().getContextClassLoader();
}
String classFile = className.replace('.', '/') + ".class";
URL locationURL = loader.getResource(classFile);
String location = null;
if (locationURL != null) {
location = locationURL.toExternalForm();
if (location.endsWith(classFile)) {
location = location.substring(0, location.length() - classFile.length());
}
location = location.replaceAll("^(jar|zip):|!/$", EMPTY_STRING);
}
return location;
}
/** 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(Class clazz) {
String shortName = ClassUtil.getShortName(clazz);
int dotIndex = shortName.lastIndexOf('.');
shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1) : shortName);
return Introspector.decapitalize(shortName);
}
/**
* 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) {
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 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.assertNotNull(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) {
StringBuilder result = new StringBuilder();
while (clazz.isArray()) {
clazz = clazz.getComponentType();
result.append(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(Method method) {
Assert.assertNotNull(method, "Method must not be null");
return method.getDeclaringClass().getName() + "." + method.getName();
}
/**
* 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(Object instance) {
Assert.assertNotNull(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.
* 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(Class clazz) {
return getAllInterfacesForClass(clazz, null);
}
/**
* Return all interfaces that the given class implements as array,
* including ones implemented by superclasses.
*
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 null when accepting all declared interfaces)
* @return all interfaces that the given object implements as array
*/
public static Class[] getAllInterfacesForClass(Class clazz, ClassLoader classLoader) {
Set 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 getAllInterfacesAsSet(Object instance) {
Assert.assertNotNull(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.
* 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 getAllInterfacesForClassAsSet(Class clazz) {
return getAllInterfacesForClassAsSet(clazz, null);
}
/**
* Return all interfaces that the given class implements as Set,
* including ones implemented by superclasses.
* 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 null when accepting all declared interfaces)
* @return all interfaces that the given object implements as Set
*/
public static Set getAllInterfacesForClassAsSet(Class clazz, ClassLoader classLoader) {
Assert.assertNotNull(clazz, "Class must not be null");
if (clazz.isInterface() && isVisible(clazz, classLoader)) {
return Collections.singleton(clazz);
}
Set interfaces = new LinkedHashSet();
while (clazz != null) {
Class[] ifcs = clazz.getInterfaces();
for (Class ifc : ifcs) {
interfaces.addAll(getAllInterfacesForClassAsSet(ifc, classLoader));
}
clazz = clazz.getSuperclass();
}
return 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 null,
* in which case this method will always return true)
*/
public static boolean isVisible(Class clazz, ClassLoader classLoader) {
if (classLoader == null) {
return true;
}
try {
Class actualClass = classLoader.loadClass(clazz.getName());
return (clazz == actualClass);
// Else: different interface class found...
}
catch (ClassNotFoundException ex) {
// No interface class found...
return false;
}
}
/**
* 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(Class clazz) {
String className = clazz.getName();
int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
return className.substring(lastDotIndex + 1) + CLASS_FILE_SUFFIX;
}
/**
* 判断该类型是不是包装类型
* @param clazz
* @return
*/
public static boolean isBasicClass(Class clazz) {
boolean isPrimitive = false;
try {
if (clazz.isPrimitive() || clazz.isAssignableFrom(String.class)) {
isPrimitive = true;
} else {
isPrimitive = ((Class) clazz.getField("TYPE").get(null))
.isPrimitive();
}
} catch (Exception e) {
isPrimitive = false;
}
return isPrimitive;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy