org.codehaus.jackson.map.introspect.BasicBeanDescription 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.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.*;
import org.codehaus.jackson.map.*;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.map.type.TypeBindings;
import org.codehaus.jackson.map.util.Annotations;
import org.codehaus.jackson.type.JavaType;
/**
* Default {@link BeanDescription} implementation.
* Can theoretically be subclassed to customize
* some aspects of property introspection.
*/
public class BasicBeanDescription extends BeanDescription
{
/*
/**********************************************************
/* General configuration
/**********************************************************
*/
final protected MapperConfig _config;
final protected AnnotationIntrospector _annotationIntrospector;
/**
* Information collected about the class introspected.
*/
final protected AnnotatedClass _classInfo;
/**
* We may need type bindings for the bean type. If so, we'll
* construct it lazily
*/
protected TypeBindings _bindings;
/*
/**********************************************************
/* Member information
/**********************************************************
*/
/**
* Properties collected for the POJO.
*/
protected final List _properties;
// // for deserialization
protected AnnotatedMethod _anySetterMethod;
protected Map _injectables;
/**
* Set of properties that can be ignored during deserialization, due
* to being marked as ignored.
*/
protected Set _ignoredPropertyNames;
// // for serialization
protected AnnotatedMethod _jsonValueMethod;
protected AnnotatedMethod _anyGetterMethod;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
/**
* @deprecated Since 1.9, should use factory methods instead
*/
@Deprecated
public BasicBeanDescription(MapperConfig config, JavaType type,
AnnotatedClass ac)
{
this(config, type, ac, Collections.emptyList());
}
/**
* @since 1.9
*/
protected BasicBeanDescription(MapperConfig config, JavaType type,
AnnotatedClass ac, List properties)
{
super(type);
_config = config;
_annotationIntrospector = (config == null) ? null : config.getAnnotationIntrospector();
_classInfo = ac;
_properties = properties;
}
/**
* Factory method to use for constructing an instance to use for building
* deserializers.
*
* @since 1.9
*/
public static BasicBeanDescription forDeserialization(POJOPropertiesCollector coll)
{
BasicBeanDescription desc = new BasicBeanDescription(coll.getConfig(),
coll.getType(), coll.getClassDef(), coll.getProperties());
desc._anySetterMethod = coll.getAnySetterMethod();
desc._ignoredPropertyNames = coll.getIgnoredPropertyNames();
desc._injectables = coll.getInjectables();
return desc;
}
/**
* Factory method to use for constructing an instance to use for building
* serializers.
*
* @since 1.9
*/
public static BasicBeanDescription forSerialization(POJOPropertiesCollector coll)
{
BasicBeanDescription desc = new BasicBeanDescription(coll.getConfig(),
coll.getType(), coll.getClassDef(), coll.getProperties());
desc._jsonValueMethod = coll.getJsonValueMethod();
desc._anyGetterMethod = coll.getAnyGetterMethod();
return desc;
}
/**
* Factory method to use for constructing an instance to use for purposes
* other than building serializers or deserializers; will only have information
* on class, not on properties.
*
* @since 1.9
*/
public static BasicBeanDescription forOtherUse(MapperConfig config,
JavaType type, AnnotatedClass ac)
{
return new BasicBeanDescription(config, type,
ac, Collections.emptyList());
}
/*
/**********************************************************
/* Simple accessors from BeanDescription
/**********************************************************
*/
/**
* @since 1.9
*/
@Override
public AnnotatedClass getClassInfo() { return _classInfo; }
@Override
public List findProperties() {
return _properties;
}
/**
* Method for locating the getter method that is annotated with
* {@link org.codehaus.jackson.annotate.JsonValue} annotation,
* if any. If multiple ones are found,
* an error is reported by throwing {@link IllegalArgumentException}
*/
@Override
public AnnotatedMethod findJsonValueMethod()
{
return _jsonValueMethod;
}
@Override
public Set getIgnoredPropertyNames() {
if (_ignoredPropertyNames == null) {
return Collections.emptySet();
}
return _ignoredPropertyNames;
}
/**
* Method for checking whether class being described has any
* annotations recognized by registered annotation introspector.
*/
@Override
public boolean hasKnownClassAnnotations() {
return _classInfo.hasAnnotations();
}
@Override
public Annotations getClassAnnotations() {
return _classInfo.getAnnotations();
}
@Override
public TypeBindings bindingsForBeanType()
{
if (_bindings == null) {
_bindings = new TypeBindings(_config.getTypeFactory(), _type);
}
return _bindings;
}
@Override
public JavaType resolveType(java.lang.reflect.Type jdkType) {
if (jdkType == null) {
return null;
}
return bindingsForBeanType().resolveType(jdkType);
}
/**
* Method that will locate the no-arg constructor for this class,
* if it has one, and that constructor has not been marked as
* ignorable.
*
* @since 1.9
*/
@Override
public AnnotatedConstructor findDefaultConstructor()
{
return _classInfo.getDefaultConstructor();
}
/**
* Method used to locate the method of introspected class that
* implements {@link org.codehaus.jackson.annotate.JsonAnySetter}. If no such method exists
* null is returned. If more than one are found, an exception
* is thrown.
* Additional checks are also made to see that method signature
* is acceptable: needs to take 2 arguments, first one String or
* Object; second any can be any type.
*/
@Override
public AnnotatedMethod findAnySetter() throws IllegalArgumentException
{
if (_anySetterMethod != null) {
/* Also, let's be somewhat strict on how field name is to be
* passed; String, Object make sense, others not
* so much.
*/
/* !!! 18-May-2009, tatu: how about enums? Can add support if
* requested; easy enough for devs to add support within
* method.
*/
Class type = _anySetterMethod.getParameterClass(0);
if (type != String.class && type != Object.class) {
throw new IllegalArgumentException("Invalid 'any-setter' annotation on method "+_anySetterMethod.getName()+"(): first argument not of type String or Object, but "+type.getName());
}
}
return _anySetterMethod;
}
@Override
public Map findInjectables()
{
return _injectables;
}
public List getConstructors()
{
return _classInfo.getConstructors();
}
/*
/**********************************************************
/* Simple accessors, extended
/**********************************************************
*/
public AnnotatedMethod findMethod(String name, Class[] paramTypes)
{
return _classInfo.findMethod(name, paramTypes);
}
/**
* Method called to create a "default instance" of the bean, currently
* only needed for obtaining default field values which may be used for
* suppressing serialization of fields that have "not changed".
*
* @param fixAccess If true, method is allowed to fix access to the
* default constructor (to be able to call non-public constructor);
* if false, has to use constructor as is.
*
* @return Instance of class represented by this descriptor, if
* suitable default constructor was found; null otherwise.
*/
public Object instantiateBean(boolean fixAccess)
{
AnnotatedConstructor ac = _classInfo.getDefaultConstructor();
if (ac == null) {
return null;
}
if (fixAccess) {
ac.fixAccess();
}
try {
return ac.getAnnotated().newInstance();
} catch (Exception e) {
Throwable t = e;
while (t.getCause() != null) {
t = t.getCause();
}
if (t instanceof Error) throw (Error) t;
if (t instanceof RuntimeException) throw (RuntimeException) t;
throw new IllegalArgumentException("Failed to instantiate bean of type "+_classInfo.getAnnotated().getName()+": ("+t.getClass().getName()+") "+t.getMessage(), t);
}
}
/*
/**********************************************************
/* Introspection for serialization, factories
/**********************************************************
*/
public List getFactoryMethods()
{
// must filter out anything that clearly is not a factory method
List candidates = _classInfo.getStaticMethods();
if (candidates.isEmpty()) {
return candidates;
}
ArrayList result = new ArrayList();
for (AnnotatedMethod am : candidates) {
if (isFactoryMethod(am)) {
result.add(am);
}
}
return result;
}
/**
* Method that can be called to locate a single-arg constructor that
* takes specified exact type (will not accept supertype constructors)
*
* @param argTypes Type(s) of the argument that we are looking for
*/
public Constructor findSingleArgConstructor(Class... argTypes)
{
for (AnnotatedConstructor ac : _classInfo.getConstructors()) {
// This list is already filtered to only include accessible
/* (note: for now this is a redundant check; but in future
* that may change; thus leaving here for now)
*/
if (ac.getParameterCount() == 1) {
Class actArg = ac.getParameterClass(0);
for (Class expArg : argTypes) {
if (expArg == actArg) {
return ac.getAnnotated();
}
}
}
}
return null;
}
/**
* Method that can be called to find if introspected class declares
* a static "valueOf" factory method that returns an instance of
* introspected type, given one of acceptable types.
*
* @param expArgTypes Types that the matching single argument factory
* method can take: will also accept super types of these types
* (ie. arg just has to be assignable from expArgType)
*/
public Method findFactoryMethod(Class... expArgTypes)
{
// So, of all single-arg static methods:
for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
if (isFactoryMethod(am)) {
// And must take one of expected arg types (or supertype)
Class actualArgType = am.getParameterClass(0);
for (Class expArgType : expArgTypes) {
// And one that matches what we would pass in
if (actualArgType.isAssignableFrom(expArgType)) {
return am.getAnnotated();
}
}
}
}
return null;
}
protected boolean isFactoryMethod(AnnotatedMethod am)
{
/* First: return type must be compatible with the introspected class
* (i.e. allowed to be sub-class, although usually is the same
* class)
*/
Class rt = am.getRawType();
if (!getBeanClass().isAssignableFrom(rt)) {
return false;
}
/* Also: must be a recognized factory method, meaning:
* (a) marked with @JsonCreator annotation, or
* (a) "valueOf" (at this point, need not be public)
*/
if (_annotationIntrospector.hasCreatorAnnotation(am)) {
return true;
}
if ("valueOf".equals(am.getName())) {
return true;
}
return false;
}
/**
* Method for getting ordered list of named Creator properties.
* Returns an empty list is none found. If multiple Creator
* methods are defined, order between properties from different
* methods is undefined; however, properties for each such
* Creator are ordered properly relative to each other. For the
* usual case of just a single Creator, named properties are
* thus properly ordered.
*/
public List findCreatorPropertyNames()
{
List names = null;
for (int i = 0; i < 2; ++i) {
List l = (i == 0)
? getConstructors() : getFactoryMethods();
for (AnnotatedWithParams creator : l) {
int argCount = creator.getParameterCount();
if (argCount < 1) continue;
String name = _annotationIntrospector.findPropertyNameForParam(creator.getParameter(0));
if (name == null) continue;
if (names == null) {
names = new ArrayList();
}
names.add(name);
for (int p = 1; p < argCount; ++p) {
names.add(_annotationIntrospector.findPropertyNameForParam(creator.getParameter(p)));
}
}
}
if (names == null) {
return Collections.emptyList();
}
return names;
}
/*
/**********************************************************
/* Introspection for serialization, other
/**********************************************************
*/
/**
* Method for determining whether null properties should be written
* out for a Bean of introspected type. This is based on global
* feature (lowest priority, passed as argument)
* and per-class annotation (highest priority).
*/
public JsonSerialize.Inclusion findSerializationInclusion(JsonSerialize.Inclusion defValue)
{
if (_annotationIntrospector == null) {
return defValue;
}
return _annotationIntrospector.findSerializationInclusion(_classInfo, defValue);
}
/**
* Method used to locate the method of introspected class that
* implements {@link org.codehaus.jackson.annotate.JsonAnyGetter}.
* If no such method exists null is returned.
* If more than one are found, an exception is thrown.
*
* @since 1.6
*/
@Override
public AnnotatedMethod findAnyGetter() throws IllegalArgumentException
{
if (_anyGetterMethod != null) {
/* For now let's require a Map; in future can add support for other
* types like perhaps Iterable?
*/
Class type = _anyGetterMethod.getRawType();
if (!Map.class.isAssignableFrom(type)) {
throw new IllegalArgumentException("Invalid 'any-getter' annotation on method "+_anyGetterMethod.getName()+"(): return type is not instance of java.util.Map");
}
}
return _anyGetterMethod;
}
/**
* Method for locating all back-reference properties (setters, fields) bean has
*
* @since 1.6
*/
public Map findBackReferenceProperties()
{
HashMap result = null;
// First, gather setter methods
for (AnnotatedMethod am : _classInfo.memberMethods()) {
if (am.getParameterCount() == 1) {
AnnotationIntrospector.ReferenceProperty prop = _annotationIntrospector.findReferenceType(am);
if (prop != null && prop.isBackReference()) {
if (result == null) {
result = new HashMap();
}
if (result.put(prop.getName(), am) != null) {
throw new IllegalArgumentException("Multiple back-reference properties with name '"+prop.getName()+"'");
}
}
}
}
// then settable fields
for (AnnotatedField af : _classInfo.fields()) {
AnnotationIntrospector.ReferenceProperty prop = _annotationIntrospector.findReferenceType(af);
if (prop != null && prop.isBackReference()) {
if (result == null) {
result = new HashMap();
}
if (result.put(prop.getName(), af) != null) {
throw new IllegalArgumentException("Multiple back-reference properties with name '"+prop.getName()+"'");
}
}
}
return result;
}
/*
/**********************************************************
/* Helper methods for field introspection
/**********************************************************
*/
/**
* @param ignoredProperties (optional) names of properties to ignore;
* any fields that would be recognized as one of these properties
* is ignored.
* @param forSerialization If true, will collect serializable property
* fields; if false, deserializable
*
* @return Ordered Map with logical property name as key, and
* matching field as value.
*/
public LinkedHashMap _findPropertyFields(
Collection ignoredProperties, boolean forSerialization)
{
LinkedHashMap results = new LinkedHashMap();
for (BeanPropertyDefinition property : _properties) {
AnnotatedField f = property.getField();
if (f != null) {
String name = property.getName();
if (ignoredProperties != null) {
if (ignoredProperties.contains(name)) {
continue;
}
}
results.put(name, f);
}
}
return results;
}
/*
/**********************************************************
/* Deprecated methods from BeanDescription
/**********************************************************
*/
@SuppressWarnings("deprecation")
@Override
public LinkedHashMap findGetters(VisibilityChecker visibilityChecker,
Collection ignoredProperties)
{
LinkedHashMap results = new LinkedHashMap();
for (BeanPropertyDefinition property : _properties) {
AnnotatedMethod m = property.getGetter();
if (m != null) {
String name = property.getName();
if (ignoredProperties != null) {
if (ignoredProperties.contains(name)) {
continue;
}
}
results.put(name, m);
}
}
return results;
}
@SuppressWarnings("deprecation")
@Override
public LinkedHashMap findSetters(VisibilityChecker visibilityChecker)
{
LinkedHashMap results = new LinkedHashMap();
for (BeanPropertyDefinition property : _properties) {
AnnotatedMethod m = property.getSetter();
if (m != null) {
results.put(property.getName(), m);
}
}
return results;
}
@SuppressWarnings("deprecation")
@Override
public LinkedHashMap findSerializableFields(VisibilityChecker visibilityChecker,
Collection ignoredProperties)
{
return _findPropertyFields(ignoredProperties, true);
}
@SuppressWarnings("deprecation")
@Override
public LinkedHashMap findDeserializableFields(VisibilityChecker visibilityChecker,
Collection ignoredProperties)
{
return _findPropertyFields(ignoredProperties, false);
}
}