How to use

ObjectMapper

in

com.fasterxml.jackson.databind

/**
 *  Example to readJson using TreeModel
 */
private static void readJson() throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode rootNode = mapper.readValue("{\"message\":\"Hi\",\"place\":{\"name\":\"World!\"}}", JsonNode.class);
  String message = rootNode.get("message").asText(); // get property message
  JsonNode childNode =  rootNode.get("place"); // get object Place
  String place = childNode.get("name").asText(); // get property name
  System.out.println(message + " " + place); // print "Hi World!"
}

  @Test
  public void testDeserializationSerialization()
      throws IOException
  {
    ObjectMapper mapper = new ObjectMapper();

    for (String input : testInputs) {
      RangePartition partition = mapper.readValue(input, RangePartition.class);

      String serialized = mapper.writeValueAsString(partition);
      assertEquals(serialized, input);
    }
  }
}

public static String parseString(String body, String field) {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode node = null;
  try {
    node = mapper.readTree(body);
    JsonNode leaf = node.get(field);
    if (leaf != null)
      return leaf.asText();
  } catch (IOException e) {
    e.printStackTrace();
  }
  return null;
}

public MappingJackson2MessageConverter() {
  this.objectMapper = new ObjectMapper();
  this.objectMapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false);
  this.objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}

 ObjectMapper mapper = new ObjectMapper();
JsonNode actualObj = mapper.readTree("{\"k1\":\"v1\"}");

public JsonOutputter() {
  mapper = new ObjectMapper();
  mapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);
  mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
  mapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
}

