1. JSON-LIB ist eine Java-Klassenbibliothek, die die Funktion der Konvertierung von Java-Objekten, einschließlich Bohnen, Karten, Sammlungen, Java-Arrays und XML, in JSON oder Reverse Conversion bietet.
2. Json-Lib Homepage: http://json-lib.sourceforge.net/
3. Ausführungsumgebung
Der folgende Bibliotheksunterstützung ist erforderlich
Commons-Lang 2.5
Commons-Beanutils 1.8.0
Commons-Collections 3.2.1
Commons-Logging 1.1.1
Ezmorph 1.0.6
4. Funktionale Beispiele
Hier ist ein Code-Beispiel, das durch JUNIT-CASE-Beispiel angegeben ist
Die Codekopie lautet wie folgt:
Paket com.mai.json;
statische org.junit.assert.asserTequals importieren;
Import Java.util.ArrayList;
import Java.util.date;
import Java.util.hashMap;
Import Java.util.iterator;
importieren java.util.list;
import Java.util.map;
import net.sf.ezmorph.morpher;
import net.sf.ezmorph.morpherregistry;
import net.sf.ezmorph.bean.beanmorpher;
import net.sf.json.jsonArray;
import net.sf.json.jsonObject;
import net.sf.json.util.jsonutils;
import org.apache.commons.beanutils.propertyutils;
import org.junit.test;
öffentliche Klasse JSONLIBTEST {
/*
* Normale Typen, Liste, Sammlung usw. werden alle mit JSONArray analysiert
*
* Die Karte und benutzerdefinierte Typen werden mit JSONObject analysiert
* Die Karte kann als Objekt verstanden werden, und die Schlüssel-/Wertpaare im Inneren können als Attribute/Attributwerte des Objekts verstanden werden
* Das ist {key1: value1, key2, value2 ...}
*
* 1. JsonObject ist ein Name: Wertesammlung.
* Durch das GetJsonObject (Schlüssel) können Sie ein JSONObject erhalten, -> umzuwandeln, um es zu karten, um zu kartieren.
* Durch seine GetjsonArray (Schlüssel) können Sie einen JsonArray bekommen,
*
*
*/
// Konvertieren Sie Arrays im Allgemeinen in JSON
@Prüfen
public void testArraytojson () {
boolean [] boolarray = new boolean [] {true, false, true};
JsonArray jsonArray = jsonArray.fromObject (Boolarray);
System.out.println (JsonArray);
// druckt [wahr, falsch, wahr]
}
// das Sammelobjekt in JSON konvertieren
@Prüfen
public void testlisttojson () {
Listlist = new ArrayList ();
list.add ("First");
list.add ("zweite");
JsonArray jsonArray = jsonArray.fromObject (Liste);
System.out.println (JsonArray);
// druckt ["First", "Second"]
}
// Verwenden Sie JSONArray oder JsonObject in JSON, je nach Situation, in JSON, je nach Situation
@Prüfen
public void testjonstrtttrojson () {
JsonArray jsonArray = jsonArray.fromObject ("['Json', 'ist', 'Easy']");
System.out.println (JsonArray);
// druckt ["json", ",", "einfach"]
}
// Die Karte mit JSONObject in JSON konvertieren
@Prüfen
public void testmaptojson () {
Map map = new HashMap ();
map.put ("name", "json");
map.put ("bool", boolean.true);
map.put ("int", neue Ganzzahl (1));
map.put ("arr", neuer String [] {"a", "b"});
map.put ("func", "function (i) {return this.arr [i];}");
JsonObject jsonObject = jsonObject.fromObject (MAP);
System.out.println (JSONObject);
}
// Verbundtypbohnen in JSON
@Prüfen
public void testbeadtojson () {
Mybean bean = new mybean ();
Bean.setID ("001");
Bean.SetName ("Bankkarte");
bean.setDate (neues Datum ());
List Cardnum = new ArrayList ();
Cardnum.add ("Agricultural Bank");
cardnum.add ("ICBC");
cardnum.add ("ccb");
cardnum.add (neue Person ("Test"));
bean.setCardnum (cardnum);
JsonObject jsonObject = jsonObject.fromObject (Bean);
System.out.println (JSONObject);
}
// JSON vom normalen Typ in Objekt umwandeln
@Prüfen
public void testjsontoObject () löst Ausnahme {aus {
String json = "{name =/" json/", bool: true, int: 1, double: 2.2, Funktion: Funktion (a) {return a;}, Array: [1,2]}";
JsonObject jsonObject = jsonObject.fromObject (JSON);
System.out.println (JSONObject);
Object bean = jsonObject.tobean (jsonObject);
assertequals (jsonObject.get ("name"), PropertyUtils.getProperty (Bean, "Name"));
assertequals (jsonObject.get ("bool"), propertyutils.getProperty (Bean, "bool"));
assertequals (jsonObject.get ("int"), PropertyUtils.getProperty (Bean, "int"));
assertequals (jsonObject.get ("double"), PropertyUtils.getProperty (Bean, "double"));
assertequals (jsonObject.get ("func"), propertyutils.getProperty (Bean, "func"));
System.out.println (PropertyUtils.getProperty (Bean, "Name"));
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"));
für (Objektobjekt: ArrayList) {
System.out.println (Objekt);
}
}
// JSON in ein zusammengesetztes Objekt analysieren, einschließlich der Liste
@Prüfen
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", Person.class);
Mybeanwithperson diybean = (mybeanwithperson) jsonObject.tobean (jsonObject.fromObject (JSON), mybeanwithperson.class, classMap);
System.out.println (Diybean);
Listlist = diybean.getList ();
für (Objekt O: Liste) {
if (o Instanz der Person) {
Person p = (Person) o;
System.out.println (p.getName ());
}
}
}
// JSON in ein zusammengesetztes Objekt analysieren, einschließlich Karte
@Prüfen
public void testjsontobeanhavamap () {
// MAP als Objekt vorstellen
String json = "{list: [{name: 'test1'}, {name: 'test2'}], map: {testone: {name: 'test1'}, testtwo: {name: 'test2'}}}" ;
Map classMap = new HashMap ();
classmap.put ("list", Person.class);
classmap.put ("map", map.class);
// Tipp verwenden, JSON direkt in ein bestimmtes benutzerdefiniertes Objekt analysieren, wobei die Liste vollständig analysiert wird. Die Karte ist nicht vollständig analysiert
Mybeanwithperson diybean = (mybeanwithperson) jsonObject.tobean (jsonObject.fromObject (JSON), mybeanwithperson.class, classMap);
System.out.println (Diybean);
System.out.println ("DO DO DIE LISTE REALEIT");
Liste <Person> list = diybean.getList ();
für (Person O: Liste) {
Person p = (Person) o;
System.out.println (p.getName ());
}
System.out.println ("DO MAP REALEIT");
// Registrieren Sie den Transformator zuerst in der Registrierung, und Sie müssen die Klasse im Ezmorph -Paket verwenden
Morpherregistry Morpherregistry = jsonUtils.getMorpherregistry ();
Morpher Dynamorpher = New BeanMorpher (Person.Class, Morpherregistry);
Morpherregistry.registerMorpher (Dynamorpher);
Map map = diybean.getMap ();
/*Die Karte hier hat keine Typ -Hinweise. Daher ist das gespeicherte Objekt ein Typ net.sf.ezmorph.bean.morphdynabean*/////////////////
System.out.println (MAP);
/*Ausgabe:
{testone=net.sf.ezmorph.bean.morphdynabean@f73c1 [
{name = test1}
], testtwo=net.sf.ezmorph.bean.morphdynabean@186c6b2 [
{name = test2}
]}
*/
Liste <Person> output = new ArrayList ();
für (iterator i = map.Values (). iterator (); i.hasnext ();) {
// Verwenden Sie den Registrar, um die Objekttransformation auf dem angegebenen Dynabean durchzuführen
output.add ((Person) Morpherregistry.morph (Person.Class, I.Next ()));
}
für (Person P: Ausgabe) {
System.out.println (p.getName ());
/*Ausgabe:
Test1
Test2
*/
}
}
}
5. Folgendes enthält die für das obigen Beispiel erforderlichen Ressourcen, einschließlich JAR -Pakete und Code
/Dateien/Mailingfeng/JSON-LIB/JSON-LIB-Anwendungsfall erfordert JAR-Pakete und Java-Klassen.rar