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

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

Introduction

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

Prototype

@Override
public JsonFactory getFactory() 

Source Link

Document

Method that can be used to get hold of JsonFactory that this mapper uses if it needs to construct JsonParser s and/or JsonGenerator s.

Usage

From source file:com.iflytek.edu.cloud.frame.doc.BuildDocMain.java

public static void main(String[] args) throws Exception {
    ServiceDocBuilder docBuilder = new ServiceDocBuilder();
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    File jsonFile = getJsonFile();
    JsonGenerator jsonGenerator = mapper.getFactory().createGenerator(jsonFile, JsonEncoding.UTF8);
    jsonGenerator.writeObject(docBuilder.buildDoc());

    LOGGER.info("?API?" + jsonFile.getPath());
}

From source file:de.softwareforge.streamery.StreameryMain.java

public static final void main(String... args) throws Exception {
    final ObjectMapper mapper = new ObjectMapper();
    final DBI h2Dbi = getH2Dbi();

    setupData(h2Dbi);/*from  ww w.  j  a  v a2 s.co m*/

    mapper.enable(SerializationFeature.INDENT_OUTPUT);

    Query<Data> q = h2Dbi.open().createQuery("SELECT * FROM data").setFetchSize(200).map(DataMapper.INSTANCE);

    final Observable<Data> observable = JdbiObservable.from(q);

    observable.subscribe(new JsonStreamer<>(mapper.getFactory()));
}

From source file:com.infinities.keystone4j.utils.JsonUtils.java

public static JsonNode convertToJsonNode(String text) throws JsonProcessingException, IOException {
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory factory = mapper.getFactory(); // since 2.1 use
    // mapper.getFactory()
    // instead//from   w w  w .ja v  a2  s . co  m
    JsonParser jp = factory.createParser(text);
    JsonNode node = mapper.readTree(jp);
    return node;
}

From source file:je.backit.rest.JacksonContextResolver.java

private static ObjectMapper init() {
    ObjectMapper om = new ObjectMapper();
    om.registerModule(new JSR310Module());
    om.registerModule(new JooqModule());
    om.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    om.getFactory().configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false)
            .configure(JsonGenerator.Feature.FLUSH_PASSED_TO_STREAM, false);
    om.configure(WRITE_DATES_AS_TIMESTAMPS, false);
    om.setVisibilityChecker(om.getSerializationConfig().getDefaultVisibilityChecker()
            .withIsGetterVisibility(NONE).withGetterVisibility(NONE).withFieldVisibility(ANY));
    return om;/*w ww  .  j  a  v a  2  s .  co  m*/
}

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

public static String encode(Object o) throws IOException {
    StringWriter writer = new StringWriter();
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
    JsonFactory factory = mapper.getFactory();
    try (JsonGenerator g = factory.createGenerator(writer)) {
        g.writeStartObject();/*from   w w  w .  jav a2  s .  co  m*/
        for (Field f : o.getClass().getDeclaredFields()) {
            try {
                f.setAccessible(true);
                Object value = f.get(o);
                if (value != null) {
                    if (f.getType().isAssignableFrom(List.class)) {
                        String items = mapper.writeValueAsString(value);
                        g.writeStringField(f.getName(), items);
                    } else if (f.getType().isArray()) {
                        if (f.getType().getComponentType().isAssignableFrom(byte.class)) {
                            g.writeBinaryField(f.getName(), (byte[]) value);
                        } else {
                            int length = Array.getLength(value);
                            g.writeFieldName(f.getName());
                            g.writeStartArray();
                            for (int i = 0; i < length; i++) {
                                Object av = Array.get(value, i);
                                if (av instanceof Double) {
                                    g.writeNumber(new BigDecimal((Double) av).toPlainString());
                                } else if (av instanceof Float) {
                                    g.writeNumber(new BigDecimal((Float) av).toPlainString());
                                } else if (av instanceof Integer) {
                                    g.writeNumber(new BigDecimal((Integer) av).toPlainString());
                                } else {
                                    g.writeObject(av);
                                }
                                /*if (av instanceof Double)
                                g.writeNumber(new BigDecimal((Double) av));
                                else if (av instanceof Float)
                                g.writeNumber(new BigDecimal((Float) av));
                                else if (av instanceof Integer)
                                g.writeNumber((Integer) av);*/
                            }
                            g.writeEndArray();
                        }
                    } else {
                        g.writeObjectField(f.getName(), value);
                    }
                }

            } catch (IllegalAccessException e) {
                logger.warn("Could not get field: {}", f.getName(), e);
            }
        }
        g.writeEndObject();
    }
    if (logger.isDebugEnabled())
        logger.debug(writer.toString());
    return writer.toString();
}

