1. JSON-LIB es una biblioteca de clase Java que proporciona la función de convertir objetos Java, incluidos frijoles, mapas, colecciones, matrices Java y XML, en JSON o conversión inversa.
2. JSON-LIB Página de inicio: http://json-lib.sourceforge.net/
3. Entorno de ejecución
Se requiere el siguiente soporte de la biblioteca
Commons-lang 2.5
Commons-Beanutils 1.8.0
colecciones comunes 3.2.1
Registro de bienes comunes 1.1.1
Ezmorph 1.0.6
4. Ejemplos funcionales
Aquí hay un ejemplo de código dado por el ejemplo de Junit-Case
La copia del código es la siguiente:
paquete com.mai.json;
importar org.junit.assert.assertequals;
import java.util.arrayList;
import java.util.date;
import java.util.hashmap;
import java.util.iterator;
import java.util.list;
import java.util.map;
importar net.sf.ezmorph.morpher;
importar net.sf.ezmorph.morpherRegistry;
importar net.sf.ezmorph.bean.beanmorpher;
importar net.sf.json.jsonarray;
importar net.sf.json.jsonObject;
importar net.sf.json.util.jsonutils;
importar org.apache.commons.beanutils.propertyutils;
importar org.junit.test;
clase pública JSONLIBTEST {
/*
* Los tipos normales, la lista, la colección, etc. se analizan utilizando jsonarray
*
* El mapa y los tipos personalizados se analizan usando jsonObject
* El mapa puede entenderse como un objeto, y los pares de clave/valor en el interior pueden entenderse como los atributos/valores de atributo del objeto
* Eso es {key1: value1, key2, value2 ...}
*
* 1. JSONOBECT es un nombre: colección de valores.
* A través de su getJsonObject (clave), puede obtener un JSONObject, -> convertirlo en mapa,
* A través de su getJsonArray (clave) puedes obtener un jsonarray,
*
*
*/
// Generalmente convierte las matrices a JSON
@Prueba
public void testArrayToJson () {
boolean [] boolArray = new Boolean [] {True, False, True};
JSONArray JSONArray = JSONArray.FromObject (BoolArray);
System.out.println (JSONArray);
// imprime [verdadero, falso, verdadero]
}
// Convertir el objeto de colección a JSON
@Prueba
public void testListToJson () {
List List = new ArrayList ();
list.add ("primero");
list.add ("segundo");
JSONArray JSONArray = JSONArray.FromObject (lista);
System.out.println (JSONArray);
// imprime ["Primero", "segundo"]
}
// Convertir JSON a JSON, dependiendo de la situación, use JSONArray o JsonObject
@Prueba
public void testjSonstrTOjson () {
JSONArray JSONArray = JSONArray.FromObject ("['Json', 'es', 'fácil']");
System.out.println (JSONArray);
// imprime ["json", "es", "fácil"]
}
// Convertir el mapa a JSON, usando JSONObject
@Prueba
public void testMapToJson () {
Mapa map = nuevo hashmap ();
map.put ("nombre", "json");
map.put ("bool", boolean.true);
map.put ("int", nuevo entero (1));
map.put ("arr", nueva cadena [] {"A", "b"});
map.put ("func", "función (i) {return this.arr [i];}");
JsonObject jsonObject = jsonObject.FromObject (map);
System.out.println (jsonObject);
}
// compuesto tipo frijol en json
@Prueba
public void testBeadToJson () {
MyBean Bean = new MyBean ();
frijoles.setid ("001");
bean.setName ("tarjeta bancaria");
bean.setDate (nueva fecha ());
List cardnum = new ArrayList ();
Cardnum.add ("Banco Agrícola");
cardnum.add ("icbc");
cardnum.add ("ccb");
cardnum.add (nueva persona ("prueba"));
Bean.setCardnum (Cardnum);
JsonObject jsonObject = jsonObject.FromObject (bean);
System.out.println (jsonObject);
}
// Convertir JSON de tipo normal en objeto
@Prueba
public void testjSontoObject () lanza la excepción {
String json = "{name =/" json/", bool: true, int: 1, double: 2.2, function: function (a) {return a;}, array: [1,2]}";
JsonObject jsonObject = jsonObject.FromObject (JSON);
System.out.println (jsonObject);
Objeto bean = jsonObject.tobean (jsonObject);
afirmarequals (jsonObject.get ("name"), PropertyUtils.getProperty (bean, "nombre"));
afirmarequals (jsonObject.get ("bool"), PropertyUtils.getProperty (bean, "bool"));
afirmarequals (jsonObject.get ("int"), PropertyUtils.getProperty (bean, "int"));
afirmarequals (jsonObject.get ("double"), PropertyUtils.getProperty (bean, "double"));
afirmarequals (jsonObject.get ("func"), propertyUnils.getProperty (bean, "func"));
System.out.println (PropertyUtils.getProperty (bean, "nombre"));
System.out.println (PropertyUtils.getProperty (bean, "bool"));
System.out.println (PropertyUtils.getProperty (bean, "int"));
System.out.println (PropertyUtils.getProperty (bean, "double"));
System.out.println (PropertyUtils.getProperty (bean, "func"));
System.out.println (PropertyUtils.getProperty (bean, "array"));
List arrayList = (list) jsonArray.tocollection (jsonObject.getJsonArray ("Array"));
for (objeto objeto: arrayList) {
System.out.println (objeto);
}
}
// analizar JSON en un objeto de tipo compuesto, incluida la lista
@Prueba
public void testjSontoBeanHavalist () {
String json = "{list: [{name: 'test1'}, {name: 'test2'}], map: {test1: {name: 'test1'}, test2: {name: 'test2'}}}" ;
// string json = "{list: [{name: 'test1'}, {name: 'test2'}]}";
Map classMap = new HashMap ();
classmap.put ("list", persona.class);
Mybeanwithperson diybean = (mybeanwithperson) jsonobject.tobean (jsonObject.FromObject (JSON), myBeanWithperson.class, classMap);
System.out.println (Diybean);
List list = DiyBean.getList ();
para (objeto o: list) {
if (o instancia de persona) {
Persona p = (persona) o;
System.out.println (p.getName ());
}
}
}
// analizar JSON en un objeto de tipo compuesto, incluido el mapa
@Prueba
public void testjSontoBeanHavamap () {
// Piense en el mapa como un objeto
String json = "{list: [{name: 'test1'}, {name: 'test2'}], map: {testone: {name: 'test1'}, testTwo: {name: 'test2'}}}" ;
Map classMap = new HashMap ();
classmap.put ("list", persona.class);
classmap.put ("map", map.class);
// Usar sugerencia, analizar directamente JSON en un objeto personalizado especificado, donde la lista está completamente analizada, el mapa no está completamente analizado
Mybeanwithperson diybean = (mybeanwithperson) jsonobject.tobean (jsonObject.FromObject (JSON), myBeanWithperson.class, classMap);
System.out.println (Diybean);
System.out.println ("Do la versión de la lista");
Lista <Oll> list = DiyBean.getList ();
para (persona o: lista) {
Persona p = (persona) o;
System.out.println (p.getName ());
}
System.out.println ("Do the Map Release");
// Registre primero el transformador en el registro, y debe usar la clase en el paquete Ezmorph
MorpherRegistry MorpherRegistry = jsonutils.getMorpherRegistry ();
Morpher DynamorPher = new BeanMorpher (Person.Class, MorpherRegistry);
morherregistry.Registermorher (DynamorPher);
Mapa map = diybean.getMap ();
/*El mapa aquí no tiene pistas de tipo, por lo que de acuerdo con el valor predeterminado, el objeto almacenado es un tipo net.sf.ezmorph.bean.morphdynabean*/
System.out.println (mapa);
/*Producción:
{testone=net.sf.ezmorph.bean.morphdynabean@f73c1 [
{name = test1}
], testtwo=net.sf.ezmorph.bean.morphdynabean@186c6b2 [
{name = test2}
]}
*/
List <Oll> output = new ArrayList ();
para (iterator i = map.values (). iterator (); i.hasnext ();) {
// Use el registrador para realizar la transformación de objetos en el Dynabean especificado
output.Add ((persona) MorpherRegistry.morph (Person.Class, I.Next ()));
}
para (persona p: salida) {
System.out.println (p.getName ());
/*Producción:
prueba1
test2
*/
}
}
}
5. Lo siguiente proporciona los recursos requeridos para el ejemplo anterior, incluidos los paquetes y el código JAR
/Archivos/Mailingfeng/JSON-LIB/JSON-LIB El caso de uso requiere paquetes JAR y clases Java.rar