Example usage for com.fasterxml.jackson.databind JsonDeserializer deserialize

List of usage examples for com.fasterxml.jackson.databind JsonDeserializer deserialize

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.databind.*
  5. JsonDeserializer
  6. deserialize

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind JsonDeserializer deserialize.

Prototype

public abstract T deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext);

Source Link

Usage

From source file:com.addthis.codec.jackson.CodecTypeDeserializer.java

@Override
public Object deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt) throws IOException {
    // a jackson thing we might as well include
    if (jp.canReadTypeId()) {
        Object typeId = jp.getTypeId();
        if (typeId != null) {
            return _deserializeWithNativeTypeId(jp, ctxt, typeId);
        }// w  w  w .  ja v a2 s  .co m
    }
    // can use this to approximate error location if a sub-method throws an exception
    JsonLocation currentLocation = jp.getTokenLocation();
    JsonNode jsonNode;
    // empty objects can appear with END_OBJECT. that has special handling lots of places, but not in readTree
    if (jp.getCurrentToken() == JsonToken.END_OBJECT) {
        jsonNode = ctxt.getNodeFactory().objectNode();
    } else {
        jsonNode = jp.readValueAsTree();
    }
    ObjectCodec objectCodec = jp.getCodec();

    try {
        Object bean = null;
        // _array handler
        if (jsonNode.isArray()) {
            bean = _deserializeTypedFromArray((ArrayNode) jsonNode, objectCodec, ctxt);
            // object handler
        } else if (jsonNode.isObject()) {
            bean = _deserializeTypedFromObject((ObjectNode) jsonNode, objectCodec, ctxt);
        }
        if (bean != null) {
            return bean;
        } else {
            // Jackson 2.6+ throws NPE on null typeId parameter (underlying Map changed from HashMap
            // to ConcurrentHashMap), so use empty string instead of null
            JsonDeserializer<Object> deser = _findDeserializer(ctxt, "");
            JsonParser treeParser = jp.getCodec().treeAsTokens(jsonNode);
            treeParser.nextToken();
            return deser.deserialize(treeParser, ctxt);
        }
    } catch (JsonMappingException ex) {
        throw Jackson.maybeImproveLocation(currentLocation, ex);
    }
}

From source file:com.addthis.codec.jackson.CodecTypeDeserializer.java

@Nullable
private Object _deserializeObjectFromInlinedType(ObjectNode objectNode, ObjectCodec objectCodec,
        DeserializationContext ctxt) throws IOException {
    String matched = null;//from  w  ww . ja  va 2s . c  o  m
    for (String alias : pluginMap.inlinedAliases()) {
        if (objectNode.get(alias) != null) {
            if (matched != null) {
                String message = String.format(
                        "no type specified, more than one key, and both %s and %s match for inlined types.",
                        matched, alias);
                JsonMappingException exception = ctxt.instantiationException(_baseType.getRawClass(), message);
                exception.prependPath(_baseType, matched);
                throw exception;
            }
            matched = alias;
        }
    }
    if (matched != null) {
        ConfigObject aliasDefaults = pluginMap.aliasDefaults(matched);
        JsonNode configValue = objectNode.get(matched);
        String primaryField = (String) aliasDefaults.get("_primary").unwrapped();
        objectNode.remove(matched);
        Jackson.setAt(objectNode, configValue, primaryField);
        Jackson.merge(objectNode, Jackson.configConverter(aliasDefaults));
        if (_typeIdVisible) {
            objectNode.put(_typePropertyName, matched);
        }
        try {
            JsonDeserializer<Object> deser = _findDeserializer(ctxt, matched);
            JsonParser treeParser = objectCodec.treeAsTokens(objectNode);
            treeParser.nextToken();
            return deser.deserialize(treeParser, ctxt);
        } catch (IOException cause) {
            IOException unwrapped = Jackson.maybeUnwrapPath(primaryField, cause);
            if (unwrapped != cause) {
                throw wrapWithPath(unwrapped, idRes.typeFromId(ctxt, matched), matched);
            } else {
                throw unwrapped;
            }
        }
    } else {
        return null;
    }
}

