package org.codehaus.jackson.map.ser;
import java.util.*;
import org.codehaus.jackson.map.*;
import org.codehaus.jackson.map.introspect.*;
import org.codehaus.jackson.map.jsontype.NamedType;
import org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
import org.codehaus.jackson.map.ser.std.MapSerializer;
import org.codehaus.jackson.map.type.*;
import org.codehaus.jackson.map.util.ArrayBuilders;
import org.codehaus.jackson.map.util.ClassUtil;
import org.codehaus.jackson.type.JavaType;
/**
* Factory class that can provide serializers for any regular Java beans
* (as defined by "having at least one get method recognizable as bean
* accessor" -- where {@link Object#getClass} does not count);
* as well as for "standard" JDK types. Latter is achieved
* by delegating calls to {@link BasicSerializerFactory}
* to find serializers both for "standard" JDK types (and in some cases,
* sub-classes as is the case for collection classes like
* {@link java.util.List}s and {@link java.util.Map}s) and bean (value)
* classes.
*<p>
* Note about delegating calls to {@link BasicSerializerFactory}:
* although it would be nicer to use linear delegation
* for construction (to essentially dispatch all calls first to the
* underlying {@link BasicSerializerFactory}; or alternatively after
* failing to provide bean-based serializer}, there is a problem:
* priority levels for detecting standard types are mixed. That is,
* we want to check if a type is a bean after some of "standard" JDK
* types, but before the rest.
* As a result, "mixed" delegation used, and calls are NOT done using
* regular {@link SerializerFactory} interface but rather via
* direct calls to {@link BasicSerializerFactory}.
*<p>
* Finally, since all caching is handled by the serializer provider
* (not factory) and there is no configurability, this
* factory is stateless.
* This means that a global singleton instance can be used.
*<p>
* Notes for version 1.7 (and above): the new module registration system
* required addition of {@link #withConfig}, which has to
* be redefined by sub-classes so that they can work properly with
* pluggable additional serializer providing components.
*/
public class BeanSerializerFactory
extends BasicSerializerFactory
{
/**
* Like {@link BasicSerializerFactory}, this factory is stateless, and
* thus a single shared global (== singleton) instance can be used
* without thread-safety issues.
*/
public final static BeanSerializerFactory instance = new BeanSerializerFactory(null);
/**
* Configuration settings for this factory; immutable instance (just like this
* factory), new version created via copy-constructor (fluent-style)
*
* @since 1.7
*/
protected final Config _factoryConfig;
/*
/**********************************************************
/* Config class implementation
/**********************************************************
*/
/**
* Configuration settings container class for bean serializer factory
*
* @since 1.7
*/
public static class ConfigImpl extends Config
{
/**
* Constant for empty <code>Serializers</code> array (which by definition
* is stateless and reusable)
*/
protected final static Serializers[] NO_SERIALIZERS = new Serializers[0];
protected final static BeanSerializerModifier[] NO_MODIFIERS = new BeanSerializerModifier[0];
/**
* List of providers for additional serializers, checked before considering default
* basic or bean serialializers.
*
* @since 1.7
*/
protected final Serializers[] _additionalSerializers;
/**
* @since 1.8
*/
protected final Serializers[] _additionalKeySerializers;
/**
* List of modifiers that can change the way {@link BeanSerializer} instances
* are configured and constructed.
*/
protected final BeanSerializerModifier[] _modifiers;
public ConfigImpl() {
this(null, null, null);
}
protected ConfigImpl(Serializers[] allAdditionalSerializers,
Serializers[] allAdditionalKeySerializers,
BeanSerializerModifier[] modifiers)
{
_additionalSerializers = (allAdditionalSerializers == null) ?
NO_SERIALIZERS : allAdditionalSerializers;
_additionalKeySerializers = (allAdditionalKeySerializers == null) ?
NO_SERIALIZERS : allAdditionalKeySerializers;
_modifiers = (modifiers == null) ? NO_MODIFIERS : modifiers;
}
@Override
public Config withAdditionalSerializers(Serializers additional)
{
if (additional == null) {
throw new IllegalArgumentException("Can not pass null Serializers");
}
Serializers[] all = ArrayBuilders.insertInListNoDup(_additionalSerializers, additional);
return new ConfigImpl(all, _additionalKeySerializers, _modifiers);
}
@Override
public Config withAdditionalKeySerializers(Serializers additional)
{
if (additional == null) {
throw new IllegalArgumentException("Can not pass null Serializers");
}
Serializers[] all = ArrayBuilders.insertInListNoDup(_additionalKeySerializers, additional);
return new ConfigImpl(_additionalSerializers, all, _modifiers);
}
@Override
public Config withSerializerModifier(BeanSerializerModifier modifier)
{
if (modifier == null) {
throw new IllegalArgumentException("Can not pass null modifier");
}
BeanSerializerModifier[] modifiers = ArrayBuilders.insertInListNoDup(_modifiers, modifier);
return new ConfigImpl(_additionalSerializers, _additionalKeySerializers, modifiers);
}
@Override
public boolean hasSerializers() { return _additionalSerializers.length > 0; }
@Override
public boolean hasKeySerializers() { return _additionalKeySerializers.length > 0; }
@Override
public boolean hasSerializerModifiers() { return _modifiers.length > 0; }
@Override
public Iterable<Serializers> serializers() {
return ArrayBuilders.arrayAsIterable(_additionalSerializers);
}
@Override
public Iterable<Serializers> keySerializers() {
return ArrayBuilders.arrayAsIterable(_additionalKeySerializers);
}
@Override
public Iterable<BeanSerializerModifier> serializerModifiers() {
return ArrayBuilders.arrayAsIterable(_modifiers);
}
}
/*
/**********************************************************
/* Life-cycle: creation, configuration
/**********************************************************
*/
/**
* Constructor for creating instances with specified configuration.
*/
protected BeanSerializerFactory(Config config)
{
if (config == null) {
config = new ConfigImpl();
}
_factoryConfig = config;
}
@Override public Config getConfig() { return _factoryConfig; }
/**
* Method used by module registration functionality, to attach additional
* serializer providers into this serializer factory. This is typically
* handled by constructing a new instance with additional serializers,
* to ensure thread-safe access.
*
* @since 1.7
*/
@Override
public SerializerFactory withConfig(Config config)
{
if (_factoryConfig == config) {
return this;
}
/* 22-Nov-2010, tatu: Handling of subtypes is tricky if we do immutable-with-copy-ctor;
* and we pretty much have to here either choose between losing subtype instance
* when registering additional serializers, or losing serializers.
* Instead, let's actually just throw an error if this method is called when subtype
* has not properly overridden this method; this to indicate problem as soon as possible.
*/
if (getClass() != BeanSerializerFactory.class) {
throw new IllegalStateException("Subtype of BeanSerializerFactory ("+getClass().getName()
+") has not properly overridden method 'withAdditionalSerializers': can not instantiate subtype with "
+"additional serializer definitions");
}
return new BeanSerializerFactory(config);
}
@Override
protected Iterable<Serializers> customSerializers() {
return _factoryConfig.serializers();
}
/*
/**********************************************************
/* SerializerFactory impl
/**********************************************************
*/
/**
* Main serializer constructor method. We will have to be careful
* with respect to ordering of various method calls: essentially
* we want to reliably figure out which classes are standard types,
* and which are beans. The problem is that some bean Classes may
* implement standard interfaces (say, {@link java.lang.Iterable}.
*<p>
* Note: sub-classes may choose to complete replace implementation,
* if they want to alter priority of serializer lookups.
*/
@Override
@SuppressWarnings("unchecked")
public JsonSerializer<Object> createSerializer(SerializationConfig config, JavaType origType,
BeanProperty property)
throws JsonMappingException
{
// Very first thing, let's check if there is explicit serializer annotation:
BasicBeanDescription beanDesc = config.introspect(origType);
JsonSerializer<?> ser = findSerializerFromAnnotation(config, beanDesc.getClassInfo(), property);
if (ser != null) {
return (JsonSerializer<Object>) ser;
}
// Next: we may have annotations that further define types to use...
JavaType type = modifyTypeByAnnotation(config, beanDesc.getClassInfo(), origType);
// and if so, we consider it implicit "force static typing" instruction
boolean staticTyping = (type != origType);
if (type != origType && type.getRawClass() != origType.getRawClass()) {
// [JACKSON-799]: need to re-introspect
beanDesc = config.introspect(type);
}
// Container types differ from non-container types:
if (origType.isContainerType()) {
return (JsonSerializer<Object>) buildContainerSerializer(config, type, beanDesc, property, staticTyping);
}
// Modules may provide serializers of all types:
for (Serializers serializers : _factoryConfig.serializers()) {
ser = serializers.findSerializer(config, type, beanDesc, property);
if (ser != null) {
return (JsonSerializer<Object>) ser;
}
}
/* Otherwise, we will check "primary types"; both marker types that
* indicate specific handling (JsonSerializable), or main types that have
* precedence over container types
*/
ser = findSerializerByLookup(type, config, beanDesc, property, staticTyping);
if (ser == null) {
ser = findSerializerByPrimaryType(type, config, beanDesc, property, staticTyping);
if (ser == null) {
/* And this is where this class comes in: if type is not a
* known "primary JDK type", perhaps it's a bean? We can still
* get a null, if we can't find a single suitable bean property.
*/
ser = findBeanSerializer(config, type, beanDesc, property);
/* Finally: maybe we can still deal with it as an
* implementation of some basic JDK interface?
*/
if (ser == null) {
ser = findSerializerByAddonType(config, type, beanDesc, property, staticTyping);
}
}
}
return (JsonSerializer<Object>) ser;
}
@Override
@SuppressWarnings("unchecked")
public JsonSerializer<Object> createKeySerializer(SerializationConfig config, JavaType type,
BeanProperty property)
{
// Minor optimization: to avoid constructing beanDesc, bail out if none registered
if (!_factoryConfig.hasKeySerializers()) {
return null;
}
// We should not need any member method info; at most class annotations for Map type
BasicBeanDescription beanDesc = config.introspectClassAnnotations(type.getRawClass());
JsonSerializer<?> ser = null;
// Only thing we have here are module-provided key serializers:
for (Serializers serializers : _factoryConfig.keySerializers()) {
ser = serializers.findSerializer(config, type, beanDesc, property);
if (ser != null) {
break;
}
}
return (JsonSerializer<Object>) ser;
}
/*
/**********************************************************
/* Other public methods that are not part of
/* JsonSerializerFactory API
/**********************************************************
*/
/**
* Method that will try to construct a {@link BeanSerializer} for
* given class. Returns null if no properties are found.
*/
@SuppressWarnings("unchecked")
public JsonSerializer<Object> findBeanSerializer(SerializationConfig config, JavaType type,
BasicBeanDescription beanDesc, BeanProperty property)
throws JsonMappingException
{
// First things first: we know some types are not beans...
if (!isPotentialBeanType(type.getRawClass())) {
return null;
}
JsonSerializer<Object> serializer = constructBeanSerializer(config, beanDesc, property);
// [JACKSON-440] Need to allow overriding actual serializer, as well...
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
serializer = (JsonSerializer<Object>)mod.modifySerializer(config, beanDesc, serializer);
}
}
return serializer;
}
/**
* Method called to create a type information serializer for values of given
* non-container property
* if one is needed. If not needed (no polymorphic handling configured), should
* return null.
*
* @param baseType Declared type to use as the base type for type information serializer
*
* @return Type serializer to use for property values, if one is needed; null if not.
*
* @since 1.5
*/
public TypeSerializer findPropertyTypeSerializer(JavaType baseType, SerializationConfig config,
AnnotatedMember accessor, BeanProperty property)
throws JsonMappingException
{
AnnotationIntrospector ai = config.getAnnotationIntrospector();
TypeResolverBuilder<?> b = ai.findPropertyTypeResolver(config, accessor, baseType);
// Defaulting: if no annotations on member, check value class
if (b == null) {
return createTypeSerializer(config, baseType, property);
}
Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(accessor, config, ai);
return b.buildTypeSerializer(config, baseType, subtypes, property);
}
/**
* Method called to create a type information serializer for values of given
* container property
* if one is needed. If not needed (no polymorphic handling configured), should
* return null.
*
* @param containerType Declared type of the container to use as the base type for type information serializer
*
* @return Type serializer to use for property value contents, if one is needed; null if not.
*
* @since 1.5
*/
public TypeSerializer findPropertyContentTypeSerializer(JavaType containerType, SerializationConfig config,
AnnotatedMember accessor, BeanProperty property)
throws JsonMappingException
{
JavaType contentType = containerType.getContentType();
AnnotationIntrospector ai = config.getAnnotationIntrospector();
TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, accessor, containerType);
// Defaulting: if no annotations on member, check value class
if (b == null) {
return createTypeSerializer(config, contentType, property);
}
Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(accessor, config, ai);
return b.buildTypeSerializer(config, contentType, subtypes, property);
}
/*
/**********************************************************
/* Overridable non-public factory methods
/**********************************************************
*/
/**
* Method called to construct serializer for serializing specified bean type.
*
* @since 1.6
*/
@SuppressWarnings("unchecked")
protected JsonSerializer<Object> constructBeanSerializer(SerializationConfig config,
BasicBeanDescription beanDesc, BeanProperty property)
throws JsonMappingException
{
// 13-Oct-2010, tatu: quick sanity check: never try to create bean serializer for plain Object
if (beanDesc.getBeanClass() == Object.class) {
throw new IllegalArgumentException("Can not create bean serializer for Object.class");
}
BeanSerializerBuilder builder = constructBeanSerializerBuilder(beanDesc);
// First: any detectable (auto-detect, annotations) properties to serialize?
List<BeanPropertyWriter> props = findBeanProperties(config, beanDesc);
if (props == null) {
props = new ArrayList<BeanPropertyWriter>();
}
// [JACKSON-440] Need to allow modification bean properties to serialize:
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
props = mod.changeProperties(config, beanDesc, props);
}
}
// Any properties to suppress?
props = filterBeanProperties(config, beanDesc, props);
// Do they need to be sorted in some special way?
props = sortBeanProperties(config, beanDesc, props);
// [JACKSON-440] Need to allow reordering of properties to serialize
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
props = mod.orderProperties(config, beanDesc, props);
}
}
builder.setProperties(props);
builder.setFilterId(findFilterId(config, beanDesc));
AnnotatedMethod anyGetter = beanDesc.findAnyGetter();
if (anyGetter != null) { // since 1.6
if (config.isEnabled(SerializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
anyGetter.fixAccess();
}
JavaType type = anyGetter.getType(beanDesc.bindingsForBeanType());
// copied from BasicSerializerFactory.buildMapSerializer():
boolean staticTyping = config.isEnabled(SerializationConfig.Feature.USE_STATIC_TYPING);
JavaType valueType = type.getContentType();
TypeSerializer typeSer = createTypeSerializer(config, valueType, property);
// last 2 nulls; don't know key, value serializers (yet)
MapSerializer mapSer = MapSerializer.construct(/* ignored props*/ null, type, staticTyping,
typeSer, property, null, null);
builder.setAnyGetter(new AnyGetterWriter(anyGetter, mapSer));
}
// One more thing: need to gather view information, if any:
processViews(config, builder);
// And maybe let interested parties mess with the result bit more...
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
builder = mod.updateBuilder(config, beanDesc, builder);
}
}
JsonSerializer<Object> ser = (JsonSerializer<Object>) builder.build();
/* However, after all modifications: no properties, no serializer
* (note; as per [JACKSON-670], check was moved later on from an earlier location)
*/
if (ser == null) {
/* 27-Nov-2009, tatu: Except that as per [JACKSON-201], we are
* ok with that as long as it has a recognized class annotation
* (which may come from a mix-in too)
*/
if (beanDesc.hasKnownClassAnnotations()) {
return builder.createDummy();
}
}
return ser;
}
/**
* Method called to construct a filtered writer, for given view
* definitions. Default implementation constructs filter that checks
* active view type to views property is to be included in.
*/
protected BeanPropertyWriter constructFilteredBeanWriter(BeanPropertyWriter writer, Class<?>[] inViews)
{
return FilteredBeanPropertyWriter.constructViewBased(writer, inViews);
}
protected PropertyBuilder constructPropertyBuilder(SerializationConfig config,
BasicBeanDescription beanDesc)
{
return new PropertyBuilder(config, beanDesc);
}
protected BeanSerializerBuilder constructBeanSerializerBuilder(BasicBeanDescription beanDesc) {
return new BeanSerializerBuilder(beanDesc);
}
/**
* Method called to find filter that is configured to be used with bean
* serializer being built, if any.
*
* @since 1.7
*/
protected Object findFilterId(SerializationConfig config, BasicBeanDescription beanDesc)
{
return config.getAnnotationIntrospector().findFilterId(beanDesc.getClassInfo());
}
/*
/**********************************************************
/* Overridable non-public introspection methods
/**********************************************************
*/
/**
* Helper method used to skip processing for types that we know
* can not be (i.e. are never consider to be) beans:
* things like primitives, Arrays, Enums, and proxy types.
*<p>
* Note that usually we shouldn't really be getting these sort of
* types anyway; but better safe than sorry.
*/
protected boolean isPotentialBeanType(Class<?> type)
{
return (ClassUtil.canBeABeanType(type) == null) && !ClassUtil.isProxyType(type);
}
/**
* Method used to collect all actual serializable properties.
* Can be overridden to implement custom detection schemes.
*/
protected List<BeanPropertyWriter> findBeanProperties(SerializationConfig config, BasicBeanDescription beanDesc)
throws JsonMappingException
{
List<BeanPropertyDefinition> properties = beanDesc.findProperties();
AnnotationIntrospector intr = config.getAnnotationIntrospector();
// [JACKSON-429]: ignore specified types
removeIgnorableTypes(config, beanDesc, properties);
// and possibly remove ones without matching mutator...
if (config.isEnabled(SerializationConfig.Feature.REQUIRE_SETTERS_FOR_GETTERS)) {
removeSetterlessGetters(config, beanDesc, properties);
}
// nothing? can't proceed (caller may or may not throw an exception)
if (properties.isEmpty()) {
return null;
}
// null is for value type serializer, which we don't have access to from here (ditto for bean prop)
boolean staticTyping = usesStaticTyping(config, beanDesc, null, null);
PropertyBuilder pb = constructPropertyBuilder(config, beanDesc);
ArrayList<BeanPropertyWriter> result = new ArrayList<BeanPropertyWriter>(properties.size());
TypeBindings typeBind = beanDesc.bindingsForBeanType();
// [JACKSON-98]: start with field properties, if any
for (BeanPropertyDefinition property : properties) {
AnnotatedMember accessor = property.getAccessor();
// [JACKSON-235]: suppress writing of back references
AnnotationIntrospector.ReferenceProperty prop = intr.findReferenceType(accessor);
if (prop != null && prop.isBackReference()) {
continue;
}
String name = property.getName();
if (accessor instanceof AnnotatedMethod) {
result.add(_constructWriter(config, typeBind, pb, staticTyping, name, (AnnotatedMethod) accessor));
} else {
result.add(_constructWriter(config, typeBind, pb, staticTyping, name, (AnnotatedField) accessor));
}
}
return result;
}
/*
/**********************************************************
/* Overridable non-public methods for manipulating bean properties
/**********************************************************
*/
/**
* Overridable method that can filter out properties. Default implementation
* checks annotations class may have.
*/
protected List<BeanPropertyWriter> filterBeanProperties(SerializationConfig config,
BasicBeanDescription beanDesc, List<BeanPropertyWriter> props)
{
AnnotationIntrospector intr = config.getAnnotationIntrospector();
AnnotatedClass ac = beanDesc.getClassInfo();
String[] ignored = intr.findPropertiesToIgnore(ac);
if (ignored != null && ignored.length > 0) {
HashSet<String> ignoredSet = ArrayBuilders.arrayToSet(ignored);
Iterator<BeanPropertyWriter> it = props.iterator();
while (it.hasNext()) {
if (ignoredSet.contains(it.next().getName())) {
it.remove();
}
}
}
return props;
}
/**
* Overridable method that will impose given partial ordering on
* list of discovered propertied. Method can be overridden to
* provide custom ordering of properties, beyond configurability
* offered by annotations (whic allow alphabetic ordering, as
* well as explicit ordering by providing array of property names).
*<p>
* By default Creator properties will be ordered before other
* properties. Explicit custom ordering will override this implicit
* default ordering.
*/
/**
* Method that used to be called (pre-1.9) to impose configured
* ordering on list of discovered properties.
* With 1.9 it is not needed any more as ordering is done earlier.
*
* @deprecated Since 1.9 this method does nothing, so there is no
* benefit from overriding it; it will be removed from 2.0.
*/
@Deprecated
protected List<BeanPropertyWriter> sortBeanProperties(SerializationConfig config,
BasicBeanDescription beanDesc, List<BeanPropertyWriter> props)
{
return props;
}
/**
* Method called to handle view information for constructed serializer,
* based on bean property writers.
*<p>
* Note that this method is designed to be overridden by sub-classes
* if they want to provide custom view handling. As such it is not
* considered an internal implementation detail, and will be supported
* as part of API going forward.
*<p>
* NOTE: signature of this method changed in 1.7, due to other significant
* changes (esp. use of builder for serializer construction).
*/
protected void processViews(SerializationConfig config, BeanSerializerBuilder builder)
{
// [JACKSON-232]: whether non-annotated fields are included by default or not is configurable
List<BeanPropertyWriter> props = builder.getProperties();
boolean includeByDefault = config.isEnabled(SerializationConfig.Feature.DEFAULT_VIEW_INCLUSION);
final int propCount = props.size();
int viewsFound = 0;
BeanPropertyWriter[] filtered = new BeanPropertyWriter[propCount];
// Simple: view information is stored within individual writers, need to combine:
for (int i = 0; i < propCount; ++i) {
BeanPropertyWriter bpw = props.get(i);
Class<?>[] views = bpw.getViews();
if (views == null) { // no view info? include or exclude by default?
if (includeByDefault) {
filtered[i] = bpw;
}
} else {
++viewsFound;
filtered[i] = constructFilteredBeanWriter(bpw, views);
}
}
// minor optimization: if no view info, include-by-default, can leave out filtering info altogether:
if (includeByDefault && viewsFound == 0) {
return;
}
builder.setFilteredProperties(filtered);
}
/**
* Method that will apply by-type limitations (as per [JACKSON-429]);
* by default this is based on {@link org.codehaus.jackson.annotate.JsonIgnoreType} annotation but
* can be supplied by module-provided introspectors too.
*/
protected void removeIgnorableTypes(SerializationConfig config, BasicBeanDescription beanDesc,
List<BeanPropertyDefinition> properties)
{
AnnotationIntrospector intr = config.getAnnotationIntrospector();
HashMap<Class<?>,Boolean> ignores = new HashMap<Class<?>,Boolean>();
Iterator<BeanPropertyDefinition> it = properties.iterator();
while (it.hasNext()) {
BeanPropertyDefinition property = it.next();
AnnotatedMember accessor = property.getAccessor();
if (accessor == null) {
it.remove();
continue;
}
Class<?> type = accessor.getRawType();
Boolean result = ignores.get(type);
if (result == null) {
BasicBeanDescription desc = config.introspectClassAnnotations(type);
AnnotatedClass ac = desc.getClassInfo();
result = intr.isIgnorableType(ac);
// default to false, non-ignorable
if (result == null) {
result = Boolean.FALSE;
}
ignores.put(type, result);
}
// lotsa work, and yes, it is ignorable type, so:
if (result.booleanValue()) {
it.remove();
}
}
}
/**
* Helper method that will remove all properties that do not have a
* mutator.
*
* @since 1.9
*/
protected void removeSetterlessGetters(SerializationConfig config, BasicBeanDescription beanDesc,
List<BeanPropertyDefinition> properties)
{
Iterator<BeanPropertyDefinition> it = properties.iterator();
while (it.hasNext()) {
BeanPropertyDefinition property = it.next();
// one caveat: as per [JACKSON-806], only remove implicit properties;
// explicitly annotated ones should remain
if (!property.couldDeserialize() && !property.isExplicitlyIncluded()) {
it.remove();
}
}
}
/*
/**********************************************************
/* Internal helper methods
/**********************************************************
*/
/**
* Secondary helper method for constructing {@link BeanPropertyWriter} for
* given member (field or method).
*/
protected BeanPropertyWriter _constructWriter(SerializationConfig config, TypeBindings typeContext,
PropertyBuilder pb, boolean staticTyping, String name, AnnotatedMember accessor)
throws JsonMappingException
{
if (config.isEnabled(SerializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
accessor.fixAccess();
}
JavaType type = accessor.getType(typeContext);
BeanProperty.Std property = new BeanProperty.Std(name, type, pb.getClassAnnotations(), accessor);
// Does member specify a serializer? If so, let's use it.
JsonSerializer<Object> annotatedSerializer = findSerializerFromAnnotation(config, accessor, property);
// And how about polymorphic typing? First special to cover JAXB per-field settings:
TypeSerializer contentTypeSer = null;
if (ClassUtil.isCollectionMapOrArray(type.getRawClass())) {
contentTypeSer = findPropertyContentTypeSerializer(type, config, accessor, property);
}
// and if not JAXB collection/array with annotations, maybe regular type info?
TypeSerializer typeSer = findPropertyTypeSerializer(type, config, accessor, property);
BeanPropertyWriter pbw = pb.buildWriter(name, type, annotatedSerializer,
typeSer, contentTypeSer, accessor, staticTyping);
// how about views? (1.4+)
AnnotationIntrospector intr = config.getAnnotationIntrospector();
pbw.setViews(intr.findSerializationViews(accessor));
return pbw;
}
}