Example usage for com.fasterxml.jackson.databind ObjectMapper enable

List of usage examples for com.fasterxml.jackson.databind ObjectMapper enable

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind ObjectMapper enable.

Prototype

public ObjectMapper enable(SerializationFeature f) 

Source Link

Document

Method for enabling specified DeserializationConfig feature.

Usage

From source file:com.twitter.ambrose.util.JSONUtil.java

private static ObjectMapper newMapper() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    mapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
    mapper.configure(JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT, false);
    mapper.disable(SerializationFeature.FLUSH_AFTER_WRITE_VALUE);
    mapper.disable(SerializationFeature.CLOSE_CLOSEABLE);
    mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

    Reflections reflections = new Reflections("com.twitter.ambrose");
    Set<Class<? extends Job>> jobSubTypes = reflections.getSubTypesOf(Job.class);
    mapper.registerSubtypes(jobSubTypes.toArray(new Class<?>[jobSubTypes.size()]));
    return mapper;
}

From source file:uk.dsxt.voting.common.utils.web.JettyRunner.java

public static void configureMapper(ResourceConfig resourceConfig) {
    // create custom ObjectMapper
    ObjectMapper mapper = new ObjectMapper();
    mapper.setNodeFactory(JsonNodeFactory.withExactBigDecimals(true));
    mapper.enable(SerializationFeature.INDENT_OUTPUT);

    // create JsonProvider to provide custom ObjectMapper
    JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider();
    provider.setMapper(mapper);/*from  w w w  . ja v a2  s  .  c  om*/
    resourceConfig.register(provider);
}

From source file:us.colloquy.util.ElasticLoader.java

