Durante el proceso de desarrollo, a menudo necesita intercambiar datos con otros sistemas. Los formatos de intercambio de datos incluyen XML, JSON, etc. JSON es un formato de datos liviano que es más eficiente que XML. XML requiere muchas etiquetas, que sin duda ocupan el tráfico de red. JSON hace un buen trabajo en este sentido. Echemos un vistazo al formato de JSON.
JSON puede tener dos formatos, uno es el formato de objeto y el otro es objeto de matriz.
{"Nombre": "Json", "Dirección": "Distrito Xicheng, Beijing", "Age": 25} // Cadena de formato de objeto de JSON
[{"Nombre": "Json", "Dirección": "Distrito Xicheng, Beijing", "Age": 25}] // Formato de objeto de datos
De los dos formatos anteriores, podemos ver que la única diferencia entre el formato de objeto y el formato de objeto de matriz es que [] se agrega al formato de objeto. Luego mire la estructura específica. Se puede ver que ambos aparecen en forma de pares de valores clave, separados por comas (,) en el estado inglés.
Este formato también es muy popular cuando la transmisión de datos se lleva a cabo en el front-end y el fondo. El back-end devuelve una cadena en formato JSON. El front-end usa el método json.parse () en JS para analizar la cadena JSON en un objeto JSON, y luego recorrer el front-end.
Vamos al tema e introduzcamos la conversión mutua entre los objetos JSON y Java en Java.
Para realizar la transferencia mutua entre los objetos JSON y Java, debe usar un paquete JAR de terceros. El paquete JSON-LIB se usa aquí. La dirección de descarga es: https://sourceforge.net/projects/json-lib/. JSON-LIB requiere el soporte de cinco paquetes: Commons-Beanutils-1.8.0.Jar, Commons-Collections-3.2.1.jar, Commons-Lang-2.5.Jar, Commons-logging-1.1.jar y Ezmorph-1.0.6.Jar. Puede descargarlo desde Internet usted mismo. La dirección de descarga ya no se publicará aquí.
JSON-LIB proporciona varias clases que pueden completar esta función, como JsonObject, JSONArray. A partir del nombre de la clase, podemos ver que el Jsonobject transformado debe estar en formato de objeto, mientras que el JSONArray transformado debe ser objetos de matriz (es decir, con la forma []).
1. La transferencia mutua de objetos ordinarios de Java y cadenas JSON
objeto java-》》 cadena
Un objeto Java normal se refiere a un Java Bean en Java, es decir, una clase de entidad, como
paquete com.cn.study.day3; public class Student {// Name private String name; // age private string age; // dirección privada dirección de cadena; public string getName () {name de return;} public void setName (name de cadena) {this.name = name;} public String getAge () {Age de return Age;} public dirección;} public void setAddress (dirección de cadena) {this.address = dirección;}@overridePublic string toString () {return "student [name =" + name + ", age =" + age + ", dirección =" + dirección + "]";}}Arriba hay una clase de entidad Java normal mía, vea cómo JSON-LIB lo convierte en una forma de cadena,
public static void convertoBject () {Student stu = new Student (); stu.setName ("json"); stu.setage ("23"); stu.setaddress ("distrito de Beijing xicheng"); // 1. Use jsonObjectJSONObject json = jsonObject.FromObject (stu); // 2. Use jsonarrayjsonArray array = jsonArray.FromObject (stu); string strjson = json.ToString (); string strRArray = array.ToString (); system.println ("strjson:"+strjson); system.out.println ("strarray:"+strarray);}Definí la clase de entidad de un estudiante y luego la convertí en cadenas JSON usando Jsonobject y Jsonarray respectivamente. Veamos el resultado impreso a continuación.
strjson: {"Dirección": "Distrito Xicheng, Beijing", "Age": "23", "Nombre": "Json"}
StrRarray: [{"Dirección": "Distrito Xicheng, Beijing", "Age": "23", "Nombre": "Json"}]
A partir de los resultados, podemos ver que ambos métodos pueden convertir los objetos Java en cadenas JSON, pero la estructura convertida es diferente.
Cadena JSON-》》 Objeto Java
Lo anterior explica cómo convertir los objetos Java en cadenas JSON. Veamos cómo convertir el formato de cadena JSON en objetos Java.
Primero, debe definir dos cadenas en diferentes formatos, debe usar/escapar de cotizaciones dobles.
public static void jSonstrToJava () {// Defina dos cadenas de diferentes formatos String ObjectStr = "{/" name/":/" json/",/" edad/":/" 24/",/" dirección/":/" distrito xicheng, beijing/"}"; cadena de cadenas; Arraystr = "[{/" name/":/" json/",/" edad/":/" 24/",/" dirección/":/" distrito de Beijing xicheng, beijing/"}]"; // 1. Use jsonObjectJSONObject jsonObject = jsonObject.FromObject (ObjectStr); Student stu = (Student) JSONObject.Tobean (jsonObject, student.class); // 2. Use jsonArrayJsonArray JSonArray = jsonArray.FromObject (Arraystr); // Obtenga el primer elemento del objeto JSONArray O = JSonArray.get (0); jsonObject jsonObject2 = jsonObject.FromObject (o); Student stu2 = (Student) jsonObject.Tobean (jsonObject2, Student.class); System.out.println ("Stu:"+Stu); System.out.println ("Stu2:"+Stu2);}El resultado de la impresión es:
Stu: Student [nombre = JSON, Age = 24, Dirección = Distrito Xicheng, Beijing]
Stu2: Student [Name = JSson, Age = 24, Dirección = Distrito Xicheng, Beijing]
Como se puede ver en el código anterior, usar JSONObject puede convertir fácilmente las cadenas de formato JSON en objetos Java, pero usar JSONArray no es tan fácil, porque tiene el símbolo "[]", por lo que después de obtener el objeto JSONArray, tomamos el primer elemento, que es la deformación del estudiante que necesitamos, y luego usamos JSONObject para obtenerlo fácilmente.
2. Transferencia de List and JSON Strings
Lista-》》 Cadena JSON
public static void listToJson () {Student stu = new Student (); stu.setName ("json"); stu.setage ("23"); stu.setaddress ("distrito haidiano de Beijing"); list <drutent> lists = new ArrayList <entudent> (); lists.add (stu); // 1. Use jsonObject // jsonObject listObject = jsonObject.FromObject (listas); // 2. Use jsonarrayjsonArray listArray = jsonArray.FromObject (listas); // System.out.println ("ListObject:"+ListObject.ToString ()); System.out.println ("ListArray:"+ListArray.ToString ());}He usado jsonobject para apostar. Veamos los resultados antes del comentario.
Excepción en el hilo "principal" net.sf.json.jsonexception: 'Object' es una matriz. Usa JSONArray en su lugar
Dime que hay una excepción. Al verificar el código fuente, descubrí que al usar el método FromObject, primero juzgaré el tipo de parámetro. Aquí me digo que el parámetro aprobado es un tipo de matriz porque se usa la lista de matrices. Veamos el resultado después del comentario.
listArray: [{"Dirección": "Distrito de Haidian, Beijing", "Age": "23", "Nombre": "Json"}]
Este resultado es normal.
Cadena JSON-》》 Lista
Del ejemplo anterior, podemos ver que el objeto de lista solo se puede convertir en el formato del objeto de matriz. Así que veamos la conversión de la cadena a la lista a continuación.
public static void jSonTolist () {string arraystr = "[{/" name/":/" json/",/" edad/":/" 24/",/" dirección/":/" beijing xicheng distrito/"}]"; // Convertir a ListList <deudent> list2 = (list <diet>) jsonarray.tolist (jSonArray.FromObOt (ArrayMoTM (ArrayStRomOtM, Array (ArrayStRomOt (ArrayMoT Student.class); para (Student Stu: list2) {System.out.println (stu);} // Convertir a Array Student [] ss = (Student []) jsonArray.toarray (jsonArray.FromObject (Arraystr), Student.class); para (Student Student: SS) {System.Println (Student);}}}Imprima el resultado,
Estudiante [nombre = JSON, Age = 24, Dirección = Distrito Xicheng, Beijing]
Estudiante [nombre = JSON, Age = 24, Dirección = Distrito Xicheng, Beijing]
Dado que el formato de la cadena está en el formato con "[]", el objeto JSONArray se selecciona aquí, que tiene métodos tolistas y tolistas para su uso. El primero se convierte en una matriz en Java, o en una lista en Java. Dado que hay una clase de entidad aquí para corresponder, se especifica el tipo de genérico (student.class) al usarla, por lo que se puede obtener el objeto convertido.
3. El mapa y la conversión de cadena JSON
Mapa-》》 Cadena JSON
public static void maptoJson () {Student stu = new Student (); stu.setName ("json"); stu.setage ("23"); stu.setaddress ("shanghai, china"); map <string, stu> map = new Hashmap <string, student> (); map.put ("primero", stu); // 1. JsonObjectJsonObject mapobject = jsonObject.FromObject (map); system.out.println ("mapobject"+mapobject.ToString ()); // 2. JSONArrayJSONArray MAPARRAY = JSONArray.FromObject (map); System.out.println ("MAPARRAY:"+MAPARRAY.TOSTRING ());}Imprima el resultado,
mapobject {"primero": {"dirección": "shanghai, china", "edad": "23", "nombre": "json"}}
MAPARRAY: [{"Primero": {"Dirección": "Shanghai, China", "Age": "23", "Nombre": "Json"}}]
Dos formularios se imprimen arriba.
Cadena JSON-》》 Mapa
Las cadenas JSON no se pueden convertir directamente en objetos de mapa. Para obtener el valor correspondiente a las claves en los mapas, se requieren otros métodos.
public static void void JSontomap () {String StrObject = "{{/" primer/": {/" dirección/":/" shanghai, China/",/" edad/"edad/":/"23/",/"name/" Hashmap (); map.put ("Primero", student.class); // se usa el método de tobean, y se requieren tres parámetros para myBean my = (mybean) jsonObject.tobean (jsonObject, myBean.Class, map); system.out.println (my.getFirst ());}Imprima el resultado,
Estudiante [nombre = JSON, edad = 23, dirección = Shanghai, China]
A continuación se muestra el código de MyBean.
paquete com.cn.study.day4; import java.util.map; import com.cn.study.day3.student; public class myBean {private Student First; public Student getFirst () {return First;} public void setFirst (estudiante primero) {this.first = primero;}}Usando el método Tobean (), se pasan tres parámetros, el primero es el objeto JSONObject, el segundo es mybean.class y el tercero es un objeto de mapa. A través de MyBean, podemos saber que debe haber un primer atributo en esta clase, y su tipo es estudiante, que corresponde a los tipos de clave y valor en el mapa, es decir, el tipo de valor correspondiente al primer tipo de clave.
Lo anterior es una explicación detallada de los ejemplos de conversión mutua de cadenas JSON y objetos Java presentados por el editor. ¡Espero que te sea útil!