import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public static SecurityAnalysisResult read(Path jsonFile) {
    Objects.requireNonNull(jsonFile);

    try (InputStream is = Files.newInputStream(jsonFile)) {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);

        SimpleModule module = new SimpleModule();
        module.addDeserializer(SecurityAnalysisResult.class, new SecurityAnalysisResultDeserializer());
        module.addDeserializer(NetworkMetadata.class, new NetworkMetadataDeserializer());
        module.addDeserializer(PostContingencyResult.class, new PostContingencyResultDeserializer());
        module.addDeserializer(LimitViolationsResult.class, new LimitViolationResultDeserializer());
        module.addDeserializer(LimitViolation.class, new LimitViolationDeserializer());
        module.addDeserializer(Contingency.class, new ContingencyDeserializer());
        module.addDeserializer(ContingencyElement.class, new ContingencyElementDeserializer());
        objectMapper.registerModule(module);

        return objectMapper.readValue(is, SecurityAnalysisResult.class);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
protected <R extends Object> R readInternal(final DocumentDbPersistentEntity<?> entity, Class<R> type,
                                            final Document sourceDocument) {
    final ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    try {
        final DocumentDbPersistentProperty idProperty = entity.getIdProperty();
        final Object idValue = sourceDocument.getId();

        final JSONObject jsonObject = new JSONObject(sourceDocument.toJson());
        if (idProperty != null) {
            // Replace the key id to the actual id field name in domain
            jsonObject.remove("id");
            jsonObject.put(idProperty.getName(), idValue);
        }

        return objectMapper.readValue(jsonObject.toString(), type);
    } catch (IOException e) {
        throw  new IllegalStateException("Failed to read the source document " + sourceDocument.toJson()
                + "  to target type " + type, e);
    }
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
protected List<PackageMetadata> deserializeFromIndexFiles(List<File> indexFiles) {
	List<PackageMetadata> packageMetadataList = new ArrayList<>();
	YAMLMapper yamlMapper = new YAMLMapper();
	yamlMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
	for (File indexFile : indexFiles) {
		try {
			MappingIterator<PackageMetadata> it = yamlMapper.readerFor(PackageMetadata.class).readValues(indexFile);
			while (it.hasNextValue()) {
				PackageMetadata packageMetadata = it.next();
				packageMetadataList.add(packageMetadata);
			}
		}
		catch (IOException e) {
			throw new IllegalArgumentException("Can't parse Release manifest YAML", e);
		}
	}
	return packageMetadataList;
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
@Inject
public CommentUserEventService(Duniter4jClient client,
                               PluginSettings settings,
                               CryptoService cryptoService,
                               UserService userService,
                               UserEventService userEventService) {
    super("duniter.user.event.comment", client, settings, cryptoService);
    this.userService = userService;
    this.userEventService = userEventService;
    objectMapper = JacksonUtils.newObjectMapper()
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    this.changeListenSources = ImmutableList.of(
            new ChangeSource(MarketIndexDao.INDEX, MarketCommentDao.TYPE),
            new ChangeSource(RegistryIndexDao.INDEX, RegistryCommentDao.TYPE));
    ChangeService.registerListener(this);

    this.trace = logger.isTraceEnabled();

    this.recordType = RecordDao.TYPE;
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
@JsonIgnore
public List<AppStatus> getAppStatusList() {
	try {
		ObjectMapper mapper = new ObjectMapper();
		mapper.addMixIn(AppStatus.class, AppStatusMixin.class);
		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
		SimpleModule module = new SimpleModule("CustomModel", Version.unknownVersion());
		SimpleAbstractTypeResolver resolver = new SimpleAbstractTypeResolver();
		resolver.addMapping(AppInstanceStatus.class, AppInstanceStatusImpl.class);
		module.setAbstractTypes(resolver);
		mapper.registerModule(module);
		TypeReference<List<AppStatus>> typeRef = new TypeReference<List<AppStatus>>() {
		};
		if (this.platformStatus != null) {
			return mapper.readValue(this.platformStatus, typeRef);
		}
		return new ArrayList<AppStatus>();
	}
	catch (Exception e) {
		throw new IllegalArgumentException("Could not parse Skipper Platfrom Status JSON:" + platformStatus, e);
	}
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public ObjectMapper provideObjectMapper() {
  ObjectMapper objectMapper = new ObjectMapper();
  objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  objectMapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);
  objectMapper.setSerializationInclusion(Include.NON_NULL);
  objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
  objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
  objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

  objectMapper.setDateFormat(provideDateFormat());

  return objectMapper;
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
@Override
protected String doInBackground(Void... params) {
    ObjectMapper objectMapper = new ObjectMapper().disable(DeserializationFeature.FAIL_ON_MISSING_CREATOR_PROPERTIES).disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES);
    String comentarioJSON="";
    //Construyo el JSON
    try {
        comentarioJSON = objectMapper.writeValueAsString(comentario);
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    String resultado = null;

    //Cojo el resultado en un String
    resultado = ConsultasBBDD.hacerConsulta(ConsultasBBDD.insertaComentario, comentarioJSON, "POST");


    return resultado;
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
protected RestTemplate getRestTemplate() {
	ObjectMapper mapper = new ObjectMapper();
	mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
	mapper.registerModule(new Jackson2HalModule());

	MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
	converter.setSupportedMediaTypes(Arrays.asList(MediaTypes.HAL_JSON));
	converter.setObjectMapper(mapper);

	return new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public DefaultLicenseManager(String publicKey) {
    this.currentVersion = DefaultLicenseManager.LicenseVersion.PRODUCT_SIGNATURE_VERSION;
    this.registeredProducts = new LinkedList();
    this.loadedLicenses = new HashMap();
    this.productToActiveLicenseMap = new HashMap();
    this.productToStarterLicenseMap = new HashMap();
    this.licenseManagerListeners = new LinkedList();

    try {
        X509EncodedKeySpec e = new X509EncodedKeySpec(Base.decode(publicKey == null?"H4sIAAAAAAAAAAEmAdn+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA58/mQ8VjKWDj9ai3mTzFX0b2S0VbV7LIQFv97U8ePdFoLu/cAcTvw7jsvQAT/3RHS7kzXXOk4OGDb7rmL85Dw6nfDs1jFA1auvrICW2vvOdpLrOOijJX5S5EJWHxKoBXSOfxU/fKFa93iuSVKJdqXJeah2Lgs/wq54BBcp4SrxogwWiuqFImqDo7BZKAZgLSm/v2IlICxKGM9QgAoYYLL/bongBpp6SxTy1gm/YD108jJxEk5wuFefDPDMlP0kioSsmGonU6o++pqYLuLkbFdNOdbmtoTphzP5vNaLaTQBmw9vuFHqh80BmIEQi6pK/Wz2RjOU6CYDpn9wv1Lgo2JQIDAQABbOI6ryYBAAA=":publicKey));
        KeyFactory kf = KeyFactory.getInstance("RSA");
        this.publicKey = kf.generatePublic(e);
    } catch (InvalidKeySpecException | IOException | NoSuchAlgorithmException var4) {
        throw new IllegalStateException("PublicKey could not be initialized.", var4);
    }

    this.jsonObjectMapper = new ObjectMapper();
    this.licenseAnnotationValidator = new LicenseAnnotationValidator(this);
    this.jsonObjectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    mapper = Jackson2ObjectMapperBuilder.json()
            .featuresToDisable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)
            .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
            .build();
    mapper.findAndRegisterModules();
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public JsonMapper() {
    // calls the default constructor
    super();

    // configures ISO8601 formatter for date without time zone
    // the used format is 'yyyy-MM-dd'
    super.setDateFormat(new SimpleDateFormat(FMT_ISO_LOCAL_DATE));

    // enforces to skip null and empty values in the serialized JSON output
    super.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);

    // enforces to skip null references in the serialized output of Map
    super.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);

    // enables serialization failures, when mapper encounters unknown properties names
    super.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);

    // configures the format to prevent writing of the serialized output for java.util.Date
    // instances as timestamps. any date should be written in ISO format
    super.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
private void configureerMapper() {
    // Configuratie
    this.disable(MapperFeature.AUTO_DETECT_CREATORS);
    this.disable(MapperFeature.AUTO_DETECT_FIELDS);
    this.disable(MapperFeature.AUTO_DETECT_GETTERS);
    this.disable(MapperFeature.AUTO_DETECT_IS_GETTERS);
    this.disable(MapperFeature.AUTO_DETECT_SETTERS);

    // Default velden niet als JSON exposen (expliciet annoteren!)
    setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.NONE);
    this.enable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY);
    this.enable(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS);

    // serialization
    this.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
    this.enable(SerializationFeature.WRITE_ENUMS_USING_INDEX);

    // deserialization
    this.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public static GenesisJson loadGenesisJson(InputStream genesisJsonIS) throws RuntimeException {
    String json = null;
    try {
        json = new String(ByteStreams.toByteArray(genesisJsonIS));

        ObjectMapper mapper = new ObjectMapper()
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES);

        GenesisJson genesisJson  = mapper.readValue(json, GenesisJson.class);
        return genesisJson;
    } catch (Exception e) {

        Utils.showErrorAndExit("Problem parsing genesis: "+ e.getMessage(), json);

        throw new RuntimeException(e.getMessage(), e);
    }
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public List<Account> getAccounts() {
    final Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    final ObjectMapper mapper = new ObjectMapper()
            .configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    List<Account> accounts = null;
    try {
        accounts = mapper.readValue(rulesFile, 
                new TypeReference<List<Account>>() {});
        if (accounts != null) {
            accounts.forEach((account) -> {
                final Set<ConstraintViolation<Account>> accountViolations = validator.validate(account);
                if (accountViolations.size() > 0) {
                    throw new AccountValidationException(accountViolations);
                }
                account.getRules().sort((o1, o2) -> o1.getType().compareTo(o2.getType()));
            });
        }
    } catch (IOException ex) {
        Logger.getLogger(AccountService.class.getName()).log(Level.SEVERE, null, ex);
    }

    return accounts;
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
@Override
protected EpubPublication doInBackground(String... urls) {
    String strUrl = urls[0];

    try {
        URL url = new URL(strUrl);
        URLConnection urlConnection = url.openConnection();
        InputStream inputStream = urlConnection.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        StringBuilder stringBuilder = new StringBuilder();
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            stringBuilder.append(line);
        }

        Log.d("TestActivity", "EpubPublication => " + stringBuilder.toString());

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        return objectMapper.readValue(stringBuilder.toString(), EpubPublication.class);
    } catch (IOException e) {
        Log.e(TAG, "SpineListTask error " + e);
    }
    return null;
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
/**
 * Parses Json into type
 * @param str Entity content
 * @param clazz Class
 * @return Result
 */
@SneakyThrows
public <U> U parseJson(String str, Class<U> clazz) {
    
    if (log.isInfoEnabled()) {
        
        if (log.isDebugEnabled()) {
            log.debug("Reading " + clazz.getSimpleName() + " from " + str);
        } else {
            String printStr = str;
            if (printStr.length() > 128) {
                printStr = printStr.substring(0, 128);
            }
            log.info("Reading " + clazz.getSimpleName() + " from " + printStr);
        }
        
    }
    
    ObjectMapper objectMapper = new ObjectMapper()
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
            .configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

    return objectMapper.readValue(str, clazz);
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
@Override
protected List<University> doInBackground(Void... voids) {
    String fileName = "university_sample.txt";
    StringBuilder stringBuilder = new StringBuilder();
    List<University> universities = null;
    try {
        // 1. Load data from local sample data file
        InputStream inputStream = mContext.getAssets().open(fileName);
        // 2. use Jackson library to map the JSON to List of University POJO
        ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        universities = Arrays.asList(mapper.readValue(inputStream, University[].class));
        return universities;
    } catch (IOException  e ) {
        e.printStackTrace();
        return null;
    }


}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public static ObjectMapper createDefaultMapper() {

		final ObjectMapper mapper = new ObjectMapper();
		mapper.setSerializationInclusion(Include.NON_NULL);
		mapper.configure(SerializationFeature.INDENT_OUTPUT, false);
		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
		mapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);

		SimpleModule module = new SimpleModule();
		module.addSerializer(Transaction.class, new TransactionSerializer());
		module.addDeserializer(Transaction.class, new TransactionDeserializer());
		module.addSerializer(Difficulty.class, new DifficultySerializer());
		module.addDeserializer(Difficulty.class, new DifficultyDeserializer());
		module.addSerializer(Block.class, new BlockSerializer());
		module.addDeserializer(Block.class, new BlockDeserializer());
		mapper.registerModule(module);

		return mapper;

	}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
private void configureFeature(Object feature, boolean enabled) {
	if (feature instanceof JsonParser.Feature) {
		this.objectMapper.configure((JsonParser.Feature) feature, enabled);
	}
	else if (feature instanceof JsonGenerator.Feature) {
		this.objectMapper.configure((JsonGenerator.Feature) feature, enabled);
	}
	else if (feature instanceof SerializationFeature) {
		this.objectMapper.configure((SerializationFeature) feature, enabled);
	}
	else if (feature instanceof DeserializationFeature) {
		this.objectMapper.configure((DeserializationFeature) feature, enabled);
	}
	else if (feature instanceof MapperFeature) {
		this.objectMapper.configure((MapperFeature) feature, enabled);
	}
	else {
		throw new FatalBeanException("Unknown feature class: " + feature.getClass().getName());
	}
}
 

import com.fasterxml.jackson.databind.DeserializationFeature; //导入依赖的package包/类
public ApiFactory(String baseUrl) {
    HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
    logging.setLevel(HttpLoggingInterceptor.Level.BODY);

    this.okHttpClient = new OkHttpClient.Builder().readTimeout(60, TimeUnit.SECONDS)
                                                  .connectTimeout(60, TimeUnit.SECONDS)
                                                  .cookieJar(new SimpleCookieJar())
                                                  .addInterceptor(logging)
                                                  .build();
    this.retrofit = new Retrofit.Builder().baseUrl(baseUrl)
                                          .addConverterFactory(JacksonConverterFactory.create(
                                                  new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
                                                                    .setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE)
                                                                    .setVisibility(PropertyAccessor.FIELD,
                                                                            JsonAutoDetect.Visibility.ANY))) // 配置Json序列化的时候只使用field name，不走getter setter
                                          .client(okHttpClient)
                                          .build();
}