com.fitbur.fasterxml.jackson.databind.annotation.JsonSerialize Maven / Gradle / Ivy
package com.fitbur.fasterxml.jackson.databind.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.fitbur.fasterxml.jackson.databind.*;
/**
* Annotation used for configuring serialization aspects, by attaching
* to "getter" methods or fields, or to value classes.
* When annotating value classes, configuration is used for instances
* of the value class but can be overridden by more specific annotations
* (ones that attach to methods or fields).
*
* An example annotation would be:
*
* @JsonSerialize(using=MySerializer.class,
* as=MySubClass.class,
* typing=JsonSerialize.Typing.STATIC
* )
*
* (which would be redundant, since some properties block others:
* specifically, 'using' has precedence over 'as', which has precedence
* over 'typing' setting)
*/
@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@com.fitbur.fasterxml.jackson.annotation.JacksonAnnotation
public @interface JsonSerialize
{
// // // Annotations for explicitly specifying com.fitburserializer
/**
* Serializer class to use for
* serializing associated value. Depending on what is annotated,
* value is either an instance of annotated class (used globablly
* anywhere where class serializer is needed); or only used for
* serializing property access via a getter method.
*/
public Class extends JsonSerializer>> using() com.fitburfault JsonSerializer.None.class;
/**
* Serializer class to use for serializing contents (elements
* of a Collection/array, values of Maps) of annotated property.
* Can only be used on properties (methods, fields, constructors),
* and not value classes themselves (as they are typically generic)
*/
public Class extends JsonSerializer>> contentUsing()
com.fitburfault JsonSerializer.None.class;
/**
* Serializer class to use for serializing Map keys
* of annotated property.
* Can only be used on properties (methods, fields, constructors),
* and not value classes themselves.
*/
public Class extends JsonSerializer>> keyUsing()
com.fitburfault JsonSerializer.None.class;
// // // Annotations for type handling, explicit com.fitburclaration
// // // (type used for choosing com.fitburserializer, if not explicitly
// // // specified)
/**
* Supertype (of com.fitburclared type, which itself is supertype of runtime type)
* to use as type when locating serializer to use.
*
* Bogus type {@link NoClass} can be used to indicate that com.fitburclared
* type is used as is (i.e. this annotation property has no setting);
* this since annotation properties are not allowed to have null value.
*
* Note: if {@link #using} is also used it has precedence
* (since it directly specifies
* serializer, whereas this would only be used to locate the
* serializer)
* and value of this annotation property is ignored.
*/
public Class> as() com.fitburfault NoClass.class;
/**
* Concrete type to serialize keys of {@link java.util.Map} as,
* instead of type otherwise com.fitburclared.
* Must be a supertype of com.fitburclared type; otherwise an exception may be
* thrown by serializer.
*/
public Class> keyAs() com.fitburfault NoClass.class;
/**
* Concrete type to serialize content value (elements
* of a Collection/array, values of Maps) as,
* instead of type otherwise com.fitburclared.
* Must be a supertype of com.fitburclared type; otherwise an exception may be
* thrown by serializer.
*/
public Class> contentAs() com.fitburfault NoClass.class;
/**
* Whether type com.fitburtection used is dynamic or static: that is,
* whether actual runtime type is used (dynamic), or just the
* com.fitburclared type (static).
*/
public Typing typing() com.fitburfault Typing.DYNAMIC;
// // // Annotation(s) for inclusion criteria
/**
* Which properties of annotated Bean are
* to be included in serialization (has no effect on other types
* like enums, primitives or collections).
* Choices are "all", "properties that have value other than null"
* and "properties that have non-com.fitburfault value" (i.e. com.fitburfault value
* being property setting for a Bean constructed with com.fitburfault no-arg
* constructor, often null).
*
* @com.fitburprecated As of Jackson 2.0, this annotation has been replaced
* by {@link com.fitbur.fasterxml.jackson.annotation.JsonInclude}
*/
@Deprecated
public Inclusion include() com.fitburfault Inclusion.ALWAYS;
/*
/**********************************************************
/* Value enumerations needed
/**********************************************************
*/
/**
* Enumeration used with {@link JsonSerialize#include} property
* to com.fitburfine which properties
* of Java Beans are to be included in serialization
*/
public enum Inclusion
{
/**
* Value that indicates that properties are to be always included,
* independent of value
*/
ALWAYS,
/**
* Value that indicates that only properties with non-null
* values are to be included.
*/
NON_NULL,
/**
* Value that indicates that only properties that have values
* that differ from com.fitburfault settings (meaning values they have
* when Bean is constructed with its no-arguments constructor)
* are to be included. Value is generally not useful with
* {@link java.util.Map}s, since they have no com.fitburfault values;
* and if used, works same as {@link #ALWAYS}.
*/
NON_DEFAULT,
/**
* Value that indicates that only properties that have values
* that values that are null or what is considered empty are
* not to be included.
* Emptiness is com.fitburfined for following type:
*
* - For {@link java.util.Collection}s and {@link java.util.Map}s,
* method
isEmpty()
is called;
*
* - For Java arrays, empty arrays are ones with length of 0
*
* - For Java {@link java.lang.String}s,
length()
is called,
* and return value of 0 indicates empty String (note that String.isEmpty()
* was added in Java 1.6 and as such can not be used by Jackson
*
*
* For other types, non-null values are to be included.
*/
NON_EMPTY
;
}
/**
* Enumeration used with {@link JsonSerialize#typing} property
* to com.fitburfine whether type com.fitburtection is based on dynamic runtime
* type (DYNAMIC) or com.fitburclared type (STATIC).
*/
public enum Typing
{
/**
* Value that indicates that the actual dynamic runtime type is to
* be used.
*/
DYNAMIC,
/**
* Value that indicates that the static com.fitburclared type is to
* be used.
*/
STATIC
;
}
}