java反射（2）：类（Class<T>）
来源：互联网 发布：二次元动漫制作软件 编辑：程序博客网 时间：2024/06/08 07:00
第0章：简介
第1章：Class工具类
Class工具类ClassUtils.java如下：
package com.lsl.core.reflection;
import java.beans.Introspector;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
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.List;
import java.util.Map;
import java.util.Set;
/**
* Class工具类
* copy from spring core or commons lang package
* @author <a href="mailto:417877417@qq.com">menergy</a>
* @version 2013-11-11
*/
public abstract class ClassUtils {
/** 数组类名后缀: "[]" */
public static final String ARRAY_SUFFIX = "[]";
/** 内在数组类名前缀: "[" */
private static final String INTERNAL_ARRAY_PREFIX = "[";
/**内在非原始数组类名前缀: "[L" */
private static final String NON_PRIMITIVE_ARRAY_PREFIX = "[L";
/** 包分隔符 '.' */
private static final char PACKAGE_SEPARATOR = '.';
/** 内部类分隔符 '$' */
private static final char INNER_CLASS_SEPARATOR = '$';
/** code生成库（CGLIB） 类分隔符 "$$" */
public static final String CGLIB_CLASS_SEPARATOR = "$$";
/** ".class"文件后缀 */
public static final String CLASS_FILE_SUFFIX = ".class";
/**
* Map<基本数据类型封装类,基本数据类型类>
* example: Integer.class -> int.class.
*/
private static final Map<Class<?>, Class<?>> wrapperClassToPrimitiveClassMap = new HashMap<Class<?>, Class<?>>(8);
/**
* Map<基本数据类型类, 基本数据类型封装类>
* example：int.class -> Integer.class.
*/
private static final Map<Class<?>, Class<?>> primitiveClassToWrapperClassMap = new HashMap<Class<?>, Class<?>>(8);
/**
* Map<基本数据类型名, 基本数据类型类>
* example: "int" -> "int.class".
*/
private static final Map<String, Class<?>> primitiveNameToPrimitiveClassMap = new HashMap<String, Class<?>>(32);
/**
* Map: 普通"java.lang"类名做主键，对应的Class作为值
*/
private static final Map<String, Class<?>> commonClassCache = new HashMap<String, Class<?>>(32);
/**
* Map<基本数据类型，数组类名称中基本数据类型的缩写>
* example: Map<"int", "I">
*/
private static final Map<String, String> abbreviationMap = new HashMap<String, String>();
/**
* Map<数组类名称中基本数据类型的缩写，基本数据类型>
* example: Map<"I", "int">
*/
private static final Map<String, String> reverseAbbreviationMap = new HashMap<String, String>();
/**
* 添加基本数据类型和数组类名称中基本数据类型的缩写的关系
*
* @param primitive
* @param abbreviation
*/
private static void addAbbreviation(String primitive, String abbreviation) {
abbreviationMap.put(primitive, abbreviation);
reverseAbbreviationMap.put(abbreviation, primitive);
}
static {
addAbbreviation("int", "I");
addAbbreviation("boolean", "Z");
addAbbreviation("float", "F");
addAbbreviation("long", "J");
addAbbreviation("short", "S");
addAbbreviation("byte", "B");
addAbbreviation("double", "D");
addAbbreviation("char", "C");
wrapperClassToPrimitiveClassMap.put(Boolean.class, boolean.class);
wrapperClassToPrimitiveClassMap.put(Byte.class, byte.class);
wrapperClassToPrimitiveClassMap.put(Character.class, char.class);
wrapperClassToPrimitiveClassMap.put(Double.class, double.class);
wrapperClassToPrimitiveClassMap.put(Float.class, float.class);
wrapperClassToPrimitiveClassMap.put(Integer.class, int.class);
wrapperClassToPrimitiveClassMap.put(Long.class, long.class);
wrapperClassToPrimitiveClassMap.put(Short.class, short.class);
for (Map.Entry<Class<?>, Class<?>> entry : wrapperClassToPrimitiveClassMap.entrySet()) {
primitiveClassToWrapperClassMap.put(entry.getValue(), entry.getKey());
registerCommonClasses(entry.getKey());
}
Set<Class<?>> primitiveTypes = new HashSet<Class<?>>(32);
primitiveTypes.addAll(wrapperClassToPrimitiveClassMap.values());
primitiveTypes.addAll(Arrays.asList(new Class<?>[] {
boolean[].class, byte[].class, char[].class, double[].class,
float[].class, int[].class, long[].class, short[].class}));
primitiveTypes.add(void.class);
for (Class<?> primitiveType : primitiveTypes) {
primitiveNameToPrimitiveClassMap.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);
}
/**
* 注册普通类
*
* @param commonClasses
*/
private static void registerCommonClasses(Class<?>... commonClasses) {
for (Class<?> clazz : commonClasses) {
commonClassCache.put(clazz.getName(), clazz);
}
}
/**
* 基本数据类型名转成基本数据类型类
* example: "int" ->"int.class"
* @param name 基本数据类型名 example:"[B", "char"
* @return 基本数据类型类
*/
public static Class<?> convertPrimitiveNameToPrimitiveClass(String primitiveName) {
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 (primitiveName != null && primitiveName.length() <= 8) {
// Could be a primitive - likely.
result = primitiveNameToPrimitiveClassMap.get(primitiveName);
}
return result;
}
/**
* 基本数据类型转成基本数据类型封装类
* example: "int.class" -> "Integer.class" ，如果失败则"int.class" -> "int.class"
* @param clazz
* @return
*/
public static Class<?> convertPrimitiveClassToWrapperClass(Class<?> clazz) {
Class<?> convertedClass = clazz;
if (clazz != null && clazz.isPrimitive()) {
convertedClass = (Class<?>) primitiveClassToWrapperClassMap.get(clazz);
}
return convertedClass;
}
/**
* 基本数据类型转成基本数据类型封装类（数组方式）
*example: "int.class[]" -> "Integer.class[]"
*
* @param classes
* @return
*/
public static Class<?>[] convertPrimitiveClassesToWrapperClasses(Class<?>[] classes) {
if (classes == null) {
return null;
}
if (classes.length == 0) {
return classes;
}
Class<?>[] convertedClasses = new Class[classes.length];
for (int i = 0; i < classes.length; i++) {
convertedClasses[i] = convertPrimitiveClassToWrapperClass(classes[i]);
}
return convertedClasses;
}
/**
* 基本数据类型封装类转成基本数据类型
*example: "Integer.class" -> "int.class"
*
* @param clazz
* @return
*/
public static Class<?> convertWrapperClassToPrimitiveClass(Class<?> clazz) {
return (Class<?>) wrapperClassToPrimitiveClassMap.get(clazz);
}
/**
* 基本数据类型封装类转成基本数据类型（数组方式）
*example: "Integer.class[]" -> "int.class[]"
*
* @param classes
* @return
*/
public static Class<?>[] convertWrapperClassesToPrimitiveClasses(Class<?>[] classes) {
if (classes == null) {
return null;
}
if (classes.length == 0) {
return classes;
}
Class<?>[] convertedClasses = new Class[classes.length];
for (int i = 0; i < classes.length; i++) {
convertedClasses[i] = convertWrapperClassToPrimitiveClass(classes[i]);
}
return convertedClasses;
}
/**
* 类名集称转换成类集
*example: List<"java.lang.String"> -> List<"String.class">
*
* @param classNames 全限定类名集合
* @return
*/
public static List<Class<?>> convertClassNamesToClasses(List<String> classNames) {
if (classNames == null) {
return null;
}
List<Class<?>> classes = new ArrayList<Class<?>>(classNames.size());
for (Iterator<String> it = classNames.iterator(); it.hasNext();) {
String className = (String) it.next();
try {
classes.add(Class.forName(className));
} catch (Exception ex) {
classes.add(null);
}
}
return classes;
}
/**
* 类转换成类名称
*example: List<"String.class"> -> List<"java.lang.String">
*
* @param classes
* @return
*/
public static List<String> convertClassesToClassNames(List<Class<?>> classes) {
if (classes == null) {
return null;
}
List<String> classNames = new ArrayList<String>(classes.size());
for (Iterator<Class<?>> it = classes.iterator(); it.hasNext();) {
Class<?> clazz = (Class<?>) it.next();
if (clazz == null) {
classNames.add(null);
} else {
classNames.add(clazz.getName());
}
}
return classNames;
}
/**
* 将资源路径"/"转换成类名路径"."
* example: "java/lang/String" -> "java.lang.String"
*
* @param resourcePath
* @return
*/
public static String convertResourcePathToClassName(String resourcePath) {
if (resourcePath == null) {
throw new IllegalArgumentException("Resource path must not be null");
}
return resourcePath.replace('/', '.');
}
/**
* 将类名路径"."转换成资源路径"/"
*example: "java.lang.String" -> "java/lang/String"
*
* @param className
* @return
*/
public static String convertClassNameToResourcePath(String className) {
if (className == null) {
throw new IllegalArgumentException("Class name must not be null");
}
return className.replace('.', '/');
}
/**
* 将类的包名转换成资源路径
*example: "java.lang" -> "java/lang"
*
* @param clazz
* @return
*/
public static String convertClassPackageToResourcePath(Class<?> clazz) {
if (clazz == null) {
return "";
}
String className = clazz.getName();
int packageEndIndex = className.lastIndexOf('.');
if (packageEndIndex == -1) {
return "";
}
String packageName = className.substring(0, packageEndIndex);
return packageName.replace('.', '/');
}
/**
* 将资源路径加到包路径中
*
* @param clazz
* @param resourceName
* @return
*/
public static String addResourcePathToPackagePath(Class<?> clazz, String resourceName) {
if (resourceName == null) {
throw new IllegalArgumentException("Resource name must not be null");
}
if (!resourceName.startsWith("/")) {
return convertClassPackageToResourcePath(clazz) + "/" + resourceName;
}
return convertClassPackageToResourcePath(clazz) + resourceName;
}
/**
* 将类名集转成字符串
*
* @param classes
* @return
*/
public static String convertClassNamesToString(Collection<Class<?>> classes) {
if (classes == null || classes.isEmpty()) {
return "[]";
}
StringBuilder sb = new StringBuilder("[");
for (Iterator<Class<?>> it = classes.iterator(); it.hasNext(); ) {
Class<?> clazz = it.next();
sb.append(clazz.getName());
if (it.hasNext()) {
sb.append(", ");
}
}
sb.append("]");
return sb.toString();
}
/**
* 将类名集转成字符串
*
* @param classes
* @return
*/
public static String convertClassNamesToString(Class<?>... classes) {
return convertClassNamesToString(Arrays.asList(classes));
}
/**
* 将类名集转成类数组
*
* @param collection
* @return
*/
public static Class<?>[] convertClassCollectionToClassArray(Collection<Class<?>> collection) {
if (collection == null) {
return null;
}
return collection.toArray(new Class<?>[collection.size()]);
}
/**
* 获取默认类加载器
*
* @return
*/
public static ClassLoader getDefaultClassLoader() {
ClassLoader cl = null;
try {
cl = Thread.currentThread().getContextClassLoader();
}
catch (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;
}
/**
* 用自定义类加载器类加载器复写线程上下文类加载器
*
* @param classLoaderToUse 用户自定义类加载器
* @return
*/
public static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse) {
Thread currentThread = Thread.currentThread();
ClassLoader threadContextClassLoader = currentThread.getContextClassLoader();
if (classLoaderToUse != null && !classLoaderToUse.equals(threadContextClassLoader)) {
currentThread.setContextClassLoader(classLoaderToUse);
return threadContextClassLoader;
}
else {
return null;
}
}
/**
* 置换Class.forName()方法，以扩展支持对基本数据类型和数组的类实例化
*
* @param name 类名
* @return
* @throws ClassNotFoundException
* @throws LinkageError
*/
@Deprecated
public static Class<?> forName(String name) throws ClassNotFoundException, LinkageError {
return forName(name, getDefaultClassLoader());
}
/**
* 置换Class.forName()方法，以扩展支持对基本数据类型和数组的类实例化
*
* @param name 类名
* @param classLoader 类加载器
* @return
* @throws ClassNotFoundException
* @throws LinkageError
*/
public static Class<?> forName(String name, ClassLoader classLoader) throws ClassNotFoundException, LinkageError {
if (name == null) {
throw new IllegalArgumentException("Name must not be null");
}
Class<?> clazz = convertPrimitiveNameToPrimitiveClass(name);
if (clazz == null) {
clazz = commonClassCache.get(name);
}
if (clazz != null) {
return clazz;
}
// "java.lang.String[]" style arrays
if (name.endsWith(ARRAY_SUFFIX)) {
String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
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(";")) {
String elementName = name.substring(NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1);
Class<?> elementClass = forName(elementName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
}
// "[[I" or "[[Ljava.lang.String;" style arrays
if (name.startsWith(INTERNAL_ARRAY_PREFIX)) {
String elementName = name.substring(INTERNAL_ARRAY_PREFIX.length());
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 (ClassNotFoundException ex) {
int lastDotIndex = name.lastIndexOf('.');
if (lastDotIndex != -1) {
String innerClassName = name.substring(0, lastDotIndex) + '$' + name.substring(lastDotIndex + 1);
try {
return classLoaderToUse.loadClass(innerClassName);
}
catch (ClassNotFoundException ex2) {
// swallow - let original exception get through
}
}
throw ex;
}
}
/**
* 获得新对象
*
* @param clazz 类
* @return
*/
public static Object getNewInstance(Class<?> clazz){
if (clazz == null) {
throw new IllegalArgumentException("clazz must not be null");
}
Object obj = null;
try {
obj = clazz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (obj == null) {
throw new IllegalArgumentException("Error:the new object is null");
}
return obj;
}
/**
* 解析类名（包括基本数据类型和数组）
*
* @param className
* @param classLoader
* @return
* @throws IllegalArgumentException
*/
public static Class<?> resolveClassName(String className, ClassLoader classLoader) throws IllegalArgumentException {
try {
return forName(className, classLoader);
}
catch (ClassNotFoundException ex) {
throw new IllegalArgumentException("Cannot find class [" + className + "]", ex);
}
catch (LinkageError ex) {
throw new IllegalArgumentException(
"Error loading class [" + className + "]: problem with class file or dependent class.", ex);
}
}
/**
* 判断提供的类名是否存在且可以被加载
*
* @param className example:"com.lsl.test.ExceptionTest"
* @return
*/
@Deprecated
public static boolean isPresent(String className) {
return isPresent(className, getDefaultClassLoader());
}
/**
* 判断提供的类名是否存在且可以被加载
*
* @param className example:"com.lsl.test.ExceptionTest"
* @param classLoader
* @return
*/
public static boolean isPresent(String className, ClassLoader classLoader) {
try {
forName(className, classLoader);
return true;
}
catch (Throwable ex) {
// Class or one of its dependencies is not present...
return false;
}
}
/**
* 获取用户自定义类
*
* @param instance
* @return
*/
public static Class<?> getUserClass(Object instance) {
if (instance == null) {
throw new IllegalArgumentException("Instance must not be null");
}
return getUserClass(instance.getClass());
}
/**
* 获取用户自定义类
* 对于被cglib AOP过的对象, 取得真实的Class类型
* @param clazz
* @return
*/
public static Class<?> getUserClass(Class<?> clazz) {
if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
Class<?> superClass = clazz.getSuperclass();
if (superClass != null && !Object.class.equals(superClass)) {
return superClass;
}
}
return clazz;
}
/**
* 判断给定的类是否缓存安全
*（是否指定类存在于指定类加载器或其父类加载器）
* @param clazz 给定的类
* @param classLoader 类加载器
* @return
*/
public static boolean isCacheSafe(Class<?> clazz, ClassLoader classLoader) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
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;
}
/**
* 获取类简略名称
*
* @param className
* @return
*/
public static String getShortClassName(String className) {
if(className == null || className.length() == 0){
throw new IllegalArgumentException("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;
}
/**
* 获取类简略名称
*
* @param clazz
* @return
*/
public static String getShortClassName(Class<?> clazz) {
return getShortClassName(getQualifiedName(clazz));
}
/**
* 获取小写开头的javabean属性格式的字符串对应类的简略名称
*
* @param clazz
* @return
*/
public static String getShortNameAsProperty(Class<?> clazz) {
String shortName = ClassUtils.getShortClassName(clazz);
int dotIndex = shortName.lastIndexOf('.');
shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1) : shortName);
//获得一个字符串并将它转换成普通 Java 变量名称大写形式的实用工具方法
return Introspector.decapitalize(shortName);
}
/**
* 获取规范类名称（包括数组类）
*
* @param clazz
* @return
*/
public static String getQualifiedName(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
if (clazz.isArray()) {
return getQualifiedNameForArray(clazz);
}
else {
return clazz.getName();
}
}
/**
* 为数组构建一个规范类名
*
* @param clazz
* @return
*/
private static String getQualifiedNameForArray(Class<?> clazz) {
StringBuilder result = new StringBuilder();
while (clazz.isArray()) {
//返回表示数组组件类型的Class
clazz = clazz.getComponentType();
result.append(ClassUtils.ARRAY_SUFFIX);
}
result.insert(0, clazz.getName());
return result.toString();
}
/**
* 获取.class文件名称，格式："String.class"
*
* @param clazz
* @return
*/
public static String getClassFileName(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
String className = clazz.getName();
int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
return className.substring(lastDotIndex + 1) + CLASS_FILE_SUFFIX;
}
/**
* 获取包名，格式："java.lang"
*
* @param clazz
* @return
*/
public static String getPackageName(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
return getPackageName(clazz.getName());
}
/**
* 获取包名，格式："java.lang"
*
* @param fqClassName 全限定类名
* @return
*/
public static String getPackageName(String fqClassName) {
if (fqClassName == null) {
throw new IllegalArgumentException("Class name must not be null");
}
int lastDotIndex = fqClassName.lastIndexOf(PACKAGE_SEPARATOR);
return (lastDotIndex != -1 ? fqClassName.substring(0, lastDotIndex) : "");
}
/**
* 获取规范方法名
*
* @param method
* @return
*/
public static String getQualifiedMethodName(Method method) {
if (method == null) {
throw new IllegalArgumentException("Method must not be null");
}
return method.getDeclaringClass().getName() + "." + method.getName();
}
/**
* 获取对象的描述名，通常等同于对象的简略名称，数组则带[]
*
* @param value
* @return
*/
public static String getDescriptiveType(Object value) {
if (value == null) {
return null;
}
Class<?> clazz = value.getClass();
if (Proxy.isProxyClass(clazz)) {
StringBuilder result = new StringBuilder(clazz.getName());
result.append(" implementing ");
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();
}
}
/**
* 判断Class是否与用户知道的类名匹配
*
* @param clazz
* @param className
* @return
*/
public static boolean isMatchesClassName(Class<?> clazz, String className) {
return (className != null &&
(className.equals(clazz.getName()) || className.equals(clazz.getSimpleName()) ||
(clazz.isArray() && className.equals(getQualifiedNameForArray(clazz)))));
}
/**
*是否是基本数据类型封装类
*
* @param clazz
* @return
*/
public static boolean isPrimitiveWrapper(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
return wrapperClassToPrimitiveClassMap.containsKey(clazz);
}
/**
* 是否是基本数据类型类或者是其封装类
*
* @param clazz
* @return
*/
public static boolean isPrimitiveOrWrapper(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
return (clazz.isPrimitive() || isPrimitiveWrapper(clazz));
}
/**
* 是否是基本数据类型数组类
*
* @param clazz
* @return
*/
public static boolean isPrimitiveArray(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
return (clazz.isArray() && clazz.getComponentType().isPrimitive());
}
/**
* 是否是基本数据类型封装类数组类
*
* @param clazz
* @return
*/
public static boolean isPrimitiveWrapperArray(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
return (clazz.isArray() && isPrimitiveWrapper(clazz.getComponentType()));
}
/**
* 源类是否可以分配给目标类（包括基本数据类型），即目标类（toClass）是源类（clazz）的父类或接口，或两者一样
*
* @param clazz 源 类
* @param toClass 目标类
* @param autoboxing true表示自动装箱/自动拆箱
* @return
*/
public static boolean isAssignable(Class<?> clazz, Class<?> toClazz, boolean autoboxing) {
if (toClazz == null) {
return false;
}
// have to check for null, as isAssignableFrom doesn't
if (clazz == null) {
return !(toClazz.isPrimitive());
}
//自动装箱/自动拆箱:
if (autoboxing) {
if (clazz.isPrimitive() && !toClazz.isPrimitive()) {
clazz = convertPrimitiveClassToWrapperClass(clazz);
if (clazz == null) {
return false;
}
}
if (toClazz.isPrimitive() && !clazz.isPrimitive()) {
clazz = convertWrapperClassToPrimitiveClass(clazz);
if (clazz == null) {
return false;
}
}
}
if (clazz.equals(toClazz)) {
return true;
}
if (clazz.isPrimitive()) {
if (toClazz.isPrimitive() == false) {
return false;
}
if (Integer.TYPE.equals(clazz)) {
return Long.TYPE.equals(toClazz)
|| Float.TYPE.equals(toClazz)
|| Double.TYPE.equals(toClazz);
}
if (Long.TYPE.equals(clazz)) {
return Float.TYPE.equals(toClazz)
|| Double.TYPE.equals(toClazz);
}
if (Boolean.TYPE.equals(clazz)) {
return false;
}
if (Double.TYPE.equals(clazz)) {
return false;
}
if (Float.TYPE.equals(clazz)) {
return Double.TYPE.equals(toClazz);
}
if (Character.TYPE.equals(clazz)) {
return Integer.TYPE.equals(toClazz)
|| Long.TYPE.equals(toClazz)
|| Float.TYPE.equals(toClazz)
|| Double.TYPE.equals(toClazz);
}
if (Short.TYPE.equals(clazz)) {
return Integer.TYPE.equals(toClazz)
|| Long.TYPE.equals(toClazz)
|| Float.TYPE.equals(toClazz)
|| Double.TYPE.equals(toClazz);
}
if (Byte.TYPE.equals(clazz)) {
return Short.TYPE.equals(toClazz)
|| Integer.TYPE.equals(toClazz)
|| Long.TYPE.equals(toClazz)
|| Float.TYPE.equals(toClazz)
|| Double.TYPE.equals(toClazz);
}
// should never get here
return false;
}
return toClazz.isAssignableFrom(clazz);
}
/**
* 源类是否可以分配给目标（包括基本数据类型，不自动装箱或拆箱），即目标类（toClass）是源类（clazz）的父类或接口，或两者一样
*
* @param clazz 源 类
* @param toClass 目标类
* @return
*/
public static boolean isAssignable(Class<?> clazz, Class<?> toClazz) {
return isAssignable(clazz, toClazz, false);
}
/**
* 源类数组是否可以分配给目标类数组（包括基本数据类型）
*
* @param classArray 源类数组
* @param toClassArray 目标类数组
* @param autoboxing true表示自动装箱/自动拆箱
* @return
*/
public static boolean isAssignable(Class<?>[] classArray, Class<?>[] toClassArray, boolean autoboxing) {
if ((classArray == null && toClassArray != null && toClassArray.length > 0) ||
(toClassArray == null && classArray != null && classArray.length > 0) ||
(classArray != null && toClassArray != null && classArray.length != toClassArray.length)) {
return false;
}
if (classArray == null) {
classArray = new Class[0];
}
if (toClassArray == null) {
toClassArray = new Class[0];
}
for (int i = 0; i < classArray.length; i++) {
if (isAssignable(classArray[i], toClassArray[i], autoboxing) == false) {
return false;
}
}
return true;
}
/**
* 源类数组是否可以分配给目标类数组
*
* @param classArray 源类数组
* @param toClassArray 目标类数组
* @return
*/
public static boolean isAssignable(Class<?>[] classArray, Class<?>[] toClassArray) {
return isAssignable(classArray, toClassArray, false);
}
/**
* 右边的值是否可分配给左边的类型
*
* @param type 左边的类型
* @param value 右边的值
* @return
*/
public static boolean isAssignableValue(Class<?> type, Object value) {
if (type == null) {
throw new IllegalArgumentException("Type must not be null");
}
return (value != null ? isAssignable(value.getClass(), type) : !type.isPrimitive());
}
/**
* 是否是内部类或者是静态嵌套类
*
* @param clazz
* @return
*/
public static boolean isInnerClass(Class<?> clazz) {
if (clazz == null) {
return false;
}
return clazz.getName().indexOf(INNER_CLASS_SEPARATOR) >= 0;
}
/**
* 获取类的所有接口（包括父类的接口）
*
* @param clazz
* @return
*/
public static List<Class<?>> getInterfacesOfClassAsList(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
List<Class<?>> interfacesFound = new ArrayList<Class<?>>();
getInterfacesOfClassAsList(clazz, interfacesFound);
return interfacesFound;
}
/**
* 获取类的所有接口（包括父类），返回List格式
*
* @param clazz
* @param interfacesFound 存放获取的结果
*/
private static void getInterfacesOfClassAsList(Class<?> clazz, List<Class<?>> interfacesFound) {
while (clazz != null) {
Class<?>[] interfaces = clazz.getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
if (!interfacesFound.contains(interfaces[i])) {
interfacesFound.add(interfaces[i]);
getInterfacesOfClassAsList(interfaces[i], interfacesFound);
}
}
clazz = clazz.getSuperclass();
}
}
/**
* 获取对象的所有接口(包括父类)，返回数组格式
*
* @param instance
* @return 类数组
*/
public static Class<?>[] getInterfacesOfInstanceAsArray (Object instance) {
if (instance == null) {
throw new IllegalArgumentException("Instance must not be null");
}
return getInterfacesOfClassInClassLoaderAsArray(instance.getClass());
}
/**
* 获取类的所有接口(包括父类)，返回数组格式
*
* @param clazz
* @return 类数组
*/
public static Class<?>[] getInterfacesOfClassInClassLoaderAsArray(Class<?> clazz) {
return getInterfacesOfClassInClassLoaderAsArray(clazz, null);
}
/**
* 获取类的所有在指定类加载器中可见的接口(包括父类)，返回数组格式
*
* @param clazz
* @param classLoader
* @return 类数组
*/
public static Class<?>[] getInterfacesOfClassInClassLoaderAsArray(Class<?> clazz, ClassLoader classLoader) {
Set<Class> ifcs = getInterfacesOfClassInClassLoaderAsSet(clazz, classLoader);
return ifcs.toArray(new Class[ifcs.size()]);
}
/**
* 获取对象所有的接口类（返回类集合形式）
*
* @param instance
* @return 类的Set集合
*/
public static Set<Class> getInterfacesOfInstanceAsSet(Object instance) {
if (instance == null) {
throw new IllegalArgumentException("Instance must not be null");
}
return getInterfacesOfClassInClassLoaderAsSet(instance.getClass());
}
/**
* 获取类的所有接口类(包括父类)，返回Set格式
*
* @param clazz
* @return
*/
public static Set<Class> getInterfacesOfClassInClassLoaderAsSet(Class clazz) {
return getInterfacesOfClassInClassLoaderAsSet(clazz, null);
}
/**
* 获取类的所有在指定类加载器中可见的接口(包括父类)，返回Set格式
*
* @param clazz 类
* @param classLoader 类加载器
* @return
*/
public static Set<Class> getInterfacesOfClassInClassLoaderAsSet(Class clazz, ClassLoader classLoader) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
if (clazz.isInterface() && isClassVisibleInClassLoader(clazz, classLoader)) {
//static T set<T> singleton（T o）方法返回一个只包含指定对象的不可变 set
return Collections.singleton(clazz);
}
Set<Class> interfaces = new LinkedHashSet<Class>();
while (clazz != null) {
Class<?>[] ifcs = clazz.getInterfaces();
for (Class<?> ifc : ifcs) {
interfaces.addAll(getInterfacesOfClassInClassLoaderAsSet(ifc, classLoader));
}
clazz = clazz.getSuperclass();
}
return interfaces;
}
/**
* 获取指定类的所有父类
*
* @param clazz
* @return
*/
public static List<Class<?>> getAllSuperclasses(Class<?> clazz) {
if (clazz == null) {
throw new IllegalArgumentException("Class must not be null");
}
List<Class<?>> clazzes = new ArrayList<Class<?>>();
Class<?> superclass = clazz.getSuperclass();
while (superclass != null) {
clazzes.add(superclass);
superclass = superclass.getSuperclass();
}
return clazzes;
}
/**
* 是否指定的类在类加载器中可见
*
* @param clazz
* @param classLoader
* @return
*/
public static boolean isClassVisibleInClassLoader(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;
}
}
/**
* 获取多个接口的代理类
*
* @param interfaces 类口数组类
* @param classLoader 类加载器
* @return
*/
public static Class<?> getProxyClassByInterfaces(Class<?>[] interfaces, ClassLoader classLoader) {
if (interfaces == null || interfaces.length == 0) {
throw new IllegalArgumentException("Interfaces must not be empty");
}
if (classLoader == null) {
throw new IllegalArgumentException("ClassLoader must not be null");
}
return Proxy.getProxyClass(classLoader, interfaces);
}
/**
* 是否是CGLIB代理对象
*
* @param object
* @return
*/
public static boolean isCglibProxy(Object object) {
return ClassUtils.isCglibProxyClass(object.getClass());
}
/**
* 是否是CGLIB代理类
*
* @param clazz
* @return
*/
public static boolean isCglibProxyClass(Class<?> clazz) {
return (clazz != null && isCglibProxyClassName(clazz.getName()));
}
/**
* 是否是CGLIB代理类名（即类名中包括“$$”字符）
*
* @param className 全限定类名
* @return
*/
public static boolean isCglibProxyClassName(String className) {
return (className != null && className.contains(CGLIB_CLASS_SEPARATOR));
}
/**
* 获取类名简写
*
* @param object
* @param valueIfNull
* @return
*/
public static String getShortCanonicalName(Object object, String valueIfNull) {
if (object == null) {
return valueIfNull;
}
return getShortCanonicalName(object.getClass().getName());
}
/**
* 获取类名简写
*
* @param cls
* @return
*/
public static String getShortCanonicalName(Class<?> clazz) {
if (clazz == null) {
return "";
}
return getShortCanonicalName(clazz.getName());
}
/**
* 获取类名简写
*
* @param canonicalName
* @return
*/
public static String getShortCanonicalName(String canonicalName) {
return ClassUtils.getShortClassName(getCanonicalName(canonicalName));
}
/**
* 获取包名
*
* @param object
* @param valueIfNull
* @return
*/
public static String getPackageCanonicalName(Object object, String valueIfNull) {
if (object == null) {
return valueIfNull;
}
return getPackageCanonicalName(object.getClass().getName());
}
/**
* 获取包名
*
* @param clazz
* @return
*/
public static String getPackageCanonicalName(Class<?> clazz) {
if (clazz == null) {
return "";
}
return getPackageCanonicalName(clazz.getName());
}
/**
* 获取包名
*
* @param canonicalName
* @return
*/
public static String getPackageCanonicalName(String canonicalName) {
return ClassUtils.getPackageName(getCanonicalName(canonicalName));
}
/**
* 将类名转成规范的JLS格式名
*
* @param className
* @return
*/
public static String toCanonicalName(String className) {
className = deleteWhitespace(className);
if (className == null) {
throw new IllegalArgumentException("className must not be null or only white space");
} else if (className.endsWith("[]")) {
StringBuilder classNameBuffer = new StringBuilder();
while (className.endsWith("[]")) {
className = className.substring(0, className.length() - 2);
classNameBuffer.append("[");
}
String abbreviation = (String) abbreviationMap.get(className);
if (abbreviation != null) {
classNameBuffer.append(abbreviation);
} else {
classNameBuffer.append("L").append(className).append(";");
}
className = classNameBuffer.toString();
}
return className;
}
/**
* 将规范的JLS格式名转换成类名
*
* @param className
* @return
*/
private static String getCanonicalName(String className) {
className = deleteWhitespace(className);
if (className == null) {
return null;
} else {
int dim = 0;
while (className.startsWith("[")) {
dim++;
className = className.substring(1);
}
if (dim < 1) {
return className;
} else {
if (className.startsWith("L")) {
className = className.substring(1, className.endsWith(";") ? className.length() - 1 : className.length());
} else {
if (className.length() > 0) {
className = (String) reverseAbbreviationMap.get(className.substring(0, 1));
}
}
StringBuilder canonicalClassNameBuffer = new StringBuilder(className);
for (int i = 0; i < dim; i++) {
canonicalClassNameBuffer.append("[]");
}
return canonicalClassNameBuffer.toString();
}
}
}
/**
* 删除字符串中的空白符
*
* @param str
* @return
*/
private static String deleteWhitespace(String str) {
if (str == null || str.length() == 0) {
return str;
}
int sz = str.length();
char[] chs = new char[sz];
int count = 0;
for (int i = 0; i < sz; i++) {
if (!Character.isWhitespace(str.charAt(i))) {
chs[count++] = str.charAt(i);
}
}
if (count == sz) {
return str;
}
return new String(chs, 0, count);
}
/**
*
* @param args
*/
public static void main(String[] args) {
System.out.println(ClassUtils.isPresent("com.lsl.test.ExceptionTest"));
System.out.println(ClassUtils.getShortClassName("com.lsl.Test3"));
System.out.println(ClassUtils.getDefaultClassLoader());
System.out.println(ClassUtils.getCanonicalName(ClassUtils.toCanonicalName("com.lsl.core.exception.NestedRuntimeException[]")));
}
}
- java反射（2）：类（Class<T>）
- Java（反射的基础Class类）
- Java反射（一）Class类对象
- java反射(2）+Class.forName( )
- Java反射（一）Class
- Java 反射类--Class
- java反射：class类
- 反射T.class
- 反射（一）---类Class
- Java 泛型（Class test<T>{...}）
- 16---java反射机制00（Class类的理解）
- 黑马程序员：java中的Class类和反射（一）
- 黑马程序员：java中的Class类和反射（二）
- java基础之反射（1.认识class类）
- java基础之反射（2.class类的使用）
- java反射机制剖析（三）—类类型Class
- Java反射机制（一）：认识Class类
- java反射机制学习（一）--Class类
- hdu1151Air Raid
- Android应用基础及原理概要,四大组件
- ubuntu下软件安装卸载与查看
- 调试Opal 3.12.8中出现的错误记录
- 一些OEM的厂商的漏洞分析
- java反射（2）：类（Class<T>）
- EFM32在使用IAR开发环境配置ICf文件以及指定程序存储地址空间
- vmware 虚拟机和win7共享文件夹
- 实际项目中的常见算法--有实现--好强大--慢慢学习
- 9duoj1021
- 中文ubuntu里用户目录里的路径改成英文
- 一个按钮被点击之后背后的故事（1）
- 蓝桥杯 c++ 罗马数字转换问题
- jquery 动态合并单元格