From source file:com.addthis.codec.jackson.CodecTypeDeserializer.java

@Nullable
public Object _deserializeTypedFromObject(ObjectNode objectNode, ObjectCodec objectCodec,
        DeserializationContext ctxt) throws IOException {
    if (objectNode.hasNonNull(_typePropertyName)) {
        return _deserializeObjectFromProperty(objectNode, objectCodec, ctxt);
    }/*w w w  . jav  a  2s .  com*/
    String singleKeyName = getSingleKeyIfPresent(objectNode);
    if (singleKeyName != null) {
        Object bean = _deserializeObjectFromSingleKey(objectNode, singleKeyName, objectCodec, ctxt);
        if (bean != null) {
            return bean;
        }
    }
    Object bean = _deserializeObjectFromInlinedType(objectNode, objectCodec, ctxt);
    if (bean != null) {
        return bean;
    }
    if (idRes.isValidTypeId("_default")) {
        ConfigObject aliasDefaults = pluginMap.aliasDefaults("_default");
        JsonDeserializer<Object> deser = _findDeserializer(ctxt, "_default");
        boolean unwrapPrimary = handleDefaultsAndImplicitPrimary(objectNode, aliasDefaults, deser, ctxt);
        try {
            JsonParser treeParser = objectCodec.treeAsTokens(objectNode);
            treeParser.nextToken();
            bean = deser.deserialize(treeParser, ctxt);
        } catch (IOException cause) {
            if (unwrapPrimary) {
                throw Jackson.maybeUnwrapPath((String) aliasDefaults.get("_primary").unwrapped(), cause);
            } else {
                throw cause;
            }
        }
    }
    return bean;
}

From source file:com.meltmedia.jackson.crypto.EncryptionService.java

public Object decrypt(JsonParser parser, JsonDeserializer<?> deser, DeserializationContext context,
        JavaType type) {//w  w w  .j av  a  2 s . c  o m
    try {
        if (deser == null) {
            // TODO: This service allows for extension of EncryptedJson, but does
            // not include
            // a class defining the subtype being used.
            return mapper.readValue(decrypt((E) mapper.readValue(parser, EncryptedJson.class)), type);
        } else {
            return deser.deserialize(mapper.getFactory()
                    .createParser(decrypt((E) mapper.readValue(parser, EncryptedJson.class))), context);
        }
    } catch (EncryptionException ee) {
        throw ee;
    } catch (Exception e) {
        throw new EncryptionException("could not decyrpt value", e);
    }

}

From source file:com.basistech.rosette.dm.jackson.MorphoAnalysisListDeserializer.java

