Type Parameters:: JsonTreeType - the type of the internal tree structure used by the underlying JSON library

All Known Implementing Classes:: GsonJsonHandler, JacksonJsonHandler

public interface JsonHandler<JsonTreeType>

Handler for parsing, patching and serializing Objects to JSON

The following example implements a JsonHandler using the Jackson JSON library

import com.caplin.datasource.messaging.json.JsonHandler;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.fge.jsonpatch.JsonPatch;
import com.github.fge.jsonpatch.diff.JsonDiff;

import java.util.logging.Level;
import java.util.logging.Logger;

public class JacksonJsonHandler implements JsonHandler {
        private Logger logger;
        private ObjectMapper objectMapper;
        
        public JacksonJsonHandler(Logger logger, ObjectMapper objectMapper) {
                this.logger = logger;
                this.objectMapper = objectMapper;
        }
        
        public JacksonJsonHandler(Logger logger) {
                this(logger, new ObjectMapper());
        }
        
        public JacksonJsonHandler() {
                this(Logger.getLogger(JacksonJsonHandler.class.getName()));
        }
        
        @Override
        public JsonNode toJsonTree(Object userObject) {
        logger.log(Level.FINER, "JacksonJsonHandler.toJsonElement {0}", userObject);
                return objectMapper.valueToTree(userObject);
        }
        
        @Override
        public Object toObject(JsonNode jsonNode, Class userType) throws Exception {
        logger.log(Level.FINER, "JacksonJsonHandler.toObject {0} {1}", new Object[] {jsonNode, userType.getName()});
                return objectMapper.treeToValue(jsonNode, userType);
        }
        
        @Override
        public JsonNode parse(String jsonText) throws Exception {
        logger.log(Level.FINER, "JacksonJsonHandler.parse {0}", jsonText);
                return objectMapper.readTree(jsonText);
        }
        
        @Override
        public String format(JsonNode jsonNode) throws Exception {
        logger.log(Level.FINER, "JacksonJsonHandler.format {0}", jsonNode);
                return objectMapper.writeValueAsString(jsonNode);
        }
        
        @Override
        public JsonNode diff(JsonNode source, JsonNode target) {
        logger.log(Level.FINER, "JacksonJsonHandler.diff {0} {1}", new Object[]{source, target});
                JsonNode patchNode = JsonDiff.asJson(source, target);
                return patchNode;
        }
        
        @Override
        public JsonNode patch(JsonNode source, JsonNode diff) throws Exception {
        logger.log(Level.FINER, "JacksonJsonHandler.patch {0} {1}", new Object[] { source, diff});
                JsonPatch patch = JsonPatch.fromJson(diff);
                JsonNode patched = patch.apply(source);
                return patched;
        }
}

The following example implements a JsonHandler using the GSON JSON library

import com.caplin.datasource.messaging.json.JsonHandler;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.tananaev.jsonpatch.JsonPatchFactory;
import com.tananaev.jsonpatch.gson.AbsOperationDeserializer;
import com.tananaev.jsonpatch.gson.JsonPathDeserializer;
import com.tananaev.jsonpatch.gson.JsonPathSerializer;

import java.util.logging.Level;
import java.util.logging.Logger;

public class GsonJsonHandler implements JsonHandler {
        private Logger logger;
        private Gson gsonSerializer;
        private Gson gsonDeserializer;
        private JsonPatchFactory patchFactory;
        private GsonBuilder gsonBuilder;
        
        public GsonJsonHandler() {
                this(Logger.getLogger(GsonJsonHandler.class.getName()));
        }
        
        public GsonJsonHandler(Logger logger) {
                this.logger = logger;
                this.patchFactory = new JsonPatchFactory();
                
                this.gsonBuilder = new GsonBuilder();
                this.gsonBuilder.registerTypeAdapter(com.tananaev.jsonpatch.JsonPath.class, new JsonPathSerializer());
                this.gsonSerializer = gsonBuilder.create();
                
                this.gsonBuilder = new GsonBuilder();
                this.gsonBuilder.registerTypeAdapter(com.tananaev.jsonpatch.operation.AbsOperation.class, new AbsOperationDeserializer());
                this.gsonBuilder.registerTypeAdapter(com.tananaev.jsonpatch.JsonPath.class, new JsonPathDeserializer());
                this.gsonDeserializer = gsonBuilder.create();
        }
        
        @Override
        public JsonElement toJsonTree(Object userObject) {
        logger.log(Level.FINER, "GsonJsonHandler.toJsonElement {0}", userObject);
                return gsonSerializer.toJsonTree(userObject);
        }
        
        @Override
        public Object toObject(JsonElement jsonElement, Class userType) throws Exception {
        logger.log(Level.FINER, "GsonJsonHandler.toObject {0} {1}", new Object[] {jsonElement, userType.getName()});
                return gsonSerializer.fromJson((JsonElement)jsonElement, userType);
        }
        
