Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Jackson Data Binding Source Code
Jackson is "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java".
Jackson Databind Source Code files are provided in the source packge (jackson-databind-2.14.0-sources.jar). You can download it at Jackson Maven Website.
You can also browse Jackson Databind Source Code below:
✍: FYIcenter.com
⏎ com/fasterxml/jackson/databind/introspect/AnnotatedClass.java
package com.fasterxml.jackson.databind.introspect; import java.lang.annotation.Annotation; import java.lang.reflect.*; import java.util.*; import com.fasterxml.jackson.databind.AnnotationIntrospector; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.cfg.MapperConfig; import com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver; import com.fasterxml.jackson.databind.type.TypeBindings; import com.fasterxml.jackson.databind.type.TypeFactory; import com.fasterxml.jackson.databind.util.Annotations; import com.fasterxml.jackson.databind.util.ClassUtil; public final class AnnotatedClass extends Annotated implements TypeResolutionContext { private final static Creators NO_CREATORS = new Creators(null, Collections.<AnnotatedConstructor>emptyList(), Collections.<AnnotatedMethod>emptyList()); /* /********************************************************** /* Configuration /********************************************************** */ /** * @since 2.7 */ final protected JavaType _type; /** * Class for which annotations apply, and that owns other * components (constructors, methods) */ final protected Class<?> _class; /** * Type bindings to use for members of {@link #_class}. * * @since 2.7 */ final protected TypeBindings _bindings; /** * Ordered set of super classes and interfaces of the * class itself: included in order of precedence */ final protected List<JavaType> _superTypes; /** * Filter used to determine which annotations to gather; used * to optimize things so that unnecessary annotations are * ignored. */ final protected AnnotationIntrospector _annotationIntrospector; /** * @since 2.7 */ final protected TypeFactory _typeFactory; /** * Object that knows mapping of mix-in classes (ones that contain * annotations to add) with their target classes (ones that * get these additional annotations "mixed in"). */ final protected MixInResolver _mixInResolver; /** * Primary mix-in class; one to use for the annotated class * itself. Can be null. */ final protected Class<?> _primaryMixIn; /** * Flag that indicates whether (fulll) annotation resolution should * occur: starting with 2.11 is disabled for JDK container types. * * @since 2.11 */ final protected boolean _collectAnnotations; /* /********************************************************** /* Gathered information /********************************************************** */ /** * Combined list of Jackson annotations that the class has, * including inheritable ones from super classes and interfaces */ final protected Annotations _classAnnotations; /** * @since 2.9 */ protected Creators _creators; /** * Member methods of interest; for now ones with 0 or 1 arguments * (just optimization, since others won't be used now) */ protected AnnotatedMethodMap _memberMethods; /** * Member fields of interest: ones that are either public, * or have at least one annotation. */ protected List<AnnotatedField> _fields; /** * Lazily determined property to see if this is a non-static inner * class. * * @since 2.8.7 */ protected transient Boolean _nonStaticInnerClass; /* /********************************************************** /* Life-cycle /********************************************************** */ /** * Constructor will not do any initializations, to allow for * configuring instances differently depending on use cases * * @param type Fully resolved type; may be `null`, but ONLY if no member fields or * methods are to be accessed * @param rawType Type-erased class; pass if no `type` needed or available */ AnnotatedClass(JavaType type, Class<?> rawType, List<JavaType> superTypes, Class<?> primaryMixIn, Annotations classAnnotations, TypeBindings bindings, AnnotationIntrospector aintr, MixInResolver mir, TypeFactory tf, boolean collectAnnotations) { _type = type; _class = rawType; _superTypes = superTypes; _primaryMixIn = primaryMixIn; _classAnnotations = classAnnotations; _bindings = bindings; _annotationIntrospector = aintr; _mixInResolver = mir; _typeFactory = tf; _collectAnnotations = collectAnnotations; } @Deprecated // since 2.10 AnnotatedClass(JavaType type, Class<?> rawType, List<JavaType> superTypes, Class<?> primaryMixIn, Annotations classAnnotations, TypeBindings bindings, AnnotationIntrospector aintr, MixInResolver mir, TypeFactory tf) { this(type, rawType, superTypes, primaryMixIn, classAnnotations, bindings, aintr, mir, tf, true); } /** * Constructor (only) used for creating primordial simple types (during bootstrapping) * and array type placeholders where no fields or methods are needed. * * @since 2.9 */ AnnotatedClass(Class<?> rawType) { _type = null; _class = rawType; _superTypes = Collections.emptyList(); _primaryMixIn = null; _classAnnotations = AnnotationCollector.emptyAnnotations(); _bindings = TypeBindings.emptyBindings(); _annotationIntrospector = null; _mixInResolver = null; _typeFactory = null; _collectAnnotations = false; } /** * @deprecated Since 2.9, use methods in {@link AnnotatedClassResolver} instead. */ @Deprecated public static AnnotatedClass construct(JavaType type, MapperConfig<?> config) { return construct(type, config, (MixInResolver) config); } /** * @deprecated Since 2.9, use methods in {@link AnnotatedClassResolver} instead. */ @Deprecated public static AnnotatedClass construct(JavaType type, MapperConfig<?> config, MixInResolver mir) { return AnnotatedClassResolver.resolve(config, type, mir); } /** * Method similar to {@link #construct}, but that will NOT include * information from supertypes; only class itself and any direct * mix-ins it may have. */ /** * @deprecated Since 2.9, use methods in {@link AnnotatedClassResolver} instead. */ @Deprecated public static AnnotatedClass constructWithoutSuperTypes(Class<?> raw, MapperConfig<?> config) { return constructWithoutSuperTypes(raw, config, config); } /** * @deprecated Since 2.9, use methods in {@link AnnotatedClassResolver} instead. */ @Deprecated public static AnnotatedClass constructWithoutSuperTypes(Class<?> raw, MapperConfig<?> config, MixInResolver mir) { return AnnotatedClassResolver.resolveWithoutSuperTypes(config, raw, mir); } /* /********************************************************** /* TypeResolutionContext implementation /********************************************************** */ @Override public JavaType resolveType(Type type) { // 06-Sep-2020, tatu: Careful wrt [databind#2846][databind#2821], // call new method added in 2.12 return _typeFactory.resolveMemberType(type, _bindings); } /* /********************************************************** /* Annotated impl /********************************************************** */ @Override public Class<?> getAnnotated() { return _class; } @Override public int getModifiers() { return _class.getModifiers(); } @Override public String getName() { return _class.getName(); } @Override public <A extends Annotation> A getAnnotation(Class<A> acls) { return _classAnnotations.get(acls); } @Override public boolean hasAnnotation(Class<?> acls) { return _classAnnotations.has(acls); } @Override public boolean hasOneOf(Class<? extends Annotation>[] annoClasses) { return _classAnnotations.hasOneOf(annoClasses); } @Override public Class<?> getRawType() { return _class; } @Override @Deprecated public Iterable<Annotation> annotations() { if (_classAnnotations instanceof AnnotationMap) { return ((AnnotationMap) _classAnnotations).annotations(); } else if (_classAnnotations instanceof AnnotationCollector.OneAnnotation || _classAnnotations instanceof AnnotationCollector.TwoAnnotations) { throw new UnsupportedOperationException("please use getAnnotations/ hasAnnotation to check for Annotations"); } return Collections.emptyList(); } @Override public JavaType getType() { return _type; } /* /********************************************************** /* Public API, generic accessors /********************************************************** */ public Annotations getAnnotations() { return _classAnnotations; } public boolean hasAnnotations() { return _classAnnotations.size() > 0; } public AnnotatedConstructor getDefaultConstructor() { return _creators().defaultConstructor; } public List<AnnotatedConstructor> getConstructors() { return _creators().constructors; } /** * @since 2.9 */ public List<AnnotatedMethod> getFactoryMethods() { return _creators().creatorMethods; } /** * @deprecated Since 2.9; use {@link #getFactoryMethods} instead. */ @Deprecated public List<AnnotatedMethod> getStaticMethods() { return getFactoryMethods(); } public Iterable<AnnotatedMethod> memberMethods() { return _methods(); } public int getMemberMethodCount() { return _methods().size(); } public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes) { return _methods().find(name, paramTypes); } public int getFieldCount() { return _fields().size(); } public Iterable<AnnotatedField> fields() { return _fields(); } /** * @since 2.9 */ public boolean isNonStaticInnerClass() { Boolean B = _nonStaticInnerClass; if (B == null) { _nonStaticInnerClass = B = ClassUtil.isNonStaticInnerClass(_class); } return B.booleanValue(); } /* /********************************************************** /* Lazily-operating accessors /********************************************************** */ private final List<AnnotatedField> _fields() { List<AnnotatedField> f = _fields; if (f == null) { // 09-Jun-2017, tatu: _type only null for primordial, placeholder array types. if (_type == null) { f = Collections.emptyList(); } else { f = AnnotatedFieldCollector.collectFields(_annotationIntrospector, this, _mixInResolver, _typeFactory, _type, _collectAnnotations); } _fields = f; } return f; } private final AnnotatedMethodMap _methods() { AnnotatedMethodMap m = _memberMethods; if (m == null) { // 09-Jun-2017, tatu: _type only null for primordial, placeholder array types. // NOTE: would be great to have light-weight shareable maps; no such impl exists for now if (_type == null) { m = new AnnotatedMethodMap(); } else { m = AnnotatedMethodCollector.collectMethods(_annotationIntrospector, this, _mixInResolver, _typeFactory, _type, _superTypes, _primaryMixIn, _collectAnnotations); } _memberMethods = m; } return m; } private final Creators _creators() { Creators c = _creators; if (c == null) { if (_type == null) { c = NO_CREATORS; } else { c = AnnotatedCreatorCollector.collectCreators(_annotationIntrospector, _typeFactory, this, _type, _primaryMixIn, _collectAnnotations); } _creators = c; } return c; } /* /********************************************************** /* Standard method overrides /********************************************************** */ @Override public String toString() { return "[AnnotedClass "+_class.getName()+"]"; } @Override public int hashCode() { return _class.getName().hashCode(); } @Override public boolean equals(Object o) { if (o == this) return true; if (!ClassUtil.hasClass(o, getClass())) { return false; } return ((AnnotatedClass) o)._class == _class; } /* /********************************************************** /* Helper classes /********************************************************** */ public static final class Creators { /** * Default constructor of the annotated class, if it has one. */ public final AnnotatedConstructor defaultConstructor; /** * Single argument constructors the class has, if any. */ public final List<AnnotatedConstructor> constructors; /** * Single argument static methods that might be usable * as factory methods */ public final List<AnnotatedMethod> creatorMethods; public Creators(AnnotatedConstructor defCtor, List<AnnotatedConstructor> ctors, List<AnnotatedMethod> ctorMethods) { defaultConstructor = defCtor; constructors = ctors; creatorMethods = ctorMethods; } } }
⏎ com/fasterxml/jackson/databind/introspect/AnnotatedClass.java
Or download all of them as a single archive file:
File name: jackson-databind-2.14.0-sources.jar File size: 1187952 bytes Release date: 2022-11-05 Download
⇒ Jackson Annotations Source Code
⇐ Download and Install Jackson Binary Package
2022-03-29, 110737👍, 0💬
Popular Posts:
JDK 11 java.compiler.jmod is the JMOD file for JDK 11 Compiler module. JDK 11 Compiler module compil...
JSP(tm) Standard Tag Library 1.0 implementation - Jakarta Taglibs hosts the Standard Taglib 1.0, an ...
The JSR 105 XML Digital Signature 1.0.1 FCS implementation provides an API and implementation that a...
JDK 11 java.desktop.jmod is the JMOD file for JDK 11 Desktop module. JDK 11 Desktop module compiled ...
JDK 8 tools.jar is the JAR file for JDK 8 tools. It contains Java classes to support different JDK t...