Java JsonMappingException类代码示例

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
public static Echo_sol_Echo getEchoContract()
		throws JsonParseException, JsonMappingException, IOException, CipherException {
	Web3j web3j = Web3j.build(new HttpService());
	logger.debug("[ETH-INFO] Connected to TestRPC");

	ObjectMapper objectMapper = ObjectMapperFactory.getObjectMapper();
	WalletFile walletFile = objectMapper
			.readValue(ContractHelper.class.getResourceAsStream("/accountKeystore.json"), WalletFile.class);
	Credentials credentials = Credentials.create(Wallet.decrypt(password, walletFile));
	logger.debug("[ETH-INFO] Credentials: " + credentials.getAddress());

	logger.debug("[ETH-INFO] Loading contract: " + contractAddress);
	ese = Echo_sol_Echo.load(contractAddress, web3j, credentials, GAS_PRICE, GAS_LIMIT);

	startObservable();
	
	return ese;
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
/**
 * Validate logins yml.
 * @param loginsYml logins yml
 * @return true if valid
 */
@PostMapping(value = "/logins/validate", consumes = {TEXT_PLAIN_VALUE})
@ApiOperation(value = "Validate uaa login properties format", response = UaaValidationVM.class)
@ApiResponses(value = {
    @ApiResponse(code = 200, message = "Uaa validation result", response = UaaValidationVM.class),
    @ApiResponse(code = 500, message = "Internal server error")})
@SneakyThrows
@Timed
public UaaValidationVM validate(@RequestBody String loginsYml) {
    try {
        mapper.readValue(loginsYml, TenantLogins.class);
        return UaaValidationVM.builder().isValid(true).build();
    } catch (JsonParseException | JsonMappingException e) {
        return UaaValidationVM.builder().isValid(false).errorMessage(e.getLocalizedMessage()).build();
    }
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
/**
 * Loads and returns the AWS Java SDK internal configuration from the classpath.
 */
static InternalConfig load() throws JsonParseException, JsonMappingException, IOException {
    // First try loading via the class by using a relative path
    URL url = ClassLoaderHelper.getResource(DEFAULT_CONFIG_RESOURCE_RELATIVE_PATH, true, InternalConfig.class); // classesFirst=true
    if (url == null) { // Then try with the absolute path
        url = ClassLoaderHelper.getResource(DEFAULT_CONFIG_RESOURCE_ABSOLUTE_PATH, InternalConfig.class);
    }
    InternalConfigJsonHelper config = loadfrom(url);
    InternalConfigJsonHelper configOverride;
    URL overrideUrl = ClassLoaderHelper.getResource("/" + CONFIG_OVERRIDE_RESOURCE, InternalConfig.class);
    if (overrideUrl == null) { // Try without a leading "/"
        overrideUrl = ClassLoaderHelper.getResource(CONFIG_OVERRIDE_RESOURCE, InternalConfig.class);
    }
    if (overrideUrl == null) {
        log.debug("Configuration override " + CONFIG_OVERRIDE_RESOURCE + " not found.");
        configOverride = new InternalConfigJsonHelper();
    } else {
        configOverride = loadfrom(overrideUrl);
    }
    InternalConfig merged = new InternalConfig(config, configOverride);
    merged.setDefaultConfigFileLocation(url);
    merged.setOverrideConfigFileLocation(overrideUrl);
    return merged;
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
@PostMapping(value = "/timelines/properties/validate", consumes = {TEXT_PLAIN_VALUE})
@ApiOperation(value = "Validate timeline properties format", response = TimeLineValidationVM.class)
@ApiResponses(value = {
    @ApiResponse(code = 200, message = "Timeline validation result", response = TimeLineValidationVM.class),
    @ApiResponse(code = 500, message = "Internal server error")})
@SneakyThrows
@Timed
public TimeLineValidationVM validate(@RequestBody String timelineYml) {
    try {
        mapper.readValue(timelineYml, TenantProperties.class);
        return TimeLineValidationVM.builder().isValid(true).build();
    } catch (JsonParseException | JsonMappingException e) {
        log.error("Error while validation", e);
        return TimeLineValidationVM.builder().isValid(false).errorMessage(e.getLocalizedMessage()).build();
    }
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
@Test
void getBadReportDetails() throws NoSuchFieldException, IllegalAccessException, JsonProcessingException {
	ObjectMapper mockMapper = mock(ObjectMapper.class);
	when(mockMapper.writeValueAsBytes(any(AllErrors.class)))
		.thenThrow(new JsonMappingException("meep"));

	Converter converter = new Converter(
		new PathSource(Paths.get("../qrda-files/valid-QRDA-III-latest.xml")));
	Converter.ConversionReport badReport = converter.getReport();

	Field field = badReport.getClass().getDeclaredField("mapper");
	field.setAccessible(true);
	field.set(badReport, mockMapper);

	assertThrows(EncodeException.class, badReport::getValidationErrorsSource);
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
@Test
public void testArray() throws JsonParseException, JsonMappingException, IOException {
	assertTrue(config.getProperty("phoneNumbers", List.class) instanceof List);
	final List<Map<String, String>> testList = new ArrayList<>();

	Map<String, String> testMapEntry = new HashMap<>();
	testMapEntry.put("type", "home");
	testMapEntry.put("number", "212 555-1234");
	testList.add(testMapEntry);
	testMapEntry = new HashMap<>();
	testMapEntry.put("type", "office");
	testMapEntry.put("number", "646 555-4567");
	testList.add(testMapEntry);

	assertEquals(testList, config.getProperty("phoneNumbers", List.class));
	assertEquals(new ArrayList<>(), config.getProperty("children", List.class));
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
private static Optional<JsonSchema> getSchemma(Class<?> clazz) {
	ObjectMapper mapper = new ObjectMapper();
	Optional<JsonSchema> schema = Optional.empty();
	SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
	Optional<Class<?>> realClazz = ReflectionUtils.getGenericClass(clazz);
	boolean iterable = Iterable.class.isAssignableFrom(clazz) && realClazz.isPresent();
	if (iterable) {
		clazz = realClazz.get();
	}

	try {
		mapper.acceptJsonFormatVisitor(clazz, visitor);
		JsonSchemaGenerator schemaGen = new JsonSchemaGenerator(mapper);
		schema = Optional.ofNullable(schemaGen.generateSchema(clazz));
		if (iterable) {
			// TODO: decirle que es una collection
		}
	} catch (JsonMappingException e) {
		LOGGER.error("Se produjo un error al crear el JsonSchemma para la clase {}", clazz.getSimpleName(), e);
	}
	return schema;
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
private List<String> getAPIKeyList() throws ServerError, JsonParseException, JsonMappingException, IOException{
  	List<String> list = new ArrayList<String>();
  	
String accountListUrlPath = props.getProperty("application-list-url-path");
    
accountListUrlPath=accountListUrlPath.replaceAll("<token>",  props.getProperty("acccess-token"));
accountListUrlPath=accountListUrlPath.replaceAll("<serviceid>", props.getProperty("service-id-a"));
    
//String body = props.getProperty("tempbody");
String body = apiAccessor.get(HOST+accountListUrlPath).getBody();
   while ( body.indexOf("user_key")!=-1){							
   	int indexOfStartOfKey = body.indexOf("user_key") + 11;
   	int indexOfEndOfKey = indexOfStartOfKey+32; 
   	String apiKey = body.substring(indexOfStartOfKey, indexOfEndOfKey);	   
   	list.add(apiKey);
   	
   	body = body.substring(indexOfEndOfKey);
   	
   }
  	
  	return list;
  }
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
public static QueryObjectProvider fromJsonNode(CatalogService catalogService, VirtualObjectService virtualObjectService, PlatformServer server, JsonNode fullQuery, Integer rid, PackageMetaData packageMetaData) throws JsonParseException, JsonMappingException, IOException, QueryException {
	if (fullQuery instanceof ObjectNode) {
		JsonQueryObjectModelConverter converter = new JsonQueryObjectModelConverter(packageMetaData);
		Query query = converter.parseJson("query", (ObjectNode) fullQuery);
		return new QueryObjectProvider(catalogService, virtualObjectService, server, query, rid, packageMetaData);
	} else {
		throw new QueryException("Query root must be of type object");
	}
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
@StreamListener(target = Sink.INPUT, 
    condition="payload.messageType.toString()=='FetchGoodsCommand'")
@Transactional
public void retrievePaymentCommandReceived(String messageJson) throws JsonParseException, JsonMappingException, IOException {
  Message<FetchGoodsCommandPayload> message = new ObjectMapper().readValue(messageJson, new TypeReference<Message<FetchGoodsCommandPayload>>(){});
  
  FetchGoodsCommandPayload fetchGoodsCommand = message.getPayload();    
  String pickId = inventoryService.pickItems( // 
      fetchGoodsCommand.getItems(), fetchGoodsCommand.getReason(), fetchGoodsCommand.getRefId());
  
  messageSender.send( //
      new Message<GoodsFetchedEventPayload>( //
          "GoodsFetchedEvent", //
          message.getTraceId(), //
          new GoodsFetchedEventPayload() //
            .setRefId(fetchGoodsCommand.getRefId())
            .setPickId(pickId)));
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
public String setTestPolicy(final RestTemplate acs, final HttpHeaders headers, final String endpoint,
        final String policyFile) throws JsonParseException, JsonMappingException, IOException {

    PolicySet policySet = new ObjectMapper().readValue(new File(policyFile), PolicySet.class);
    String policyName = policySet.getName();
    acs.put(endpoint + ACS_POLICY_SET_API_PATH + policyName, new HttpEntity<>(policySet, headers));
    return policyName;
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
/**
 * A callback so a JsonGenerator can be used inline but exception are handled here
 * @param outStream OutputStream
 * @param writer The writer interface
 * @throws IOException
 */
public void withWriter(OutputStream outStream, Writer writer) throws IOException
{
    try
    {
        JsonGenerator generator = objectMapper.getJsonFactory().createJsonGenerator(outStream, encoding);
        writer.writeContents(generator, objectMapper);
    }
    catch (JsonMappingException error)
    {
        logger.error("Failed to write Json output",error);
    } 
    catch (JsonGenerationException generror)
    {
        logger.error("Failed to write Json output",generror);
    }
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
private void assertForbidden(final String path) throws IOException, ClientProtocolException, JsonParseException, JsonMappingException {
	final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + path);
	HttpResponse response = null;
	try {
		response = httpclient.execute(httpdelete);
		Assert.assertEquals(HttpStatus.SC_FORBIDDEN, response.getStatusLine().getStatusCode());
		final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8);
		final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class);
		Assert.assertEquals("security", result.get("code"));
		Assert.assertNull(result.get("cause"));
		Assert.assertNull(result.get("message"));
	} finally {
		if (response != null) {
			response.getEntity().getContent().close();
		}
	}
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
@Override
public <T> Document asDocumentInternal(T object) {
    ObjectMapper objectMapper = getObjectMapper();
    try {
        JsonNode node = objectMapper.convertValue(object, JsonNode.class);
        return loadDocument(node);
    } catch (IllegalArgumentException iae) {
        log.error("Error while converting object to document ", iae);
        if (iae.getCause() instanceof JsonMappingException) {
            JsonMappingException jme = (JsonMappingException) iae.getCause();
            if (jme.getCause() instanceof StackOverflowError) {
                throw new ObjectMappingException(errorMessage(
                        "cyclic reference detected. " + jme.getPathReference(), OME_CYCLE_DETECTED));
            }
        }
        throw iae;
    }
}
 

import com.fasterxml.jackson.databind.JsonMappingException; //导入依赖的package包/类
@StreamListener(target = Sink.INPUT, 
    condition="payload.messageType.toString()=='RetrievePaymentCommand'")
@Transactional
public void retrievePaymentCommandReceived(String messageJson) throws JsonParseException, JsonMappingException, IOException {
  Message<RetrievePaymentCommandPayload> message = new ObjectMapper().readValue(messageJson, new TypeReference<Message<RetrievePaymentCommandPayload>>(){});
  RetrievePaymentCommandPayload retrievePaymentCommand = message.getPayload();    
  
  System.out.println("Retrieve payment: " + retrievePaymentCommand.getAmount() + " for " + retrievePaymentCommand.getRefId());
  
  camunda.getRuntimeService().createMessageCorrelation(message.getMessageType()) //
    .processInstanceBusinessKey(message.getTraceId())
    .setVariable("amount", retrievePaymentCommand.getAmount()) //
    .setVariable("remainingAmount", retrievePaymentCommand.getAmount()) //
    .setVariable("refId", retrievePaymentCommand.getRefId()) //
    .correlateWithResult();    
}