From source file:com.threecrickets.jygments.style.Style.java

@SuppressWarnings("unchecked")
public static Style getByFullName(String fullName) throws ResolutionException {
    // Try cache/*from w w w  .  j  a v  a 2s  .  c o m*/
    Style style = styles.get(fullName);
    if (style != null)
        return style;

    try {
        return (Style) Jygments.class.getClassLoader().loadClass(fullName).newInstance();
    } catch (InstantiationException x) {
    } catch (IllegalAccessException x) {
    } catch (ClassNotFoundException x) {
    }

    InputStream stream = Jygments.class.getClassLoader()
            .getResourceAsStream(fullName.replace('.', '/') + ".json");
    if (stream != null) {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.getFactory().configure(JsonParser.Feature.ALLOW_COMMENTS, true);
        try {
            Map<String, Object> json = objectMapper.readValue(stream, HashMap.class);
            style = new Style();
            style.addJson(json);
            style.resolve();

            // Cache it
            Style existing = styles.putIfAbsent(fullName, style);
            if (existing != null)
                style = existing;

            return style;
        } catch (JsonParseException x) {
            throw new ResolutionException(x);
        } catch (JsonMappingException x) {
            throw new ResolutionException(x);
        } catch (IOException x) {
            throw new ResolutionException(x);
        }
    }

    return null;
}

From source file:com.threecrickets.jygments.grammar.Lexer.java

@SuppressWarnings("unchecked")
public static Lexer getByFullName(String fullName) throws ResolutionException {
    // Try cache/*w w w .jav a  2s. c  om*/
    Lexer lexer = lexers.get(fullName);
    if (lexer != null)
        return lexer;

    try {
        return (Lexer) Jygments.class.getClassLoader().loadClass(fullName).newInstance();
    } catch (InstantiationException x) {
    } catch (IllegalAccessException x) {
    } catch (ClassNotFoundException x) {
    }

    InputStream stream = Jygments.class.getClassLoader()
            .getResourceAsStream(fullName.replace('.', '/') + ".json");
    if (stream != null) {
        try {
            String converted = Util.rejsonToJson(stream);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.getFactory().configure(JsonParser.Feature.ALLOW_COMMENTS, true);
            Map<String, Object> json = objectMapper.readValue(converted, HashMap.class);
            Object className = json.get("class");
            if (className == null)
                className = "";

            lexer = getByName(className.toString());
            lexer.addJson(json);
            lexer.resolve();

            if (lexer != null) {
                // Cache it
                Lexer existing = lexers.putIfAbsent(fullName, lexer);
                if (existing != null)
                    lexer = existing;
            }

            return lexer;
        } catch (JsonParseException x) {
            throw new ResolutionException(x);
        } catch (JsonMappingException x) {
            throw new ResolutionException(x);
        } catch (IOException x) {
            throw new ResolutionException(x);
        }
    }

    return null;
}

From source file:info.bonjean.quinkana.Main.java

