Package com.fasterxml.jackson.databind.util

Class ClassUtil

java.lang.Object
com.fasterxml.jackson.databind.util.ClassUtil
public final class ClassUtil extends Object

  • Constructor Details

    • ClassUtil

      public ClassUtil()

  • Method Details

    • emptyIterator

      public static <T> Iterator<T> emptyIterator()
      Since:
      2.7

    • findSuperTypes

      public static List<JavaType> findSuperTypes(JavaType type, Class<?> endBefore, boolean addClassItself)
      Method that will find all sub-classes and implemented interfaces of a given class or interface. Classes are listed in order of precedence, starting with the immediate super-class, followed by interfaces class directly declares to implemented, and then recursively followed by parent of super-class and so forth. Note that Object.class is not included in the list regardless of whether endBefore argument is defined or not.
      Parameters:
      endBefore - Super-type to NOT include in results, if any; when encountered, will be ignored (and no super types are checked).
      Since:
      2.7

    • findRawSuperTypes

      public static List<Class<?>> findRawSuperTypes(Class<?> cls, Class<?> endBefore, boolean addClassItself)
      Since:
      2.7

    • findSuperClasses

      public static List<Class<?>> findSuperClasses(Class<?> cls, Class<?> endBefore, boolean addClassItself)
      Method for finding all super classes (but not super interfaces) of given class, starting with the immediate super class and ending in the most distant one. Class itself is included if addClassItself is true.

      NOTE: mostly/only called to resolve mix-ins as that's where we do not care about fully-resolved types, just associated annotations.

      Since:
      2.7

    • findSuperTypes

      @Deprecated public static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore)
      Deprecated.

    • findSuperTypes

      @Deprecated public static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore, List<Class<?>> result)
      Deprecated.

    • canBeABeanType

      public static String canBeABeanType(Class<?> type)
      Returns:
      Null if class might be a bean; type String (that identifies why it's not a bean) if not

    • isLocalType

      public static String isLocalType(Class<?> type, boolean allowNonStatic)

    • getOuterClass

      public static Class<?> getOuterClass(Class<?> type)
      Method for finding enclosing class for non-static inner classes

    • isProxyType

      public static boolean isProxyType(Class<?> type)
      Helper method used to weed out dynamic Proxy types; types that do not expose concrete method API that we could use to figure out automatic Bean (property) based serialization.

    • isConcrete

      public static boolean isConcrete(Class<?> type)
      Helper method that checks if given class is a concrete one; that is, not an interface or abstract class.

    • isConcrete

      public static boolean isConcrete(Member member)

    • isCollectionMapOrArray

      public static boolean isCollectionMapOrArray(Class<?> type)

    • isBogusClass

      public static boolean isBogusClass(Class<?> cls)

    • isRecordType

      public static boolean isRecordType(Class<?> cls)
      Helper method for detecting Java14-added new Record types
      Since:
      2.12

    • isObjectOrPrimitive

      public static boolean isObjectOrPrimitive(Class<?> cls)
      Since:
      2.7

    • hasClass

      public static boolean hasClass(Object inst, Class<?> raw)
      Since:
      2.9

    • verifyMustOverride

      public static void verifyMustOverride(Class<?> expType, Object instance, String method)
      Since:
      2.9

    • hasGetterSignature

      @Deprecated public static boolean hasGetterSignature(Method m)
      Deprecated.
      Since 2.6 not used; may be removed before 3.x

    • throwIfError

      public static Throwable throwIfError(Throwable t)
      Helper method that will check if argument is an Error, and if so, (re)throw it; otherwise just return
      Since:
      2.9

    • throwIfRTE

      public static Throwable throwIfRTE(Throwable t)
      Helper method that will check if argument is an RuntimeException, and if so, (re)throw it; otherwise just return
      Since:
      2.9

    • throwIfIOE

      public static Throwable throwIfIOE(Throwable t) throws IOException
      Helper method that will check if argument is an IOException, and if so, (re)throw it; otherwise just return
      Throws:
      IOException
      Since:
      2.9

    • getRootCause

      public static Throwable getRootCause(Throwable t)
      Method that can be used to find the "root cause", innermost of chained (wrapped) exceptions.

    • throwRootCauseIfIOE

      public static Throwable throwRootCauseIfIOE(Throwable t) throws IOException
      Method that works like by calling getRootCause(java.lang.Throwable) and then either throwing it (if instanceof IOException), or return.
      Throws:
      IOException
      Since:
      2.8

    • throwAsIAE

      public static void throwAsIAE(Throwable t)
      Method that will wrap 't' as an IllegalArgumentException if it is a checked exception; otherwise (runtime exception or error) throw as is

    • throwAsIAE

      public static void throwAsIAE(Throwable t, String msg)
      Method that will wrap 't' as an IllegalArgumentException (and with specified message) if it is a checked exception; otherwise (runtime exception or error) throw as is

    • throwAsMappingException

      public static <T> T throwAsMappingException(DeserializationContext ctxt, IOException e0) throws JsonMappingException
      Throws:
      JsonMappingException
      Since:
      2.9

    • unwrapAndThrowAsIAE

      public static void unwrapAndThrowAsIAE(Throwable t)
      Method that will locate the innermost exception for given Throwable; and then wrap it as an IllegalArgumentException if it is a checked exception; otherwise (runtime exception or error) throw as is

    • unwrapAndThrowAsIAE

      public static void unwrapAndThrowAsIAE(Throwable t, String msg)
      Method that will locate the innermost exception for given Throwable; and then wrap it as an IllegalArgumentException if it is a checked exception; otherwise (runtime exception or error) throw as is

    • closeOnFailAndThrowAsIOE

      public static void closeOnFailAndThrowAsIOE(JsonGenerator g, Exception fail) throws IOException
      Helper method that encapsulate logic in trying to close output generator in case of failure; useful mostly in forcing flush()ing as otherwise error conditions tend to be hard to diagnose. However, it is often the case that output state may be corrupt so we need to be prepared for secondary exception without masking original one.
      Throws:
      IOException
      Since:
      2.8

    • closeOnFailAndThrowAsIOE

      public static void closeOnFailAndThrowAsIOE(JsonGenerator g, Closeable toClose, Exception fail) throws IOException
      Helper method that encapsulate logic in trying to close given Closeable in case of failure; useful mostly in forcing flush()ing as otherwise error conditions tend to be hard to diagnose. However, it is often the case that output state may be corrupt so we need to be prepared for secondary exception without masking original one.
      Throws:
      IOException
      Since:
      2.8

    • createInstance

      public static <T> T createInstance(Class<T> cls, boolean canFixAccess) throws IllegalArgumentException
      Method that can be called to try to create an instantiate of specified type. Instantiation is done using default no-argument constructor.
      Parameters:
      canFixAccess - Whether it is possible to try to change access rights of the default constructor (in case it is not publicly accessible) or not.
      Throws:
      IllegalArgumentException - If instantiation fails for any reason; except for cases where constructor throws an unchecked exception (which will be passed as is)

    • findConstructor

      public static <T> Constructor<T> findConstructor(Class<T> cls, boolean forceAccess) throws IllegalArgumentException
      Throws:
      IllegalArgumentException

    • classOf

      public static Class<?> classOf(Object inst)
      Since:
      2.9

    • rawClass

      public static Class<?> rawClass(JavaType t)
      Since:
      2.9

    • nonNull

      public static <T> T nonNull(T valueOrNull, T defaultValue)
      Since:
      2.9

    • nullOrToString

      public static String nullOrToString(Object value)
      Since:
      2.9

    • nonNullString

      public static String nonNullString(String str)
      Since:
      2.9

    • quotedOr

      public static String quotedOr(Object str, String forNull)
      Returns either quoted value (with double-quotes) -- if argument non-null String -- or String NULL (no quotes) (if null).
      Since:
      2.9

    • getClassDescription

      public static String getClassDescription(Object classOrInstance)
      Helper method used to construct appropriate description when passed either type (Class) or an instance; in latter case, class of instance is to be used.

    • getTypeDescription

      public static String getTypeDescription(JavaType fullType)
      Helper method to create and return "backticked" description of given resolved type (or, "null" if null passed), similar to return vaue of getClassDescription(Object).
      Parameters:
      fullType - Fully resolved type or null
      Returns:
      String description of type including generic type parameters, surrounded by backticks, if type passed; or string "null" if {code null} passed
      Since:
      2.10

    • classNameOf

      public static String classNameOf(Object inst)
      Helper method used to construct appropriate description when passed either type (Class) or an instance; in latter case, class of instance is to be used.
      Since:
      2.9

    • nameOf

      public static String nameOf(Class<?> cls)
      Returns either `cls.getName()` (if `cls` not null), or "[null]" if `cls` is null.
      Since:
      2.9

    • nameOf

      public static String nameOf(Named named)
      Returns either single-quoted (apostrophe) 'named.getName()' (if named not null), or "[null]" if named is null.

      NOTE: before 2.12 returned "backticked" version instead of single-quoted name; changed to be compatible with most existing quoting usage within databind

      Since:
      2.9

    • name

      public static String name(String name)
      Returns either single-quoted (apostrophe) 'name' (if name not null), or "[null]" if name is null.
      Since:
      2.12

    • name

      public static String name(PropertyName name)
      Returns either single-quoted (apostrophe) 'name' (if name not null), or "[null]" if name is null.
      Since:
      2.12

    • backticked

      public static String backticked(String text)
      Returns either `text` (backtick-quoted) or [null].
      Since:
      2.9

    • apostrophed

      public static String apostrophed(String text)
      Returns either 'text' (single-quoted) or [null].
      Since:
      2.9

    • exceptionMessage

      public static String exceptionMessage(Throwable t)
      Helper method that returns Throwable.getMessage() for all other exceptions except for (a) JacksonException, for which getOriginalMessage() is returned, and (b) InvocationTargetException, for which the cause's message is returned, if available. Method is used to avoid accidentally including trailing location information twice in message when wrapping exceptions.
      Since:
      2.9.7

    • defaultValue

      public static Object defaultValue(Class<?> cls)
      Helper method used to get default value for wrappers used for primitive types (0 for Integer etc)

    • wrapperType

      public static Class<?> wrapperType(Class<?> primitiveType)
      Helper method for finding wrapper type for given primitive type (why isn't there one in JDK?). NOTE: throws IllegalArgumentException if given type is NOT primitive type (caller has to check).

    • primitiveType

      public static Class<?> primitiveType(Class<?> type)
      Method that can be used to find primitive type for given class if (but only if) it is either wrapper type or primitive type; returns null if type is neither.
      Since:
      2.7

    • checkAndFixAccess

      @Deprecated public static void checkAndFixAccess(Member member)
      Deprecated.
      Since 2.7 call variant that takes boolean flag.
      Equivalent to call: 
         checkAndFixAccess(member, false);

    • checkAndFixAccess

      public static void checkAndFixAccess(Member member, boolean evenIfAlreadyPublic)
      Method that is called if a Member may need forced access, to force a field, method or constructor to be accessible: this is done by calling AccessibleObject.setAccessible(boolean).
      Parameters:
      member - Accessor to call setAccessible() on.
      evenIfAlreadyPublic - Whether to always try to make accessor accessible, even if public (true), or only if needed to force by-pass of non-public access (false)
      Since:
      2.7

    • isEnumType

      public static boolean isEnumType(Class<?> rawType)
      Helper method that encapsulates reliable check on whether given raw type "is an Enum", that is, is or extends Enum.
      Since:
      2.10.1

    • findEnumType

      public static Class<? extends Enum<?>> findEnumType(EnumSet<?> s)
      Helper method that can be used to dynamically figure out enumeration type of given EnumSet, without having access to its declaration. Code is needed to work around design flaw in JDK.

    • findEnumType

      public static Class<? extends Enum<?>> findEnumType(EnumMap<?,?> m)
      Helper method that can be used to dynamically figure out enumeration type of given EnumSet, without having access to its declaration. Code is needed to work around design flaw in JDK.

    • findEnumType

      public static Class<? extends Enum<?>> findEnumType(Enum<?> en)
      Helper method that can be used to dynamically figure out formal enumeration type (class) for given enumeration. This is either class of enum instance (for "simple" enumerations), or its superclass (for enums with instance fields or methods)

    • findEnumType

      public static Class<? extends Enum<?>> findEnumType(Class<?> cls)
      Helper method that can be used to dynamically figure out formal enumeration type (class) for given class of an enumeration value. This is either class of enum instance (for "simple" enumerations), or its superclass (for enums with instance fields or methods)

    • findFirstAnnotatedEnumValue

      public static <T extends Annotation> Enum<?> findFirstAnnotatedEnumValue(Class<Enum<?>> enumClass, Class<T> annotationClass)
      A method that will look for the first Enum value annotated with the given Annotation.

      If there's more than one value annotated, the first one found will be returned. Which one exactly is used is undetermined.

      Parameters:
      enumClass - The Enum class to scan for a value with the given annotation
      annotationClass - The annotation to look for.
      Returns:
      the Enum value annotated with the given Annotation or null if none is found.
      Throws:
      IllegalArgumentException - if there's a reflection issue accessing the Enum
      Since:
      2.8

    • isJacksonStdImpl

      public static boolean isJacksonStdImpl(Object impl)
      Method that can be called to determine if given Object is the default implementation Jackson uses; as opposed to a custom serializer installed by a module or calling application. Determination is done using JacksonStdImpl annotation on handler (serializer, deserializer etc) class.

      NOTE: passing `null` is legal, and will result in true being returned.

    • isJacksonStdImpl

      public static boolean isJacksonStdImpl(Class<?> implClass)

    • isJDKClass

      public static boolean isJDKClass(Class<?> rawType)
      Accessor for checking whether given Class is under Java package of java.* or javax.* (including all sub-packages), or (starting with Jackson 2.17), sun.*).

      Added since some aspects of handling need to be changed for JDK types (and possibly some extensions under javax.?): for example, forcing of access will not work well for future JDKs (12 and later).

      Note: in Jackson 2.11 only returned true for java.* (and not javax.*); was changed in 2.12. sun.* was added in 2.17.

      Since:
      2.11

    • isJDK17OrAbove

      public static boolean isJDK17OrAbove()
      Convenience method for: 
         return getJDKMajorVersion() >= 17
      that also catches any possible exceptions so it is safe to call from static contexts.
      Returns:
      True if we can determine that the code is running on JDK 17 or above; false otherwise.
      Since:
      2.15

    • getJDKMajorVersion

      public static int getJDKMajorVersion()
      Returns:
      Major version of JDK we are running on
      Throws:
      IllegalStateException - If JDK version information cannot be determined
      Since:
      2.15

    • isNonStaticInnerClass

      public static boolean isNonStaticInnerClass(Class<?> cls)

    • getPackageName

      @Deprecated public static String getPackageName(Class<?> cls)
      Deprecated.
      Since 2.12 (just call methods directly or check class name)
      Since:
      2.7

    • hasEnclosingMethod

      public static boolean hasEnclosingMethod(Class<?> cls)
      Since:
      2.7

    • getDeclaredFields

      @Deprecated public static Field[] getDeclaredFields(Class<?> cls)
      Deprecated.
      since 2.11 (just call Class method directly)

    • getDeclaredMethods

      @Deprecated public static Method[] getDeclaredMethods(Class<?> cls)
      Deprecated.
      since 2.11 (just call Class method directly)

    • findClassAnnotations

      public static Annotation[] findClassAnnotations(Class<?> cls)
      Since:
      2.7

    • getClassMethods

      public static Method[] getClassMethods(Class<?> cls)
      Helper method that gets methods declared in given class; usually a simple thing, but sometimes (as per [databind#785]) more complicated, depending on classloader setup.
      Since:
      2.9

    • getConstructors

      public static ClassUtil.Ctor[] getConstructors(Class<?> cls)
      Since:
      2.7

    • getDeclaringClass

      public static Class<?> getDeclaringClass(Class<?> cls)
      Since:
      2.7

    • getGenericSuperclass

      public static Type getGenericSuperclass(Class<?> cls)
      Since:
      2.7

    • getGenericInterfaces

      public static Type[] getGenericInterfaces(Class<?> cls)
      Since:
      2.7

    • getEnclosingClass

      public static Class<?> getEnclosingClass(Class<?> cls)
      Since:
      2.7