com.fasterxml.jackson.databind.ObjectMapper#valueToTree ( )源码实例Demo

/**
 * Replace $ref array elements.
 *
 * @param entry Array reference to be replaced from actual value.
 */
private static void generateArraySchemas(Map.Entry<String, JsonNode> entry) {
    JsonNode entryRef;
    JsonNode ref;
    JsonNode schemaProperty;
    if (entry.getValue() != null) {
        schemaProperty = entry.getValue();
        if (schemaProperty == null) {
            return;
        }
        Iterator<JsonNode> arrayElements = schemaProperty.elements();
        List<JsonNode> nodeList = Lists.newArrayList(arrayElements);
        for (int i = 0; i < nodeList.size(); i++) {
            entryRef = nodeList.get(i);
            if (entryRef.has(Constants.SCHEMA_REFERENCE)) {
                ref = extractSchemaObject(entryRef);
                nodeList.remove(i);
                nodeList.add(ref);
            }
        }
        ObjectMapper mapper = new ObjectMapper();
        ArrayNode array = mapper.valueToTree(nodeList);
        entry.setValue(array);
    }
}
 

public DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
		ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
		boolean client, UrlBuilder urlBuilder) {
	this.propertiesProvider = propertiesProvider;
	this.client = client;
	this.resultFactory = resultFactory;
	this.resourceFilterDirectory = resourceFilterDirectory;

	PreconditionUtil.verify(client || resourceFilterDirectory != null, "filterBehavior necessary on server-side");

	this.util = newDocumentMapperUtil(resourceRegistry, objectMapper, propertiesProvider, urlBuilder);
	this.resourceMapper = newResourceMapper(util, client, objectMapper);
	this.includeLookupSetter = newIncludeLookupSetter(resourceRegistry, resourceMapper, propertiesProvider, objectMapper);

	if (serverInfo != null && !serverInfo.isEmpty()) {
		jsonapi = objectMapper.valueToTree(serverInfo);
	}
}
 

private void generatePreprocessedJsonFromMetricEntry(final Map.Entry<String, Object> idToMetricEntry,
                                                     final JsonGenerator jsonGenerator,
                                                     final ObjectMapper objectMapper) throws IOException {
  final JsonNode jsonNode = objectMapper.valueToTree(idToMetricEntry.getValue());
  jsonGenerator.writeFieldName(idToMetricEntry.getKey());
  jsonGenerator.writeStartObject();
  jsonGenerator.writeFieldName("id");
  jsonGenerator.writeString(idToMetricEntry.getKey());
  jsonGenerator.writeFieldName("data");
  jsonGenerator.writeTree(jsonNode);
  jsonGenerator.writeEndObject();
}
 

@Test
public void shouldSerializeMessage() throws IOException {
    //when
    UnifiedPushMessage unifiedPushMessage = new UnifiedPushMessage();

    Message message = new Message();

    message.setAlert("HELLO!");
    message.getApns().setActionCategory("some value");
    message.setSound("default");
    message.setBadge(2);
    message.getApns().setContentAvailable(true);

    final HashMap<String, Object> data = new HashMap<>();
    data.put("key", "value");
    data.put("key2", "other value");
    message.setUserData(data);

    message.setSimplePush("version=123");
    unifiedPushMessage.setMessage(message);

    final Criteria criteria = new Criteria();
    criteria.setAliases(Arrays.asList("someUsername"));
    criteria.setDeviceTypes(Arrays.asList("someDevice"));
    criteria.setCategories(Arrays.asList("someCategories"));
    criteria.setVariants(Arrays.asList("someVariantIDs"));
    unifiedPushMessage.setCriteria(criteria);

    final Config config = new Config();
    config.setTimeToLive(3360);
    unifiedPushMessage.setConfig(config);

    //then
    final ObjectMapper mapper = new ObjectMapper();
    final JsonNode value = mapper.valueToTree(unifiedPushMessage);

    JsonNode format = mapper.reader().readTree(getClass().getResourceAsStream("/message-format.json"));
    assertEquals(format, value);
}
 

@Test
public void callMethodWithVarArgParameters() throws Exception {
	Map<String, Object> paramsMap = new HashMap<>();
	paramsMap.put("argOne", "one");
	paramsMap.put("argTwo", 2);
	paramsMap.put("argThree", "three");
	paramsMap.put("argFour", 4);
	paramsMap.put("argFive", (Object) "five");
	paramsMap.put("argSix", 6.0f);
	paramsMap.put("argSeven", 7d);
	Object[] callParams = new Object[paramsMap.size() * 2];
	int i = 0;
	for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
		callParams[i++] = entry.getKey();
		callParams[i++] = entry.getValue();
	}

	jsonRpcServerAnnotatedMethod.handleRequest(
		messageWithMapParamsStream("varargObjectMethod", callParams),
		byteArrayOutputStream
	);
	JsonNode res = result();
	ObjectMapper mapper = new ObjectMapper();
	JsonNode resultNode = mapper.readTree(res.asText());
	// params order saved during call, but order not guaranteed
	ObjectNode expectedResult = mapper.valueToTree(paramsMap);
	expectedResult.set("argTwo", mapper.valueToTree(2));
	expectedResult.set("argFour", mapper.valueToTree(4));
	Assert.assertEquals(expectedResult.toString(), resultNode.toString());
}
 

