Quel est le meilleur JSON convertisseur POJO

Question

Ici, je suis annonce une JSON POJO convertion

java api

1. GSon
2. Jackson
3. JSONGen
4. JSON Outils

Pouvez-vous s'il vous plaît énumérer ces api en fonction de leurs performances et leur facilité d'utilisation. Aussi laissez-moi savoir s'il y a une autre API Java qui est meilleure que la précédente

Answer 1

Principalement cela dépend du contexte du type d'application que vous développez, et il est du côté du client (par exemple, Android) ou côté serveur (par exemple, SpringMVC). C'est mon expérience, peut-être que quelqu'un a plus de points pour le prouver. J'utilise toujours Jackson dans les serveurs SpringMVC, pourquoi ?, Parce que c'est simple, quand vous développez un webservices RESTfull, vous laissez à SpringMVC la gestion du système, comme les demandes de redirection, la logique métier, etc. Vous aurez alors deux servlets un pour gérer la demande de la page comme aller à http://myserver.com/home/myprofile/ et une autre servlet pour exposer une API RESTfull, c'est où Jackson entrer, comme vous le savez (ou peut-être pas) toutes les webapps qui tournent dans Tomcat a un web .xml, ici vous dire à l'instance Tomcat qui servlet Il est va gérer ce que demande, check-out cet exemple:

<!-- 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 C'est une bibliothèque qui utilise Jackson à linéariser/désérialiser HttpRequest. Notez que toutes les requêtes vers/home/* sont gérées par SpringMVC et toutes les requêtes vers/rest/* sont traitées par Jersey. Donc, quand vous frappez quelque chose comme frappé à « http://server.com/server/rest/animals/ » et la demande Il est livré à:

@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(); 
    } 

} 

Vous pouvez retourner une collection d'objets et de Jersey prendra soin de sérialisation. Tout derrière la scène sans configurer rien mais du xml. Bien sûr, vous pouvez utiliser d'autres bibliothèques pour sérialiser json sur le serveur comme GSON. Mais vous devez implémenter votre propre HttpMessageConverter (cette classe s'occupe de sérialiser/désérialiser le json) ce que Jersey avait déjà.

Toujours que je travaille côté client (Android) J'utilise gson pour sérialiser/désérialiser json du côté serveur. Je préfère utiliser Gson parce que c'est assez simple, plutôt que d'utiliser RestTemplate ou une bibliothèque. La seule chose que je dois faire avec Gson est ... rien:

ce tour une instance d'objet en JSON: String json = new Gson().toJson(new Puppy("Robert",2));

Et cela se JSON dans un objet: Animal robert = new Gson().fromJson("{name:\"Robert\",age:\"2\"}", Animal.class);

Avec cette genre d'outil que vous pouvez faire un certain client http Restfull cool, comme celui-ci:

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; 
    } 

} 

Les mauvaises nouvelles sont que vous devez envelopper presque tout dans un objet. Par exemple, vous ne pouvez pas faire quelque chose comme new Gson().fromJson(string, String.class). Mais il est assez flexible, je le recommande fortement pour l'utiliser dans les applications Android.

Bien longue histoire courte, c'est tout ce que je sais sur les technologies JSON, espérons que cela vous aide. :)