En termes simples, Jackson est une bibliothèque de classes Java utilisée pour traiter les données au format JSON, et ses performances sont très bonnes. Cet article donnera un exemple d'analyse plus détaillée de l'utilisation de Jackson. Les détails sont les suivants :
1. Introduction
Jackson a une efficacité de sérialisation et de désérialisation relativement élevée. Selon les tests, quelle que soit la forme de conversion, Jackson > Gson > Json-lib, et la puissance de traitement de Jackson est même près de 10 fois supérieure à celle de Json-lib, et c'est correct. très élevé. En revanche, Json-lib semble avoir cessé de se mettre à jour, et la dernière version est également basée sur JDK15, tandis que la communauté Jackson est plus active.
Ci-dessous, nous présenterons brièvement l'utilisation de Jackson avec des exemples.
2. Utiliser
Jackson fournit de nombreuses classes et méthodes, et la classe la plus couramment utilisée en sérialisation et désérialisation est la classe ObjectMapper, qui est similaire à JsonObject et ArrayObject dans Json-lib. Cette classe fournit des méthodes telles que readTree(), readValue(), writeValueAsString() pour la conversion. L'adresse de documentation spécifique à cette classe est : http://jackson.codehaus.org/1.7.9/javadoc/org/codehaus/jackson/map/ObjectMapper.html.
Afin d'éviter des descriptions répétées, les objectMapper mentionnés ci-dessous proviennent tous de ObjectMapper objectMapper = new ObjectMapper(). L'utilisation sera brièvement présentée ci-dessous en termes de sérialisation et de désérialisation.
1. Sérialisation
① Sérialiser les propres classes de Java
Exemple de test
Liste list=new ArrayList();list.add(1);list.add(2);list.add(3);
Implémenter la sérialisation :
Chaîne teststringlist=objectMapper.writeValueAsString(list);System.out.println(teststringlist);
Le résultat affiché sur la console est :
[1,2,3]
en conclusion:
Jackson peut facilement implémenter la sérialisation de types généraux.
②Sérialisation des classes personnalisées
Exemple de test :
étudiant de classe publique {private int age=10;private String name="hhh"; public String[] list={"hao","haouhao","keyi"}; public Date time=new Date(); () { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; }} Pour rendre l'exemple plus général, cette classe inclut le type de valeur int, le type de référence String, String[] et le type de date Date.
Implémenter la sérialisation
étudiant st=nouvel étudiant();String teststringstu=objectMapper.writeValueAsString(st);System.out.println(teststringstu);
Le résultat affiché sur la console est :
{"list":["hao","haouhao","keyi"],"time":1375429228382,"name":"hhh","age":10}en conclusion:
Grâce à la sortie, on peut voir que la chaîne Json convertie est conforme au format. Cependant, la représentation du temps est un peu médiocre. Les modifications apportées au format de l'heure seront introduites ci-dessous.
③Définition du format de l'heure
Jackson a son propre format d'heure par défaut, qui se présente sous la forme d'horodatages, et son effet est tel qu'indiqué dans les résultats ci-dessus (par exemple : 1375429228382). Si vous souhaitez définir ce format comme invalide, passez
objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, false)
Il peut être configuré de manière à ce que la génération de l'heure utilise une notation dite conforme à la norme [ISO-8601], produisant une heure similaire au format suivant : "1970-01-01T00:00:00.000+0000".
Bien entendu, vous pouvez également personnaliser le format de l’heure de sortie.
Implémentation d'un format d'heure personnalisé
L'exemple utilise également la classe d'étudiant présentée ci-dessus.
étudiant st=nouveau étudiant();java.text.DateFormat myFormat = new java.text.SimpleDateFormat("aaaa-MM-jj hh:mm:ss");objectMapper.getSerializationConfig().setDateFormat(myFormat);String teststringstu= objectMapper.writeValueAsString(st);System.out.println(teststringstu); La sortie d'inaptitude sur la console est :
{"list":["hao","haouhao","keyi"],"time":"2013-08-02 03:48:20","name":"hhh","age":10}en conclusion:
On peut voir que le format de sortie temporelle est devenu ce que nous souhaitons. La méthode de définition du format de sortie de l'heure dans Jackson est beaucoup plus simple que de définir le format de l'heure dans Json-lib.
④ Une autre méthode de sérialisation
Implémenter la sérialisation
L'exemple utilisé est toujours la classe d'élève précédente.
étudiant st=nouveau étudiant();JsonGenerator jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(System.out, JsonEncoding.UTF8);jsonGenerator.writeObject(st System.out.println();
Le résultat sur la console est :
{"list":["hao","haouhao","keyi"],"time":1375429228382,"name":"hhh","age":10}en conclusion:
Cette méthode peut également obtenir la valeur de la méthode ci-dessus. Mais faites attention à cette fonction dans cette méthode : createJsonGenerator(), qui nécessite deux paramètres, l'un est le paramètre de type OutputStream et l'autre est le paramètre de type JsonEncoding. Grâce à ces deux paramètres, nous pouvons comprendre que cette méthode peut non seulement écrire Json directement dans le flux réseau, mais également écrire Json dans le flux de fichiers ou le flux mémoire. C’est donc plus polyvalent.
2. Désérialisation
①Désérialisation unique
Cette méthode utilise principalement la méthode <testJsonClass> readValue(String content, Class<testJsonClass> valueType) fournie par ObjectMapper. Cette méthode nécessite la saisie d'une chaîne Json et de la classe correspondante de la classe à remplir, et renvoie la classe remplie.
Analyser la chaîne Json dans une classe personnalisée
Lorsque la chaîne Json est :
Chaîne test1="{"objectID":357,"geoPoints":[{"x":504604.59802246094,"y":305569.9150390625}]}"temps.
Définissez d’abord une classe :
public class testJsonClass { public int objectID; public List geoPoints=new ArrayList();}Utilisez ensuite l'extrait de code suivant pour désérialiser Json dans cette classe :
testJsonClass testClass= objectMapper.readValue(test1, testJsonClass.class);
utiliser
System.out.println(testClass.objectID);System.out.println(testClass.geoPoints)
Les valeurs que vous pouvez voir en sortie sur la console sont :
357[{x=504604.59802246094, y=305569.9150390625}] Désérialisez la chaîne Json dans la propre classe du système lorsque la chaîne Json est.
Chaîne json = "{"error":0,"data":{"name":"ABC","age":20,"phone":{"home":"abc","mobile":"def"}," amis":[{"name":"DEF","téléphone" :{"home":"hij","mobile":"klm"}},{"name":"GHI","phone":{"home":"nop","mobile":"qrs"} }]},"autre":{"surnom":[]}}". Définissez une variable à l'aide des cartes Map : Map<String, Map<String, Object>> du système. Utilisez ensuite maps = objectMapper.readValue(json, Map.class) pour désérialiser Json dans les cartes variables.
passer
System.out.println(maps.get("erreur"));System.out.println((Object)(maps.get("data").get("phone"))) Vous pouvez obtenir les résultats suivants dans la console :
0{home=abc, mobile=def}②Désérialisation progressive
Cette méthode est plus flexible et peut extraire uniquement la valeur des informations de chaîne Json qui intéresse l'utilisateur. Il est principalement implémenté à l'aide du readTree fourni par ObjectMapper et de la classe JsonNode fournie par Jackson.
Exemple de test
Chaîne test="{"results":[{"objectID":357,"geoPoints":[{"x":504604.59802246094,"y":305569.915039 0625}]},{"objectID":358,"geoPoints":[{"x":504602.2680053711,"y":305554.43603515625}]}]}";Cette chaîne Json est relativement complexe, notamment sous la forme de tableaux imbriqués, et est universelle.
Implémenter la désérialisation
JsonNode node= objectMapper.readTree(test); //Lire la chaîne Json dans la mémoire dans une structure arborescente JsonNode contents=node.get("results");//Obtenir les informations sous le nœud de résultats pour (int i=0 ; i<contents.size();i++) //Parcourez les informations sous les résultats, la fonction size() peut obtenir le nombre d'informations contenues dans le nœud, similaire à la longueur du tableau {System.out.println(contents.get(i).get("objectID" ). getIntValue()); //Lire la valeur d'un nœud enfant sous le nœud JsonNode geoNumber=contents.get(i).get("geoPoints");for(int j=0;j<geoNumber.size();j++) //Parcourez les informations sous les nœuds enfants {System.out.println(geoNumber.get(j).get("x").getDoubleValue()+" " +geoNumber.get(j).get("y").getDoubleValue());}}Le résultat sur la console est :
357504604.59802246094 305569.9150390625358504602.2680053711 305554.43603515625
en conclusion:
Cette méthode est similaire à l'analyse DOM dans l'analyse XML. L'avantage est que la structure est détaillée, ce qui facilite l'extraction des informations souhaitées. Bien entendu, l’inconvénient est le même que cette méthode : elle prend du temps et de l’espace.
3. Résumé
Les opérations de Jackson sur Json sont principalement celles indiquées ci-dessus. Sa méthode est très pratique à utiliser et très flexible. Elle fournit des opérations ponctuelles et des opérations permettant de lire des informations à la demande. Et Jackson dispose d'une gamme complète de fonctions, qui peuvent contrôler la sérialisation et la désérialisation dans divers détails, tels que la fonction d'annotation, la fonction d'injection retardée pour Hibernate et la fonction de définition du format de l'heure. Parce que ces fonctions ne sont pas actuellement nécessaires, laissez-les attentivement. pour plus tard. Dans le même temps, Jackson prend également en charge une série d'opérations de sérialisation et de désérialisation sur XML. L'idée est à peu près la même que celle de l'analyse de Json.
Concernant les défauts actuels de Jackson, certaines personnes sur Internet ont testé qu'il prenait plus de mémoire que Json-lib. Utiliser l’espace pour le temps en vaut généralement la peine.