@Override
public List<MorphoAnalysis> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {

    if (!cached) {
        throw new JsonMappingException(jp,
                "attempt to deserialize with un-contextualized MorphoAnalysisListDeserializer");
    }/*w ww .j  ava 2s .c om*/

    /*
     * This will be entered pointing to the array start.
     */
    if (jp.getCurrentToken() != JsonToken.START_ARRAY) {
        throw ctxt.wrongTokenException(jp, JsonToken.START_ARRAY, "Expected array of items");
    }

    JsonDeserializer<Object> currentDeserializer = castDeserializer(
            ctxt.getAttribute(MorphoAnalysisListDeserializer.class));
    if (currentDeserializer == null) {
        currentDeserializer = maDeserializer;
        ctxt.setAttribute(MorphoAnalysisListDeserializer.class, maDeserializer);
    }

    List<MorphoAnalysis> result = Lists.newArrayList();
    while (jp.nextToken() != JsonToken.END_ARRAY) {
        // if we just read it in as the wrong class, any leftovers will end up in extendedAttributes, and we can cope.

        MorphoAnalysis analysis = (MorphoAnalysis) currentDeserializer.deserialize(jp, ctxt);
        if (analysis.getExtendedProperties().size() != 0) {
            // so, we have leftovers. Note that this will not trim han and arabic down. Tough

            if (analysis.getExtendedProperties().containsKey("morphemes")) {
                KoreanMorphoAnalysis.Builder builder = new KoreanMorphoAnalysis.Builder();
                copyBasic(analysis, builder);

                List<String> morphemes = cast(analysis.getExtendedProperties().get("morphemes"));
                List<String> morphemeTags = cast(analysis.getExtendedProperties().get("morphemeTags"));
                for (int x = 0; x < morphemes.size(); x++) {
                    builder.addMorpheme(morphemes.get(x), morphemeTags.get(x));
                }

                for (Map.Entry<String, Object> me : analysis.getExtendedProperties().entrySet()) {
                    if (!"morphemes".equals(me.getKey()) && !"morphemeTags".equals(me.getKey())) {
                        builder.extendedProperty(me.getKey(), me.getValue());
                    }
                }

                analysis = builder.build();
                ctxt.setAttribute(MorphoAnalysisListDeserializer.class, korMaDeserializer);

            } else if (analysis.getExtendedProperties().containsKey("readings")) {
                // convert to Han.
                HanMorphoAnalysis.Builder builder = new HanMorphoAnalysis.Builder();
                copyBasic(analysis, builder);

                for (String reading : cast(analysis.getExtendedProperties().get("readings"))) {
                    builder.addReading(reading);
                }

                for (Map.Entry<String, Object> me : analysis.getExtendedProperties().entrySet()) {
                    if (!"readings".equals(me.getKey())) {
                        builder.extendedProperty(me.getKey(), me.getValue());
                    }
                }

                analysis = builder.build();
                ctxt.setAttribute(MorphoAnalysisListDeserializer.class, hanMaDeserializer);
            } else if (anyArabicFields(analysis.getExtendedProperties().keySet())) {
                ArabicMorphoAnalysis.Builder builder = new ArabicMorphoAnalysis.Builder();
                copyBasic(analysis, builder);

                Integer prefixLength = (Integer) analysis.getExtendedProperties().get("prefixLength");
                Integer stemLength = (Integer) analysis.getExtendedProperties().get("stemLength");
                if (prefixLength != null && stemLength != null) {
                    builder.lengths(prefixLength, stemLength);
                }
                String root = (String) analysis.getExtendedProperties().get("root");
                if (root != null) {
                    builder.root(root);
                }
                Boolean definiteArticle = (Boolean) analysis.getExtendedProperties().get("definiteArticle");
                if (definiteArticle != null) {
                    builder.definiteArticle(definiteArticle);
                }
                Boolean strippablePrefix = (Boolean) analysis.getExtendedProperties().get("strippablePrefix");
                if (strippablePrefix != null) {
                    builder.strippablePrefix(strippablePrefix);
                }

                List<String> prefixes = cast(analysis.getExtendedProperties().get("prefixes"));
                if (prefixes != null) {
                    List<String> prefixTags = cast(analysis.getExtendedProperties().get("prefixTags"));
                    for (int x = 0; x < prefixes.size(); x++) {
                        builder.addPrefix(prefixes.get(x), prefixTags.get(x));
                    }
                }

                List<String> stems = cast(analysis.getExtendedProperties().get("stems"));
                if (stems != null) {
                    List<String> stemTags = cast(analysis.getExtendedProperties().get("stemTags"));
                    for (int x = 0; x < stems.size(); x++) {
                        builder.addStem(stems.get(x), stemTags.get(x));
                    }
                }

                List<String> suffixes = cast(analysis.getExtendedProperties().get("suffixes"));
                if (suffixes != null) {
                    List<String> suffixTags = cast(analysis.getExtendedProperties().get("suffixTags"));
                    for (int x = 0; x < suffixes.size(); x++) {
                        builder.addSuffix(suffixes.get(x), suffixTags.get(x));
                    }
                }

                for (Map.Entry<String, Object> me : analysis.getExtendedProperties().entrySet()) {
                    if (!ARABIC_FIELDS.contains(me.getKey())) {
                        builder.extendedProperty(me.getKey(), me.getValue());
                    }
                }

                analysis = builder.build();
                ctxt.setAttribute(MorphoAnalysisListDeserializer.class, arMaDeserializer);
            }
        }
        result.add(analysis);
    }
    return ImmutableList.copyOf(result);
}