public static void uploadLettersToElasticServer(Properties properties, List<Letter> letterList) {
    if (letterList.size() > 0) {
        try (RestHighLevelClient client = new RestHighLevelClient(RestClient
                .builder(new HttpHost("localhost", 9200, "http"), new HttpHost("localhost", 9201, "http")))) {

            BulkRequest request = new BulkRequest();

            ObjectMapper ow = new ObjectMapper(); // create once, reuse

            ow.enable(SerializationFeature.INDENT_OUTPUT);

            for (Letter letter : letterList) {
                try {
                    String json = ow.writerWithDefaultPrettyPrinter().writeValueAsString(letter);

                    String name = "unk";

                    if (letter.getTo().size() > 0) {
                        name = letter.getTo().get(0).getLastName();

                    }/*from   w w w  . ja v  a2 s.c om*/

                    String id = letter.getId() + "-" + letter.getDate() + "-" + letter.getSource();

                    if (StringUtils.isNotEmpty(json)) {
                        IndexRequest indexRequest = new IndexRequest("lntolstoy-letters", "letters", id)
                                .source(json, XContentType.JSON);

                        request.add(new UpdateRequest("lntolstoy-letters", "letters", id)
                                .doc(json, XContentType.JSON).upsert(indexRequest));
                    } else {
                        System.out.println("empty doc: " + id.toString());
                    }

                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }
            }

            BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);

            if (bulkResponse.hasFailures())
            // process failures by iterating through each bulk response item
            {
                System.err.println(bulkResponse.buildFailureMessage());

                for (BulkItemResponse b : bulkResponse) {
                    System.out.println("Error inserting id: " + b.getId());
                    System.out.println("Failure message: " + b.getFailureMessage());
                }
            } else {
                System.out.println("Bulk indexing succeeded.");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    } else {
        System.out.println("The list for bulk import is empty!");
    }
}

From source file:de.taimos.dvalin.jaxrs.MapperFactory.java

public static ObjectMapper createDefault() {
    ObjectMapper m = new ObjectMapper();
    m.registerModule(new JodaModule());
    m.registerModule(new GuavaModule());
    m.setSerializationInclusion(Include.NON_NULL);
    m.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    m.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    m.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
    m.enable(MapperFeature.AUTO_DETECT_GETTERS);
    return m;/*w ww .  j  a  v  a 2s  .c  o m*/
}

From source file:de.cinovo.cloudconductor.api.lib.helper.MapperFactory.java

/**
 * @return the object mapper/*from  w  w  w. j  a  v a  2s.com*/
 */
public static ObjectMapper createDefault() {
    ObjectMapper m = new ObjectMapper();
    m.registerModule(new JodaModule());
    m.registerModule(new GuavaModule());
    m.setSerializationInclusion(Include.NON_NULL);
    m.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    m.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    m.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
    m.enable(MapperFeature.AUTO_DETECT_GETTERS);
    return m;
}

From source file:org.mstc.zmq.json.Decoder.java

@SuppressWarnings("unchecked")
public static void decode(String input, Field[] fields, Object b) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
    if (logger.isDebugEnabled())
        logger.debug(input);//  w w  w .  j a v a 2 s  . co  m
    JsonFactory factory = mapper.getFactory();
    try (JsonParser jp = factory.createParser(input)) {
        /* Sanity check: verify that we got "Json Object" */
        if (jp.nextToken() != JsonToken.START_OBJECT) {
            throw new IOException("Expected data to start with an Object");
        }

        /* Iterate over object fields */
        while (jp.nextToken() != JsonToken.END_OBJECT) {
            String fieldName = jp.getCurrentName();
            jp.nextToken();
            Field field = getField(fieldName, fields);
            if (field == null) {
                throw new IOException(
                        "Could not find field [" + fieldName + "] on class " + b.getClass().getName());
            }
            try {
                if (field.getType().isAssignableFrom(List.class)) {
                    String adder = getAdder(fieldName);
                    TypeFactory t = TypeFactory.defaultInstance();
                    ParameterizedType listType = (ParameterizedType) field.getGenericType();
                    Class<?> listClass = (Class<?>) listType.getActualTypeArguments()[0];
                    List list = mapper.readValue(jp.getValueAsString(),
                            t.constructCollectionType(List.class, listClass));
                    Method m = b.getClass().getDeclaredMethod(adder, Collection.class);
                    m.invoke(b, list);
                } else if (field.getType().isArray()) {
                    Class<?> type = field.getType();
                    String setter = getSetter(fieldName);
                    Method m = b.getClass().getDeclaredMethod(setter, field.getType());
                    logger.info("Field {} is array of {}[], {}, using method {}", field.getName(),
                            field.getType().getComponentType(), jp.getCurrentToken().name(), m);
                    if (jp.getCurrentToken().id() == JsonToken.START_ARRAY.id()) {
                        List list = new ArrayList();
                        while (jp.nextToken() != JsonToken.END_ARRAY) {
                            String value = jp.getText();
                            switch (jp.getCurrentToken()) {
                            case VALUE_STRING:
                                list.add(value);
                                break;
                            case VALUE_NUMBER_INT:
                                if (type.getComponentType().isAssignableFrom(double.class)) {
                                    list.add(Double.parseDouble(value));
                                } else if (type.getComponentType().isAssignableFrom(float.class)) {
                                    list.add(Float.parseFloat(value));
                                } else {
                                    list.add(Integer.parseInt(value));
                                }
                                break;
                            case VALUE_NUMBER_FLOAT:
                                logger.info("Add float");
                                list.add(jp.getFloatValue());
                                break;
                            case VALUE_NULL:
                                break;
                            default:
                                logger.warn("[3] Not sure how to handle {} yet", jp.getCurrentToken().name());
                            }
                        }
                        Object array = Array.newInstance(field.getType().getComponentType(), list.size());
                        for (int i = 0; i < list.size(); i++) {
                            Object val = list.get(i);
                            Array.set(array, i, val);
                        }
                        m.invoke(b, array);
                    } else {
                        if (type.getComponentType().isAssignableFrom(byte.class)) {
                            m.invoke(b, jp.getBinaryValue());
                        }
                    }
                } else {
                    String setter = getSetter(fieldName);
                    logger.debug("{}: {}", setter, field.getType().getName());
                    Method m = b.getClass().getDeclaredMethod(setter, field.getType());

                    switch (jp.getCurrentToken()) {
                    case VALUE_STRING:
                        m.invoke(b, jp.getText());
                        break;
                    case VALUE_NUMBER_INT:
                        m.invoke(b, jp.getIntValue());
                        break;
                    case VALUE_NUMBER_FLOAT:
                        m.invoke(b, jp.getFloatValue());
                        break;
                    case VALUE_NULL:
                        logger.debug("Skip invoking {}.{}, property is null", b.getClass().getName(),
                                m.getName());
                        break;
                    case START_OBJECT:
                        StringBuilder sb = new StringBuilder();
                        while (jp.nextToken() != JsonToken.END_OBJECT) {
                            switch (jp.getCurrentToken()) {
                            case VALUE_STRING:
                                sb.append("\"").append(jp.getText()).append("\"");
                                break;
                            case FIELD_NAME:
                                if (sb.length() > 0)
                                    sb.append(",");
                                sb.append("\"").append(jp.getText()).append("\"").append(":");
                                break;
                            case VALUE_NUMBER_INT:
                                sb.append(jp.getIntValue());
                                break;
                            case VALUE_NUMBER_FLOAT:
                                sb.append(jp.getFloatValue());
                                break;
                            case VALUE_NULL:
                                sb.append("null");
                                break;
                            default:
                                logger.warn("[2] Not sure how to handle {} yet", jp.getCurrentToken().name());
                            }
                        }
                        String s = String.format("%s%s%s", JsonToken.START_OBJECT.asString(), sb.toString(),
                                JsonToken.END_OBJECT.asString());
                        Object parsed = getNested(field.getType(), s.getBytes());
                        m.invoke(b, parsed);
                        break;
                    default:
                        logger.warn("[1] Not sure how to handle {} yet", jp.getCurrentToken().name());
                    }
                }
            } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException
                    | IllegalArgumentException e) {
                logger.error("Failed setting field [{}], builder: {}", fieldName, b.getClass().getName(), e);
            }
        }
    }
}

