Json serialización de Java que funciona con GWT

Estoy buscando un serializador Json (de) simple para Java que pueda funcionar con GWT. Busqué en Google un poco y encontré algunas soluciones que requieren anotar a cada miembro o definir interfaces inútiles. Muy aburrido. ¿Por qué no tenemos algo realmente simple como

class MyBean { ... } new GoodSerializer().makeString(new MyBean()); new GoodSerializer().makeObject("{ ... }", MyBean.class) 

Echa un vistazo a los tipos de superposición de GWT. Creo que esta es, de lejos, la forma más fácil de trabajar con JSON en GWT. Aquí hay un ejemplo de código modificado del artículo vinculado:

 public class Customer extends JavaScriptObject { public final native String getFirstName() /*-{ return this.first_name; }-*/; public final native void setFirstName(String value) /*-{ this.first_name = value; }-*/; public final native String getLastName() /*-{ return this.last_name; }-*/; public final native void setLastName(String value) /*-{ this.last_name = value; }-*/; } 

Una vez que haya definido el tipo de superposición, es fácil crear un objeto JavaScript desde JSON y acceder a sus propiedades en Java:

 public static final native Customer buildCustomer(String json) /*-{ return eval('(' + json + ')'); }-*/; 

Si desea la representación JSON del objeto nuevamente, puede ajustar el tipo de superposición en un JSONObject:

 Customer customer = buildCustomer("{'Bart', 'Simpson'}"); customer.setFirstName("Lisa"); // Displays {"first_name":"Lisa","last_name":"Simpson"} Window.alert(new JSONObject(customer).toString()); 

Otra cosa que debes probar es el nuevo marco AutoBean presentado con GWT 2.1.

