Java 类com.fasterxml.jackson.databind.JsonDeserializer 实例源码

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;
}

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);
            }
        }
    }
}

@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;
}

/**
 * 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;
}

@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;
  }
}

@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;
}

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;
}