        @Override
        public JsonElement parse(String jsonText) throws Exception {
        logger.log(Level.FINER, "GsonJsonHandler.parse {0}", jsonText);
                return JsonParser.parseString(jsonText);
        }
        
        @Override
        public String format(JsonElement jsonElement) throws Exception {
        logger.log(Level.FINER, "GsonJsonHandler.format {0}", jsonElement);
                return gsonSerializer.toJson(jsonElement);
        }
        
        @Override
        public JsonElement diff(JsonElement source, JsonElement target) {
        logger.log(Level.FINER, "GsonJsonHandler.diff {0} {1}", new Object[]{source, target});
                com.tananaev.jsonpatch.JsonPatch patchNode = patchFactory.create(source, target);
                return gsonSerializer.toJsonTree(patchNode);
        }
        
        @Override
        public JsonElement patch(JsonElement source, JsonElement diff) throws Exception {
        logger.log(Level.FINER, "GsonJsonHandler.patch {0} {1}", new Object[] { source, diff});
                com.tananaev.jsonpatch.JsonPatch patch = gsonDeserializer.fromJson(diff, com.tananaev.jsonpatch.JsonPatch.class);
                JsonElement patched = patch.apply(source);
                return patched;
        }
}

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`JsonTreeType`	`diff(JsonTreeType source, JsonTreeType target)`	Creates a JSON patch of the difference between two JSON tree representations
`java.lang.String`	`format(JsonTreeType jsonTree)`	Formats a JSON tree representation of an object to a JSON String.
`JsonTreeType`	`parse(java.lang.String jsonText)`	Parses a JSON text into a JSON tree representation used by the underlying JSON library.
`JsonTreeType`	`patch(JsonTreeType source, JsonTreeType jsonPatch)`	Updates a JSON tree representation with a JSON patch
`JsonTreeType`	`toJsonTree(java.lang.Object pojo)`	Serializes a plain Java object (POJO) to a JSON tree representation used by the underlying JSON library.
`java.lang.Object`	`toObject(JsonTreeType jsonTree, java.lang.Class userType)`	Deserializes a JSON tree representation to a plain Java object

- Method Detail
  - toJsonTree
```
JsonTreeType toJsonTree(java.lang.Object pojo)
                 throws java.lang.Exception
```
    Serializes a plain Java object (POJO) to a JSON tree representation used by the underlying JSON library.
    
    Parameters:
    
    pojo - a plain Java object
    
    Returns:
    
    a JSON tree representation of the object
    
    Throws:
    
    java.lang.Exception - if conversion fails
  - toObject
```
java.lang.Object toObject(JsonTreeType jsonTree,
                          java.lang.Class userType)
                   throws java.lang.Exception
```
    Deserializes a JSON tree representation to a plain Java object
    
    Parameters:
    
    jsonTree - a JSON tree representation of the object
    
    userType - the type of the object to deserialize into
    
    Returns:
    
    a new object of type userType
    
    Throws:
    
    java.lang.Exception - if deserialization fails
  - parse
```
JsonTreeType parse(java.lang.String jsonText)
            throws java.lang.Exception
```
    Parses a JSON text into a JSON tree representation used by the underlying JSON library.
    
    Parameters:
    
    jsonText - the JSON text to parse
    
    Returns:
    
    a JSON tree representation of the JSON text
    
    Throws:
    
    java.lang.Exception - if the parsing fails
  - format
```
java.lang.String format(JsonTreeType jsonTree)
                 throws java.lang.Exception
```
    Formats a JSON tree representation of an object to a JSON String.
    
    Parameters:
    
    jsonTree - a JSON tree representation of an object
    
    Returns:
    
    the JSON String
    
    Throws:
    
    java.lang.Exception - if formatting fails
  - diff
```
JsonTreeType diff(JsonTreeType source,
                  JsonTreeType target)
           throws java.lang.Exception
```
    Creates a JSON patch of the difference between two JSON tree representations
    
    Parameters:
    
    source - a JSON tree representation of the source object
    
    target - a JSON tree representation of the target object
    
    Returns:
    
    a JSON tree representation of the JSON patch needed to patch source to create target.
    
    Throws:
    
    java.lang.Exception - if the difference operation fails
  - patch
```
JsonTreeType patch(JsonTreeType source,
                   JsonTreeType jsonPatch)
            throws java.lang.Exception
```
    Updates a JSON tree representation with a JSON patch
    
    Parameters:
    
    source - a JSON tree representation of the source object
    
    jsonPatch - a JSON tree representation of the JSON patch
    
    Returns:
    
    the updated, patched object
    
    Throws:
    
    java.lang.Exception - if the patch fails

Interface JsonHandler<JsonTreeType>

Method Summary

Method Detail

toJsonTree

toObject

parse

format

diff

patch