pax_global_header 0000666 0000000 0000000 00000000064 13147456330 0014520 g ustar 00root root 0000000 0000000 52 comment=2f3f5823230a8fbaef4240e9212718d7aef0e6d0
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/ 0000775 0000000 0000000 00000000000 13147456330 0026166 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/.gitattributes 0000664 0000000 0000000 00000000137 13147456330 0031062 0 ustar 00root root 0000000 0000000 # Do not merge `pom.xml` from older version, as it will typically conflict
pom.xml merge=ours
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/.gitignore 0000664 0000000 0000000 00000000235 13147456330 0030156 0 ustar 00root root 0000000 0000000 # use glob syntax.
syntax: glob
*.class
*~
*.bak
*.off
*.old
.DS_Store
# building
target
# Eclipse
.classpath
.project
.settings
# IDEA
*.iml
*.ipr
*.iws
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/.travis.yml 0000664 0000000 0000000 00000000153 13147456330 0030276 0 ustar 00root root 0000000 0000000 language: java
jdk:
- oraclejdk7
- oraclejdk8
# whitelist
branches:
only:
- master
- "2.7"
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/README.md 0000664 0000000 0000000 00000003514 13147456330 0027450 0 ustar 00root root 0000000 0000000 **NOTE**: This module has become part of [Jackson Base Modules](../../../jackson-modules-base) repo.
as of Jackson 2.9
This repo still exists to allow release of patch versions of older versions; it will be hidden (made private)
in near future.
-----
## Overview
This Jackson extension module provides support for using JAXB (`javax.xml.bind`) annotations as an alternative to native Jackson annotations.
It is most often used to make it easier to reuse existing data beans that used with JAXB framework to read and write XML.
## Maven dependency
To use this extension on Maven-based projects, use following dependency:
```xml
com.fasterxml.jackson.modulejackson-module-jaxb-annotations2.4.0
```
(or whatever version is most up-to-date at the moment)
## Usage
To enable use of JAXB annotations, one must add `JaxbAnnotationIntrospector` provided by this module. There are two ways to do this:
* Register `JaxbAnnotationModule`, or
* Directly add `JaxbAnnotationIntrospector`
Module registration works in standard way:
```java
JaxbAnnotationModule module = new JaxbAnnotationModule();
// configure as necessary
objectMapper.registerModule(module);
```
and the alternative -- explicit configuration is done as:
```java
AnnotationIntrospector introspector = new JaxbAnnotationIntrospector();
// if ONLY using JAXB annotations:
mapper.setAnnotationIntrospector(introspector);
// if using BOTH JAXB annotations AND Jackson annotations:
AnnotationIntrospector secondary = new JacksonAnnotationIntrospector();
mapper.setAnnotationIntrospector(new AnnotationIntrospector.Pair(introspector, secondary);
```
Note that by default Module version will use JAXB annotations as the primary, and Jackson annotations as secondary source; but you can change this behavior
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/create-test-report.sh 0000775 0000000 0000000 00000000050 13147456330 0032251 0 ustar 00root root 0000000 0000000 #!/bin/sh
mvn surefire-report:report
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/pom.xml 0000664 0000000 0000000 00000006630 13147456330 0027510 0 ustar 00root root 0000000 0000000
4.0.0com.fasterxml.jacksonjackson-bom2.8.10com.fasterxml.jackson.modulejackson-module-jaxb-annotations2.8.10Jackson module: JAXB-annotationsbundleSupport for using JAXB annotations as an alternative to "native" Jackson annotations, for configuring data binding.
http://github.com/FasterXML/jackson-module-jaxb-annotationsscm:git:git@github.com:FasterXML/jackson-module-jaxb-annotations.gitscm:git:git@github.com:FasterXML/jackson-module-jaxb-annotations.githttp://github.com/FasterXML/jackson-module-jaxb-annotationsjackson-module-jaxb-annotations-2.8.10com/fasterxml/jackson/module/jaxb${project.groupId}.jaxbcom.fasterxml.jackson.corejackson-corecom.fasterxml.jackson.corejackson-annotationscom.fasterxml.jackson.corejackson-databindjavax.xml.bindjaxb-api2.2providedjunitjunittestjavax.ws.rsjsr311-api1.1.1testorg.apache.maven.pluginsmaven-surefire-plugin${version.plugin.surefire}com/fasterxml/jackson/**/failing/*.javacom.google.code.maven-replacer-pluginreplacerprocess-packageVersionprocess-sources
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/release-notes/ 0000775 0000000 0000000 00000000000 13147456330 0030734 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/release-notes/CREDITS 0000664 0000000 0000000 00000000515 13147456330 0031755 0 ustar 00root root 0000000 0000000 Here are people who have contributed to development Jackson JSON processor
JAXB annotation support component.
(version numbers in brackets indicate release in which the problem was fixed)
Ryan Heaton: author, submitted code first version was based on
Tatu Saloranta, tatu.saloranta@iki.fi: author (all code since initial version)
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/release-notes/VERSION 0000664 0000000 0000000 00000010703 13147456330 0032005 0 ustar 00root root 0000000 0000000 Project: jackson-module-jaxb-annotations
------------------------------------------------------------------------
=== Releases ===
------------------------------------------------------------------------
2.9.0 (not yet released)
2.8.10 (24-Aug-2017)
2.8.9 (12-Jun-2017)
2.8.8 (05-Apr-2017)
2.8.7 (21-Feb-2017)
2.8.6 (12-Jan-2017)
2.8.5 (14-Nov-2016)
2.8.4 (14-Oct-2016)
No changes since 2.8.3
2.8.3 (17-Sep-2016)
#61: Transient fields serialized when @XmlAccessorType(XmlAccessType.FIELD)
is present
(reported by dsharp1@github)
2.8.2 (30-Aug-2016)
2.8.1 (20-Jul-2016)
2.8.0 (04-Jul-2016)
No changes since 2.7
2.7.9 (not yet released)
#63: Error in type resolution of reference type (`Optional`)
(reported by adrianriley@github)
2.7.8 (26-Sep-2016)
2.7.7 (27-Aug-2016)
2.7.6 (23-Jul-2016)
2.7.5 (11-Jun-2016)
2.7.4 (29-Apr-2016)
No changes since 2.7.3
2.7.3 (16-Mar-2016)
- Minor changes to `JaxbAnnotationIntrospector.findEnumValues()` to help
with proper merging of explicit name overrides.
2.7.2 (26-Feb-2016)
- Change build to produce JDK6-compatible jar, to allow use on JDK6 runtime
2.7.1 (02-Feb-2016)
No change since 2.7.0.
2.7.0 (09-Jan-2016)
#52: Add a feature in `JaxbAnnotationIntrospector` to define meaning of
`nillable=false` as "JsonInclude.NON_EMPTY"
2.6.6 (05-Apr-2016)
2.6.5 (19-Jan-2016)
2.6.4 (07-Dec-2015)
2.6.3 (12-Oct-2015)
No changes since 2.6.2
2.6.2 (15-Sep-2015)
#47: JaxbAnnotationIntrospector does not pick up 'required' property of @XmlAttribute
(reported by phantomjinx@github)
2.6.1 (09-Aug-2015)
2.6.0 (19-Jul-2015)
No changes since 2.5.
2.5.4 (09-Jun-2015)
No changes since 2.5.3
2.5.3 (24-Apr-2015)
#40: XmlElementRef ignored if inside XmlElementWrapper
(reported by gkresic@github)
2.5.2 (29-Mar-2015)
No changes since 2.5.1.
2.5.1 (06-Feb-2015)
#39: JaxbAnnotationIntrospector does not honor JsonInclude.Include.NON_EMPTY set on ObjectMapper
(reported by jdmichal@github)
2.5.0 (01-Jan-2015)
#31: Add a way to configure name to use for `@XmlValue` annotated properties #31
2.4.4 (24-Nov-2014)
#32: fix deserialization of Collection with @XmlJavaTypeAdapter on method
(contributed by Andy C, q3aiml@github)
#33: Using @XmlEnum to generate an enum of type Integer in json schema
(requested by jesse8888@github)
- Fixes to handling of `@XmlValue` provided name (problem with #30 fix)
2.4.3 (03-Oct-2014)
No changes.
2.4.2 (14-Aug-2014)
#30: Need a way to override name @XmlValue induces when not doing XML
2.4.1 (17-Jun-2014)
No changes since 2.4.0.
2.4.0 (02-Jun-2014)
No functional changes.
2.3.3 (10-Apr-2014)
2.3.2 (01-Mar-2014)
2.3.1 (28-Dec-2013)
No functional changes.
2.3.0 (14-Nov-2013)
#25: @XmlElementWrapper() should work wrt USE_WRAPPER_NAME_AS_PROPERTY_NAME,
use underlying "default" property name
2.2.3 (23-Aug-2013)
#21: Add LICENSE, NOTICE in jar
2.2.2 (27-May-2013)
2.2.1 (03-May-2013)
No changes.
2.2.0 (22-Apr-2013)
* Fixed last problems with identity adapters resolved
* Improved handling of adapters for Map types
2.1.2 (04-Dec-2012)
* [Issue#16]: Problems with XmlAdapters for deserialization contents of
Collection types
(reported by rcpoison@github)
* Changed JaxbAnnotationIntrospector to force access if need be (mostly
needed for constructing Adapter instances)
2.1.1 (11-Nov-2012)
No functional changes.
2.1.0 (08-Oct-2012)
Improvements:
* [Issue#1]: Support @XmlSeeAlso for specifying subtypes
* [Issue#10]: (partial) support for "identity" adapters, for property adapters
(but not yet for class-annotated)
* [Issue#11]: Add 'JaxbAnnotationModule.setFirstAsId()' to support alternative
Object Id serialization ("always-as-id" instead of "first-as-POJO-then-as-id")
2.0.5 (27-Jul-2012)
Fixes:
* [Issue-9]: Problems with multiple @XmlID, @XmlIDREF properties
2.0.4 (26-Jun-2012)
No fixes or changes, released along with other core components
2.0.3 (15-Jun-2012)
Fixes:
* [Issue-7] Handling of @XmlElementWrapper incorrect wrt @XmlElement
(wrong precedence), when used with Jackon XML backend
* [Issue-8] Incorrect matching of XmlAdapter/@XmlJavaTypeAdapter, Collection
types
(reported by @stoyarchukav)
2.0.2 (14-May-2012)
No fixes; updated core dependencies to 2.0.2.
2.0.1 (23-Apr-2012)
* Made compilation target 1.5; should now work on JDK 1.5
2.0.0 (25-Mar-2012)
Fixes:
* [JACKSON-722]: Ability to use @XmlJavaTypeAdapter for List/Map values
New features:
* [Issue#2]: Support @XmlID, @XmlIDREF
[entries for versions 1.x and earlier not retained; refer to earlier releases)
jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/ 0000775 0000000 0000000 00000000000 13147456330 0026755 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/ 0000775 0000000 0000000 00000000000 13147456330 0027701 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/ 0000775 0000000 0000000 00000000000 13147456330 0030622 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/com/ 0000775 0000000 0000000 00000000000 13147456330 0031400 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/com/fasterxml/ 0000775 0000000 0000000 00000000000 13147456330 0033405 5 ustar 00root root 0000000 0000000 jackson/ 0000775 0000000 0000000 00000000000 13147456330 0034756 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/com/fasterxml module/ 0000775 0000000 0000000 00000000000 13147456330 0036243 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/com/fasterxml/jackson jaxb/ 0000775 0000000 0000000 00000000000 13147456330 0037167 5 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/com/fasterxml/jackson/module AdapterConverter.java 0000664 0000000 0000000 00000002606 13147456330 0043306 0 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/com/fasterxml/jackson/module/jaxb package com.fasterxml.jackson.module.jaxb;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.databind.util.StdConverter;
public class AdapterConverter
extends StdConverter
{
protected final JavaType _inputType, _targetType;
protected final XmlAdapter _adapter;
protected final boolean _forSerialization;
@SuppressWarnings("unchecked")
public AdapterConverter(XmlAdapter adapter,
JavaType inType, JavaType outType, boolean ser)
{
_adapter = (XmlAdapter) adapter;
_inputType = inType;
_targetType = outType;
_forSerialization = ser;
}
@Override
public Object convert(Object value)
{
try {
if (_forSerialization) {
return _adapter.marshal(value);
}
return _adapter.unmarshal(value);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
}
@Override
public JavaType getInputType(TypeFactory typeFactory) {
return _inputType;
}
@Override
public JavaType getOutputType(TypeFactory typeFactory) {
return _targetType;
}
}
JaxbAnnotationIntrospector.java 0000664 0000000 0000000 00000200510 13147456330 0045363 0 ustar 00root root 0000000 0000000 jackson-module-jaxb-annotations-jackson-module-jaxb-annotations-2.8.10/src/main/java/com/fasterxml/jackson/module/jaxb package com.fasterxml.jackson.module.jaxb;
import java.beans.Introspector;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
import javax.xml.bind.*;
import javax.xml.bind.annotation.*;
import javax.xml.bind.annotation.adapters.*;
import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.introspect.*;
import com.fasterxml.jackson.databind.jsontype.NamedType;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.jsontype.impl.StdTypeResolverBuilder;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.databind.util.BeanUtil;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.Converter;
import com.fasterxml.jackson.module.jaxb.deser.DataHandlerJsonDeserializer;
import com.fasterxml.jackson.module.jaxb.ser.DataHandlerJsonSerializer;
/**
* Annotation introspector that leverages JAXB annotations where applicable to JSON mapping.
* As of Jackson 2.0, most JAXB annotations are supported at least to some degree.
* Ones that are NOT yet supported are:
*
*
{@link XmlAnyAttribute} not yet used (as of 1.5) but may be in future (as an alias for @JsonAnySetter?)
*
{@link XmlAnyElement} not yet used, may be as per [JACKSON-253]
*
{@link javax.xml.bind.annotation.XmlAttachmentRef}: JSON does not support external attachments
*
{@link XmlElementDecl}
*
{@link XmlElementRefs} because Jackson doesn't have any support for 'named' collection items -- however,
* this may become partially supported as per [JACKSON-253].
*
{@link javax.xml.bind.annotation.XmlInlineBinaryData} since the underlying concepts
* (like XOP) do not exist in JSON -- Jackson will always use inline base64 encoding as the method
*
{@link javax.xml.bind.annotation.XmlList} because JSON does have (or necessarily need)
* method of serializing list of values as space-separated Strings
*
{@link javax.xml.bind.annotation.XmlMimeType}
*
{@link javax.xml.bind.annotation.XmlMixed} since JSON has no concept of mixed content
*
{@link XmlRegistry}
*
{@link XmlSchema} not used, unlikely to be used
*
{@link XmlSchemaType} not used, unlikely to be used
*
{@link XmlSchemaTypes} not used, unlikely to be used
*
{@link XmlSeeAlso} not yet supported, but [ISSUE-1] filed to use it, so may be supported.
*
*
* Note also the following limitations:
*
*
*
Any property annotated with {@link XmlValue} will have implicit property named 'value' on
* its JSON object; although (as of 2.4) it should be possible to override this name
*
*
*
* A note on compatibility with Jackson XML module: since this module does not depend
* on Jackson XML module, it is bit difficult to make sure we will properly expose
* all information. But effort is made (as of version 2.3.3) to expose this information,
* even without using a specific sub-class from that project.
*
* @author Ryan Heaton
* @author Tatu Saloranta
*/
public class JaxbAnnotationIntrospector
extends AnnotationIntrospector
implements Versioned
{
private static final long serialVersionUID = -1L;
protected final static String DEFAULT_NAME_FOR_XML_VALUE = "value";
protected final static boolean DEFAULT_IGNORE_XMLIDREF = false;
protected final static String MARKER_FOR_DEFAULT = "##default";
// @since 2.5
protected final static JsonFormat.Value FORMAT_STRING = new JsonFormat.Value().withShape(JsonFormat.Shape.STRING);
// @since 2.5
protected final static JsonFormat.Value FORMAT_INT = new JsonFormat.Value().withShape(JsonFormat.Shape.NUMBER_INT);
protected final String _jaxbPackageName;
protected final JsonSerializer _dataHandlerSerializer;
protected final JsonDeserializer _dataHandlerDeserializer;
protected final TypeFactory _typeFactory;
protected final boolean _ignoreXmlIDREF;
/**
* When using {@link XmlValue} annotation, a placeholder name is assigned
* to property (unless overridden by explicit name); this configuration
* value specified what that name is.
*/
protected String _xmlValueName = DEFAULT_NAME_FOR_XML_VALUE;
/**
* Inclusion value to return for properties annotated with
* {@link XmlElement} and {@link XmlElementWrapper}, in case nillable
* property is left as false. Default setting is
* null; this is typically changed to either
* {@link com.fasterxml.jackson.annotation.JsonInclude.Include#NON_NULL}
* or {@link com.fasterxml.jackson.annotation.JsonInclude.Include#NON_EMPTY}.
*
* @since 2.7
*/
protected JsonInclude.Include _nonNillableInclusion = null;
/**
* @deprecated Since 2.1, use constructor that takes TypeFactory.
*/
@Deprecated
public JaxbAnnotationIntrospector() {
this(TypeFactory.defaultInstance());
}
public JaxbAnnotationIntrospector(MapperConfig config) {
this(config.getTypeFactory());
}
public JaxbAnnotationIntrospector(TypeFactory typeFactory) {
this(typeFactory, DEFAULT_IGNORE_XMLIDREF);
}
/**
* @param typeFactory Type factory used for resolving type information
* @param ignoreXmlIDREF Whether {@link XmlIDREF} annotation should be processed
* JAXB style (meaning that references are always serialized using id), or
* not (first reference as full POJO, others as ids)
*/
public JaxbAnnotationIntrospector(TypeFactory typeFactory, boolean ignoreXmlIDREF)
{
_typeFactory = (typeFactory == null)? TypeFactory.defaultInstance() : typeFactory;
_ignoreXmlIDREF = ignoreXmlIDREF;
_jaxbPackageName = XmlElement.class.getPackage().getName();
JsonSerializer dataHandlerSerializer = null;
JsonDeserializer dataHandlerDeserializer = null;
/* Data handlers included dynamically, to try to prevent issues on platforms
* with less than complete support for JAXB API
*/
try {
dataHandlerSerializer = (JsonSerializer) DataHandlerJsonSerializer.class.newInstance();
dataHandlerDeserializer = (JsonDeserializer) DataHandlerJsonDeserializer.class.newInstance();
} catch (Throwable e) {
//dataHandlers not supported...
}
_dataHandlerSerializer = dataHandlerSerializer;
_dataHandlerDeserializer = dataHandlerDeserializer;
}
/**
* Method that will return version information stored in and read from jar
* that contains this class.
*/
@Override
public Version version() {
return PackageVersion.VERSION;
}
/*
/**********************************************************
/* Configuration
/**********************************************************
*/
/**
* Configuration method that can be used to change default name
* ("value") used for properties annotated with {@link XmlValue};
* note that setting it to null will actually avoid
* name override, and name will instead be derived from underlying
* method name using standard bean name introspection.
*
* @since 2.5
*/
public void setNameUsedForXmlValue(String name) {
_xmlValueName = name;
}
/**
* Accessor for getting currently configured placeholder named
* used for property annotated with {@link XmlValue}.
*/
public String getNameUsedForXmlValue() {
return _xmlValueName;
}
/**
* Method to call to change inclusion criteria used for property annotated
* with {@link XmlElement} or {@link XmlElementWrapper}, with nillable
* set as false.
*
* @since 2.7
*/
public JaxbAnnotationIntrospector setNonNillableInclusion(JsonInclude.Include incl) {
_nonNillableInclusion = incl;
return this;
}
/**
* @since 2.7
*/
public JsonInclude.Include getNonNillableInclusion() {
return _nonNillableInclusion;
}
/*
/**********************************************************
/* Extended API (XmlAnnotationIntrospector)
/**********************************************************
*/
// From XmlAnnotationIntrospector
// @Override
public String findNamespace(Annotated ann) {
String ns = null;
if (ann instanceof AnnotatedClass) {
// For classes, it must be @XmlRootElement. Also, we do
// want to use defaults from package, base class
XmlRootElement elem = findRootElementAnnotation((AnnotatedClass) ann);
if (elem != null) {
ns = elem.namespace();
}
} else {
// For others, XmlElement or XmlAttribute work (anything else?)
XmlElement elem = findAnnotation(XmlElement.class, ann, false, false, false);
if (elem != null) {
ns = elem.namespace();
}
if (ns == null || MARKER_FOR_DEFAULT.equals(ns)) {
XmlAttribute attr = findAnnotation(XmlAttribute.class, ann, false, false, false);
if (attr != null) {
ns = attr.namespace();
}
}
}
// JAXB uses marker for "not defined"
if (MARKER_FOR_DEFAULT.equals(ns)) {
ns = null;
}
return ns;
}
// From XmlAnnotationIntrospector
// @Override
/**
* Here we assume fairly simple logic; if there is XmlAttribute to be found,
* we consider it an attribute; if XmlElement, not-an-attribute; and otherwise
* we will consider there to be no information.
* Caller is likely to default to considering things as elements.
*/
public Boolean isOutputAsAttribute(Annotated ann) {
XmlAttribute attr = findAnnotation(XmlAttribute.class, ann, false, false, false);
if (attr != null) {
return Boolean.TRUE;
}
XmlElement elem = findAnnotation(XmlElement.class, ann, false, false, false);
if (elem != null) {
return Boolean.FALSE;
}
return null;
}
// From XmlAnnotationIntrospector
// @Override
public Boolean isOutputAsText(Annotated ann) {
XmlValue attr = findAnnotation(XmlValue.class, ann, false, false, false);
if (attr != null) {
return Boolean.TRUE;
}
return null;
}
/*
/**********************************************************
/* General annotations (for classes, properties)
/**********************************************************
*/
@Override
public ObjectIdInfo findObjectIdInfo(Annotated ann)
{
/* To work in the way that works with JAXB and Jackson,
* we need to do things in bit of round-about way, starting
* with AnnotatedClass, locating @XmlID property, if any.
*/
if (!(ann instanceof AnnotatedClass)) {
return null;
}
AnnotatedClass ac = (AnnotatedClass) ann;
/* Ideally, should not have to infer settings for class from
* individual fields and/or methods; but for now this
* has to do ...
*/
PropertyName idPropName = null;
method_loop:
for (AnnotatedMethod m : ac.memberMethods()) {
XmlID idProp = m.getAnnotation(XmlID.class);
if (idProp == null) {
continue;
}
switch (m.getParameterCount()) {
case 0: // getter
idPropName = findJaxbPropertyName(m, m.getRawType(),
BeanUtil.okNameForGetter(m, true));
break method_loop;
case 1: // setter
idPropName = findJaxbPropertyName(m, m.getRawType(),
BeanUtil.okNameForSetter(m, true));
break method_loop;
}
}
if (idPropName == null) {
for (AnnotatedField f : ac.fields()) {
XmlID idProp = f.getAnnotation(XmlID.class);
if (idProp != null) {
idPropName = findJaxbPropertyName(f, f.getRawType(), f.getName());
break;
}
}
}
if (idPropName != null) {
/* Scoping... hmmh. Could XML requires somewhat global scope, n'est pas?
* The alternative would be to use declared type of this class.
*/
Class scope = Object.class; // alternatively would use 'ac.getRawType()'
// and we will assume that there exists property thus named...
return new ObjectIdInfo(idPropName,
scope, ObjectIdGenerators.PropertyGenerator.class,
// should we customize Object Id resolver somehow?
SimpleObjectIdResolver.class);
}
return null;
}
@Override
public ObjectIdInfo findObjectReferenceInfo(Annotated ann, ObjectIdInfo base)
{
if (!_ignoreXmlIDREF) {
XmlIDREF idref = ann.getAnnotation(XmlIDREF.class);
/* JAXB makes XmlIDREF mean "always as id", as far as I know.
* May need to make it configurable in future, but for not that
* is fine...
*/
if (idref != null) {
if (base == null) {
base = ObjectIdInfo.empty();
}
base = base.withAlwaysAsId(true);
}
}
return base;
}
/*
/**********************************************************
/* General class annotations
/**********************************************************
*/
@Override
public PropertyName findRootName(AnnotatedClass ac)
{
XmlRootElement elem = findRootElementAnnotation(ac);
if (elem != null) {
return _combineNames(elem.name(), elem.namespace(), "");
}
return null;
}
/*
@Override
public String[] findPropertiesToIgnore(Annotated a) {
// nothing in JAXB for this?
return null;
}
*/
/* 08-Nov-2009, tatus: This is bit trickier: by default JAXB
* does actually ignore all unknown properties.
* But since there is no annotation to
* specify or change this, it seems wrong to claim such setting
* is in effect. May need to revisit this issue in future
*/
/*
@Override
public Boolean findIgnoreUnknownProperties(AnnotatedClass ac);
@Override
public JsonIgnoreProperties.Value findPropertyIgnorals(Annotated ac);
*/
@Override
public Boolean isIgnorableType(AnnotatedClass ac) {
// Does JAXB have any such indicators? No?
return null;
}
/*
/**********************************************************
/* General member (field, method/constructor) annotations
/**********************************************************
*/
@Override
public boolean hasIgnoreMarker(AnnotatedMember m) {
return m.getAnnotation(XmlTransient.class) != null;
}
//(ryan) JAXB has @XmlAnyAttribute and @XmlAnyElement annotations, but they're not applicable in this case
// because JAXB says those annotations are only applicable to methods with specific signatures
// that Jackson doesn't support (Jackson's any setter needs 2 arguments, name and value, whereas
// JAXB expects use of Map
// 28-May-2016, tatu: While `@XmlAnyAttribute` looks ALMOST like applicable (esp.
// assuming Jackson could use `Map` field, not just setter/getter), it is alas not.
// The reason is that key is expected to be `QNmae`, XML/JAXB specific name and
// something Jackson does not require or use
/*
@Override
public boolean hasAnySetterAnnotation(AnnotatedMethod am) { }
@Override
public boolean hasAnySetterAnnotation(AnnotatedMethod am)
*/
@Override
public Boolean hasRequiredMarker(AnnotatedMember m) {
XmlElement elem = m.getAnnotation(XmlElement.class);
if ((elem != null) && elem.required()) {
return Boolean.TRUE;
}
XmlAttribute attr = m.getAnnotation(XmlAttribute.class);
if ((attr != null) && attr.required()) {
return Boolean.TRUE;
}
// 09-Sep-2015, tatu: Not 100% sure that we should ever return `false`
// here (as it blocks calls to secondary introspector), but since that
// was the existing behavior before 2.6, is retained for now.
if ((elem != null) || (attr != null)) {
return null;
}
return Boolean.FALSE;
}
@Override
public PropertyName findWrapperName(Annotated ann)
{
XmlElementWrapper w = findAnnotation(XmlElementWrapper.class, ann, false, false, false);
if (w != null) {
/* 18-Sep-2013, tatu: As per [jaxb-annotations#24], need to take special care with empty
* String, as that should indicate here "use underlying unmodified
* property name" (that is, one NOT overridden by @JsonProperty)
*/
PropertyName name = _combineNames(w.name(), w.namespace(), "");
// clumsy, yes, but has to do:
if (!name.hasSimpleName()) {
if (ann instanceof AnnotatedMethod) {
AnnotatedMethod am = (AnnotatedMethod) ann;
String str;
if (am.getParameterCount() == 0) {
str = BeanUtil.okNameForGetter(am, true);
} else {
str = BeanUtil.okNameForSetter(am, true);
}
if (str != null) {
return name.withSimpleName(str);
}
}
return name.withSimpleName(ann.getName());
}
return name;
}
return null;
}
// since 2.4
@Override
public String findImplicitPropertyName(AnnotatedMember m) {
XmlValue valueInfo = m.getAnnotation(XmlValue.class);
if (valueInfo != null) {
return _xmlValueName;
}
return null;
}
@Override
public JsonFormat.Value findFormat(Annotated m) {
/* [jaxb-annotations#33]: Use @XmlEnum value (Class) to indicate format,
* iff it makes sense
*/
if (m instanceof AnnotatedClass) {
XmlEnum ann = m.getAnnotation(XmlEnum.class);
if (ann != null) {
Class type = ann.value();
if (type == String.class || type.isEnum()) {
return FORMAT_STRING;
}
if (Number.class.isAssignableFrom(type)) {
return FORMAT_INT;
}
}
}
return null;
}
/*
/**********************************************************
/* Property auto-detection
/**********************************************************
*/
@Override
public VisibilityChecker findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker checker)
{
XmlAccessType at = findAccessType(ac);
if (at == null) {
/* JAXB default is "PUBLIC_MEMBER"; however, here we should not
* override settings if there is no annotation -- that would mess
* up global baseline. Fortunately Jackson defaults are very close
* to JAXB 'PUBLIC_MEMBER' settings (considering that setters and
* getters must come in pairs)
*/
return checker;
}
// Note: JAXB does not do creator auto-detection, can (and should) ignore
switch (at) {
case FIELD: // all fields, independent of visibility; no methods
return checker.withFieldVisibility(Visibility.ANY)
.withSetterVisibility(Visibility.NONE)
.withGetterVisibility(Visibility.NONE)
.withIsGetterVisibility(Visibility.NONE)
;
case NONE: // no auto-detection
return checker.withFieldVisibility(Visibility.NONE)
.withSetterVisibility(Visibility.NONE)
.withGetterVisibility(Visibility.NONE)
.withIsGetterVisibility(Visibility.NONE)
;
case PROPERTY:
return checker.withFieldVisibility(Visibility.NONE)
.withSetterVisibility(Visibility.PUBLIC_ONLY)
.withGetterVisibility(Visibility.PUBLIC_ONLY)
.withIsGetterVisibility(Visibility.PUBLIC_ONLY)
;
case PUBLIC_MEMBER:
return checker.withFieldVisibility(Visibility.PUBLIC_ONLY)
.withSetterVisibility(Visibility.PUBLIC_ONLY)
.withGetterVisibility(Visibility.PUBLIC_ONLY)
.withIsGetterVisibility(Visibility.PUBLIC_ONLY)
;
}
return checker;
}
/**
* Method for locating JAXB {@link XmlAccessType} annotation value
* for given annotated entity, if it has one, or inherits one from
* its ancestors (in JAXB sense, package etc). Returns null if
* nothing has been explicitly defined.
*/
protected XmlAccessType findAccessType(Annotated ac)
{
XmlAccessorType at = findAnnotation(XmlAccessorType.class, ac, true, true, true);
return (at == null) ? null : at.value();
}
/*
/**********************************************************
/* Class annotations for PM type handling (1.5+)
/**********************************************************
*/
@Override
public TypeResolverBuilder findTypeResolver(MapperConfig config,
AnnotatedClass ac, JavaType baseType)
{
// no per-class type resolvers, right?
return null;
}
@Override
public TypeResolverBuilder findPropertyTypeResolver(MapperConfig config,
AnnotatedMember am, JavaType baseType)
{
/* First: @XmlElements and @XmlElementRefs only applies type for immediate property, if it
* is NOT a structured type.
*/
if (baseType.isContainerType()) return null;
return _typeResolverFromXmlElements(am);
}
@Override
public TypeResolverBuilder findPropertyContentTypeResolver(MapperConfig config,
AnnotatedMember am, JavaType containerType)
{
/* First: let's ensure property is a container type: caller should have
* verified but just to be sure
*/
if (containerType.getContentType() == null) {
throw new IllegalArgumentException("Must call method with a container or reference type (got "+containerType+")");
}
return _typeResolverFromXmlElements(am);
}
protected TypeResolverBuilder _typeResolverFromXmlElements(AnnotatedMember am)
{
/* If simple type, @XmlElements and @XmlElementRefs are applicable.
* Note: @XmlElement and @XmlElementRef are NOT handled here, since they
* are handled specifically as non-polymorphic indication
* of the actual type
*/
XmlElements elems = findAnnotation(XmlElements.class, am, false, false, false);
XmlElementRefs elemRefs = findAnnotation(XmlElementRefs.class, am, false, false, false);
if (elems == null && elemRefs == null) {
return null;
}
TypeResolverBuilder b = new StdTypeResolverBuilder();
// JAXB always uses type name as id
b = b.init(JsonTypeInfo.Id.NAME, null);
// and let's consider WRAPPER_OBJECT to be canonical inclusion method
b = b.inclusion(JsonTypeInfo.As.WRAPPER_OBJECT);
return b;
}
@Override
public List findSubtypes(Annotated a)
{
// No package/superclass defaulting (only used with fields, methods)
XmlElements elems = findAnnotation(XmlElements.class, a, false, false, false);
ArrayList result = null;
if (elems != null) {
result = new ArrayList();
for (XmlElement elem : elems.value()) {
String name = elem.name();
if (MARKER_FOR_DEFAULT.equals(name)) name = null;
result.add(new NamedType(elem.type(), name));
}
} else {
XmlElementRefs elemRefs = findAnnotation(XmlElementRefs.class, a, false, false, false);
if (elemRefs != null) {
result = new ArrayList();
for (XmlElementRef elemRef : elemRefs.value()) {
Class refType = elemRef.type();
// only good for types other than JAXBElement (which is XML based)
if (!JAXBElement.class.isAssignableFrom(refType)) {
// first consider explicit name declaration
String name = elemRef.name();
if (name == null || MARKER_FOR_DEFAULT.equals(name)) {
XmlRootElement rootElement = (XmlRootElement) refType.getAnnotation(XmlRootElement.class);
if (rootElement != null) {
name = rootElement.name();
}
}
if (name == null || MARKER_FOR_DEFAULT.equals(name)) {
name = Introspector.decapitalize(refType.getSimpleName());
}
result.add(new NamedType(refType, name));
}
}
}
}
// Check @XmlSeeAlso as well.
/* 17-Aug-2012, tatu: But wait! For structured type, what we really is
* value (content) type!
* If code below does not make full (or any) sense, do not despair -- it
* is wrong. Yet it works. The call sequence before we get here is mangled,
* its logic twisted... but as Dire Straits put it: "That ain't working --
* that's The Way You Do It!"
*/
XmlSeeAlso ann = a.getAnnotation(XmlSeeAlso.class);
if (ann != null) {
if (result == null) {
result = new ArrayList();
}
for (Class cls : ann.value()) {
result.add(new NamedType(cls));
}
}
return result;
}
@Override
public String findTypeName(AnnotatedClass ac) {
XmlType type = findAnnotation(XmlType.class, ac, false, false, false);
if (type != null) {
String name = type.name();
if (!MARKER_FOR_DEFAULT.equals(name)) return name;
}
return null;
}
/*
/**********************************************************
/* Serialization: general annotations
/**********************************************************
*/
@Override
public JsonSerializer findSerializer(Annotated am)
{
final Class type = _rawSerializationType(am);
/*
// As per [JACKSON-722], more checks for structured types
XmlAdapter adapter = findAdapter(am, true, type);
if (adapter != null) {
boolean fromClass = !(am instanceof AnnotatedMember);
// Ugh. Must match to see if adapter's bounded type (result to map to) matches property type
if (isContainerType(type)) {
Class bt = findAdapterBoundType(adapter);
if (bt.isAssignableFrom(type)) {
return new XmlAdapterJsonSerializer(adapter, fromClass);
}
// Note: if used for value type, handled in different place
} else {
return new XmlAdapterJsonSerializer(adapter, fromClass);
}
}
*/
// Add support for additional core XML types needed by JAXB
if (type != null) {
if (_dataHandlerSerializer != null && isDataHandler(type)) {
return _dataHandlerSerializer;
}
}
return null;
}
/**
* Determines whether the type is assignable to class javax.activation.DataHandler without requiring that class
* to be on the classpath.
*
* @param type The type.
* @return Whether the type is assignable to class javax.activation.DataHandler
*/
private boolean isDataHandler(Class type)
{
return type != null && (Object.class != type)
&& (("javax.activation.DataHandler".equals(type.getName()) || isDataHandler(type.getSuperclass())));
}
@Override
public Object findContentSerializer(Annotated a) {
return null;
}
@Override
@Deprecated // since 2.7
public Class findSerializationType(Annotated a)
{
Class allegedType = _getTypeFromXmlElement(a);
if (allegedType != null){
Class rawPropType = _rawSerializationType(a);
if (!isContainerType(rawPropType)) {
return allegedType;
}
}
return null;
}
/**
* Implementation of this method is slightly tricky, given that JAXB defaults differ
* from Jackson defaults. As of version 1.5 and above, this is resolved by honoring
* Jackson defaults (which are configurable), and only using JAXB explicit annotations.
*/
@Override
@Deprecated // since 2.7; remove from 2.8
public JsonInclude.Include findSerializationInclusion(Annotated a, JsonInclude.Include defValue)
{
XmlElementWrapper w = a.getAnnotation(XmlElementWrapper.class);
if (w != null) {
if (w.nillable()) {
return JsonInclude.Include.ALWAYS;
}
// [jaxb-annotations#52]: Allow specifying inclusion for `nillable=false` too
if (_nonNillableInclusion != null) {
return _nonNillableInclusion;
}
}
XmlElement e = a.getAnnotation(XmlElement.class);
if (e != null) {
if (e.nillable()) {
return JsonInclude.Include.ALWAYS;
}
// [jaxb-annotations#52]: Allow specifying inclusion for `nillable=false` too
if (_nonNillableInclusion != null) {
return _nonNillableInclusion;
}
}
//better pass default value through, if no explicit direction indicating otherwise
return defValue;
}
@Override // @since 2.7
public JsonInclude.Value findPropertyInclusion(Annotated a)
{
JsonInclude.Include incl = findSerializationInclusion(a, null);
if (incl == null) {
return JsonInclude.Value.empty();
}
return JsonInclude.Value.construct(incl, null);
}
@Override // @since 2.7
public JavaType refineSerializationType(final MapperConfig config,
final Annotated a, final JavaType baseType) throws JsonMappingException
{
Class serClass = _getTypeFromXmlElement(a);
if (serClass == null) {
return baseType;
}
// First, JAXB has no annotations for key type, so can skip that part (wrt std annotations)
// But the meaning of main annotation(s) varies between container/non-container types
final TypeFactory tf = config.getTypeFactory();
if (baseType.getContentType() == null) { // non-container/-structured types, usually scalar:
// 27-Nov-2015, tatu: Since JAXB has just one annotation, must ignore it in
// one direction, typically serialization (but not always):
if (!serClass.isAssignableFrom(baseType.getRawClass())) {
return baseType;
}
if (baseType.hasRawClass(serClass)) {
// 30-Nov-2015, tatu: As per [databind#1023], need to allow forcing of
// static typing this way
return baseType.withStaticTyping();
}
try {
return tf.constructGeneralizedType(baseType, serClass);
} catch (IllegalArgumentException iae) {
throw new JsonMappingException(null,
String.format("Failed to widen type %s with annotation (value %s), from '%s': %s",
baseType, serClass.getName(), a.getName(), iae.getMessage()),
iae);
}
} else {
// Otherwise, structured type:
JavaType contentType = baseType.getContentType();
if (contentType != null) { // collection[like], map[like], array, reference
// as per earlier, may need to ignore annotation meant for deserialization
if (!serClass.isAssignableFrom(contentType.getRawClass())) {
return baseType;
}
// And then value types for all containers:
if (contentType.hasRawClass(serClass)) {
contentType = contentType.withStaticTyping();
} else {
try {
contentType = tf.constructGeneralizedType(contentType, serClass);
} catch (IllegalArgumentException iae) {
throw new JsonMappingException(null,
String.format("Failed to widen value type of %s with concrete-type annotation (value %s), from '%s': %s",
baseType, serClass.getName(), a.getName(), iae.getMessage()),
iae);
}
}
return baseType.withContentType(contentType);
}
}
return baseType;
}
/*
/**********************************************************
/* Serialization: class annotations
/**********************************************************
*/
@Override
public String[] findSerializationPropertyOrder(AnnotatedClass ac)
{
// @XmlType.propOrder fits the bill here:
XmlType type = findAnnotation(XmlType.class, ac, true, true, true);
if (type == null) {
return null;
}
String[] order = type.propOrder();
if (order == null || order.length == 0) {
return null;
}
return order;
}
@Override
public Boolean findSerializationSortAlphabetically(Annotated ann) {
return _findAlpha(ann);
}
private final Boolean _findAlpha(Annotated ann) {
XmlAccessorOrder order = findAnnotation(XmlAccessorOrder.class, ann, true, true, true);
return (order == null) ? null : (order.value() == XmlAccessOrder.ALPHABETICAL);
}
@Override
public Object findSerializationConverter(Annotated a)
{
Class serType = _rawSerializationType(a);
// Can apply to both container and regular type; no difference yet here
XmlAdapter adapter = findAdapter(a, true, serType);
if (adapter != null) {
return _converter(adapter, true);
}
return null;
}
@Override
public Object findSerializationContentConverter(AnnotatedMember a)
{
// But this one only applies to structured (container) types:
Class serType = _rawSerializationType(a);
if (isContainerType(serType)) {
XmlAdapter adapter = _findContentAdapter(a, true);
if (adapter != null) {
return _converter(adapter, true);
}
}
return null;
}
/*
/**********************************************************
/* Serialization: property annotations
/**********************************************************
*/
@Override
public PropertyName findNameForSerialization(Annotated a)
{
// need bit of delegation (note: copy of super-class functionality)
if (a instanceof AnnotatedMethod) {
AnnotatedMethod am = (AnnotatedMethod) a;
if (!isVisible(am)) {
return null;
}
return findJaxbPropertyName(am, am.getRawType(),
BeanUtil.okNameForGetter(am, true));
}
if (a instanceof AnnotatedField) {
AnnotatedField af = (AnnotatedField) a;
if (!isVisible(af)) {
return null;
}
// Hmmh. As per [jaxb-annotations#61], looks like we must do one more thing to
// avoid accidentally exposing transient fields: this is necessary because later on
// our returning of "" suggests explicit annotation, which is NOT true, but may be
// necessary to indicate that visibility level is satisfied. That works ok except
// for specific case of transient fields that we must suppress now
if (af.isTransient()) {
return null;
}
PropertyName name = findJaxbPropertyName(af, af.getRawType(), null);
/* This may seem wrong, but since JAXB field auto-detection
* needs to find even non-public fields (if enabled by
* JAXB access type), we need to return name like so:
*/
// 31-Oct-2014, tatu: As per [jaxb-annotations#31], need to be careful to indicate "use default"
// and NOT to force use of specific name; latter would establish explicit name
// and what we want is implicit (unless there is real explicitly annotated name)
if (name == null) {
return PropertyName.USE_DEFAULT;
}
return name;
}
return null;
}
@Override
public boolean hasAsValueAnnotation(AnnotatedMethod am) {
//since jaxb says @XmlValue can exist with attributes, this won't map as a JSON value.
return false;
}
/**
*