Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
cn.hutool.core.util.ClassUtil Maven / Gradle / Ivy
package cn.hutool.core.util;
import cn.hutool.core.bean.NullWrapperBean;
import cn.hutool.core.convert.BasicType;
import cn.hutool.core.exceptions.UtilException;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IORuntimeException;
import cn.hutool.core.io.resource.ResourceUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.ClassScanner;
import cn.hutool.core.lang.Filter;
import cn.hutool.core.lang.Singleton;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.net.URI;
import java.net.URL;
import java.time.temporal.TemporalAccessor;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
/**
* 类工具类 对象类型
* @param obj 对象，如果为{@code null} 返回{@code null}
* @return 对象类型，提供对象如果为{@code null} 返回{@code null}
*/
@SuppressWarnings("unchecked")
public static Class getClass(T obj) {
return ((null == obj) ? null : (Class) obj.getClass());
}
/**
* 获得外围类
* isSimple为false: "com.xiaoleilu.hutool.util.ClassUtil"
* isSimple为true: "ClassUtil"
*
*
* @param clazz 类
* @param isSimple 是否简单类名，如果为true，返回不带包名的类名
* @return 类名
* @since 3.0.7
*/
public static String getClassName(Class clazz, boolean isSimple) {
if (null == clazz) {
return null;
}
return isSimple ? clazz.getSimpleName() : clazz.getName();
}
/**
* 获取完整类名的短格式如： packages = StrUtil.split(className, CharUtil.DOT);
if (null == packages || packages.size() < 2) {
return className;
}
final int size = packages.size();
final StringBuilder result = StrUtil.builder();
result.append(packages.get(0).charAt(0));
for (int i = 1; i < size - 1; i++) {
result.append(CharUtil.DOT).append(packages.get(i).charAt(0));
}
result.append(CharUtil.DOT).append(packages.get(size - 1));
return result.toString();
}
/**
* 获得对象数组的类数组
*
* @param objects 对象数组，如果数组中存在{@code null}元素，则此元素被认为是Object类型
* @return 类数组
*/
public static Class[] getClasses(Object... objects) {
Class[] classes = new Class[objects.length];
Object obj;
for (int i = 0; i < objects.length; i++) {
obj = objects[i];
if (obj instanceof NullWrapperBean) {
// 自定义null值的参数类型
classes[i] = ((NullWrapperBean) obj).getWrappedClass();
} else if (null == obj) {
classes[i] = Object.class;
} else {
classes[i] = obj.getClass();
}
}
return classes;
}
/**
* 指定类是否与给定的类名相同
*
* @param clazz 类
* @param className 类名，可以是全类名（包含包名），也可以是简单类名（不包含包名）
* @param ignoreCase 是否忽略大小写
* @return 指定类是否与给定的类名相同
* @since 3.0.7
*/
public static boolean equals(Class clazz, String className, boolean ignoreCase) {
if (null == clazz || StrUtil.isBlank(className)) {
return false;
}
if (ignoreCase) {
return className.equalsIgnoreCase(clazz.getName()) || className.equalsIgnoreCase(clazz.getSimpleName());
} else {
return className.equals(clazz.getName()) || className.equals(clazz.getSimpleName());
}
}
// ----------------------------------------------------------------------------------------- Scan classes
/**
* 扫描指定包路径下所有包含指定注解的类
*
* @param packageName 包路径
* @param annotationClass 注解类
* @return 类集合
* @see ClassScanner#scanPackageByAnnotation(String, Class)
*/
public static Set> scanPackageByAnnotation(String packageName, final Class annotationClass) {
return ClassScanner.scanPackageByAnnotation(packageName, annotationClass);
}
/**
* 扫描指定包路径下所有指定类或接口的子类或实现类
*
* @param packageName 包路径
* @param superClass 父类或接口
* @return 类集合
* @see ClassScanner#scanPackageBySuper(String, Class)
*/
public static Set> scanPackageBySuper(String packageName, final Class superClass) {
return ClassScanner.scanPackageBySuper(packageName, superClass);
}
/**
* 扫描该包路径下所有class文件
*
* @return 类集合
* @see ClassScanner#scanPackage()
*/
public static Set> scanPackage() {
return ClassScanner.scanPackage();
}
/**
* 扫描该包路径下所有class文件
*
* @param packageName 包路径 com | com. | com.abs | com.abs.
* @return 类集合
* @see ClassScanner#scanPackage(String)
*/
public static Set> scanPackage(String packageName) {
return ClassScanner.scanPackage(packageName);
}
/**
* 扫描包路径下满足class过滤器条件的所有class文件，> scanPackage(String packageName, Filter> classFilter) {
return ClassScanner.scanPackage(packageName, classFilter);
}
// ----------------------------------------------------------------------------------------- Method
/**
* 获得指定类中的Public方法名 getPublicMethodNames(Class clazz) {
return ReflectUtil.getPublicMethodNames(clazz);
}
/**
* 获得本类及其父类所有Public方法
*
* @param clazz 查找方法的类
* @return 过滤后的方法列表
*/
public static Method[] getPublicMethods(Class clazz) {
return ReflectUtil.getPublicMethods(clazz);
}
/**
* 获得指定类过滤后的Public方法列表
*
* @param clazz 查找方法的类
* @param filter 过滤器
* @return 过滤后的方法列表
*/
public static List getPublicMethods(Class clazz, Filter filter) {
return ReflectUtil.getPublicMethods(clazz, filter);
}
/**
* 获得指定类过滤后的Public方法列表
*
* @param clazz 查找方法的类
* @param excludeMethods 不包括的方法
* @return 过滤后的方法列表
*/
public static List getPublicMethods(Class clazz, Method... excludeMethods) {
return ReflectUtil.getPublicMethods(clazz, excludeMethods);
}
/**
* 获得指定类过滤后的Public方法列表
*
* @param clazz 查找方法的类
* @param excludeMethodNames 不包括的方法名列表
* @return 过滤后的方法列表
*/
public static List getPublicMethods(Class clazz, String... excludeMethodNames) {
return ReflectUtil.getPublicMethods(clazz, excludeMethodNames);
}
/**
* 查找指定Public方法 如果找不到对应的方法或方法不为public的则返回{@code null}
*
* @param clazz 类
* @param methodName 方法名
* @param paramTypes 参数类型
* @return 方法
* @throws SecurityException 无权访问抛出异常
*/
public static Method getPublicMethod(Class clazz, String methodName, Class... paramTypes) throws SecurityException {
return ReflectUtil.getPublicMethod(clazz, methodName, paramTypes);
}
/**
* 获得指定类中的Public方法名 getDeclaredMethodNames(Class clazz) {
return ReflectUtil.getMethodNames(clazz);
}
/**
* 获得声明的所有方法，包括本类及其父类和接口的所有方法和Object类的方法
*
* @param clazz 类
* @return 方法数组
*/
public static Method[] getDeclaredMethods(Class clazz) {
return ReflectUtil.getMethods(clazz);
}
/**
* 查找指定对象中的所有方法（包括非public方法），也包括父对象和Object类的方法
*
* @param obj 被查找的对象
* @param methodName 方法名
* @param args 参数
* @return 方法
* @throws SecurityException 无访问权限抛出异常
*/
public static Method getDeclaredMethodOfObj(Object obj, String methodName, Object... args) throws SecurityException {
return getDeclaredMethod(obj.getClass(), methodName, getClasses(args));
}
/**
* 查找指定类中的所有方法（包括非public方法），也包括父类和Object类的方法 找不到方法会返回{@code null}
*
* @param clazz 被查找的类
* @param methodName 方法名
* @param parameterTypes 参数类型
* @return 方法
* @throws SecurityException 无访问权限抛出异常
*/
public static Method getDeclaredMethod(Class clazz, String methodName, Class... parameterTypes) throws SecurityException {
return ReflectUtil.getMethod(clazz, methodName, parameterTypes);
}
// ----------------------------------------------------------------------------------------- Field
/**
* 查找指定类中的所有字段（包括非public字段）， 字段不存在则返回{@code null}
*
* @param clazz 被查找字段的类
* @param fieldName 字段名
* @return 字段
* @throws SecurityException 安全异常
*/
public static Field getDeclaredField(Class clazz, String fieldName) throws SecurityException {
if (null == clazz || StrUtil.isBlank(fieldName)) {
return null;
}
try {
return clazz.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
// e.printStackTrace();
}
return null;
}
/**
* 查找指定类中的所有字段（包括非public字段)
*
* @param clazz 被查找字段的类
* @return 字段
* @throws SecurityException 安全异常
*/
public static Field[] getDeclaredFields(Class clazz) throws SecurityException {
if (null == clazz) {
return null;
}
return clazz.getDeclaredFields();
}
// ----------------------------------------------------------------------------------------- Classpath
/**
* 获得ClassPath，不解码路径中的特殊字符（例如空格和中文）
*
* @return ClassPath集合
*/
public static Set getClassPathResources() {
return getClassPathResources(false);
}
/**
* 获得ClassPath
*
* @param isDecode 是否解码路径中的特殊字符（例如空格和中文）
* @return ClassPath集合
* @since 4.0.11
*/
public static Set getClassPathResources(boolean isDecode) {
return getClassPaths(StrUtil.EMPTY, isDecode);
}
/**
* 获得ClassPath，不解码路径中的特殊字符（例如空格和中文）
*
* @param packageName 包名称
* @return ClassPath路径字符串集合
*/
public static Set getClassPaths(String packageName) {
return getClassPaths(packageName, false);
}
/**
* 获得ClassPath
*
* @param packageName 包名称
* @param isDecode 是否解码路径中的特殊字符（例如空格和中文）
* @return ClassPath路径字符串集合
* @since 4.0.11
*/
public static Set getClassPaths(String packageName, boolean isDecode) {
String packagePath = packageName.replace(StrUtil.DOT, StrUtil.SLASH);
Enumeration resources;
try {
resources = getClassLoader().getResources(packagePath);
} catch (IOException e) {
throw new UtilException(e, "Loading classPath [{}] error!", packagePath);
}
final Set paths = new HashSet<>();
String path;
while (resources.hasMoreElements()) {
path = resources.nextElement().getPath();
paths.add(isDecode ? URLUtil.decode(path, CharsetUtil.systemCharsetName()) : path);
}
return paths;
}
/**
* 获得ClassPath，将编码后的中文路径解码为原字符
* config/a/db.config
* spring/xml/test.xml
*
*
* @param resource 资源（相对Classpath的路径）
* @return 资源URL
* @see ResourceUtil#getResource(String)
*/
public static URL getResourceURL(String resource) throws IORuntimeException {
return ResourceUtil.getResource(resource);
}
/**
* 获取指定路径下的资源列表
* config/a
* spring/xml
*
*
* @param resource 资源路径
* @return 资源列表
* @see ResourceUtil#getResources(String)
*/
public static List getResources(String resource) {
return ResourceUtil.getResources(resource);
}
/**
* 获得资源相对路径对应的URL
*
* @param resource 资源相对路径
* @param baseClass 基准Class，获得的相对路径相对于此Class所在路径，如果为{@code null}则相对ClassPath
* @return {@link URL}
* @see ResourceUtil#getResource(String, Class)
*/
public static URL getResourceUrl(String resource, Class baseClass) {
return ResourceUtil.getResource(resource, baseClass);
}
/**
* @return 获得Java ClassPath路径，不包括 jre
*/
public static String[] getJavaClassPaths() {
return System.getProperty("java.class.path").split(System.getProperty("path.separator"));
}
/**
* 获取当前线程的{@link ClassLoader}
*
* @return 当前线程的class loader
* @see ClassLoaderUtil#getClassLoader()
*/
public static ClassLoader getContextClassLoader() {
return ClassLoaderUtil.getContextClassLoader();
}
/**
* 获取{@link ClassLoader}
* 1、获取当前线程的ContextClassLoader
* 2、获取{@link ClassLoaderUtil}类对应的ClassLoader
* 3、获取系统ClassLoader（{@link ClassLoader#getSystemClassLoader()}）
*
*
* @return 类加载器
*/
public static ClassLoader getClassLoader() {
return ClassLoaderUtil.getClassLoader();
}
/**
* 比较判断types1和types2两组类，如果types1中所有的类都与types2对应位置的类相同，或者是其父类或接口，则返回{@code true}
*
* @param types1 类组1
* @param types2 类组2
* @return 是否相同、父类或接口
*/
public static boolean isAllAssignableFrom(Class[] types1, Class[] types2) {
if (ArrayUtil.isEmpty(types1) && ArrayUtil.isEmpty(types2)) {
return true;
}
if (null == types1 || null == types2) {
// 任何一个为null不相等（之前已判断两个都为null的情况）
return false;
}
if (types1.length != types2.length) {
return false;
}
Class type1;
Class type2;
for (int i = 0; i < types1.length; i++) {
type1 = types1[i];
type2 = types2[i];
if (isBasicType(type1) && isBasicType(type2)) {
// 原始类型和包装类型存在不一致情况
if (BasicType.unWrap(type1) != BasicType.unWrap(type2)) {
return false;
}
} else if (false == type1.isAssignableFrom(type2)) {
return false;
}
}
return true;
}
/**
* 加载类
*
* @param 对象类型
* @param className 类名
* @param isInitialized 是否初始化
* @return 类
*/
@SuppressWarnings("unchecked")
public static Class loadClass(String className, boolean isInitialized) {
return (Class) ClassLoaderUtil.loadClass(className, isInitialized);
}
/**
* 加载类并初始化
*
* @param 对象类型
* @param className 类名
* @return 类
*/
public static Class loadClass(String className) {
return loadClass(className, true);
}
// ---------------------------------------------------------------------------------------------------- Invoke start
/**
* 执行方法 对象类型
* @param classNameWithMethodName 类名和方法名表达式，类名与方法名用{@code .}或{@code #}连接 例如：com.xiaoleilu.hutool.StrUtil.isEmpty 或 com.xiaoleilu.hutool.StrUtil#isEmpty
* @param args 参数，必须严格对应指定方法的参数类型和数量
* @return 返回结果
*/
public static T invoke(String classNameWithMethodName, Object[] args) {
return invoke(classNameWithMethodName, false, args);
}
/**
* 执行方法 对象类型
* @param classNameWithMethodName 类名和方法名表达式，例如：com.xiaoleilu.hutool.StrUtil#isEmpty或com.xiaoleilu.hutool.StrUtil.isEmpty
* @param isSingleton 是否为单例对象，如果此参数为false，每次执行方法时创建一个新对象
* @param args 参数，必须严格对应指定方法的参数类型和数量
* @return 返回结果
*/
public static T invoke(String classNameWithMethodName, boolean isSingleton, Object... args) {
if (StrUtil.isBlank(classNameWithMethodName)) {
throw new UtilException("Blank classNameDotMethodName!");
}
int splitIndex = classNameWithMethodName.lastIndexOf('#');
if (splitIndex <= 0) {
splitIndex = classNameWithMethodName.lastIndexOf('.');
}
if (splitIndex <= 0) {
throw new UtilException("Invalid classNameWithMethodName [{}]!", classNameWithMethodName);
}
final String className = classNameWithMethodName.substring(0, splitIndex);
final String methodName = classNameWithMethodName.substring(splitIndex + 1);
return invoke(className, methodName, isSingleton, args);
}
/**
* 执行方法 对象类型
* @param className 类名，完整类路径
* @param methodName 方法名
* @param args 参数，必须严格对应指定方法的参数类型和数量
* @return 返回结果
*/
public static T invoke(String className, String methodName, Object[] args) {
return invoke(className, methodName, false, args);
}
/**
* 执行方法 对象类型
* @param className 类名，完整类路径
* @param methodName 方法名
* @param isSingleton 是否为单例对象，如果此参数为false，每次执行方法时创建一个新对象
* @param args 参数，必须严格对应指定方法的参数类型和数量
* @return 返回结果
*/
public static T invoke(String className, String methodName, boolean isSingleton, Object... args) {
Class clazz = loadClass(className);
try {
final Method method = getDeclaredMethod(clazz, methodName, getClasses(args));
if (null == method) {
throw new NoSuchMethodException(StrUtil.format("No such method: [{}]", methodName));
}
if (isStatic(method)) {
return ReflectUtil.invoke(null, method, args);
} else {
return ReflectUtil.invoke(isSingleton ? Singleton.get(clazz) : clazz.newInstance(), method, args);
}
} catch (Exception e) {
throw new UtilException(e);
}
}
// ---------------------------------------------------------------------------------------------------- Invoke end
/**
* 是否为包装类型
*
* @param clazz 类
* @return 是否为包装类型
*/
public static boolean isPrimitiveWrapper(Class clazz) {
if (null == clazz) {
return false;
}
return BasicType.WRAPPER_PRIMITIVE_MAP.containsKey(clazz);
}
/**
* 是否为基本类型（包括包装类和原始类）
*
* @param clazz 类
* @return 是否为基本类型
*/
public static boolean isBasicType(Class clazz) {
if (null == clazz) {
return false;
}
return (clazz.isPrimitive() || isPrimitiveWrapper(clazz));
}
/**
* 是否简单值类型或简单值类型的数组
* 原始类型
* String、other CharSequence
* Number
* Date
* URI
* URL
* Locale
* Class
*
*
* @param clazz 类
* @return 是否为简单值类型
*/
public static boolean isSimpleValueType(Class clazz) {
return isBasicType(clazz) //
|| clazz.isEnum() //
|| CharSequence.class.isAssignableFrom(clazz) //
|| Number.class.isAssignableFrom(clazz) //
|| Date.class.isAssignableFrom(clazz) //
|| clazz.equals(URI.class) //
|| clazz.equals(URL.class) //
|| clazz.equals(Locale.class) //
|| clazz.equals(Class.class)//
// jdk8 date object
|| TemporalAccessor.class.isAssignableFrom(clazz); //
}
/**
* 检查目标类是否可以从原类转化
* 1、非接口
* 2、非抽象类
* 3、非Enum枚举
* 4、非数组
* 5、非注解
* 6、非原始类型（int, long等）
*
*
* @param clazz 类
* @return 是否为标准类
*/
public static boolean isNormalClass(Class clazz) {
return null != clazz //
&& false == clazz.isInterface() //
&& false == isAbstract(clazz) //
&& false == clazz.isEnum() //
&& false == clazz.isArray() //
&& false == clazz.isAnnotation() //
&& false == clazz.isSynthetic() //
&& false == clazz.isPrimitive();//
}
/**
* 判断类是否为枚举类型
*
* @param clazz 类
* @return 是否为枚举类型
* @since 3.2.0
*/
public static boolean isEnum(Class clazz) {
return null != clazz && clazz.isEnum();
}
/**
* 获得给定类的第一个泛型参数
*
* @param clazz 被检查的类，必须是已经确定泛型类型的类
* @return {@link Class}
*/
public static Class getTypeArgument(Class clazz) {
return getTypeArgument(clazz, 0);
}
/**
* 获得给定类的泛型参数
*
* @param clazz 被检查的类，必须是已经确定泛型类型的类
* @param index 泛型类型的索引号，即第几个泛型类型
* @return {@link Class}
*/
public static Class getTypeArgument(Class clazz, int index) {
final Type argumentType = TypeUtil.getTypeArgument(clazz, index);
return TypeUtil.getClass(argumentType);
}
/**
* 获得给定类所在包的名称
* 1、如果为原始类型，返回0
* 2、非原始类型返回{@code null}
*
*
* @param clazz 类
* @return 默认值
* @since 3.0.8
*/
public static Object getDefaultValue(Class clazz) {
// 原始类型
if (clazz.isPrimitive()) {
return getPrimitiveDefaultValue(clazz);
}
return null;
}
/**
* 获取指定原始类型分的默认值
* 1、如果为原始类型，返回0
* 2、非原始类型返回{@code null}
*
*
* @param clazz 类
* @return 默认值
* @since 5.8.0
*/
public static Object getPrimitiveDefaultValue(Class clazz) {
if (long.class == clazz) {
return 0L;
} else if (int.class == clazz) {
return 0;
} else if (short.class == clazz) {
return (short) 0;
} else if (char.class == clazz) {
return (char) 0;
} else if (byte.class == clazz) {
return (byte) 0;
} else if (double.class == clazz) {
return 0D;
} else if (float.class == clazz) {
return 0f;
} else if (boolean.class == clazz) {
return false;
}
return null;
}
/**
* 获得默认值列表
*
* @param classes 值类型
* @return 默认值列表
* @since 3.0.9
*/
public static Object[] getDefaultValues(Class... classes) {
final Object[] values = new Object[classes.length];
for (int i = 0; i < classes.length; i++) {
values[i] = getDefaultValue(classes[i]);
}
return values;
}
/**
* 是否为JDK中定义的类或接口，判断依据：
*
*
* 1、以java.、javax.开头的包名
* 2、ClassLoader为null
*
*
* @param clazz 被检查的类
* @return 是否为JDK中定义的类或接口
* @since 4.6.5
*/
public static boolean isJdkClass(Class clazz) {
final Package objectPackage = clazz.getPackage();
if (null == objectPackage) {
return false;
}
final String objectPackageName = objectPackage.getName();
return objectPackageName.startsWith("java.") //
|| objectPackageName.startsWith("javax.") //
|| clazz.getClassLoader() == null;
}
/**
* 获取class类路径URL, 不管是否在jar包中都会返回文件夹的路径