Usted define interfaces para sus beans y una fábrica que los vende, y GWT genera implementaciones para usted.

 interface MyBean { String getFoo(); void setFoo(String foo); } interface MyBiggerBean { List getBeans(); void setBeans(List beans>; } interface Beanery extends AutoBeanFactory{ AutoBean makeBean(); AutoBean makeBigBean(); } Beanery beanFactory = GWT.create(Beanery.class); void go() { MyBean bean = beanFactory.makeBean().as(); bean.setFoo("Hello, beans"); } 

El AutoBeanCodex se puede utilizar para serializarlos desde y hacia json.

 AutoBean autoBean = AutoBeanUtils.getAutoBean(bean); String asJson = AutoBeanCodex.encode(autoBean).getPayload(); AutoBean autoBeanCloneAB = AutoBeanCodex.decode(beanFactory, MyBean.class, asJson ); MyBean autoBeanClone = autoBeanCloneAB.as(); assertTrue(AutoBeanUtils.deepEquals(autoBean, autoBeanClone)); 

También funcionan del lado del servidor: use AutoBeanFactoryMagic.create(Beanery.class) lugar de GWT.create(Beanery.class) .

La forma más simple sería usar la API JSON incorporada de GWT. Aquí está la documentación . Y aquí hay un gran tutorial sobre cómo usarlo.

Es tan simple como esto:

 String json = //json string JSONValue value = JSONParser.parse(json); 

La API JSONValue es genial. Le permite encadenar validaciones a medida que extrae valores del objeto JSON para que se emitan excepciones si algo falla con el formato.

Parece que encontré la respuesta correcta a mi pregunta

Descubrí que la conversión de Bean a json y json to bean en GWT no es una tarea trivial. Las bibliotecas conocidas no funcionarían porque GWT requeriría su código fuente completo y este código fuente debe usar solo clases Java emuladas por GWT. Además, no puedes usar la reflexión en GWT. Requisitos muy difíciles!

Encontré la única solución existente llamada gwt-jsonizer . Utiliza una clase Generator personalizada y requiere una interfaz de satélite para cada bean “jsonable”. Lamentablemente, no funciona sin parches en la última versión de GWT y no se ha actualizado durante mucho tiempo.

Por lo tanto, personalmente decidí que es más barato y más rápido hacer que mis granos se conviertan a jason. Me gusta esto:

 public class SmartBean { private String name; public String getName() { return name; } public void setName(String value) { name = value; } public JSONObject toJson() { JSONObject result = new JSONObject(); result.put("name", new JSONString(this.name)); return result; } public void fromJson(JSONObject value) { this.name = value.get("name").isString().stringValue(); } } 

JSONxxxx son clases integradas de GWT que proporcionan soporte json de bajo nivel.

RestyGWT es una potente biblioteca para codificar o decodificar objetos Java para JSON en GWT:

 import javax.ws.rs.POST; ... public interface PizzaOrderCodec extends JsonEncoderDecoder { } 

Entonces:

 // GWT will implement the interface for you PizzaOrderCodec codec = GWT.create(PizzaOrderCodec.class); // Encoding an object to json PizzaOrder order = ... JSONValue json = codec.encode(order); // decoding an object to from json PizzaOrder other = codec.decode(json); 

También tiene varias API fáciles de usar para consumir servicios web tranquilos.

Pasar un buen rato.

Mira esto:

GWT Professional JSON Serializer: http://code.google.com/p/gwtprojsonserializer/

! Funciona con GWT 2.0+!

json.org/java parece estar incluido con GWT en estos días:

gwt-servlet-deps.jar \ org \ json \

O bien, este proyecto parece ser completo: http://code.google.com/p/piriti/

En Google Web Toolkit Applications, páginas 510 a 522, el autor, Ryan Dewsbury, muestra cómo usar la generación de código GWT para hacer serializaciones hacia y desde documentos XML y JSON.

Puedes descargar el código aquí ; desea los paquetes de códigos del capítulo 10, y luego desea buscar en el paquete src / com / gwtapps / serialization. No vi una licencia para este código, pero he enviado un correo electrónico al autor para ver lo que dice. Lo actualizaré si responde.

Problemas con esta solución:

  • Tienes que agregar una interfaz de marcador en todos tus objetos que quieras serializar (usa java.io.Serializable pero imagino que podrías usar otros; si estás utilizando hibernate para tu backend, tus pojos ya podrían estar etiquetados así) .
  • El código solo admite propiedades de cadena; podría ser extendido.
  • El código solo está escrito para 1.4 y 1.5.

Por lo tanto, esta no es una solución lista para usar, sino un excelente punto de partida para que alguien cree un serializador JSON que se ajuste a GWT. Combine eso con un serializador JSON en el lado del servidor, como json-lib y listo.

También encontré este proyecto (de nuevo, se requiere una interfaz de marcador).

Pruebe este serializador de Google Code: http://code.google.com/p/json-io/

Si necesita escribir o leer el formato JSON en Java, esta es la herramienta que debe usar. No es necesario crear clases adicionales, etc. Convierta un gráfico de objetos Java a formato JSON en una sola llamada. Haz lo opuesto: crea un objeto JSON String o Stream to Java. Esta es la biblioteca más rápida que he visto hasta ahora para hacer esto. Es más rápido que ObjectOutputStream y ObjectInputStream en la mayoría de los casos, que usan formato binario.

Utilidad muy útil.

Parece que estoy respondiendo a esta pregunta mucho …

Hay una página en code.google.com titulada Uso de GWT para JSON Mashups . Es (desafortunadamente) muy por mi cabeza, ya que no estoy tan familiarizado con GWT, por lo que puede no ser útil.

Es posible que desee consultar este proyecto https://gerrit.googlesource.com/gwtjsonrpc/

Es una biblioteca creada para admitir un sistema de revisión de código para Android, Gerrit, pero es un módulo independiente destinado a integrarse en cualquier proyecto de GWT, no solo en Gerrit.

Un tutorial razonable es probablemente el README en el nivel superior del directorio. Es bastante similar al estándar GWT RPC pero usa encoding JSON. También tiene protección XSRF incorporada.

OK, borré mi respuesta anterior porque resultó ser exactamente lo que no querías.

No sé qué tan bien funciona con GWT, pero usamos la biblioteca json-lib para serializar objetos en un proyecto Java normal donde trabajo.

Puede crear un JSONObject directamente desde un JavaBean , luego usar el método resultante de JSONObject toString () para recuperar la cadena JSON real.

Del mismo modo, también puede convertir a JSON en un JavaBean .

No estoy seguro si Jackson trabajaría para usted. No sé si hay algo específico para GWT que esté buscando; si no debería funcionar

Pero su serialización / deserialización funciona bastante bien, como:

 // read json, create object ObjectMapper mapper = new ObjectMapper(); MyBean bean = mapper.readValue(jsonAsString, MyBean.class); // and write out StringWriter sw = new StringWriter(); mapper.writeValue(sw, user); String jsonOut = sw.toString(); 

Necesita getX() ( getX() para serializar, setX() para deserializar, puede anotar métodos con otros nombres), pero eso es todo.