From source file:com.addthis.codec.jackson.CodecTypeDeserializer.java

private Object _deserializeObjectFromProperty(ObjectNode objectNode, ObjectCodec objectCodec,
        DeserializationContext ctxt) throws IOException {
    String type = objectNode.get(_typePropertyName).asText();
    if (!_typeIdVisible) {
        objectNode.remove(_typePropertyName);
    }/*from www  . ja  v  a  2s. co  m*/
    JsonDeserializer<Object> deser;
    try {
        deser = _findDeserializer(ctxt, type);
    } catch (Throwable cause) {
        throw wrapWithPath(cause, Class.class, _typePropertyName);
    }
    ConfigObject aliasDefaults = pluginMap.aliasDefaults(type);
    String primaryField;
    if (aliasDefaults.containsKey("_primary")) {
        primaryField = (String) aliasDefaults.get("_primary").unwrapped();
    } else {
        primaryField = null;
    }
    boolean unwrapPrimary = handleDefaultsAndImplicitPrimary(objectNode, aliasDefaults, deser, ctxt);
    try {
        JsonParser treeParser = objectCodec.treeAsTokens(objectNode);
        treeParser.nextToken();
        return deser.deserialize(treeParser, ctxt);
    } catch (IOException cause) {
        if (unwrapPrimary) {
            throw Jackson.maybeUnwrapPath(primaryField, cause);
        } else {
            throw cause;
        }
    }
}

From source file:com.kaaprotech.satu.jackson.SatuDeserializers.java

@Override
public JsonDeserializer<?> findCollectionDeserializer(final CollectionType type,
        final DeserializationConfig config, final BeanDescription beanDesc,
        final TypeDeserializer elementTypeDeserializer, final JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {

    if (ImmutableSet.class.isAssignableFrom(type.getRawClass())) {
        return new StdDeserializer<Object>(type) {
            private static final long serialVersionUID = 1L;

            @Override/*from   w  w w  .  ja v  a  2  s .  c  o  m*/
            public Object deserialize(JsonParser jp, DeserializationContext context) throws IOException {

                if (jp.isExpectedStartArrayToken()) {
                    JsonToken t;

                    MutableSet<Object> s = Sets.mutable.of();

                    while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
                        Object value;
                        if (t == JsonToken.VALUE_NULL) {
                            value = null;
                        } else if (elementDeserializer == null) {
                            value = jp.readValueAs(type.getContentType().getRawClass());
                        } else if (elementTypeDeserializer == null) {
                            value = elementDeserializer.deserialize(jp, context);
                        } else {
                            value = elementDeserializer.deserializeWithType(jp, context,
                                    elementTypeDeserializer);
                        }
                        s.add(value);
                    }
                    return s.toImmutable();
                }
                throw context.mappingException(type.getRawClass());
            }
        };
    }

    return super.findCollectionDeserializer(type, config, beanDesc, elementTypeDeserializer,
            elementDeserializer);
}

From source file:com.addthis.codec.jackson.CodecTypeDeserializer.java

