Annyce Davis

Davis Technology Consulting

Android: Custom Gson Deserialization

by

So here’s the scenario you have a JSON Object that contains a list of objects. Each one of the objects in the primary JSON Object also contain a list of objects. So for demonstration purposes we will use a car with a list of seats and each seat has a list of buckles (Car -> Seats -> Buckles). Completely random example, yes I know.

So if you have the use case where you don’t want to deserialize any seats that don’t have buckles this is how you can do it using a Custom GSON Deserializer.

First, this is a sample JSON response which contains the information for each car:

[{
    "description": "A nice car",
    "name": "Toyota",
    "seats": [{
        "buckles": [],
        "type": "front"
    }, {
        "buckles": ["latch", "snap"],
        "type": "front"
    }]
}]

What you will notice is that there is one Seat object that has an empty list of Buckle objects. So in that case you don’t want Gson to include that seat in the final list of seat objects.  We will use two advanced features of Gson: Exclusion Strategies and Custom Deserializer. 

Since we want to handle the “seats” array on our own we will create an Annotation that can be used by Gson to ignore the field during normal processing.

Car Class (portion):

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface SkipThis {

}

@SkipThis
private List<SeatVO> seats;

Now we can proceed to exclude any field that has our custom SkipThis annotation by means of an ExclusionStrategy.

private static class SkipThisAnnotationExclusionStrategy
implements ExclusionStrategy {
    public boolean shouldSkipClass(Class clazz) {
        return clazz.getAnnotation(CarVO.SkipThis.class) != null;
    }
 
    public boolean shouldSkipField(FieldAttributes f) {
        return f.getAnnotation(CarVO.SkipThis.class) != null;
    }
}

Finally, we can proceed to create the custom deserializer that will check for the existence of items in the “buckles” array.

@Override
public CarVO deserialize(JsonElement json, Type arg1,
                         JsonDeserializationContext arg2) throws JsonParseException {
  JsonObject carsJSON = json.getAsJsonObject();
  JsonArray seatsJSON = carsJSON.getAsJsonArray("seats");
 
  Gson g = new Gson();
  CarVO carVO = g.fromJson(json, CarVO.class);
  List<SeatVO> res = new ArrayList<SeatVO>();
 
  for (JsonElement elem : seatsJSON) {
    JsonArray bucklesJSON = elem.getAsJsonObject().getAsJsonArray("buckles");
    if (!bucklesJSON.isJsonNull() && bucklesJSON.size() > 0) {
      res.add(g.fromJson(elem, SeatVO.class));
    }
  }
 
  carVO.setSeats(res);
 
  return carVO;
}

The complete code:

Storing JSON in External EhCache Server

by

If you would like to store JSON data in an external EhCache Server you would need to use either REST or SOAP calls.  The below example uses REST calls and the HTTPBuilder library.  It assumes that you have your EhCache Server running at the following location:
http://localhost:8080/ehcache/rest.

The name of the cache that I’m using in this example is just sampleCache.

def getCachedItem(key) {
    def uri = "http://localhost:8080/ehcache/rest/sampleCache/"
    def restClient = new RESTClient(uri)

    def res
    try {
      res = restClient.get(path:key)
    }
    catch (Exception e) {
      log.error("Error retrieving item from cache for this key: $key")
    }
    
    return res?.data
  }

  def putCachedItem(key, html) {
    def url = "http://localhost:8080/ehcache/rest/sampleCache/"

    try {
      def json = html as grails.converters.JSON

      def http = new HTTPBuilder(url)
      http.request(Method.PUT) { req ->
        uri.path = key
        send('application/json', grails.converters.JSON.parse(json?.toString()))
        
        response.'201' = { resp ->
          log.info("success in adding item to cache: ${resp.status}")
        }

        response.success = { resp, object ->
          log.info("success in adding item to cache: ${resp.status}")
        }

        response.failure = { resp ->
          log.error("error adding item to cache: ${resp.statusLine}")
        }
      }
    }
    catch (Exception e) {
      log.error("Error setting the cache for this key: $key")
    }
  }

Using Grails’ JSON and HTML Builders

by

In order to generate JSON in groovy that can then be passed to a Grails controller you should use the JSONBuilder class. This class is part of the Grails util package. The code below demonstrates how to generate JSON and HTML.

Resulting JSON that is produced:

ResultSet {['text':'google', 'url':'http://www.google.com'], ...}

def writer = new StringWriter();
new grails.util.JSonBuilder(writer).json {
  ResultSet {
    links.each { link ->
      Links(text: link.text, url: link.url)
    }
  }
}
writer.toString()

This is the code to do the same with HTML, you would use the Groovy XML MarkupBuilder instead.


StringWriter w = new StringWriter()
def builder = new groovy.xml.MarkupBuilder(w)

builder.div (class: 'className'){
  links.each { link ->
    p {
      b 'Title: '
      builder.yield link.text
    }
  }
}
w.toString()

Resulting HTML that is produced:
<div class=”className”>
<p><b>Title: </b>google</p>
</div>

Follow Me

  • Bluesky