public ObjectNode toJson() {
  ObjectMapper objectMapper = new ObjectMapper();
  ObjectNode result = objectMapper.createObjectNode();
  ObjectNode renderEngine = objectMapper.createObjectNode();
  result.set("renderEngine", renderEngine);
  renderEngine.put("name", renderEngineName);
  renderEngine.set("version", renderEngineVersion.toJson());
  ObjectNode ifcModel = objectMapper.createObjectNode();
  ObjectNode user = objectMapper.createObjectNode();
  ObjectNode settings = objectMapper.createObjectNode();
  ObjectNode deserializer = objectMapper.createObjectNode();
  ObjectNode system = objectMapper.createObjectNode();
  ArrayNode jobsArray = objectMapper.createArrayNode();
    ObjectNode jobNode = objectMapper.createObjectNode();
  ObjectNode processing = objectMapper.createObjectNode();
  ArrayNode geometry = objectMapper.createArrayNode();
    ObjectNode geometryNode = objectMapper.createObjectNode();
  ArrayNode skippedNodes = objectMapper.createArrayNode();

private void doInstanceInfoCompactEncodeDecode(AbstractEurekaJacksonCodec codec, boolean isJson) throws Exception {
  InstanceInfo instanceInfo = infoIterator.next();
  String encodedString = codec.getObjectMapper(InstanceInfo.class).writeValueAsString(instanceInfo);
  if (isJson) {
    JsonNode metadataNode = new ObjectMapper().readTree(encodedString).get("instance").get("metadata");
    assertThat(metadataNode, is(nullValue()));
  }
  InstanceInfo decodedValue = codec.getObjectMapper(InstanceInfo.class).readValue(encodedString, InstanceInfo.class);
  assertThat(decodedValue.getId(), is(equalTo(instanceInfo.getId())));
  assertThat(decodedValue.getMetadata().isEmpty(), is(true));
}

ObjectMapper objectMapper = new ObjectMapper();
ObjectNode servicesJson = objectMapper.readValue(data, ObjectNode.class);
ArrayNode activeServices = (ArrayNode) servicesJson.get("active");
List<SNewServiceDescriptor> list = Collections.synchronizedList(new ArrayList<>());
ThreadPoolExecutor executor = new ThreadPoolExecutor(activeServices.size(), activeServices.size(), 1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(activeServices.size()));
for (JsonNode activeService : activeServices) {
  String providerListUrl = activeService.get("listUrl").asText();
  executor.submit(new Runnable(){

 import com.fasterxml.jackson.databind.ObjectMapper;// in play 2.3
ObjectMapper mapper = new ObjectMapper();

@Override
@Nullable
public String[] decodeInputStream(InputStream content) throws IOException {
  return this.objectMapper.readValue(content, String[].class);
}

ObjectMapper mapper = new ObjectMapper();
 mapper.getFactory().configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true);
 ObjectNode node = mapper.getNodeFactory().objectNode();
 node.put("field1", "Maël Hörz");
 System.out.println(mapper.writeValueAsString(node));

public static <T> T parseObject(String body, String field, Class<T> clazz) {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode node = null;
  try {
    node = mapper.readTree(body);
    node = node.get(field);
    return mapper.treeToValue(node, clazz);
  } catch (IOException e) {
    e.printStackTrace();
  }
  return null;
}

  @Override
  public LoadManagerReport deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
      throws IOException, JsonProcessingException {
    ObjectMapper mapper = ObjectMapperFactory.getThreadLocal();
    ObjectNode root = ObjectMapperFactory.getThreadLocal().readTree(jsonParser);
    if ((root.has("loadReportType") && root.get("loadReportType").asText().equals(LoadReport.loadReportType))
        || (root.has("underLoaded"))) {
      return mapper.readValue(root.toString(), LoadReport.class);
    } else {
      return mapper.readValue(root.toString(), LocalBrokerData.class);
    }
  }
}

public static Integer parseInteger(String body, String field) {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode node = null;
  try {
    node = mapper.readTree(body);
    JsonNode leaf = node.get(field);
    if (leaf != null)
      return leaf.asInt();
  } catch (IOException e) {
    e.printStackTrace();
  }
  return null;
}

@Test
public void testHeartbeatStatsSerialization()
    throws Exception
{
  ObjectMapper objectMapper = new ObjectMapperProvider().get();
  Stats stats = new Stats(new URI("http://example.com"));
  String serialized = objectMapper.writeValueAsString(stats);
  JsonNode deserialized = objectMapper.readTree(serialized);
  assertFalse(deserialized.has("lastFailureInfo"));
  stats.recordFailure(new SocketTimeoutException("timeout"));
  serialized = objectMapper.writeValueAsString(stats);
  deserialized = objectMapper.readTree(serialized);
  assertFalse(deserialized.get("lastFailureInfo").isNull());
  assertEquals(deserialized.get("lastFailureInfo").get("type").asText(), SocketTimeoutException.class.getName());
}

  @Test
  public void testJsonSerialization()
      throws Exception
  {
    TestingTypeManager typeManager = new TestingTypeManager();

    ObjectMapper mapper = new ObjectMapperProvider().get()
        .registerModule(new SimpleModule().addDeserializer(Type.class, new TestingTypeDeserializer(typeManager)));

    AllOrNoneValueSet all = AllOrNoneValueSet.all(HYPER_LOG_LOG);
    assertEquals(all, mapper.readValue(mapper.writeValueAsString(all), AllOrNoneValueSet.class));

    AllOrNoneValueSet none = AllOrNoneValueSet.none(HYPER_LOG_LOG);
    assertEquals(none, mapper.readValue(mapper.writeValueAsString(none), AllOrNoneValueSet.class));
  }
}

public  static void main(String[] args) throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode root = mapper.readTree(json);
  String author = root.at("/store/book/3/title").asText();
  System.out.println(author); // print ["Hello, Middle-earth! "]
  System.out.println();
  String jsonHiWorld = "{\"message\":\"Hi\",\"place\":{\"name\":\"World!\"}}\"";
  String message = mapper.readTree(jsonHiWorld).at("/message").asText();
  String place = mapper.readTree(jsonHiWorld).at("/place/name").asText();
  System.out.println(message + " " + place); // print "Hi World!"
}

@Test
public void testSerialization()
    throws Exception
{
  ObjectMapper objectMapper = new ObjectMapper();
  BingTile tile = fromCoordinates(1, 2, 3);
  String json = objectMapper.writeValueAsString(tile);
  assertEquals("{\"x\":1,\"y\":2,\"zoom\":3}", json);
  assertEquals(tile, objectMapper.readerFor(BingTile.class).readValue(json));
}

 SimpleModule module = new SimpleModule();
module.addSerializer(new ResultSetSerializer());

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(module);

[ . . . do the query . . . ]
ResultSet resultset = statement.executeQuery(query);

// Use the DataBind Api here
ObjectNode objectNode = objectMapper.createObjectNode();

// put the resultset in a containing structure
objectNode.putPOJO("results", resultset);

// generate all
objectMapper.writeValue(stringWriter, objectNode);