org.codehaus.jackson.map.introspect.JacksonAnnotationIntrospector Maven / Gradle / Ivy
Go to download
Data Mapper package is a high-performance data binding package
built on Jackson JSON processor
package org.codehaus.jackson.map.introspect;
import java.lang.annotation.Annotation;
import org.codehaus.jackson.annotate.*;
import org.codehaus.jackson.map.AnnotationIntrospector;
import org.codehaus.jackson.map.JsonDeserializer;
import org.codehaus.jackson.map.JsonSerializer;
import org.codehaus.jackson.map.annotate.JsonCachable;
import org.codehaus.jackson.map.annotate.JsonDeserialize;
import org.codehaus.jackson.map.annotate.JsonSerialize;
/**
* {@link AnnotationIntrospector} implementation that handles standard
* Jackson annotations.
*/
public class JacksonAnnotationIntrospector
extends AnnotationIntrospector
{
public JacksonAnnotationIntrospector() { }
/*
////////////////////////////////////////////////////
// General annotation properties
////////////////////////////////////////////////////
*/
@Override
public boolean isHandled(Annotation ann)
{
Class acls = ann.annotationType();
/* 16-May-2009, tatu: used to check this like so...
final String JACKSON_PKG_PREFIX = "org.codehaus.jackson";
Package pkg = acls.getPackage();
return (pkg != null) && (pkg.getName().startsWith(JACKSON_PKG_PREFIX));
*/
// but this is more reliable, now that we have tag annotation:
return acls.getAnnotation(JacksonAnnotation.class) != null;
}
/*
///////////////////////////////////////////////////////
// General class annotations
///////////////////////////////////////////////////////
*/
@Override
public Boolean findCachability(AnnotatedClass ac)
{
JsonCachable ann = ac.getAnnotation(JsonCachable.class);
if (ann == null) {
return null;
}
return ann.value() ? Boolean.TRUE : Boolean.FALSE;
}
@Override
public Boolean findFieldAutoDetection(AnnotatedClass ac)
{
JsonAutoDetect cann = ac.getAnnotation(JsonAutoDetect.class);
if (cann != null) {
JsonMethod[] methods = cann.value();
if (methods != null) {
for (JsonMethod jm : methods) {
if (jm.fieldEnabled()) {
return Boolean.TRUE;
}
}
}
return Boolean.FALSE;
}
return null;
}
/*
///////////////////////////////////////////////////////
// General method annotations
///////////////////////////////////////////////////////
*/
@Override
public boolean isIgnorableMethod(AnnotatedMethod m) {
return _isIgnorable(m);
}
@Override
public boolean isIgnorableConstructor(AnnotatedConstructor c) {
return _isIgnorable(c);
}
/*
////////////////////////////////////////////////////
// General field annotations
////////////////////////////////////////////////////
*/
@Override
public boolean isIgnorableField(AnnotatedField f) {
return _isIgnorable(f);
}
/*
///////////////////////////////////////////////////////
// Serialization: general annotations
///////////////////////////////////////////////////////
*/
@SuppressWarnings({ "unchecked", "deprecation" })
@Override
public Class> findSerializer(Annotated a)
{
/* 21-May-2009, tatu: Slight change; primary annotation is now
* @JsonSerialize; @JsonUseSerializer is deprecated
*/
JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
if (ann != null) {
Class> serClass = ann.using();
if (serClass != JsonSerializer.None.class) {
return serClass;
}
}
JsonUseSerializer oldAnn = a.getAnnotation(JsonUseSerializer.class);
if (oldAnn == null) {
return null;
}
Class serClass = oldAnn.value();
/* 21-Feb-2009, tatu: There is now a way to indicate "no class"
* (to essentially denote a 'dummy' annotation, needed for
* overriding in some cases), need to check:
*/
if (serClass == NoClass.class || serClass == JsonSerializer.None.class) {
return null;
}
if (!JsonSerializer.class.isAssignableFrom(serClass)) {
throw new IllegalArgumentException("Invalid @JsonUseSerializer annotation: Class "+serClass.getName()+" not a JsonSerializer");
}
return (Class>)serClass;
}
@Override
public JsonSerialize.Inclusion findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
{
JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
if (ann != null) {
return ann.include();
}
/* 23-May-2009, tatu: Will still support now-deprecated (as of 1.1)
* legacy annotation too:
*/
JsonWriteNullProperties oldAnn = a.getAnnotation(JsonWriteNullProperties.class);
if (oldAnn != null) {
boolean writeNulls = oldAnn.value();
return writeNulls ? JsonSerialize.Inclusion.ALWAYS : JsonSerialize.Inclusion.NON_NULL;
}
return defValue;
}
@Override
public Class findSerializationType(Annotated am)
{
// Primary annotation, JsonSerialize
JsonSerialize ann = am.getAnnotation(JsonSerialize.class);
if (ann != null) {
Class cls = ann.as();
if (cls != NoClass.class) {
return cls;
}
}
return null;
}
@Override
public JsonSerialize.Typing findSerializationTyping(Annotated a)
{
JsonSerialize ann = a.getAnnotation(JsonSerialize.class);
return (ann == null) ? null : ann.typing();
}
/*
///////////////////////////////////////////////////////
// Serialization: class annotations
///////////////////////////////////////////////////////
*/
@Override
public Boolean findGetterAutoDetection(AnnotatedClass ac)
{
JsonAutoDetect cann = ac.getAnnotation(JsonAutoDetect.class);
if (cann != null) {
JsonMethod[] methods = cann.value();
if (methods != null) {
for (JsonMethod jm : methods) {
if (jm.getterEnabled()) {
return Boolean.TRUE;
}
}
}
return Boolean.FALSE;
}
return null;
}
/*
///////////////////////////////////////////////////////
// Serialization: method annotations
///////////////////////////////////////////////////////
*/
@Override
public String findGettablePropertyName(AnnotatedMethod am)
{
/* 22-May-2009, tatu: JsonProperty is the primary annotation
* to check for
*/
JsonProperty pann = am.getAnnotation(JsonProperty.class);
if (pann != null) {
return pann.value();
}
/* 22-May-2009, tatu: JsonGetter is deprecated as of 1.1
* but still supported
*/
JsonGetter ann = am.getAnnotation(JsonGetter.class);
if (ann != null) {
return ann.value();
}
/* 22-May-2009, tatu: And finally, JsonSerialize implies
* that there is a property, although doesn't define name
*/
if (am.hasAnnotation(JsonSerialize.class)) {
return "";
}
return null;
}
@Override
public boolean hasAsValueAnnotation(AnnotatedMethod am)
{
JsonValue ann = am.getAnnotation(JsonValue.class);
// value of 'false' means disabled...
return (ann != null && ann.value());
}
@Override
public String findEnumValue(Enum value)
{
return value.name();
}
/*
///////////////////////////////////////////////////////
// Serialization: field annotations
///////////////////////////////////////////////////////
*/
@Override
public String findSerializablePropertyName(AnnotatedField af)
{
JsonProperty pann = af.getAnnotation(JsonProperty.class);
if (pann != null) {
return pann.value();
}
// Also: having JsonSerialize implies it is such a property
if (af.hasAnnotation(JsonSerialize.class)) {
return "";
}
return null;
}
/*
///////////////////////////////////////////////////////
// Deserialization: general annotations
///////////////////////////////////////////////////////
*/
@SuppressWarnings({ "unchecked", "deprecation" })
@Override
public Class> findDeserializer(Annotated a)
{
/* 21-May-2009, tatu: Slight change; primary annotation is now
* @JsonDeserialize; @JsonUseDeserializer is deprecated
*/
JsonDeserialize ann = a.getAnnotation(JsonDeserialize.class);
if (ann != null) {
Class> deserClass = ann.using();
if (deserClass != JsonDeserializer.None.class) {
return deserClass;
}
}
JsonUseDeserializer oldAnn = a.getAnnotation(JsonUseDeserializer.class);
if (oldAnn == null) {
return null;
}
Class deserClass = oldAnn.value();
if (deserClass == NoClass.class || deserClass == JsonDeserializer.None.class) {
return null;
}
if (!JsonDeserializer.class.isAssignableFrom(deserClass)) {
throw new IllegalArgumentException("Invalid @JsonUseDeserializer annotation: Class "+deserClass.getName()+" not a JsonDeserializer");
}
return (Class>)deserClass;
}
@SuppressWarnings("deprecation")
@Override
public Class findDeserializationType(Annotated am)
{
// Primary annotation, JsonDeserialize
JsonDeserialize ann = am.getAnnotation(JsonDeserialize.class);
if (ann != null) {
Class cls = ann.as();
if (cls != NoClass.class) {
return cls;
}
}
/* !!! 21-May-2009, tatu: JsonClass is deprecated; will need to
* drop support at a later point (for 2.0?)
*/
JsonClass oldAnn = am.getAnnotation(JsonClass.class);
if (oldAnn != null) {
Class cls = oldAnn.value();
if(cls != NoClass.class) {
return cls;
}
}
return null;
}
@SuppressWarnings("deprecation")
public Class findDeserializationKeyType(Annotated am)
{
// Primary annotation, JsonDeserialize
JsonDeserialize ann = am.getAnnotation(JsonDeserialize.class);
if (ann != null) {
Class cls = ann.keyAs();
if (cls != NoClass.class) {
return cls;
}
}
/* !!! 21-May-2009, tatu: JsonClass is deprecated; will need to
* drop support at a later point (for 2.0?)
*/
JsonKeyClass oldAnn = am.getAnnotation(JsonKeyClass.class);
if (oldAnn != null) {
Class cls = oldAnn.value();
if(cls != NoClass.class) {
return cls;
}
}
return null;
}
@SuppressWarnings("deprecation")
@Override
public Class findDeserializationContentType(Annotated am)
{
// Primary annotation, JsonDeserialize
JsonDeserialize ann = am.getAnnotation(JsonDeserialize.class);
if (ann != null) {
Class cls = ann.contentAs();
if (cls != NoClass.class) {
return cls;
}
}
/* !!! 21-May-2009, tatu: JsonClass is deprecated; will need to
* drop support at a later point (for 2.0?)
*/
JsonContentClass oldAnn = am.getAnnotation(JsonContentClass.class);
if (oldAnn != null) {
Class cls = oldAnn.value();
if(cls != NoClass.class) {
return cls;
}
}
return null;
}
/*
////////////////////////////////////////////////////
// Deserialization: class annotations
////////////////////////////////////////////////////
*/
@Override
public Boolean findCreatorAutoDetection(AnnotatedClass ac)
{
JsonAutoDetect cann = ac.getAnnotation(JsonAutoDetect.class);
if (cann != null) {
JsonMethod[] methods = cann.value();
if (methods != null) {
for (JsonMethod jm : methods) {
if (jm.creatorEnabled()) {
return Boolean.TRUE;
}
}
}
return Boolean.FALSE;
}
return null;
}
@Override
public Boolean findSetterAutoDetection(AnnotatedClass ac)
{
JsonAutoDetect cann = ac.getAnnotation(JsonAutoDetect.class);
if (cann != null) {
JsonMethod[] methods = cann.value();
if (methods != null) {
for (JsonMethod jm : methods) {
if (jm.setterEnabled()) {
return Boolean.TRUE;
}
}
}
return Boolean.FALSE;
}
return null;
}
/*
///////////////////////////////////////////////////////
// Deserialization: Method annotations
///////////////////////////////////////////////////////
*/
@Override
public String findSettablePropertyName(AnnotatedMethod am)
{
/* 22-May-2009, tatu: JsonProperty is the primary annotation
* to check for
*/
JsonProperty pann = am.getAnnotation(JsonProperty.class);
if (pann != null) {
return pann.value();
}
/* 22-May-2009, tatu: JsonSetter is deprecated as of 1.1
* but still supported
*/
JsonSetter ann = am.getAnnotation(JsonSetter.class);
if (ann != null) {
return ann.value();
}
/* 22-May-2009, tatu: And finally, JsonSerialize implies
* that there is a property, although doesn't define name
*/
if (am.hasAnnotation(JsonDeserialize.class)) {
return "";
}
return null;
}
@Override
public boolean hasAnySetterAnnotation(AnnotatedMethod am)
{
/* No dedicated disabling; regular @JsonIgnore used
* if needs to be ignored (and if so, is handled prior
* to this method getting called)
*/
return am.hasAnnotation(JsonAnySetter.class);
}
@Override
public boolean hasCreatorAnnotation(Annotated a)
{
/* No dedicated disabling; regular @JsonIgnore used
* if needs to be ignored (and if so, is handled prior
* to this method getting called)
*/
return a.hasAnnotation(JsonCreator.class);
}
/*
///////////////////////////////////////////////////////
// Deserialization: field annotations
///////////////////////////////////////////////////////
*/
@Override
public String findDeserializablePropertyName(AnnotatedField af)
{
JsonProperty pann = af.getAnnotation(JsonProperty.class);
if (pann != null) {
return pann.value();
}
// Also: having JsonDeserialize implies it is such a property
if (af.hasAnnotation(JsonDeserialize.class)) {
return "";
}
return null;
}
/*
///////////////////////////////////////////////////////
// Deserialization: parameters annotations
///////////////////////////////////////////////////////
*/
@Override
public String findPropertyNameForParam(AnnotatedParameter param)
{
if (param != null) {
JsonProperty pann = param.getAnnotation(JsonProperty.class);
if (pann != null) {
return pann.value();
}
/* And can not use JsonDeserialize as we can not use
* name auto-detection (names of local variables including
* parameters are not necessarily preserved in bytecode)
*/
}
return null;
}
/*
////////////////////////////////////////////////////
// Helper methods
////////////////////////////////////////////////////
*/
protected boolean _isIgnorable(Annotated a)
{
JsonIgnore ann = a.getAnnotation(JsonIgnore.class);
return (ann != null && ann.value());
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy