Java Jackson Usage Example.

JacksonHelper.java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.util.TokenBuffer;

public class JacksonHelper {

    private static final Logger LOG = LoggerFactory.getLogger(JacksonHelper.class);

    // define this by yourself
    public static ObjectMapper getObjectMapper();
  
    // read direction: json -> nodes -> object
    private static ObjectReader getObjectReader(Class<?> view) {
        if (view == null) {
            return getObjectMapper().reader();
        } else {
            return getObjectMapper().readerWithView(view);
        }
    }

    // write direction: object -> nodes -> json
    private static ObjectWriter getObjectWriter(Class<?> view) {
        if (view == null) {
            return getObjectMapper().writer();
        } else {
            return getObjectMapper().writerWithView(view);
        }
    }

    // string / bytes <=> nodes

    public static JsonNode json2tree(String json, Class<?> readView) {
        if (json == null) return null;
        try {
            ObjectReader reader = getObjectReader(readView);
            try (JsonParser parser = reader.getFactory().createParser(json)) {
                return reader.readTree(parser);
            }
        } catch (JsonProcessingException e) {
            if (LOG.isErrorEnabled()) {
                LOG.error(String.format("json2tree: %s", e.getMessage()));
            }
            return null;
        } catch (IOException e) {
            assert false; // never occur, no real i/o...
            return null;
        }
    }

    public static JsonNode jsonb2tree(byte[] jsonb, Class<?> readView) {
        if (jsonb == null) return null;
        try {
            ObjectReader reader = getObjectReader(readView);
            try (JsonParser parser = reader.getFactory().createParser(jsonb)) {
                return reader.readTree(parser);
            }
        } catch (JsonProcessingException e) {
            if (LOG.isErrorEnabled()) {
                LOG.error(String.format("jsonb2tree: %s", e.getMessage()));
            }
            return null;
        } catch (IOException e) {
            assert false; // never occur, no real i/o...
            return null;
        }
    }

    public static JsonNode json2tree(String json) {
        return json2tree(json, null);
    }

    public static JsonNode jsonb2tree(byte[] jsonb) {
        return jsonb2tree(jsonb, null);
    }

    public static String tree2json(TreeNode node, Class<?> writeView) {
        try {
            ObjectWriter writer = getObjectWriter(writeView);
            return writer.writeValueAsString(node);
        } catch (JsonProcessingException e) {
            if (LOG.isErrorEnabled()) {
                LOG.error(String.format("tree2json: %s", e.getMessage()));
            }
            return null;
        }
    }

    public static byte[] tree2jsonb(TreeNode node, Class<?> writeView) {
        try {
            ObjectWriter writer = getObjectWriter(writeView);
            return writer.writeValueAsBytes(node);
        } catch (JsonProcessingException e) {
            if (LOG.isErrorEnabled()) {
                LOG.error(String.format("tree2jsonb: %s", e.getMessage()));
            }
            return null;
        }
    }

    public static String tree2json(TreeNode node) {
        return tree2json(node, null);
    }

    public static byte[] tree2jsonb(TreeNode node) {
        return tree2jsonb(node, null);
    }

    // nodes <=> object

    public static JavaType typeOf(Type type) {
        ObjectMapper objectMapper = getObjectMapper();
        return objectMapper.getTypeFactory().constructType(type);
    }

    public static JavaType typeOf(TypeReference typeRef) {
        return typeOf(typeRef.getType());
    }

    public static <T> T tree2object(TreeNode node, JavaType type, Class<?> readView) {
        if (node == null) return null;
        try {
            ObjectReader reader = getObjectReader(readView).forType(type);
            return reader.readValue(node.traverse(reader));
        } catch (JsonProcessingException e) {
            if (LOG.isErrorEnabled()) {
                LOG.error(String.format("tree2object(%s): %s", type.getRawClass().getName(), e.getMessage()));
            }
            return null;
        } catch (IOException e) {
            assert false; // never occur, no real i/o...
            return null;
        }
    }

    public static <T> T tree2object(TreeNode node, TypeReference<T> valueTypeRef, Class<?> readView) {
        return tree2object(node, typeOf(valueTypeRef), readView);
    }

    public static <T> T tree2object(TreeNode node, Type clazz, Class<?> readView) {
        return tree2object(node, typeOf(clazz), readView);
    }

    public static <T> T tree2object(TreeNode node, JavaType type) {
        return tree2object(node, type, null);
    }

    public static <T> T tree2object(TreeNode node, TypeReference<T> valueTypeRef) {
        return tree2object(node, valueTypeRef, null);
    }

    public static <T> T tree2object(TreeNode node, Type clazz) {
        return tree2object(node, clazz, null);
    }

    public static JsonNode object2tree(Object object, Class<?> writeView) {
        if (object == null) return null;
        try {
            ObjectReader reader = getObjectReader(null);

            TokenBuffer buffer = new TokenBuffer(reader, false);
            if (reader.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
                buffer.forceUseOfBigDecimal(true);
            }

            ObjectWriter writer = getObjectWriter(writeView);
            writer.writeValue(buffer, object);

            try (JsonParser parser = buffer.asParser()) {
                return reader.readTree(parser);
            }
        } catch (IOException e) {
            assert false; // never occur, no real i/o...
            return null;
        }
    }

    public static JsonNode object2tree(Object object) {
        return object2tree(object, null);
    }

    // string / bytes <=> object

    public static <T> T json2object(String json, JavaType type) {
        if (json == null) return null;
        return tree2object(json2tree(json), type, null);
    }

    public static <T> T jsonb2object(byte[] jsonb, JavaType type) {
        if (jsonb == null) return null;
        return tree2object(jsonb2tree(jsonb), type, null);
    }

    public static <T> T jsonb2object(byte[] jsonb, Type type) {
        return jsonb2object(jsonb, typeOf(type));
    }

    public static <T> T jsonb2object(byte[] jsonb, TypeReference<T> valueTypeRef) {
        return jsonb2object(jsonb, typeOf(valueTypeRef));
    }

    public static <T> T json2object(String json, Type type) {
        return json2object(json, typeOf(type));
    }

    public static <T> T json2object(String json, TypeReference<T> valueTypeRef) {
        return json2object(json, typeOf(valueTypeRef));
    }

    public static String object2json(Object object) {
        if (object == null) return null;
        return tree2json(object2tree(object));
    }

    public static byte[] object2jsonb(Object object) {
        if (object == null) return null;
        return tree2jsonb(object2tree(object));
    }
}