@Test
public void shouldPatchBuildConfiguration() throws PatchBuilderException, IOException, JsonPatchException {
    ObjectMapper mapper = ObjectMapperProvider.getInstance();

    // given
    Instant now = Instant.now();
    Map<String, String> initialParameters = Collections.singletonMap("KEY", "VALUE");
    BuildConfiguration buildConfiguration = BuildConfiguration.builder()
            .id("1")
            .name("name")
            .creationTime(now)
            .parameters(initialParameters)
            .build();

    // when
    BuildConfigurationPatchBuilder patchBuilder = new BuildConfigurationPatchBuilder();
    patchBuilder.replaceName("new name");
    Map<String, String> newParameter = Collections.singletonMap("KEY 2", "VALUE 2");
    patchBuilder.addParameters(newParameter);

    JsonNode targetJson = mapper.valueToTree(buildConfiguration);
    JsonPatch patch = JsonPatch.fromJson(mapper.readValue(patchBuilder.getJsonPatch(), JsonNode.class));
    JsonNode result = patch.apply(targetJson);

    // then
    BuildConfiguration deserialized = mapper.treeToValue(result, BuildConfiguration.class);
    Assert.assertEquals(now, deserialized.getCreationTime());
    Assert.assertEquals("new name", deserialized.getName());

    Map<String, String> finalParameters = new HashMap<>(initialParameters);
    finalParameters.putAll(newParameter);
    assertThat(deserialized.getParameters()).containsAllEntriesOf(finalParameters);
}
 

@Test
public void jsonToTinkerpopConvertsASerializedAltNamesValuesToADbSerializedAsString() throws Exception {
  ObjectMapper objectMapper = new ObjectMapper();

  JsonNode jsonNode = objectMapper.valueToTree(Lists.newArrayList(ALT_NAME_1, ALT_NAME_2));

  String value = instance.jsonToTinkerpop(jsonNode);

  AltNames altNamesValue = objectMapper.readValue(value, AltNames.class);
  assertThat(altNamesValue.list, containsInAnyOrder(ALT_NAME_1, ALT_NAME_2));
}
 

@Override
public JsonNode convertLocalVariablesToJson(ActivityMigrationMapping.OneToOneMapping mapping, ObjectMapper objectMapper) {
    Map<String, Object> activityLocalVariables = mapping.getActivityLocalVariables();
    if (activityLocalVariables != null && !activityLocalVariables.isEmpty()) {
        return objectMapper.valueToTree(activityLocalVariables);
    }
    return null;
}
 

@Test
public void shouldReturnJson() throws IOException {
    //given
    HealthStatus status = getHealthStatus();

    //when
    final ObjectMapper mapper = new ObjectMapper();
    final JsonNode value = mapper.valueToTree(status);

    //then
    final JsonNode format = mapper.reader().readTree(getClass().getResourceAsStream("/health-format.json"));

    //because the json file will use int for the 'runtime' field and the model long
    assertThat(value.toString()).isEqualTo(format.toString());
}
 

public JsonNode loadYamlFile(String filename) {

        Yaml reader = new Yaml();
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = mapper.valueToTree(reader.load(TestWorkflowProcess.class.getResourceAsStream(filename)));

        return node;
    }
 

public void log(String client,JsonNode input,PredictionServiceResult response)
{
	ObjectMapper mapper = new ObjectMapper();
	JsonNode prediction = mapper.valueToTree(response);
	ObjectNode topNode = mapper.createObjectNode();
	topNode.put("consumer", client);
	topNode.put("input", input);
	topNode.put("prediction", prediction);
	predictLogger.info(topNode.toString());
}
 

@Test
public void testEnabled() {
  ObjectMapper mapper = objectMapper(true);

  JsonNode node = mapper.valueToTree(getObject());
  assertThat(node.has("bool")).isTrue();
  assertThat(node.get("bool").isBoolean()).isTrue();
  assertThat(node.get("bool").booleanValue()).isFalse();
}
 

@ParameterizedTest
@MethodSource("mappers")
void immutable(ObjectMapper mapper) throws JsonProcessingException {
  // write
  ImmutablePerson person = new PersonGenerator().next().withId("id123");
  ObjectNode node = mapper.valueToTree(person);
  check(node.get("_id").asText()).is("id123");
  check(ImmutableList.copyOf(node.fieldNames())).not().has("id");

  check(mapper.treeToValue(node, Person.class).id()).is("id123");
  check(mapper.treeToValue(node, ImmutablePerson.class).id()).is("id123");
}
 

public JsonNode loadYamlFile(String filename) {

        Yaml reader = new Yaml();
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = mapper.valueToTree(reader.load(TestWorkflowProcess.class.getResourceAsStream(filename)));

        return node;
    }
 

private String serializeToString(T value, ObjectMapper mapper, SerializerProvider provider) throws IOException {
  try (SegmentedStringWriter sw = new SegmentedStringWriter(new BufferRecycler())) {
    if (trySerializeToWriter(value, mapper, provider, sw)) {
      return sw.getAndClear();
    }
  }

  // fallback on old behavior
  JsonNode tree = mapper.valueToTree(value);
  if (tree.isNull()) {
    return tree.asText();
  } else {
    return mapper.writeValueAsString(tree);
  }
}
 

private JsonNode serializeValue(Object value) {
	ObjectMapper objectMapper = context.getObjectMapper();
	return objectMapper.valueToTree(value);
}
 

@Override
public JsonNode toNode( final ObjectMapper objectMapper, final T value ) {
    return objectMapper.valueToTree( value );
}
 

public static JsonNode toTree(ObjectMapper mapper, Object value) {
  return mapper.valueToTree(value);
}
 

protected static JsonNode convertToJsonUpgradeScript(Script script, ObjectMapper objectMapper) {
    if (script != null) {
        return objectMapper.valueToTree(script);
    }
    return null;
}
 

@Override
protected JsonNode convertNewAssigneeToJson(ActivityMigrationMapping.ManyToOneMapping mapping, ObjectMapper objectMapper) {
    return objectMapper.valueToTree(mapping.getWithNewAssignee());
}