private static void run(String[] args) throws QuinkanaException {
    Properties properties = new Properties();
    InputStream inputstream = Main.class.getResourceAsStream("/config.properties");

    try {/*ww  w  .  j  a  va 2  s.co  m*/
        properties.load(inputstream);
        inputstream.close();
    } catch (IOException e) {
        throw new QuinkanaException("cannot load internal properties", e);
    }

    String name = (String) properties.get("name");
    String description = (String) properties.get("description");
    String url = (String) properties.get("url");
    String version = (String) properties.get("version");
    String usage = (String) properties.get("help.usage");
    String defaultHost = (String) properties.get("default.host");
    int defaultPort = Integer.valueOf(properties.getProperty("default.port"));

    ArgumentParser parser = ArgumentParsers.newArgumentParser(name).description(description)
            .epilog("For more information, go to " + url).version("${prog} " + version).usage(usage);
    parser.addArgument("ACTION").type(Action.class).choices(Action.tail, Action.list).dest("action");
    parser.addArgument("-H", "--host").setDefault(defaultHost)
            .help(String.format("logstash host (default: %s)", defaultHost));
    parser.addArgument("-P", "--port").type(Integer.class).setDefault(defaultPort)
            .help(String.format("logstash TCP port (default: %d)", defaultPort));
    parser.addArgument("-f", "--fields").nargs("+").help("fields to display");
    parser.addArgument("-i", "--include").nargs("+").help("include filter (OR), example host=example.com")
            .metavar("FILTER").type(Filter.class);
    parser.addArgument("-x", "--exclude").nargs("+")
            .help("exclude filter (OR, applied after include), example: severity=debug").metavar("FILTER")
            .type(Filter.class);
    parser.addArgument("-s", "--single").action(Arguments.storeTrue()).help("display single result and exit");
    parser.addArgument("--version").action(Arguments.version()).help("output version information and exit");

    Namespace ns = parser.parseArgsOrFail(args);

    Action action = ns.get("action");
    List<String> fields = ns.getList("fields");
    List<Filter> includes = ns.getList("include");
    List<Filter> excludes = ns.getList("exclude");
    boolean single = ns.getBoolean("single");
    String host = ns.getString("host");
    int port = ns.getInt("port");

    final Socket clientSocket;
    final InputStream is;
    try {
        clientSocket = new Socket(host, port);
        is = clientSocket.getInputStream();
    } catch (IOException e) {
        throw new QuinkanaException("cannot connect to the server " + host + ":" + port, e);
    }

    // add a hook to ensure we clean the resources when leaving
    Runtime.getRuntime().addShutdownHook(new Thread() {
        @Override
        public void run() {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    });

    // prepare JSON parser
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory jsonFactory = mapper.getFactory();
    JsonParser jp;
    try {
        jp = jsonFactory.createParser(is);
    } catch (IOException e) {
        throw new QuinkanaException("error during JSON parser creation", e);
    }

    JsonToken token;

    // action=list
    if (action.equals(Action.list)) {
        try {
            // do this in a separate loop to not pollute the main loop
            while ((token = jp.nextToken()) != null) {
                if (token != JsonToken.START_OBJECT)
                    continue;

                // parse object
                JsonNode node = jp.readValueAsTree();

                // print fields
                Iterator<String> fieldNames = node.fieldNames();
                while (fieldNames.hasNext())
                    System.out.println(fieldNames.next());

                System.exit(0);
            }
        } catch (IOException e) {
            throw new QuinkanaException("error during JSON parsing", e);
        }
    }

    // action=tail
    try {
        while ((token = jp.nextToken()) != null) {
            if (token != JsonToken.START_OBJECT)
                continue;

            // parse object
            JsonNode node = jp.readValueAsTree();

            // filtering (includes)
            if (includes != null) {
                boolean skip = true;
                for (Filter include : includes) {
                    if (include.match(node)) {
                        skip = false;
                        break;
                    }
                }
                if (skip)
                    continue;
            }

            // filtering (excludes)
            if (excludes != null) {
                boolean skip = false;
                for (Filter exclude : excludes) {
                    if (exclude.match(node)) {
                        skip = true;
                        break;
                    }
                }
                if (skip)
                    continue;
            }

            // if no field specified, print raw output (JSON)
            if (fields == null) {
                System.out.println(node.toString());
                if (single)
                    break;
                continue;
            }

            // formatted output, build and print the string
            StringBuilder sb = new StringBuilder(128);
            for (String field : fields) {
                if (sb.length() > 0)
                    sb.append(" ");

                if (node.get(field) != null && node.get(field).textValue() != null)
                    sb.append(node.get(field).textValue());
            }
            System.out.println(sb.toString());

            if (single)
                break;
        }
    } catch (IOException e) {
        throw new QuinkanaException("error during JSON parsing", e);
    }
}

From source file:org.forgerock.openig.util.Json.java

private static <T> T parse(ObjectMapper mapper, Reader reader) throws IOException {
    if (reader == null) {
        return null;
    }/*from ww  w  . j  av  a 2s . co  m*/

    final JsonParser jp = mapper.getFactory().createParser(reader);
    final JsonToken jToken = jp.nextToken();
    if (jToken != null) {
        switch (jToken) {
        case START_ARRAY:
            return mapper.readValue(jp, new TypeReference<LinkedList<?>>() {
            });
        case START_OBJECT:
            return mapper.readValue(jp, new TypeReference<LinkedHashMap<String, ?>>() {
            });
        case VALUE_FALSE:
        case VALUE_TRUE:
            return mapper.readValue(jp, new TypeReference<Boolean>() {
            });
        case VALUE_NUMBER_INT:
            return mapper.readValue(jp, new TypeReference<Integer>() {
            });
        case VALUE_NUMBER_FLOAT:
            return mapper.readValue(jp, new TypeReference<Float>() {
            });
        case VALUE_NULL:
            return null;
        default:
            // This is very unlikely to happen.
            throw new IOException("Invalid JSON content");
        }
    }
    return null;
}

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  .  jav  a2s .  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);
            }
        }
    }
}