public JsonSerializer<?> findSerializer(
SerializationConfig config, JavaType type, BeanDescription beanDesc) {
final Class<?> rawType = type.getRawClass();
if (_jdk7Helper != null) {
Class<?> path = _jdk7Helper.getClassJavaNioFilePath();
if (path.isAssignableFrom(rawType)) {
return ToStringSerializer.instance;
}
}
if ((CLASS_DOM_NODE != null) && CLASS_DOM_NODE.isAssignableFrom(rawType)) {
return (JsonSerializer<?>) instantiate(SERIALIZER_FOR_DOM_NODE);
}
String className = rawType.getName();
String factoryName;
if (className.startsWith(PACKAGE_PREFIX_JAVAX_XML)
|| hasSuperClassStartingWith(rawType, PACKAGE_PREFIX_JAVAX_XML)) {
factoryName = SERIALIZERS_FOR_JAVAX_XML;
} else {
return null;
}
Object ob = instantiate(factoryName);
if (ob == null) { // could warn, if we had logging system (j.u.l?)
return null;
}
return ((Serializers) ob).findSerializer(config, type, beanDesc);
}
public JsonDeserializer<?> findDeserializer(
JavaType type, DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException {
final Class<?> rawType = type.getRawClass();
if (_jdk7Helper != null) {
JsonDeserializer<?> deser = _jdk7Helper.getDeserializerForJavaNioFilePath(rawType);
if (deser != null) {
return deser;
}
}
if ((CLASS_DOM_NODE != null) && CLASS_DOM_NODE.isAssignableFrom(rawType)) {
return (JsonDeserializer<?>) instantiate(DESERIALIZER_FOR_DOM_NODE);
}
if ((CLASS_DOM_DOCUMENT != null) && CLASS_DOM_DOCUMENT.isAssignableFrom(rawType)) {
return (JsonDeserializer<?>) instantiate(DESERIALIZER_FOR_DOM_DOCUMENT);
}
String className = rawType.getName();
String factoryName;
if (className.startsWith(PACKAGE_PREFIX_JAVAX_XML)
|| hasSuperClassStartingWith(rawType, PACKAGE_PREFIX_JAVAX_XML)) {
factoryName = DESERIALIZERS_FOR_JAVAX_XML;
} else {
return null;
}
Object ob = instantiate(factoryName);
if (ob == null) { // could warn, if we had logging system (j.u.l?)
return null;
}
return ((Deserializers) ob).findBeanDeserializer(type, config, beanDesc);
}
/**
* 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) {
String typeStr = ClassUtil.canBeABeanType(type);
if (typeStr != null) {
throw new IllegalArgumentException(
"Can not deserialize Class " + type.getName() + " (of type " + typeStr + ") as a Bean");
}
if (ClassUtil.isProxyType(type)) {
throw new IllegalArgumentException(
"Can not deserialize Proxy class " + type.getName() + " as a Bean");
}
/* also: can't deserialize some local classes: static are ok; in-method not;
* and with [JACKSON-594], other non-static inner classes are ok
*/
typeStr = ClassUtil.isLocalType(type, true);
if (typeStr != null) {
throw new IllegalArgumentException(
"Can not deserialize Class " + type.getName() + " (of type " + typeStr + ") as a Bean");
}
return true;
}
/**
* Since 2.7 we only need to check for class extension, as all implemented types are classes, not
* interfaces. This has performance implications for some cases, as we do not need to go over
* interfaces implemented, just superclasses
*
* @since 2.7
*/
private boolean hasSuperClassStartingWith(Class<?> rawType, String prefix) {
for (Class<?> supertype = rawType.getSuperclass();
supertype != null;
supertype = supertype.getSuperclass()) {
if (supertype == Object.class) {
return false;
}
if (supertype.getName().startsWith(prefix)) {
return true;
}
}
return false;
}
@Override
public JsonSerializer<Object> serializerInstance(Annotated annotated, Object serDef)
throws JsonMappingException {
if (serDef == null) {
return null;
}
JsonSerializer<?> ser;
if (serDef instanceof JsonSerializer) {
ser = (JsonSerializer<?>) serDef;
} else {
/* Alas, there's no way to force return type of "either class
* X or Y" -- need to throw an exception after the fact
*/
if (!(serDef instanceof Class)) {
throw new IllegalStateException(
"AnnotationIntrospector returned serializer definition of type "
+ serDef.getClass().getName()
+ "; expected type JsonSerializer or Class<JsonSerializer> instead");
}
Class<?> serClass = (Class<?>) serDef;
// there are some known "no class" markers to consider too:
if (serClass == JsonSerializer.None.class || serClass == NoClass.class) {
return null;
}
if (!JsonSerializer.class.isAssignableFrom(serClass)) {
throw new IllegalStateException(
"AnnotationIntrospector returned Class "
+ serClass.getName()
+ "; expected Class<JsonSerializer>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
if (hi != null) {
ser = hi.serializerInstance(_config, annotated, serClass);
} else {
ser =
(JsonSerializer<?>)
ClassUtil.createInstance(serClass, _config.canOverrideAccessModifiers());
}
}
return (JsonSerializer<Object>) _handleResolvable(ser);
}
/**
* The method to be called by {@link ObjectMapper} and {@link ObjectWriter} to generate <a
* href="http://json-schema.org/">JSON schema</a> for given type.
*
* @param type The type for which to generate schema
*/
public JsonSchema generateJsonSchema(Class<?> type) throws JsonMappingException {
if (type == null) {
throw new IllegalArgumentException("A class must be provided");
}
/* no need for embedded type information for JSON schema generation (all
* type information it needs is accessible via "untyped" serializer)
*/
JsonSerializer<Object> ser = findValueSerializer(type, null);
JsonNode schemaNode =
(ser instanceof SchemaAware)
? ((SchemaAware) ser).getSchema(this, null)
: JsonSchema.getDefaultSchemaNode();
if (!(schemaNode instanceof ObjectNode)) {
throw new IllegalArgumentException(
"Class "
+ type.getName()
+ " would not be serialized as a JSON object and therefore has no schema");
}
return new JsonSchema((ObjectNode) schemaNode);
}
/**
* Method called to see if given method has annotations that indicate a more specific type than
* what the argument specifies. If annotations are present, they must specify compatible Class;
* instance of which can be assigned using the method. This means that the Class has to be raw
* class of type, or its sub-class (or, implementing class if original Class instance is an
* interface).
*
* @param a Method or field that the type is associated with
* @param type Type derived from the setter argument
* @return Original type if no annotations are present; or a more specific type derived from it if
* type annotation(s) was found
* @throws JsonMappingException if invalid annotation is found
*/
private JavaType modifyTypeByAnnotation(DeserializationContext ctxt, Annotated a, JavaType type)
throws JsonMappingException {
// first: let's check class for the instance itself:
AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
Class<?> subclass = intr.findDeserializationType(a, type);
if (subclass != null) {
try {
type = type.narrowBy(subclass);
} catch (IllegalArgumentException iae) {
throw new JsonMappingException(
"Failed to narrow type "
+ type
+ " with concrete-type annotation (value "
+ subclass.getName()
+ "), method '"
+ a.getName()
+ "': "
+ iae.getMessage(),
null,
iae);
}
}
// then key class
if (type.isContainerType()) {
Class<?> keyClass = intr.findDeserializationKeyType(a, type.getKeyType());
if (keyClass != null) {
// illegal to use on non-Maps
if (!(type instanceof MapLikeType)) {
throw new JsonMappingException(
"Illegal key-type annotation: type " + type + " is not a Map(-like) type");
}
try {
type = ((MapLikeType) type).narrowKey(keyClass);
} catch (IllegalArgumentException iae) {
throw new JsonMappingException(
"Failed to narrow key type "
+ type
+ " with key-type annotation ("
+ keyClass.getName()
+ "): "
+ iae.getMessage(),
null,
iae);
}
}
JavaType keyType = type.getKeyType();
/* 21-Mar-2011, tatu: ... and associated deserializer too (unless already assigned)
* (not 100% why or how, but this does seem to get called more than once, which
* is not good: for now, let's just avoid errors)
*/
if (keyType != null && keyType.getValueHandler() == null) {
Object kdDef = intr.findKeyDeserializer(a);
if (kdDef != null) {
KeyDeserializer kd = ctxt.keyDeserializerInstance(a, kdDef);
if (kd != null) {
type = ((MapLikeType) type).withKeyValueHandler(kd);
keyType = type.getKeyType(); // just in case it's used below
}
}
}
// and finally content class; only applicable to structured types
Class<?> cc = intr.findDeserializationContentType(a, type.getContentType());
if (cc != null) {
try {
type = type.narrowContentsBy(cc);
} catch (IllegalArgumentException iae) {
throw new JsonMappingException(
"Failed to narrow content type "
+ type
+ " with content-type annotation ("
+ cc.getName()
+ "): "
+ iae.getMessage(),
null,
iae);
}
}
// ... as well as deserializer for contents:
JavaType contentType = type.getContentType();
if (contentType.getValueHandler()
== null) { // as with above, avoid resetting (which would trigger exception)
Object cdDef = intr.findContentDeserializer(a);
if (cdDef != null) {
JsonDeserializer<?> cd = null;
if (cdDef instanceof JsonDeserializer<?>) {
cdDef = (JsonDeserializer<?>) cdDef;
} else {
Class<?> cdClass =
_verifyAsClass(cdDef, "findContentDeserializer", JsonDeserializer.None.class);
if (cdClass != null) {
cd = ctxt.deserializerInstance(a, cdClass);
}
}
if (cd != null) {
type = type.withContentValueHandler(cd);
}
}
}
}
return type;
}
