/** * Convenience method that may be used by composite or container deserializers, * for reading one-off values for the composite type, taking into account * annotations that the property (passed to this method -- usually property that * has custom serializer that called this method) has. * * @since 2.4 */ public <T> T readPropertyValue(JsonParser p, BeanProperty prop, Class<T> type) throws IOException { return readPropertyValue(p, prop, getTypeFactory().constructType(type)); }
/** * Helper method that is to be used when resolving basic class name into * Class instance, the reason being that it may be necessary to work around * various ClassLoader limitations, as well as to handle primitive type * signatures. * * @since 2.6 */ public Class<?> findClass(String className) throws ClassNotFoundException { // By default, delegate to ClassUtil: can be overridden with custom handling return getTypeFactory().findClass(className); }
/** * Convenience method that may be used by composite or container deserializers, * for reading one-off values contained (for sequences, it is more efficient * to actually fetch deserializer once for the whole collection). *<p> * NOTE: when deserializing values of properties contained in composite types, * rather use {@link #readPropertyValue(JsonParser, BeanProperty, Class)}; * this method does not allow use of contextual annotations. * * @since 2.4 */ public <T> T readValue(JsonParser p, Class<T> type) throws IOException { return readValue(p, getTypeFactory().constructType(type)); }
return ctxt.getTypeFactory().constructFromCanonical(value); case STD_CURRENCY:
/** * Helper method that will check whether given annotated entity (usually class, * but may also be a property accessor) indicates that a {@link Converter} is to * be used; and if so, to construct and return suitable serializer for it. * If not, will simply return given serializer as is. */ protected JsonDeserializer<Object> findConvertingDeserializer(DeserializationContext ctxt, Annotated a, JsonDeserializer<Object> deser) throws JsonMappingException { Converter<Object,Object> conv = findConverter(ctxt, a); if (conv == null) { return deser; } JavaType delegateType = conv.getInputType(ctxt.getTypeFactory()); return (JsonDeserializer<Object>) new StdDelegatingDeserializer<Object>(conv, delegateType, deser); }
@SuppressWarnings("unchecked") @Override public MetaData deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JsonDeserializer<Object> deserializer = ctxt.findRootValueDeserializer( ctxt.getTypeFactory().constructMapType(Map.class, String.class, Object.class)); return MetaData.from((Map) deserializer.deserialize(jp, ctxt, new HashMap<>())); } }
@Override public CloseableIterable<?> deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException { final JavaType typeReference = ctxt.getTypeFactory() .constructCollectionType(List.class, valueType); return new WrappedCloseableIterable<>(ctxt.<Iterable<?>>readValue(jp, typeReference)); }
@Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { // First: if already got deserializer to delegate to, contextualize it: if (_delegateDeserializer != null) { JsonDeserializer<?> deser = ctxt.handleSecondaryContextualization(_delegateDeserializer, property, _delegateType); if (deser != _delegateDeserializer) { return withDelegate(_converter, _delegateType, deser); } return this; } // Otherwise: figure out what is the fully generic delegate type, then find deserializer JavaType delegateType = _converter.getInputType(ctxt.getTypeFactory()); return withDelegate(_converter, delegateType, ctxt.findContextualValueDeserializer(delegateType, property)); }
type = ctxt.getTypeFactory().constructSpecializedType(_baseType, type.getRawClass());
/** * Helper method that can be used to see if specified property is annotated * to indicate use of a converter for property value (in case of container types, * it is container type itself, not key or content type). *<p> * NOTE: returned deserializer is NOT yet contextualized, caller needs to take * care to do that. * * @since 2.2 */ protected JsonDeserializer<Object> findConvertingDeserializer(DeserializationContext ctxt, SettableBeanProperty prop) throws JsonMappingException { final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector(); if (intr != null) { Object convDef = intr.findDeserializationConverter(prop.getMember()); if (convDef != null) { Converter<Object,Object> conv = ctxt.converterInstance(prop.getMember(), convDef); JavaType delegateType = conv.getInputType(ctxt.getTypeFactory()); // 25-Mar-2017, tatu: should not yet contextualize // JsonDeserializer<?> deser = ctxt.findContextualValueDeserializer(delegateType, prop); JsonDeserializer<?> deser = ctxt.findNonContextualValueDeserializer(delegateType); return new StdDelegatingDeserializer<Object>(conv, delegateType, deser); } } return null; }
if (convDef != null) { Converter<Object,Object> conv = ctxt.converterInstance(prop.getMember(), convDef); JavaType delegateType = conv.getInputType(ctxt.getTypeFactory()); if (existingDeserializer == null) { existingDeserializer = ctxt.findContextualValueDeserializer(delegateType, prop);
} else { JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idProp = null; gen = ctxt.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo);
} else { // other types are to be simpler JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idProp = null; idGen = ctxt.objectIdGeneratorInstance(accessor, objectIdInfo);
resolver = ctxt.objectIdResolverInstance(accessor, objectIdInfo); JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idGen = ctxt.objectIdGeneratorInstance(accessor, objectIdInfo);
TypeFactory tf = ctxt.getTypeFactory(); JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE); JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0];
TypeFactory tf = ctxt.getTypeFactory();
JavaType delegateType = conv.getInputType(ctxt.getTypeFactory());
@Override public Resource<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JavaType rootType = JacksonHelper.findRootType(this.contentType); JavaType wrappedType = ctxt.getTypeFactory().constructParametricType(CollectionJsonDocument.class, rootType); CollectionJsonDocument<?> document = jp.getCodec().readValue(jp, wrappedType); List<? extends CollectionJsonItem<?>> items = Optional.ofNullable(document.getCollection().getItems()).orElse(new ArrayList<>()); List<Link> links = Optional.ofNullable(document.getCollection().getLinks()).orElse(new ArrayList<>()); if (items.size() == 0 && document.getCollection().getTemplate() != null) { Map<String, Object> properties = document.getCollection().getTemplate().getData().stream() .collect(Collectors.toMap(CollectionJsonData::getName, CollectionJsonData::getValue)); Object obj = PropertyUtils.createObjectFromProperties(rootType.getRawClass(), properties); return new Resource<>(obj, potentiallyAddSelfLink(links, document.getCollection().getHref())); } else { items.stream() .flatMap(item -> Optional.ofNullable(item.getLinks()) .map(Collection::stream) .orElse(Stream.empty())) .forEach(link -> { if (!links.contains(link)) links.add(link); }); return new Resource<>(items.get(0).toRawData(rootType), potentiallyAddSelfLink(links, items.get(0).getHref())); } }
@Override public PagedResources deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JavaType rootType = JacksonHelper.findRootType(this.contentType); JavaType wrappedType = ctxt.getTypeFactory().constructParametricType(CollectionJsonDocument.class, rootType); CollectionJsonDocument<?> document = jp.getCodec().readValue(jp, wrappedType); List<Object> items = new ArrayList<>(); document.getCollection().getItems().forEach(item -> { Object data = item.toRawData(rootType); List<Link> links = item.getLinks() == null ? Collections.EMPTY_LIST : item.getLinks(); if (this.contentType.hasGenericTypes()) { if (this.contentType.containedType(0).hasRawClass(Resource.class)) { items.add(new Resource<>(data, potentiallyAddSelfLink(links, item.getHref()))); } else { items.add(data); } } }); PagedResources.PageMetadata pageMetadata = null; return new PagedResources(items, pageMetadata, potentiallyAddSelfLink(document.getCollection().getLinks(), document.getCollection().getHref())); }
@Override public Resources deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JavaType rootType = JacksonHelper.findRootType(this.contentType); JavaType wrappedType = ctxt.getTypeFactory().constructParametricType(CollectionJsonDocument.class, rootType); CollectionJsonDocument<?> document = jp.getCodec().readValue(jp, wrappedType); List<Object> contentList = new ArrayList<>(); if (document.getCollection().getItems() != null) { for (CollectionJsonItem<?> item : document.getCollection().getItems()) { Object data = item.toRawData(rootType); if (this.contentType.hasGenericTypes()) { if (isResource(this.contentType)) { contentList.add(new Resource<>(data, potentiallyAddSelfLink(item.getLinks(), item.getHref()))); } else { contentList.add(data); } } } } return new Resources(contentList, potentiallyAddSelfLink(document.getCollection().getLinks(), document.getCollection().getHref())); }