# Uses of Annotation Type
com.fasterxml.jackson.annotation.JacksonAnnotation

## Uses of JacksonAnnotation in com.fasterxml.jackson.annotation

Classes in com.fasterxml.jackson.annotation with annotations of type JacksonAnnotation
Modifier and Type
Class
Description
`@interface`
`JacksonAnnotationsInside`
Meta-annotation (annotations used on other annotations) used for indicating that instead of using target annotation (annotation annotated with this annotation), Jackson should use meta-annotations it has.
`@interface`
`JacksonInject`
Jackson-specific annotation used for indicating that value of annotated property will be "injected", i.e.
`@interface`
`JsonAlias`
Annotation that can be used to define one or more alternative names for a property, accepted during deserialization as alternative to the official name.
`@interface`
`JsonAnyGetter`
Marker annotation that can be used to define a non-static, no-argument method to be an "any getter"; accessor for getting a set of key/value pairs, to be serialized as part of containing POJO (similar to unwrapping) along with regular property values it has.
`@interface`
`JsonAnySetter`
Marker annotation that can be used to define a logical "any setter" mutator -- either using non-static two-argument method (first argument name of property, second value to set) or a field (of type `Map` or POJO) - to be used as a "fallback" handler for all otherwise unrecognized properties found from JSON content.
`@interface`
`JsonAutoDetect`
Class annotation that can be used to define which kinds of Methods are to be detected by auto-detection, and with what minimum access level.
`@interface`
`JsonBackReference`
Annotation used to indicate that associated property is part of two-way linkage between fields; and that its role is "child" (or "back") link.
`@interface`
`JsonClassDescription`
Annotation used to define a human-readable description for annotated type (class).
`@interface`
`JsonCreator`
Marker annotation that can be used to define constructors and factory methods as one to use for instantiating new instances of the associated class.
`@interface`
`JsonEnumDefaultValue`
Marker annotation that can be used to define a default value used when trying to deserialize unknown Enum values.
`@interface`
`JsonFilter`
Annotation used to indicate which logical filter is to be used for filtering out properties of type (class) annotated; association made by this annotation declaring ids of filters, and `com.fasterxml.jackson.databind.ObjectMapper` (or objects it delegates to) providing matching filters by id.
`@interface`
`JsonFormat`
General-purpose annotation used for configuring details of how values of properties are to be serialized.
`@interface`
`JsonGetter`
Marker annotation that can be used to define a non-static, no-argument value-returning (non-void) method to be used as a "getter" for a logical property.
`@interface`
`JsonIdentityInfo`
Annotation used for indicating that values of annotated type or property should be serializing so that instances either contain additional object identifier (in addition actual object properties), or as a reference that consists of an object id that refers to a full serialization.
`@interface`
`JsonIdentityReference`
Optional annotation that can be used for customizing details of a reference to Objects for which "Object Identity" is enabled (see `JsonIdentityInfo`).
`@interface`
`JsonIgnore`
Marker annotation that indicates that the logical property that the accessor (field, getter/setter method or Creator parameter [of `JsonCreator`-annotated constructor or factory method]) is to be ignored by introspection-based serialization and deserialization functionality.
`@interface`
`JsonIgnoreProperties`
Annotation that can be used to either suppress serialization of properties (during serialization), or ignore processing of JSON properties read (during deserialization).
`@interface`
`JsonIgnoreType`
Marker annotation that indicates that all properties that have type annotated with this annotation are to be ignored during serialization and deserialization.
`@interface`
`JsonInclude`
Annotation used to indicate when value of the annotated property (when used for a field, method or constructor parameter), or all properties of the annotated class, is to be serialized.
`@interface`
`JsonIncludeProperties`
Annotation that can be used to either only include serialization of properties (during serialization), or only include processing of JSON properties read (during deserialization).
`@interface`
`JsonKey`
Marker annotation that indicates that the value of annotated accessor (either field or "getter" method [a method with non-void return type, no args]) is to be used as the single value to serialize for the instance.
`@interface`
`JsonManagedReference`
Annotation used to indicate that annotated property is part of two-way linkage between fields; and that its role is "parent" (or "forward") link.
`@interface`
`JsonMerge`
Annotation to specify whether annotated property value should use "merging" approach: merging meaning that the current value is first accessed (with a getter or field) and then modified with incoming data.
`@interface`
`JsonProperty`
Marker annotation that can be used to define a non-static method as a "setter" or "getter" for a logical property (depending on its signature), or non-static object field to be used (serialized, deserialized) as a logical property.
`@interface`
`JsonPropertyDescription`
Annotation used to define a human-readable description for a logical property.
`@interface`
`JsonPropertyOrder`
Annotation that can be used to define ordering (possibly partial) to use when serializing object properties.
`@interface`
`JsonRawValue`
Marker annotation that indicates that the annotated method or field should be serialized by including literal String value of the property as is, without quoting of characters.
`@interface`
`JsonRootName`
Annotation similar to `javax.xml.bind.annotation.XmlRootElement`, used to indicate name to use for root-level wrapping, if wrapping is enabled.
`@interface`
`JsonSetter`
Annotation that can be used to define a non-static, single-argument method to be used as a "setter" for a logical property as an alternative to recommended `JsonProperty` annotation; or (as of 2.9 and later), specify additional aspects of the assigning property a value during serialization.
`@interface`
`JsonSubTypes`
Annotation used with `JsonTypeInfo` to indicate subtypes of serializable polymorphic types, and to associate logical names used within JSON content (which is more portable than using physical Java class names).
`@interface`
`JsonTypeId`
Marker annotation that can be used on a property accessor (field, getter or setter, constructor parameter) to indicate that the property is to contain type id to use when including polymorphic type information.
`@interface`
`JsonTypeInfo`
Annotation used for configuring details of if and how type information is used with JSON serialization and deserialization, to preserve information about actual class of Object instances.
`@interface`
`JsonTypeName`
Annotation used for binding logical name that the annotated class has.
`@interface`
`JsonUnwrapped`
Annotation used to indicate that a POJO-valued property should be serialized "unwrapped" -- that is, if it would be serialized as Object value, its properties are instead included as properties of its containing Object -- and deserialized reproducing "missing" structure.
`@interface`
`JsonValue`
Marker annotation that indicates that the value of annotated accessor (either field or "getter" method [a method with non-void return type, no args]) is to be used as the single value to serialize for the instance, instead of the usual method of collecting properties of value.
`@interface`
`JsonView`
Annotation used for indicating view(s) that the property that is defined by method or field annotated is part of.