Home » Java » Jackson Vs. Gson [closed]

Jackson Vs. Gson [closed]

Posted by: admin November 2, 2017 Leave a comment


After searching through some existing libraries for JSON, I have finally ended up with these two:

  • Jackson
  • Google GSon

I am a bit partial towards GSON, but word on the net is that GSon suffers from a certain celestial performance issue (as of Sept 2009).

I am continuing my comparison; in the meantime, I’m looking for help to make up my mind.


I did this research the last week and I ended up with the same 2 libraries. As I’m using Spring 3 (that adopts Jackson in its default Json view ‘JacksonJsonView‘) it was more natural for me to do the same. The 2 lib are pretty much the same… at the end they simply map to a json file! 🙂

Anyway as you said Jackson has a + in performance and that’s very important for me. The project is also quite active as you can see from their web page and that’s a very good sign as well.


Jackson and Gson are the most complete Java JSON packages regarding actual data binding support; many other packages only provide primitive Map/List (or equivalent tree model) binding.
Both have complete support for generic types, as well, as enough configurability for many common use cases.

Since I am more familiar with Jackson, here are some aspects where I think Jackson has more complete support than Gson (apologies if I miss a Gson feature):

  • Extensive annotation support; including full inheritance, and advanced “mix-in” annotations (associate annotations with a class for cases where you can not directly add them)
  • Streaming (incremental) reading, writing, for ultra-high performance (or memory-limited) use cases; can mix with data binding (bind sub-trees) — EDIT: latest versions of Gson also include streaming reader
  • Tree model (DOM-like access); can convert between various models (tree <-> java object <-> stream)
  • Can use any constructors (or static factory methods), not just default constructor
  • Field and getter/setter access (earlier gson versions only used fields, this may have changed)
  • Out-of-box JAX-RS support
  • Interoperability: can also use JAXB annotations, has support/work-arounds for common packages (joda, ibatis, cglib), JVM languages (groovy, clojure, scala)
  • Ability to force static (declared) type handling for output
  • Support for deserializing polymorphic types (Jackson 1.5) — can serialize AND deserialize things like List correctly (with additional type information)
  • Integrated support for binary content (base64 to/from JSON Strings)

Gson 1.6 now includes a low-level streaming API and a new parser which is actually faster than Jackson.


Adding to other answers already given above. If case insensivity is of any importance to you, then use Jackson. Gson does not support case insensitivity for key names, while jackson does.

Here are two related links

(No) Case sensitivity support in Gson :
GSON: How to get a case insensitive element from Json?

Case sensitivity support in Jackson


It seems that GSon don’t support JAXB.
By using JAXB annotated class to create or process the JSON message, I can share the same class to create the Restful Web Service interface by using spring MVC.