What is the best json pojo converter - json

Question

Here i am listing some json to pojo convertion java api's
GSon
Jackson
JSONGen
JSON Tools
Can you please list out these api's according their performance and ease of use. Also let me know if there is any other java api which is better than the above

Answer 1

Mainly this depends on the context of what kind of app are you developing, and it it is in the client side (for example, Android) or in the server side (for example, SpringMVC). This is my experience, maybe someone has more points to prove that me. I always use Jackson in SpringMVC servers, why?, because It's simple, when you're developing a RESTfull webservices you leave to SpringMVC the managment of the system such as redirect requests, perform the bussiness logic, and more. You will have then two servlets one to manage the page request such as go to http://myserver.com/home/myprofile/ and another servlet to expose an RESTfull api, this is where Jackson enter, as you know (or maybe not) all the webapps that run in Tomcat has an web.xml, here you tell to the Tomcat instance who servlet It's gonna to handle what request, checkout this example:
<!-- Spring MVC Dispatcher Servlet -->
<servlet>
<servlet-name>SpringMvcServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:config/applicationContext.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>SpringMvcServlet</servlet-name>
<url-pattern>/home/*</url-pattern>
</servlet-mapping>
<!-- Jersey -->
<servlet>
<servlet-name>jersey-serlvet</servlet-name>
<servlet-class>com.sun.jersey.spi.spring.container.servlet.SpringServlet</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>ar.com.kimboo.server.rest</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>jersey-serlvet</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
Jersey It's a library that uses Jackson to serialize/deserialize HttpRequest. Note that all the request to /home/* are handled by SpringMVC and all request to /rest/* are handled by Jersey. So when you hit something like hit to "http://server.com/server/rest/animals/" and the request It's delivered to:
#Component
#Path("/animals")
public class AdvertisingRESTServiceImpl {
#Autowired AnimalServiceImpl animalsService;
/**
* #return All animals in the db.
* #uri http://localhost:8080/server/rest/animals/
*/
#GET #Path("/") #Produces(MediaType.APPLICATION_JSON)
public #ResponseBody List<Animals> getAllAnimals() {
return animalsService.getAllAnimals();
}
}
You can return a collection of Objects and Jersey will take care of serialize them. Everything behind scene without configure nothing but some xml. Sure you can use another libraries to serialize json in the server side like GSON. But you have to implmenet your own HttpMessageConverter (this class takes care of serialize/deserialize the json) what Jersey already had.
Always that I work in the client side (Android) I use gson to serialize/deserialize json from the server side. I prefer used Gson because It's pretty simple you, rather than use RestTemplate or some library. The only thing that I need do with Gson is... nothing:
This turn an object instance into json:
String json = new Gson().toJson(new Puppy("Robert",2));
And this turns a json into an object:
Animal robert = new Gson().fromJson("{name:\"Robert\",age:\"2\"}", Animal.class);
With this kind of tool you can do some cool Restfull http client, like this one:
public class HttpFuck {
Gson gson = new Gson();
public <T> T post(String url, Class<T> clazz, List<NameValuePair> parameters) {
// Create a new HttpClient and Post Header
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(url);
try {
// Add your data
httppost.setEntity(new UrlEncodedFormEntity(parameters));
// Execute HTTP Post Request
HttpResponse response = httpclient.execute(httppost);
StringBuilder json = inputStreamToString(response.getEntity().getContent());
T gsonObject = gson.fromJson(json.toString(), clazz);
return gsonObject;
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public <T> T get(String url, Class<T> clazz) {
// Create a new HttpClient and Post Header
HttpClient httpclient = new DefaultHttpClient();
HttpGet httppost = new HttpGet(url);
try {
// Execute HTTP Post Request
HttpResponse response = httpclient.execute(httppost);
StringBuilder json = inputStreamToString(response.getEntity().getContent());
T gsonObject = gson.fromJson(json.toString(), clazz);
return gsonObject;
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
// Fast Implementation
private StringBuilder inputStreamToString(InputStream is) throws IOException {
String line = "";
StringBuilder total = new StringBuilder();
// Wrap a BufferedReader around the InputStream
BufferedReader rd = new BufferedReader(new InputStreamReader(is));
// Read response until the end
while ((line = rd.readLine()) != null) {
total.append(line);
}
// Return full string
return total;
}
}
The bad news are that you have to wrap almost everything in an object. For example you cant do something like new Gson().fromJson(string, String.class). But It's pretty flexive, I strongly recommend it to use it in Android apps.
Well long story short, this is all that I know about json technologies, hope this helps you. :)