1. Comenzando
Hay una clase ObjectMapper en Jackson que es muy práctica, utilizada para intercambiar objetos Java y JSON.
1. Java Objeto a JSON [JSON Serialization]
import java.io.ioException; import java.text.parseException; import java.text.simpledateFormat; import com.fasterxml.jackson.databind.objectMapper; public class JackSondemo {public static void main (string [] args) lanza ParseException, ioException {user user = new user (); user.setName ("xiaomin"); user.setEmail ("[email protected]"); user.setage (20); SimpleDateFormat dateFormat = new SimpleDateFormat ("yyyy-mm-dd"); user.setBirthday (dateFormat.Parse ("1996-10-01")); /*** ObjectMapper es el núcleo de las operaciones JSON, y todas las operaciones JSON de Jackson se implementan en ObjectMapper. * ObjectMapper tiene múltiples métodos de serialización JSON, que pueden guardar cadenas JSON en diferentes medios, como archivos, salida, etc. * WriteValue (archivo Arg0, Object Arg1) convierte Arg1 en una secuencia JSON y lo guarda en el archivo Arg0. * WriteValue (OutputStream Arg0, Object Arg1) convierte Arg1 en una secuencia JSON y la guarda en la secuencia de salida de Arg0. * WriteValueasbytes (Object Arg0) convierte Arg0 en una secuencia JSON y genera el resultado en una matriz de bytes. * WriteValueAsString (Object Arg0) convierte Arg0 en una secuencia JSON y genera el resultado en una cadena. */ ObjectMapper mapper = new ObjectMapper (); // Clase de usuario a JSON // Resultado de salida: {"nombre": "xiaomin", "edad": 20, "cumpleaños": 844099200000, "correo electrónico": "[email protected]"} string json = mapper.writevalueasString (usuario); System.out.println (JSON); // colección java a json // resultado de salida: [{"nombre": "xiaomin", "edad": 20, "cumpleaños": 844099200000, "correo electrónico": "[email protected]"}] Lista <usuarios> usuarios = new ArrayList <serer> (); ussers.add (usuario); String jsonList = mApper.WriteValueAsString (usuarios); System.out.println (jsonList); }}2.Json a Java Clase [JSON Deserialization]
import java.io.ioException; import java.text.parseException; import com.fasterxml.jackson.databind.objectMapper; La clase pública JackSondemo {public static void main (String [] args) arroja ParseException, ioexception {String json = "{/"name/":/"xiaomin/" ,/"age/":20,/"birthay/":844099200000./"oMail/":/"/up / ** * ObjectMapper admite la deserialización de JSON de byte [], archivo, inputStream, cadenas, etc. */ ObjectMapper mapper = new ObjectMapper (); Usuario user = mApper.ReadValue (json, user.class); System.out.println (usuario); }}
2. Jackson admite 3 métodos de uso:
1. Enlace de datos: el más conveniente de usar.
(1) Enlace de datos completos:
String Final Static Private Model_binding = "{/" name/":/" name1/",/" type/": 1}"; public void fulLDAtAbinding () lanza la excepción {ObjectMapper mapper = new ObjectMapper (); Model User = mApper.ReadValue (model_binding, model.class); // ReadValue a una clase de entidad. System.out.println (user.getName ()); System.out.println (user.gettype ()); }Clase de modelo:
Modelo de clase estática privada {nombre de cadena privada; Tipo de intivate privado; public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public int getType () {Tipo de retorno; } public void settype (int type) {this.type = type; }}(2) Enlace de datos sin procesar:
/ ** Los tipos de Java concretos que Jackson usará para un enlace de datos simple son: JSON Type Java Type Object LinkedHashMap <String, Object> Array ArrayList <ject> Número de cadena de cadena (sin fracción) Integer, Long o BigInteger (más pequeño) Número (fracción) doble (configurable) Excepción {ObjectMapper mapper = new ObjectMapper (); Hashmap map = mApper.ReadValue (model_binding, hashmap.class); // ReadValue a un tipo de datos primitivos. System.out.println (map.get ("nombre")); System.out.println (map.get ("type")); }(3) Enlace de datos genéricos:
String final estática privada genic_binding = "{/" key1/": {/" name/":/" name2/",/" type/": 2},/" key2/": {/" name/":/" name3/",/" type/": 3}}"; public void genericDatabInding () lanza la excepción {ObjectMapper mapper = new ObjectMapper (); HashMap <String, Model> ModelMap = mApper.ReadValue (Generic_Binding, New TypeReference <Hashmap <String, Model >> () {}); // ReadValue en datos de paradigma. Modelo modelo = modelmap.get ("key2"); System.out.println (model.getName ()); System.out.println (model.gettype ()); }2. Modelo de árbol: el más flexible.
String Final STATIC static privado_model_binding = "{/" treekey1/":/" treeValue1/",/" treekey2/":/" treeValue2/",/" children/": [{/" childKey1/":/" ChildKey1/"}]}"; public void TreeModelBinding () lanza la excepción {ObjectMapper mapper = new ObjectMapper (); Jsonnode rootNode = mApper.readtree (tree_model_binding); // ruta y obtener la función igual que Get, pero cuando el nodo no se puede encontrar, devuelve el nodo faltante en lugar de NULL. String treekey2Value = rootnode.path ("treekey2"). GetTextValue (); // system.out.println ("treekey2Value:" + treekey2value); Jsonnode childrennode = rootnode.path ("niños"); String ChildKey1Value = ChildrenNode.get (0) .path ("ChildKey1"). GetTextValue (); System.out.println ("ChildKey1Value:"+ChildKey1Value); // Cree el nodo raíz ObjectNode root = mApper.CreateObjectNode (); // Crear nodo infantil1 ObjectNode nodo1 = mApper.CreateObjectNode (); node1.put ("nodekey1", 1); node1.put ("nodekey2", 2); // atar el nodo infantil 1 root.put ("niño", nodo1); // ArrayNode ArrayNode = mApper.CreatEarRAyNode (); arraynode.add (nodo1); arraynode.add (1); // unir el nodo de matriz root.put ("ArrayNode", ArrayNode); // JSON lee el nodo de árbol JSONNODE VALUETOTREEnode = mApper.Valuetotree (tree_model_binding); // unir el nodo json root.put ("valueToTreenode", valueToTreenode); // Atrae el objeto del nodo JSON JSONNode bindJSONNode = mApper.ReadValue (genic_binding, jsonnode.class); // Atar el objeto JSON del nodo. // bind json node root.put ("bindjsonnode", bindjsonnode); System.out.println (mapper.writeValueasString (root)); } 3. API de transmisión: mejor rendimiento.
Para programas con requisitos de alto rendimiento, se recomienda utilizar la API de transmisión. De lo contrario, utilizando otros métodos, ya sea para crear un jsongenerator o un jsonparser, se utiliza JSONFactory.
paquete com.jingshou.jackson; import java.io.file; import java.io.ioException; import com.fasterxml.jackson.core.jsonencoding; import com.fasterxml.jackson.core.jsonfactory; import com.fasterxml.jackson.core.jsongenerator; import com.fasterxml.jackson.core.jsonparser; import com.fasterxml.jackson.core.jsonsonkoken; public class JackSontest6 {public static void main (string [] args) lanza ioexception {jsonFactory jfactory = new JsonFactory (); /*** Escriba a Archivo ***/JSongenerator JGenerator = jfactory.createGenerator (nuevo archivo ("c: //user.json"), jsonencoding.utf8); jGenerator.WriteStarTObject (); // {jGenerator.WriteStringfield ("Nombre", "Mkyong"); // "Nombre": "Mkyong" JGenerator.WriteNumberfield ("Age", 29); // "Age": 29 JGenerator.WriteFieldName ("Mensajes"); // "Mensajes": JGenerator.WriteStarRArray (); // [JGenerator.WriteString ("Msg 1"); // "Msg 1" JGenerator.WriteString ("Msg 2"); // "Msg 2" JGenerator.WriteString ("Msg 3"); // "MSG 3" JGenerator.WriteSteArray (); //] JGenerator.WriteSdObject (); //} jGenerator.close (); /*** Leer desde el archivo ***/JSONPARSER JPARSER = JFactory.CreateParser (nuevo archivo ("c: //user.json")); // bucle hasta el token igual a "}" while (jParser.nextToken ()! = JSonToken.end_object) {String fieldName = jParser.getCurrentName (); if ("name" .equals (fieldName)) {// token actual es "nombre", // muévete a siguiente, que es el valor de "nombre" jparser.nextToken (); System.out.println (jparser.gettext ()); // mostrar mkyong} if ("edad" .equals (fieldName)) {// token actual es "edad", // mudarse a siguiente, que es el valor de "nombre" jparser.nextToken (); System.out.println (jParser.getIntValue ()); // mostrar 29} if ("mensajes" .equals (fieldName)) {jParser.nextToken (); // El token actual es "[", Mover Next // Mensajes es una matriz, bucle hasta el token igual a "]" mientras (jparser.nextToken ()! = jsonToken.end_array) {// muestra msg1, msg2, msg3 system.out.println (jparser.gettext ()); }}} jparser.close (); }}