Package org.miaixz.bus.core.xyz

Class ClassKit

java.lang.Object
org.miaixz.bus.core.xyz.ClassKit
public class ClassKit extends Object
类工具类
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Details

    • ClassKit

      public ClassKit()

  • Method Details

    • getClass

      public static <T> Class<T> getClass(T obj)
      null安全的获取对象类型
      Type Parameters:
      T - 对象类型
      Parameters:
      obj - 对象，如果为null 返回null
      Returns:
      对象类型，提供对象如果为null 返回null

    • getEnclosingClass

      public static Class<?> getEnclosingClass(Class<?> clazz)
      获得外围类 返回定义此类或匿名类所在的类，如果类本身是在包中定义的，返回null
      Parameters:
      clazz - 类
      Returns:
      外围类

    • getPackageName

      public static String getPackageName(Class<?> clazz)
      获取给定类的包的名称. 类似java.lang.String 字符串类
      Parameters:
      clazz - 类
      Returns:
      包名，如果类在默认包中定义，则为空字符串

    • getPackageName

      public static String getPackageName(String className)
      获取给定类的包的名称. 类似java.lang.String 字符串类.
      Parameters:
      className - 完整的类名
      Returns:
      包名，如果类在默认包中定义，则为空字符串

    • isTopLevelClass

      public static boolean isTopLevelClass(Class<?> clazz)
      是否为顶层类，即定义在包中的类，而非定义在类中的内部类
      Parameters:
      clazz - 类
      Returns:
      是否为顶层类

    • getClassName

      public static String getClassName(Object obj, boolean isSimple)
      获取类名
      Parameters:
      obj - 获取类名对象
      isSimple - 是否简单类名，如果为true，返回不带包名的类名
      Returns:
      类名

    • getClassName

      public static String getClassName(Class<?> clazz, boolean isSimple)
      获取类名 类名并不包含“.class”这个扩展名 例如：ClassKit这个类 
       isSimple为false: "reflect.core.org.miaixz.bus.ClassKit"
 isSimple为true: "ClassKit"
      Parameters:
      clazz - 类
      isSimple - 是否简单类名，如果为true，返回不带包名的类名
      Returns:
      类名

    • getShortClassName

      public static String getShortClassName(String className)
      获取完整类名的短格式如： text.org.miaixz.core.StringKit - o.m.c.StringKit
      Parameters:
      className - 类名
      Returns:
      短格式类名

    • getClasses

      public static Class<?>[] getClasses(Object... objects)
      获得对象数组的类数组
      Parameters:
      objects - 对象数组，如果数组中存在null元素，则此元素被认为是Object类型
      Returns:
      类数组

    • equals

      public static boolean equals(Class<?> clazz, String className, boolean ignoreCase)
      指定类是否与给定的类名相同
      Parameters:
      clazz - 类
      className - 类名，可以是全类名（包含包名），也可以是简单类名（不包含包名）
      ignoreCase - 是否忽略大小写
      Returns:
      指定类是否与给定的类名相同

    • scanPackageByAnnotation

      public static Set<Class<?>> scanPackageByAnnotation(String packageName, Class<? extends Annotation> annotationClass)
      扫描指定包路径下所有包含指定注解的类
      Parameters:
      packageName - 包路径
      annotationClass - 注解类
      Returns:
      类集合
      See Also:

    • scanPackageBySuper

      public static Set<Class<?>> scanPackageBySuper(String packageName, Class<?> superClass)
      扫描指定包路径下所有指定类或接口的子类或实现类
      Parameters:
      packageName - 包路径
      superClass - 父类或接口
      Returns:
      类集合
      See Also:

    • scanPackage

      public static Set<Class<?>> scanPackage()
      扫描该包路径下所有class文件
      Returns:
      类集合
      See Also:

    • scanPackage

      public static Set<Class<?>> scanPackage(String packageName)
      扫描该包路径下所有class文件
      Parameters:
      packageName - 包路径 com | com. | com.abs | com.abs.
      Returns:
      类集合
      See Also:

    • scanPackage

      public static Set<Class<?>> scanPackage(String packageName, Predicate<Class<?>> classFilter)
      扫描包路径下满足class过滤器条件的所有class文件， 如果包路径为 com.abs + A.class 但是输入 abs会产生classNotFoundException 因为className 应该为 com.abs.A 现在却成为abs.A,此工具类对该异常进行忽略处理,有可能是一个不完善的地方，以后需要进行修改
      Parameters:
      packageName - 包路径 com | com. | com.abs | com.abs.
      classFilter - class过滤器，过滤掉不需要的class
      Returns:
      类集合

    • getClassPathResources

      public static Set<String> getClassPathResources()
      获得ClassPath，不解码路径中的特殊字符（例如空格和中文）
      Returns:
      ClassPath集合

    • getClassPathResources

      public static Set<String> getClassPathResources(boolean isDecode)
      获得ClassPath
      Parameters:
      isDecode - 是否解码路径中的特殊字符（例如空格和中文）
      Returns:
      ClassPath集合

    • getClassPaths

      public static Set<String> getClassPaths(String packageName)
      获得ClassPath，不解码路径中的特殊字符（例如空格和中文）
      Parameters:
      packageName - 包名称
      Returns:
      ClassPath路径字符串集合

    • getClassPaths

      public static Set<String> getClassPaths(String packageName, boolean isDecode)
      获得ClassPath
      Parameters:
      packageName - 包名称
      isDecode - 是否解码路径中的特殊字符（例如空格和中文）
      Returns:
      ClassPath路径字符串集合

    • getClassPath

      public static String getClassPath()
      获得ClassPath，将编码后的中文路径解码为原字符 这个ClassPath路径会文件路径被标准化处理
      Returns:
      ClassPath

    • getClassPath

      public static String getClassPath(boolean isEncoded)
      获得ClassPath，这个ClassPath路径会文件路径被标准化处理
      Parameters:
      isEncoded - 是否编码路径中的中文
      Returns:
      ClassPath

    • isAllAssignableFrom

      public static boolean isAllAssignableFrom(Class<?>[] types1, Class<?>[] types2)
      比较判断types1和types2两组类，如果types1中所有的类都与types2对应位置的类相同，或者是其父类或接口，则返回true
      Parameters:
      types1 - 类组1
      types2 - 类组2
      Returns:
      是否相同、父类或接口

    • isPrimitiveWrapper

      public static boolean isPrimitiveWrapper(Class<?> clazz)
      是否为包装类型
      Parameters:
      clazz - 类
      Returns:
      是否为包装类型

    • isBasicType

      public static boolean isBasicType(Class<?> clazz)
      是否为基本类型（包括包装类和原始类）
      Parameters:
      clazz - 类
      Returns:
      是否为基本类型

    • isSimpleTypeOrArray

      public static boolean isSimpleTypeOrArray(Class<?> clazz)
      是否为 简单值类型 或 简单值类型的数组
      Parameters:
      clazz - 属性类
      Returns:
      是否为 简单值类型 或 简单值类型的数组
      See Also:

    • isSimpleValueType

      public static boolean isSimpleValueType(Class<?> clazz)
      是否为简单值类型 包括： 
           原始类型
     枚举
     String、other CharSequence
     Number
     Date
     URI
     URL
     I18n
     Class
     jdk8时间相关类型
      Parameters:
      clazz - 类
      Returns:
      是否为简单值类型

    • isAssignable

      public static boolean isAssignable(Class<?> targetType, Class<?> sourceType)
      检查目标类是否可以从原类转化 转化包括： 1、原类是对象，目标类型是原类型实现的接口 2、目标类型是原类型的父类 3、两者是原始类型或者包装类型（相互转换）
      Parameters:
      targetType - 目标类型
      sourceType - 原类型
      Returns:
      是否可转化

    • isSerializable

      public static boolean isSerializable(Class<?> clazz)
      给定类是否实现了序列化接口Serializable
      Parameters:
      clazz - 类
      Returns:
      是否实现序列化接口Serializable

    • isNormalClass

      public static boolean isNormalClass(Class<?> clazz)
      是否为标准的类 这个类必须： 
       1、非接口
 2、非抽象类
 3、非Enum枚举
 4、非数组
 5、非注解
 6、非原始类型（int, long等）
      Parameters:
      clazz - 类
      Returns:
      是否为标准类

    • isEnum

      public static boolean isEnum(Class<?> clazz)
      判断类是否为枚举类型
      Parameters:
      clazz - 类
      Returns:
      是否为枚举类型

    • getTypeArgument

      public static Class<?> getTypeArgument(Class<?> clazz)
      获得给定类的第一个泛型参数
      Parameters:
      clazz - 被检查的类，必须是已经确定泛型类型的类
      Returns:
      Class

    • getTypeArgument

      public static Class<?> getTypeArgument(Class<?> clazz, int index)
      获得给定类的泛型参数
      Parameters:
      clazz - 被检查的类，必须是已经确定泛型类型的类
      index - 泛型类型的索引号，即第几个泛型类型
      Returns:
      Class

    • getPackage

      public static String getPackage(Class<?> clazz)
      获得给定类所在包的名称
      Parameters:
      clazz - 类
      Returns:
      包名

    • getPackagePath

      public static String getPackagePath(Class<?> clazz)
      获得给定类所在包的路径
      Parameters:
      clazz - 类
      Returns:
      包名

    • getDefaultValue

      public static Object getDefaultValue(Class<?> clazz)
      获取指定类型分的默认值 默认值规则为： 
       1、如果为原始类型，返回0
 2、非原始类型返回null
      Parameters:
      clazz - 类
      Returns:
      默认值

    • getPrimitiveDefaultValue

      public static Object getPrimitiveDefaultValue(Class<?> clazz)
      获取指定原始类型分的默认值 默认值规则为： 
       1、如果为原始类型，返回0
 2、非原始类型返回null
      Parameters:
      clazz - 类
      Returns:
      默认值

    • getDefaultValues

      public static Object[] getDefaultValues(Class<?>... classes)
      获得默认值列表
      Parameters:
      classes - 值类型
      Returns:
      默认值列表

    • isJdkClass

      public static boolean isJdkClass(Class<?> clazz)
      是否为JDK中定义的类或接口，判断依据： 
       1、以java.、javax.开头的包名
 2、ClassLoader为null
      Parameters:
      clazz - 被检查的类
      Returns:
      是否为JDK中定义的类或接口

    • getLocation

      public static URL getLocation(Class<?> clazz)
      获取class类路径URL, 不管是否在jar包中都会返回文件夹的路径 class在jar包中返回jar所在文件夹,class不在jar中返回文件夹目录 jdk中的类不能使用此方法
      Parameters:
      clazz - 类
      Returns:
      URL

    • getLocationPath

      public static String getLocationPath(Class<?> clazz)
      获取class类路径, 不管是否在jar包中都会返回文件夹的路径 class在jar包中返回jar所在文件夹,class不在jar中返回文件夹目录 jdk中的类不能使用此方法
      Parameters:
      clazz - 类
      Returns:
      class路径

    • forName

      public static Class<?> forName(String name, boolean isInitialized, ClassLoader loader)
      加载指定名称的类，支持：
      • 替换"/"为"."
      • 自动查找内部类，如java.lang.Thread.State = java.lang.Thread$State
      Parameters:
      name - 类名
      isInitialized - 是否初始化
      loader - ClassLoader，null表示默认
      Returns:
      指定名称对应的类，如果不存在类，返回null
      See Also:

    • getSuperClasses

      public static List<Class<?>> getSuperClasses(Class<?> clazz)
      获取指定类的所有父类，结果不包括指定类本身 如果无父类，返回一个空的列表
      Parameters:
      clazz - 类, 可以为null
      Returns:
      指定类的所有父类列表，如果无父类，返回一个空的列表

    • getInterfaces

      public static List<Class<?>> getInterfaces(Class<?> cls)
      获取指定类及其父类所有的实现接口。 结果顺序取决于查找顺序，当前类在前，父类的接口在后。
      Parameters:
      cls - 被查找的类
      Returns:
      接口列表，若提供的查找类为null，则返回空列表

    • traverseTypeHierarchyWhile

      public static void traverseTypeHierarchyWhile(Class<?> root, Predicate<Class<?>> terminator)
      按广度优先遍历包括root在内，其层级结构中的所有类和接口，直到terminator返回false
      Parameters:
      root - 根类
      terminator - 对遍历到的每个类与接口执行的校验，若为false则立刻中断遍历

    • traverseTypeHierarchyWhile

      public static void traverseTypeHierarchyWhile(Class<?> root, Predicate<Class<?>> filter, Predicate<Class<?>> terminator)
      按广度优先遍历包括root在内，其层级结构中的所有类和接口，直到terminator返回false
      Parameters:
      root - 根类
      filter - 过滤器，被过滤的类及其层级结构中的类与接口将被忽略
      terminator - 对遍历到的每个类与接口执行的校验，若为false则立刻中断遍历

    • traverseTypeHierarchy

      public static void traverseTypeHierarchy(Class<?> root, Predicate<Class<?>> filter, Consumer<Class<?>> consumer, boolean includeRoot)

      按广度优先遍历包括root在内，其层级结构中的所有类和接口。 类遍历顺序如下：

      • 离type距离越近，则顺序越靠前；
      • 与type距离相同，则父类优先于接口；
      • 与type距离相同的接口，则顺序遵循接口在Class.getInterfaces()的顺序；
      Parameters:
      root - 根类
      filter - 过滤器，被过滤的类及其层级结构中的类与接口将被忽略
      consumer - 对遍历到的每个类与接口执行的操作，每个类和接口都只会被访问一次
      includeRoot - 是否包括根类

    • getClassLoader

      public static ClassLoader getClassLoader()
      获取ClassLoader，获取顺序如下：
      1. 获取调用者的ContextClassLoader
      2. 获取当前线程的ContextClassLoader
      3. 获取ClassKit对应的ClassLoader
      4. 获取系统ClassLoader（ClassLoader.getSystemClassLoader()）
      Returns:
      类加载器

    • getCallerClassLoader

      public static ClassLoader getCallerClassLoader()
      获取调用者的ClassLoader
      Returns:
      ClassLoader

    • getContextClassLoader

      public static ClassLoader getContextClassLoader()
      获取当前线程的ClassLoader
      Returns:
      当前线程的class loader
      See Also:

    • getSystemClassLoader

      public static ClassLoader getSystemClassLoader()
      获取系统ClassLoader
      Returns:
      系统ClassLoader
      See Also:

    • getJarClassLoader

      public static JarClassLoader getJarClassLoader(File jarOrDir)
      创建新的JarClassLoader，并使用此Classloader加载目录下的class文件和jar文件
      Parameters:
      jarOrDir - jar文件或者包含jar和class文件的目录
      Returns:
      JarClassLoader

    • loadClass

      public static <T> Class<T> loadClass(String name) throws InternalException
      加载类，通过传入类的字符串，返回其对应的类名，使用默认ClassLoader并初始化类（调用static模块内容和初始化static属性） 扩展Class.forName(String, boolean, ClassLoader)方法，支持以下几类类名的加载： 
       1、原始类型，例如：int
 2、数组类型，例如：int[]、Long[]、String[]
 3、内部类，例如：java.lang.Thread.State会被转为java.lang.Thread$State加载
      Type Parameters:
      T - 目标类的类型
      Parameters:
      name - 类名
      Returns:
      类名对应的类
      Throws:
      InternalException - 包装ClassNotFoundException，没有类名对应的类时抛出此异常

    • loadClass

      public static <T> Class<T> loadClass(String name, boolean isInitialized) throws InternalException
      加载类，通过传入类的字符串，返回其对应的类名，使用默认ClassLoader 扩展Class.forName(String, boolean, ClassLoader)方法，支持以下几类类名的加载： 
       1、原始类型，例如：int
 2、数组类型，例如：int[]、Long[]、String[]
 3、内部类，例如：java.lang.Thread.State会被转为java.lang.Thread$State加载
      Type Parameters:
      T - 目标类的类型
      Parameters:
      name - 类名
      isInitialized - 是否初始化类（调用static模块内容和初始化static属性）
      Returns:
      类名对应的类
      Throws:
      InternalException - 包装ClassNotFoundException，没有类名对应的类时抛出此异常

    • loadClass

      public static <T> Class<T> loadClass(String name, boolean isInitialized, ClassLoader classLoader) throws InternalException
      加载类，通过传入类的字符串，返回其对应的类名 此方法支持缓存，第一次被加载的类之后会读取缓存中的类 加载失败的原因可能是此类不存在或其关联引用类不存在 扩展Class.forName(String, boolean, ClassLoader)方法，支持以下几类类名的加载： 
       1、原始类型，例如：int
 2、数组类型，例如：int[]、Long[]、String[]
 3、内部类，例如：java.lang.Thread.State会被转为java.lang.Thread$State加载
      Type Parameters:
      T - 加载的类的类型
      Parameters:
      name - 类名
      isInitialized - 是否初始化类（调用static模块内容和初始化static属性）
      classLoader - ClassLoader，null 则使用getClassLoader()获取
      Returns:
      类名对应的类
      Throws:
      InternalException - 包装ClassNotFoundException，没有类名对应的类时抛出此异常

    • loadClass

      public static Class<?> loadClass(File jarOrDir, String name)
      加载外部类
      Parameters:
      jarOrDir - jar文件或者包含jar和class文件的目录
      name - 类名
      Returns:
      类

    • isPresent

      public static boolean isPresent(String className)
      指定类是否被提供，使用默认ClassLoader 通过调用loadClass(String, boolean, ClassLoader)方法尝试加载指定类名的类，如果加载失败返回false 加载失败的原因可能是此类不存在或其关联引用类不存在
      Parameters:
      className - 类名
      Returns:
      是否被提供

    • isPresent

      public static boolean isPresent(String className, ClassLoader classLoader)
      指定类是否被提供 通过调用loadClass(String, boolean, ClassLoader)方法尝试加载指定类名的类，如果加载失败返回false 加载失败的原因可能是此类不存在或其关联引用类不存在
      Parameters:
      className - 类名
      classLoader - ClassLoader
      Returns:
      是否被提供

    • primitiveToWrapper

      public static Class<?> primitiveToWrapper(Class<?> cls)
      将指定的基元类对象转换为其对应的包装器类对象
      Parameters:
      cls - 要转换的类可以为null
      Returns:
      如果输入为null,则返回cls， 否则返回cls 的包装器类