@Nullable
private Object _deserializeObjectFromSingleKey(ObjectNode objectNode, String singleKeyName,
        ObjectCodec objectCodec, DeserializationContext ctxt) throws IOException {
    if (idRes.isValidTypeId(singleKeyName)) {
        ConfigObject aliasDefaults = pluginMap.aliasDefaults(singleKeyName);
        String primaryField;/*from   w  ww. j  av  a  2  s .  c om*/
        if (aliasDefaults.containsKey("_primary")) {
            primaryField = (String) aliasDefaults.get("_primary").unwrapped();
        } else {
            primaryField = null;
        }
        boolean unwrapPrimary = false;
        try {
            JsonNode singleKeyValue = objectNode.get(singleKeyName);
            JsonDeserializer<Object> deser = _findDeserializer(ctxt, singleKeyName);
            if (!singleKeyValue.isObject()) {
                // if value is not an object, try supporting _primary syntax to derive one
                if (primaryField != null) {
                    ObjectNode singleKeyObject = (ObjectNode) objectCodec.createObjectNode();
                    Jackson.setAt(singleKeyObject, singleKeyValue, primaryField);
                    Jackson.merge(singleKeyObject, Jackson.configConverter(aliasDefaults));
                    singleKeyValue = singleKeyObject;
                    unwrapPrimary = true;
                } // else let the downstream serializer try to handle it or complain
            } else {
                ObjectNode singleKeyObject = (ObjectNode) singleKeyValue;
                unwrapPrimary = handleDefaultsAndImplicitPrimary(singleKeyObject, aliasDefaults, deser, ctxt);
            }
            if (_typeIdVisible && singleKeyValue.isObject()) {
                ((ObjectNode) singleKeyValue).put(_typePropertyName, singleKeyName);
            }
            JsonParser treeParser = objectCodec.treeAsTokens(singleKeyValue);
            treeParser.nextToken();
            return deser.deserialize(treeParser, ctxt);
        } catch (IOException cause) {
            if (unwrapPrimary) {
                cause = Jackson.maybeUnwrapPath(primaryField, cause);
            }
            throw wrapWithPath(cause, idRes.typeFromId(ctxt, singleKeyName), singleKeyName);
        } catch (Throwable cause) {
            throw wrapWithPath(cause, idRes.typeFromId(ctxt, singleKeyName), singleKeyName);
        }
    }
    return null;
}

From source file:com.kaaprotech.satu.jackson.SatuDeserializers.java

@Override
public JsonDeserializer<?> findMapDeserializer(final MapType type, final DeserializationConfig config,
        BeanDescription beanDesc, final KeyDeserializer keyDeserializer,
        final TypeDeserializer elementTypeDeserializer, final JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {

    if (ImmutableMap.class.isAssignableFrom(type.getRawClass())) {
        return new StdDeserializer<Object>(type) {
            private static final long serialVersionUID = 1L;

            @Override//from ww w. j ava  2s.com
            public Object deserialize(JsonParser jp, DeserializationContext context) throws IOException {

                JsonToken t = jp.getCurrentToken();
                if (t == JsonToken.START_OBJECT) {
                    t = jp.nextToken();
                }
                if (t != JsonToken.FIELD_NAME && t != JsonToken.END_OBJECT) {
                    throw context.mappingException(type.getRawClass());
                }

                MutableMap<Object, Object> m = Maps.mutable.of();

                for (; jp.getCurrentToken() == JsonToken.FIELD_NAME; jp.nextToken()) {
                    // Pointing to field name
                    String fieldName = jp.getCurrentName();
                    Object key = (keyDeserializer == null) ? fieldName
                            : keyDeserializer.deserializeKey(fieldName, context);
                    t = jp.nextToken();

                    Object value;
                    if (t == JsonToken.VALUE_NULL) {
                        value = null;
                    } else if (elementDeserializer == null) {
                        value = jp.readValueAs(type.getContentType().getRawClass());
                    } else if (elementTypeDeserializer == null) {
                        value = elementDeserializer.deserialize(jp, context);
                    } else {
                        value = elementDeserializer.deserializeWithType(jp, context, elementTypeDeserializer);
                    }
                    m.put(key, value);
                }
                return m.toImmutable();
            }
        };
    }

    return super.findMapDeserializer(type, config, beanDesc, keyDeserializer, elementTypeDeserializer,
            elementDeserializer);
}