private static void initClient() { JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider(); ObjectMapper objectMapper = JSONUtil.prettyMapper(); objectMapper.registerModule( new SimpleModule() .addDeserializer(JobDataFragment.class, new JsonDeserializer<JobDataFragment>() { @Override public JobDataFragment deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return jsonParser.readValueAs(DataPOJO.class); } } ) ); provider.setMapper(objectMapper); client = ClientBuilder.newBuilder().register(provider).register(MultiPartFeature.class).build(); WebTarget rootTarget = client.target("http://localhost:" + currentDremioDaemon.getWebServer().getPort()); currentApiV2 = rootTarget.path(API_LOCATION); }
/** * Create a DeserializationProblemHandler that may be added to an * ObjectMapper, and will handle unknown properties by forwarding * the error information to the given consumer, if it is not * <code>null</code> * * @param jsonErrorConsumer The consumer for {@link JsonError}s * @return The problem handler */ private static DeserializationProblemHandler createDeserializationProblemHandler( Consumer<? super JsonError> jsonErrorConsumer) { return new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty( DeserializationContext ctxt, JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException, JsonProcessingException { if (jsonErrorConsumer != null) { jsonErrorConsumer.accept(new JsonError( "Unknown property: " + propertyName, jp.getParsingContext(), null)); } return super.handleUnknownProperty( ctxt, jp, deserializer, beanOrClass, propertyName); } }; }
@SuppressWarnings("unchecked") @Test public void testDeserialize() { boolean status = false; try { DeserializationContext ctxt = Mockito.mock(DeserializationContext.class); @SuppressWarnings("rawtypes") JsonDeserializer JsonDeserializer = Mockito.mock(JsonDeserializer.class); Object object = null; Mockito.when(jsonParser.nextFieldName()).thenReturn("abc", (String) null); Mockito.when(readerHelpData.getDeser()).thenReturn(JsonDeserializer); Mockito.when(JsonDeserializer.deserialize(jsonParser, ctxt)).thenReturn(object); Object deserializeObject = abstractDeserializer.deserialize(jsonParser, ctxt); Assert.assertNotNull(deserializeObject); } catch (Exception e) { status = true; } Assert.assertFalse(status); }
private static <T1, T2> SimpleModule newWrappingModule(final Class<T1> wrapped, final Class<T2> wrapper, final Converter<T1, T2> converter) { SimpleModule module = new SimpleModule(); module.addDeserializer(wrapper, new JsonDeserializer<T2>() { @Override public T2 deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { return converter.convert(ctxt.readValue(p, wrapped)); } }); module.addSerializer(wrapper, new JsonSerializer<T2>() { @Override public void serialize(T2 value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException { serializers.defaultSerializeValue(converter.revert(value), gen); } }); return module; }
private static void initMasterClient() { JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider(); ObjectMapper objectMapper = JSONUtil.prettyMapper(); objectMapper.registerModule( new SimpleModule() .addDeserializer(JobDataFragment.class, new JsonDeserializer<JobDataFragment>() { @Override public JobDataFragment deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return jsonParser.readValueAs(DataPOJO.class); } } ) ); provider.setMapper(objectMapper); masterClient = ClientBuilder.newBuilder().register(provider).register(MultiPartFeature.class).build(); WebTarget rootTarget = masterClient.target("http://localhost:" + masterDremioDaemon.getWebServer().getPort()); masterApiV2 = rootTarget.path(API_LOCATION); }
private static ObjectMapper configureObjectMapper( ObjectMapper objectMapper, boolean shouldIncludeRawResponses) { if (shouldIncludeRawResponses) { SimpleModule module = new SimpleModule(); module.setDeserializerModifier(new BeanDeserializerModifier() { @Override public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { if (Response.class.isAssignableFrom(beanDesc.getBeanClass())) { return new RawResponseDeserializer(deserializer); } return deserializer; } }); objectMapper.registerModule(module); } objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); return objectMapper; }
@Override public void setupModule(final SetupContext context) { super.setupModule(context); context.addBeanDeserializerModifier(new BeanDeserializerModifier() { @Override public JsonDeserializer<?> modifyCollectionDeserializer(final DeserializationConfig config, final CollectionType type, final BeanDescription beanDesc, final JsonDeserializer<?> deserializer) { if (deserializer instanceof CollectionDeserializer) { return new ListDeserializer((CollectionDeserializer) deserializer); } else { return super.modifyCollectionDeserializer(config, type, beanDesc, deserializer); } } }); }
@Override public JsonDeserializer<?> modifyMapDeserializer( DeserializationConfig config, MapType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { // statements if (isMapOfStringAndListOfStatements(type)) { return new ModifiedMapDeserializer<String, List<JacksonStatement>>(deserializer); } // labels and descriptions else if (isMapOfStringAndMonolingualTextValue(type)) { return new ModifiedMapDeserializer<String, JacksonMonolingualTextValue>(deserializer); } // sitelinks else if (isMapOfStringAndSitelink(type)) { return new ModifiedMapDeserializer<String, JacksonSiteLink>(deserializer); } // aliases and miscallaneous that does not need this workaround else { return deserializer; } }
@Bean public ObjectMapper objectMapper() { ObjectMapper mapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.setDeserializerModifier( new BeanDeserializerModifier() { @Override public JsonDeserializer<Enum> modifyEnumDeserializer( DeserializationConfig config, final JavaType type, BeanDescription beanDesc, final JsonDeserializer<?> deserializer ) { return new JsonDeserializer<Enum>() { @Override public Enum deserialize( JsonParser jp, DeserializationContext ctxt ) throws IOException { Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass(); return Enum.valueOf( rawClass, jp.getValueAsString().toUpperCase() ); } }; } } ); module.addDeserializer( Expression.class, new ExpressionDeserializer( expressionParser() ) ); module.addDeserializer( Range.class, new RangeDeserializer() ); mapper.registerModule( module ); return mapper; }
private void addJsonBean(Object bean) { if (bean instanceof JsonSerializer) { addSerializerWithDeducedType((JsonSerializer<?>) bean); } if (bean instanceof JsonDeserializer) { addDeserializerWithDeducedType((JsonDeserializer<?>) bean); } for (Class<?> innerClass : bean.getClass().getDeclaredClasses()) { if (JsonSerializer.class.isAssignableFrom(innerClass) || JsonDeserializer.class.isAssignableFrom(innerClass)) { try { addJsonBean(innerClass.newInstance()); } catch (Exception ex) { throw new IllegalStateException(ex); } } } }
private static <TFrom, TTo> JsonDeserializer<TFrom> getJsonDeserializer( @Nullable final Transformer<TFrom, TTo> serializer) { if (serializer == null) { return null; } final TypeReference<TTo> serializedType = typeReferenceOf(serializer); if (serializer instanceof ResourceTransformer) { @SuppressWarnings("unchecked") final ResourceTransformer<TFrom> resourceSerializer = (ResourceTransformer<TFrom>) serializer; return new ResourceDeserializer<>(resourceSerializer); } else { return new JsonDeserializer<TFrom>() { @Override public TFrom deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { TTo deserialized = jp.readValueAs(serializedType); return serializer.transformFrom(deserialized); } }; } }
public static ObjectMapper newInstance() { ObjectMapper mapper = new ObjectMapper(); //mapper.setSerializationInclusion(Inclusion.ALWAYS); //mapper.configure(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES, false); //mapper.getSerializerProvider().setNullValueSerializer(new NullValueSerializer()); /*Json反序列化时忽略多余的属性*/ mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); SimpleModule module = new SimpleModule("JsonUtil", new Version(1, 0, 0, null)); //JavaObject to JSONString module.addSerializer(new ToJsonLongSerializer()); module.addSerializer(new ToJsonSqlTimestampSerializer(DEFAULT_DATETIME_PATTERN)); module.addSerializer(new ToJsonDateSerializer(DEFAULT_DATETIME_PATTERN)); module.addSerializer(new ToJsonStringSerializer()); //JSONString to JavaObject module.addDeserializer(Date.class, new CustomDateDeSerializer(Date.class,DEFAULT_FORMATS)); module.addDeserializer(Timestamp.class, (JsonDeserializer)new CustomSqlTimestampDeSerializer(Timestamp.class,DEFAULT_FORMATS)); module.addDeserializer(java.sql.Date.class,(JsonDeserializer)new CustomSqlDateDeSerializer(java.sql.Date.class, DEFAULT_FORMATS)); mapper.registerModule(module); return mapper; }
@SuppressWarnings("rawtypes") private static Matcher<JsonDeserializer> anInlineAssociationDeserializerMatching( final Matcher<RestOperations> restOperations, final ClientProxyFactory proxyFactory) { return new TypeSafeMatcher<JsonDeserializer>() { @Override public boolean matchesSafely(JsonDeserializer item) { if (!(item instanceof InlineAssociationDeserializer)) { return false; } InlineAssociationDeserializer other = (InlineAssociationDeserializer) item; return restOperations.matches(other.getRestOperations()) && proxyFactory == other.getProxyFactory(); } @Override public void describeTo(Description description) { description.appendText("instanceof ").appendValue(InlineAssociationDeserializer.class) .appendText(", restOperations ").appendValue(restOperations) .appendText(", proxyFactory ").appendValue(proxyFactory); } }; }
@Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { JsonFormat.Value format = findFormatOverrides(ctxt, property, handledType()); if (format != null) { if (format.hasPattern()) { final String pattern = format.getPattern(); final Locale locale = format.hasLocale() ? format.getLocale() : ctxt.getLocale(); DateTimeFormatter df; if (locale == null) { df = DateTimeFormatter.ofPattern(pattern); } else { df = DateTimeFormatter.ofPattern(pattern, locale); } //Issue #69: For instant serializers/deserializers we need to configure the formatter with //a time zone picked up from JsonFormat annotation, otherwise serialization might not work if (format.hasTimeZone()) { df = df.withZone(format.getTimeZone().toZoneId()); } return withDateFormat(df); } // any use for TimeZone? } return this; }
@SuppressWarnings("unchecked") @Override public Analyzer<?> deserialize(final JsonParser p, final DeserializationContext ctxt) throws IOException, JsonProcessingException { final JsonDeserializer<?> specDeserializer = ctxt .findNonContextualValueDeserializer(TypeFactory.defaultInstance().uncheckedSimpleType(AnalyzerSpec.class)); final AnalyzerSpec spec = (AnalyzerSpec) specDeserializer.deserialize(p, ctxt); final AnalyzerCreationResult creationResult = spec.getAnalyzerType().tryCreateAnalyzer(spec); if (!creationResult.wasSuccessful()) { throw new IOException( "Could not create analyzer from spec, global result: " + creationResult.getGlobalResult() + ", parameter results: "); } return creationResult.getAnalyzer(); }
/** * Constructor * Adds the provided list of custom serializers to the object mapper returned by this class. * @param jsonObjectSerializers list of custom serializers to be used by the object mapper */ @Autowired public JsonObjectMapper(JsonObjectSerializers jsonObjectSerializers) { SimpleModule entityModule = new SimpleModule("de.oliverwetterau.neo4j.websockets"); entityModule.addSerializer(Result.class, new ResultSerializer()); entityModule.addSerializer(de.oliverwetterau.neo4j.websockets.core.data.Error.class, new ErrorSerializer()); entityModule.addDeserializer(Result.class, new ResultDeserializer()); if (jsonObjectSerializers != null) { for (Map.Entry<Class,JsonSerializer> jsonSerializer : jsonObjectSerializers.getSerializers().entrySet()) { entityModule.addSerializer(jsonSerializer.getKey(), jsonSerializer.getValue()); } for (Map.Entry<Class,JsonDeserializer> jsonDeserializer : jsonObjectSerializers.getDeserializers().entrySet()) { entityModule.addDeserializer(jsonDeserializer.getKey(), jsonDeserializer.getValue()); } } textObjectMapper.registerModule(entityModule); binaryObjectMapper.registerModule(entityModule); }
@Override public boolean handleUnknownProperty(DeserializationContext ctxt, com.fasterxml.jackson.core.JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException { if (beanOrClass instanceof Asset && "inactive".equals(propertyName)) { logger.info("[MIGRATION] inactive asset is deprecated since 1.0.1"); return true; } if (beanOrClass instanceof Property && "bidirectional".equals(propertyName)) { logger.info("[MIGRATION] bidirectional property is deprecated since 1.0.2"); return true; } //By default return false return super.handleUnknownProperty(ctxt, jp, deserializer, beanOrClass, propertyName); }
/** * Method called to finalize setup of this deserializer, * after deserializer itself has been registered. This * is needed to handle recursive and transitive dependencies. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { JsonDeserializer<?> deser = _valueDeserializer; TypeDeserializer typeDeser = _typeDeserializerForValue; if (deser == null) { deser = ctxt.findContextualValueDeserializer(_containerType.getContentType(), property); } if (typeDeser != null) { typeDeser = typeDeser.forProperty(property); } if (deser == _valueDeserializer && typeDeser == _typeDeserializerForValue) { return this; } return withResolved(typeDeser, deser); }
@Override protected T _deserializeFromSingleValue(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonDeserializer<?> valueDes = _valueDeserializer; final TypeDeserializer typeDeser = _typeDeserializerForValue; JsonToken t = jp.getCurrentToken(); Object value; if (t == JsonToken.VALUE_NULL) { value = null; } else if (typeDeser == null) { value = valueDes.deserialize(jp, ctxt); } else { value = valueDes.deserializeWithType(jp, ctxt, typeDeser); } @SuppressWarnings("unchecked") T result = (T) Sequences.sequence(value); return result; }
/** * JAVADOC Method Level Comments * * @throws Exception JAVADOC. */ @SuppressWarnings({"rawtypes", "unchecked"}) @Override public void afterPropertiesSet() throws Exception { //Set up SimpleModule module = new SimpleModule("user", new Version(1, 0, 0, "User serializer/deserializer", null, null)); if (CollectionUtils.isNotEmpty(serialisers)) { for (JsonSerializer<?> serialiser : serialisers) { module.addSerializer(serialiser); } } if (MapUtils.isNotEmpty(deserialisers)) { for (Map.Entry<Class, JsonDeserializer> deserialiserEntry : deserialisers.entrySet()) { module.addDeserializer(deserialiserEntry.getKey(), deserialiserEntry.getValue()); } } mapper.registerModule(module); }
@Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { if (property != null) { JsonFormat.Value format = ctxt.getAnnotationIntrospector().findFormat((Annotated) property.getMember()); if (format != null) { if (format.hasPattern()) { final String pattern = format.getPattern(); final Locale locale = format.hasLocale() ? format.getLocale() : ctxt.getLocale(); DateTimeFormatter df; if (locale == null) { df = DateTimeFormatter.ofPattern(pattern); } else { df = DateTimeFormatter.ofPattern(pattern, locale); } return withDateFormat(df); } // any use for TimeZone? } } return this; }
@Test public void testRoundTrip() { ObjectMapperProvider objectMapperProvider = new ObjectMapperProvider(); objectMapperProvider.setJsonDeserializers(ImmutableMap.<Class<?>, JsonDeserializer<?>>of(Type.class, new TypeDeserializer(new TypeRegistry()))); JsonCodec<Signature> codec = new JsonCodecFactory(objectMapperProvider, true).jsonCodec(Signature.class); Signature expected = new Signature("function", SCALAR, StandardTypes.BIGINT, ImmutableList.of(StandardTypes.BOOLEAN, StandardTypes.DOUBLE, StandardTypes.VARCHAR)); String json = codec.toJson(expected); Signature actual = codec.fromJson(json); assertEquals(actual.getName(), expected.getName()); assertEquals(actual.getKind(), expected.getKind()); assertEquals(actual.getReturnType(), expected.getReturnType()); assertEquals(actual.getArgumentTypes(), expected.getArgumentTypes()); }
@Bean public Module customJacksonModuleToSerializeInstantAsIso8601() { SimpleModule module = new SimpleModule(); module.addDeserializer(Instant.class, new JsonDeserializer<Instant>() { @Override public Instant deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return Instant.from(DateTimeFormatter.ISO_INSTANT.parse(jsonParser.getText())); } }); module.addSerializer(Instant.class, new JsonSerializer<Instant>() { @Override public void serialize(Instant instant, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { jsonGenerator.writeString(DateTimeFormatter.ISO_INSTANT.format(instant)); } }); return module; }
private static void setupMapper(ObjectMapper mapper) { // Serialize dates using ISO8601 format // Jackson uses timestamps by default, so use StdDateFormat to get ISO8601 mapper.getSerializationConfig().with(new StdDateFormat()); // Deserialize dates using ISO8601 format mapper.getDeserializationConfig().with(new StdDateFormat()); // Prevent exceptions from being thrown for unknown properties // mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, // false); mapper.addHandler(new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException, JsonProcessingException { return true; } }); // ignore fields with null values mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); }
@Autowired public DashboardConfigService(final JsonDeserializer<TagName> tagNameDeserializer) { super( "dashboards.json", "defaultDashboardsConfigFile.json", DashboardConfig.class, DashboardConfig.builder().build(), new Jackson2ObjectMapperBuilder() .mixIn(Widget.class, WidgetMixins.class) .mixIn(WidgetDatasource.class, WidgetDatasourceMixins.class) .deserializersByType(ImmutableMap.of(TagName.class, tagNameDeserializer)) .serializersByType(ImmutableMap.of(TagName.class, new TagNameSerializer())) .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE) ); }
protected FindConfigFileService(final FilterProvider filterProvider, final TextEncryptor textEncryptor, final JsonSerializer<FieldPath> fieldPathSerializer, final JsonDeserializer<FieldPath> fieldPathDeserializer) { final ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder() .featuresToEnable(SerializationFeature.INDENT_OUTPUT) .mixIns(customMixins()) .serializersByType(ImmutableMap.of(FieldPath.class, fieldPathSerializer)) .deserializersByType(ImmutableMap.of(FieldPath.class, fieldPathDeserializer)) .createXmlMapper(false) .build(); setConfigFileLocation(CONFIG_FILE_LOCATION); setConfigFileName(CONFIG_FILE_NAME); setDefaultConfigFile(getDefaultConfigFile()); setMapper(objectMapper); setTextEncryptor(textEncryptor); setFilterProvider(filterProvider); }
private final Object _deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext) { if (paramJsonParser.getCurrentToken() != JsonToken.START_OBJECT) throw paramDeserializationContext.wrongTokenException(paramJsonParser, JsonToken.START_OBJECT, "need JSON Object to contain As.WRAPPER_OBJECT type information for class " + baseTypeName()); if (paramJsonParser.nextToken() != JsonToken.FIELD_NAME) throw paramDeserializationContext.wrongTokenException(paramJsonParser, JsonToken.FIELD_NAME, "need JSON String that contains type id (for subtype of " + baseTypeName() + ")"); String str = paramJsonParser.getText(); JsonDeserializer localJsonDeserializer = _findDeserializer(paramDeserializationContext, str); paramJsonParser.nextToken(); if ((this._typeIdVisible) && (paramJsonParser.getCurrentToken() == JsonToken.START_OBJECT)) { TokenBuffer localTokenBuffer = new TokenBuffer(null); localTokenBuffer.writeStartObject(); localTokenBuffer.writeFieldName(this._typePropertyName); localTokenBuffer.writeString(str); JsonParserSequence localJsonParserSequence = JsonParserSequence.createFlattened(localTokenBuffer.asParser(paramJsonParser), paramJsonParser); paramJsonParser = localJsonParserSequence; localJsonParserSequence.nextToken(); } Object localObject = localJsonDeserializer.deserialize(paramJsonParser, paramDeserializationContext); if (paramJsonParser.nextToken() != JsonToken.END_OBJECT) throw paramDeserializationContext.wrongTokenException(paramJsonParser, JsonToken.END_OBJECT, "expected closing END_OBJECT after type information and deserialized value"); return localObject; }
protected final JsonDeserializer<Object> _findDefaultImplDeserializer(DeserializationContext paramDeserializationContext) { if (this._defaultImpl == null) { if (!paramDeserializationContext.isEnabled(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE)) return NullifyingDeserializer.instance; return null; } if (this._defaultImpl.getRawClass() == NoClass.class) return NullifyingDeserializer.instance; synchronized (this._defaultImpl) { if (this._defaultImplDeserializer == null) this._defaultImplDeserializer = paramDeserializationContext.findContextualValueDeserializer(this._defaultImpl, this._property); JsonDeserializer localJsonDeserializer = this._defaultImplDeserializer; return localJsonDeserializer; } }
public UriSchemeModule() { super(CloudConvertMapperProvider.class.getSimpleName()); addDeserializer(URI.class, new JsonDeserializer<URI>() { @Override public URI deserialize(JsonParser jp, DeserializationContext dc) throws IOException, JsonProcessingException { URI url = URI.create(jp.readValueAs(String.class)); if (url.getScheme() == null) { try { url = new URI(defaultScheme, url.getSchemeSpecificPart(), url.getFragment()); } catch (URISyntaxException e) { throw new JsonProcessingException("Malformed URL", e) {}; } } return url; } }); }
@Test public void classesShouldExtendRapidoidThing() { for (String cls : Cls.getRapidoidClasses()) { if (cls.startsWith("org.rapidoid.plugin.app.") || cls.startsWith("org.rapidoid.fluent.") || cls.startsWith("org.rapidoid.benchmark.")) continue; Class<?> clazz = Cls.get(cls); if (!clazz.isInterface() && !clazz.isEnum() && !clazz.isAnnotation()) { U.must(RapidoidThing.class.isAssignableFrom(clazz) || clazz == TestCommons.class || Exception.class.isAssignableFrom(clazz) || ClassLoader.class.isAssignableFrom(clazz) || HibernatePersistenceProvider.class.isAssignableFrom(clazz) || OutputStream.class.isAssignableFrom(clazz) || Map.class.isAssignableFrom(clazz) || JsonSerializer.class.isAssignableFrom(clazz) || JsonDeserializer.class.isAssignableFrom(clazz) || LogFactory.class.isAssignableFrom(clazz) || Thread.class.isAssignableFrom(clazz), "" + cls); } } }
protected SettableBeanProperty constructSettableProperty(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanPropertyDefinition paramBeanPropertyDefinition, Type paramType) { AnnotatedMember localAnnotatedMember = paramBeanPropertyDefinition.getMutator(); if (paramDeserializationContext.canOverrideAccessModifiers()) localAnnotatedMember.fixAccess(); JavaType localJavaType1 = paramBeanDescription.resolveType(paramType); BeanProperty.Std localStd = new BeanProperty.Std(paramBeanPropertyDefinition.getName(), localJavaType1, paramBeanPropertyDefinition.getWrapperName(), paramBeanDescription.getClassAnnotations(), localAnnotatedMember, paramBeanPropertyDefinition.isRequired()); JavaType localJavaType2 = resolveType(paramDeserializationContext, paramBeanDescription, localJavaType1, localAnnotatedMember); if (localJavaType2 != localJavaType1) localStd.withType(localJavaType2); JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localAnnotatedMember); JavaType localJavaType3 = modifyTypeByAnnotation(paramDeserializationContext, localAnnotatedMember, localJavaType2); TypeDeserializer localTypeDeserializer = (TypeDeserializer)localJavaType3.getTypeHandler(); Object localObject; if ((localAnnotatedMember instanceof AnnotatedMethod)) localObject = new MethodProperty(paramBeanPropertyDefinition, localJavaType3, localTypeDeserializer, paramBeanDescription.getClassAnnotations(), (AnnotatedMethod)localAnnotatedMember); else localObject = new FieldProperty(paramBeanPropertyDefinition, localJavaType3, localTypeDeserializer, paramBeanDescription.getClassAnnotations(), (AnnotatedField)localAnnotatedMember); if (localJsonDeserializer != null) localObject = ((SettableBeanProperty)localObject).withValueDeserializer(localJsonDeserializer); AnnotationIntrospector.ReferenceProperty localReferenceProperty = paramBeanPropertyDefinition.findReferenceType(); if ((localReferenceProperty != null) && (localReferenceProperty.isManagedReference())) ((SettableBeanProperty)localObject).setManagedReferenceName(localReferenceProperty.getName()); return localObject; }
@SuppressWarnings("unchecked") protected T _deserializeEntries(JsonParser jp, DeserializationContext ctxt) throws IOException { final KeyDeserializer keyDes = keyDeserializer; final JsonDeserializer<?> valueDes = valueDeserializer; final TypeDeserializer typeDeser = typeDeserializerForValue; MapF<Object, Object> map = newInstance(); for (; jp.getCurrentToken() == JsonToken.FIELD_NAME; jp.nextToken()) { String fieldName = jp.getCurrentName(); Object key = (keyDes == null) ? fieldName : keyDes.deserializeKey(fieldName, ctxt); JsonToken t = jp.nextToken(); Object value; if (t == JsonToken.VALUE_NULL) { value = null; } else if (typeDeser == null) { value = valueDes.deserialize(jp, ctxt); } else { value = valueDes.deserializeWithType(jp, ctxt, typeDeser); } map.put(key, value); } return (T) map.unmodifiable(); }
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { KeyDeserializer keyDeser = keyDeserializer; JsonDeserializer<?> deser = valueDeserializer; TypeDeserializer typeDeser = typeDeserializerForValue; if ((keyDeser != null) && (deser != null) && (typeDeser == null)) { return this; } if (keyDeser == null) { keyDeser = ctxt.findKeyDeserializer(mapType.getKeyType(), property); } if (deser == null) { deser = ctxt.findContextualValueDeserializer(mapType.getContentType(), property); } if (typeDeser != null) { typeDeser = typeDeser.forProperty(property); } return withResolved(keyDeser, typeDeser, deser); }
private Collection<String> deserializeUsingCustom(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext, Collection<String> paramCollection, JsonDeserializer<String> paramJsonDeserializer) { while (true) { JsonToken localJsonToken = paramJsonParser.nextToken(); if (localJsonToken == JsonToken.END_ARRAY) break; String str; if (localJsonToken == JsonToken.VALUE_NULL) str = null; else str = (String)paramJsonDeserializer.deserialize(paramJsonParser, paramDeserializationContext); paramCollection.add(str); } return paramCollection; }
protected JsonDeserializer<?> findConvertingContentDeserializer(DeserializationContext paramDeserializationContext, BeanProperty paramBeanProperty, JsonDeserializer<?> paramJsonDeserializer) { AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector(); if ((localAnnotationIntrospector != null) && (paramBeanProperty != null)) { Object localObject = localAnnotationIntrospector.findDeserializationContentConverter(paramBeanProperty.getMember()); if (localObject != null) { Converter localConverter = paramDeserializationContext.converterInstance(paramBeanProperty.getMember(), localObject); JavaType localJavaType = localConverter.getInputType(paramDeserializationContext.getTypeFactory()); if (paramJsonDeserializer == null) paramJsonDeserializer = paramDeserializationContext.findContextualValueDeserializer(localJavaType, paramBeanProperty); return new StdDelegatingDeserializer(localConverter, localJavaType, paramJsonDeserializer); } } return paramJsonDeserializer; }
protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty) { JsonDeserializer localJsonDeserializer = paramSettableBeanProperty.getValueDeserializer(); if (((localJsonDeserializer instanceof BeanDeserializerBase)) && (!((BeanDeserializerBase)localJsonDeserializer).getValueInstantiator().canCreateUsingDefault())) { Class localClass1 = paramSettableBeanProperty.getType().getRawClass(); Class localClass2 = ClassUtil.getOuterClass(localClass1); if ((localClass2 != null) && (localClass2 == this._beanType.getRawClass())) for (Constructor localConstructor : localClass1.getConstructors()) { Class[] arrayOfClass = localConstructor.getParameterTypes(); if ((arrayOfClass.length == 1) && (arrayOfClass[0] == localClass2)) { if (paramDeserializationContext.getConfig().canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(localConstructor); return new InnerClassProperty(paramSettableBeanProperty, localConstructor); } } } return paramSettableBeanProperty; }