Example usage for com.fasterxml.jackson.databind.type TypeFactory defaultInstance

List of usage examples for com.fasterxml.jackson.databind.type TypeFactory defaultInstance

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind.type TypeFactory defaultInstance.

Prototype

public static TypeFactory defaultInstance() 

Source Link

Usage

From source file:com.hengyi.japp.print.client.domain.SapT001.java

public void fetchSapYmmbancis() throws Exception {
    if (sapYmmbancis.get() != null)
        return;//  w  w  w.ja v  a2 s.com
    String json = destination.path("sapT001s").path(getBukrs()).path("sapYmmbancis")
            .request(APPLICATION_JSON_TYPE).get(String.class);
    List<SapYmmbanci> list = objectMapper.readValue(json,
            TypeFactory.defaultInstance().constructCollectionType(List.class, SapYmmbanci.class));
    sapYmmbancis.set(FXCollections.observableArrayList(list));
}

From source file:com.tekstosense.segmenter.SegmenterTest.java

@Test
public void testSegmenter() throws IOException {
    String[] args = { "-input",
            "/home/rishi/Desktop/testDoc/To check/paper 2009-Semantic interpretation and knowledge extraction.pdf",
            "-format", "STDOUT" };

    String heading = "Semantic interpretation and knowledge extraction ";

    Params cliParams = Params.getParams(args);
    ObjectMapper mapper = new ObjectMapper();

    String path = cliParams.getInput();
    PdfSections pdf2Xml = new PdfSections(cliParams);
    pdf2Xml.processFile(path);//from  w ww  .j  a  v  a 2s .co m
    List<Structure> structure = mapper.readValue(pdf2Xml.generateOutput().get(0),
            TypeFactory.defaultInstance().constructCollectionType(List.class, Structure.class));
    Assert.assertTrue(structure.get(0).getHeading().equals(heading));

}

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);/*from  w  ww  . j  ava 2  s.c  o  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:com.github.jasonruckman.sidney.core.type.Types.java

public static JavaType type(Type type, TypeBindings typeBindings) {
    return TypeFactory.defaultInstance().constructType(type, typeBindings);
}

From source file:org.camunda.spin.impl.json.jackson.format.JacksonJsonDataFormatMapper.java

public <T> T mapInternalToJava(Object parameter, Class<T> type) {
    JavaType javaType = TypeFactory.defaultInstance().constructType(type);
    T result = mapInternalToJava(parameter, javaType);
    return result;
}

From source file:org.springframework.amqp.support.converter.DefaultJackson2JavaTypeMapper.java

private JavaType getClassIdType(String classId) {
    if (getIdClassMapping().containsKey(classId)) {
        return TypeFactory.defaultInstance().constructType(getIdClassMapping().get(classId));
    }//from  w w w  .j  a  v  a 2 s  .co m

    try {
        return TypeFactory.defaultInstance()
                .constructType(ClassUtils.forName(classId, getClass().getClassLoader()));
    } catch (ClassNotFoundException e) {
        throw new MessageConversionException("failed to resolve class name. Class not found [" + classId + "]",
                e);
    } catch (LinkageError e) {
        throw new MessageConversionException("failed to resolve class name. Linkage error [" + classId + "]",
                e);
    }
}

From source file:org.chtijbug.drools.platform.web.annotation.JsonPathArgumentResolver.java

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    String body = getRequestBody(webRequest);
    JSONArray jsonArray = JsonPath.read(body, parameter.getParameterAnnotation(JsonArg.class).value());
    JavaType collectionType = TypeFactory.defaultInstance().constructType(parameter.getGenericParameterType());
    return objectMapper.readValue(jsonArray.toJSONString(), collectionType);
}

From source file:com.vethrfolnir.services.DataMappingService.java

@Inject
private void load() {
    if (assetManager == null) {
        throw new RuntimeException(
                "AssetManaget has not been set in your setup! Mapping service cannot be performed!");
    }/*from ww w  .j  av a 2 s . com*/

    defaultTypeFactory = TypeFactory.defaultInstance();

    jsonMapper.setVisibilityChecker(jsonMapper.getDeserializationConfig().getDefaultVisibilityChecker()
            .withCreatorVisibility(JsonAutoDetect.Visibility.NONE)
            .withFieldVisibility(JsonAutoDetect.Visibility.ANY)
            .withGetterVisibility(JsonAutoDetect.Visibility.NONE)
            .withIsGetterVisibility(JsonAutoDetect.Visibility.NONE)
            .withSetterVisibility(JsonAutoDetect.Visibility.NONE));

    jsonMapper.configure(SerializationFeature.INDENT_OUTPUT, true).configure(Feature.ALLOW_COMMENTS, true);

    defaultPrettyPrinter = new DefaultPrettyPrinter();
    defaultPrettyPrinter.indentArraysWith(new Lf2SpacesIndenter());
}

From source file:io.jjcastillo.bconferencia.helper.Storage.java

public static ArrayList<Auditorio> fromJSON(final String jsonPacket) {
    ArrayList<Auditorio> data = null;
    try {/*from w ww  . ja  va  2  s  . c o  m*/
        data = new ObjectMapper().readValue(jsonPacket,
                TypeFactory.defaultInstance().constructCollectionType(List.class, Auditorio.class));
    } catch (Exception e) {
        // Handle the problem
        System.out.println(e.getMessage());
    }
    return data;
}

From source file:com.github.jasonruckman.sidney.core.type.Types.java

public static JavaType parameterizedType(Class<?> type, Class[] paramTypes) {
    return TypeFactory.defaultInstance().constructParametricType(type, paramTypes);
}