From source file:org.springframework.data.custom.RestTest.java

public static ObjectMapper mapper() {
    final HalHandlerInstantiator instantiator = new HalHandlerInstantiator(new DefaultRelProvider(), null,
            null);//  w ww.  ja  v  a  2s.  c  o m

    final ObjectMapper m = new ObjectMapper();
    m.registerModule(new Jackson2HalModule());
    m.registerModule(new SimpleModule() {
        {
            setMixInAnnotation(Link.class, LinkReadMixin.class);
        }
    });
    m.setHandlerInstantiator(instantiator);
    m.enable(SerializationFeature.INDENT_OUTPUT);
    return m;
}

From source file:com.infinities.skyport.util.JsonUtil.java

public static ObjectMapper getObjectMapper() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper = objectMapper.setAnnotationIntrospector(jaxbAnnotationPair);
    // make deserializer use JAXB annotations (only)
    objectMapper = objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
    objectMapper = objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    // objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, false);
    objectMapper.configure(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS, true);
    return objectMapper;
}

From source file:de.taimos.dvalin.interconnect.model.InterconnectMapper.java

private static ObjectMapper createMapper() {
    ObjectMapper mapper = new ObjectMapper();
    JodaModule jm = new JodaModule();
    // make some modifications to ensure correct tz serialization and get map keys working
    jm.addKeyDeserializer(DateTime.class, new DateTimeKeyDeserializer());
    jm.addDeserializer(DateTime.class, new DateTimeDeserializerWithTZ());
    mapper.registerModule(jm);/*w  ww  .ja v  a  2 s .co  m*/
    mapper.registerModule(new GuavaModule());
    mapper.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    return mapper;
}

From source file:com.nike.cerberus.server.config.CmsConfig.java

public static ObjectMapper configureObjectMapper() {
    final ObjectMapper om = new ObjectMapper();
    om.findAndRegisterModules();/*from  w w w.j ava2s .  c  o  m*/
    om.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
    om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    om.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    om.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    om.enable(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS);
    om.enable(SerializationFeature.INDENT_OUTPUT);
    return om;
}