Apprentissage Java 4-9_Json Apprentissage

Others 2020-10-28 19:36:32 views: null

JSON

JavaScript Object Notation, la notation d'objets JS, est un format d'échange de données léger

1. Comment représenter un livre

一本书:
	书名
	简介
	
java:
class Book{
	private String name;
	private String info;

	get/set...
}
Book b = new Book();
b.setName(“金苹果”);
b.setInfo(“种苹果”);
...

js:
var b = new Object();
b.name = "金苹果";
b.info = "种苹果";

XML:
<book>
    <name>金苹果</name>
    <info>种苹果</info>
</book>

JSON:
{
    "name":"金苹果",
    "info":"种苹果"
}

json est plus petit, plus rapide et plus facile à analyser que xml

Deux, format d'objet et format de tableau

2.1 Format d'objet

{
    
     
    "name":"金苹果", 
    "info":"种苹果"
}

2.2 Format de tableau

{
    
    
    "name":"伟杰老师",
    "age":18,
    "pengyou":["张三","李四","王二","麻子",{
    
    
        "name":"野马老师",
        "info":"像匹野马一样狂奔在技术钻研的道路上"
	}],
    "heihei":{
    
    
        "name":"大长刀",
        "length":"40m"
	}
}

Trois fonctionnalités JSON

3.1 Caractéristiques

  1. JSON est du texte brut
  2. JSON est "auto-descriptif" (lisible par l'homme)
  3. JSON a une structure hiérarchique (il y a une valeur dans la valeur)
  4. JSON peut être analysé par JavaScript
  5. Les données JSON peuvent être transmises à l'aide d'AJAX

3.2 Différences avec XML

  1. Pas de balise de fermeture
  2. Plus court
  3. Lecture et écriture plus rapides
  4. Capable d'utiliser la méthode JavaScript eval () intégrée pour l'analyse
  5. Utiliser un tableau
  6. Aucun mot réservé

Quatre, syntaxe JSON

  1. Règles de grammaire, la grammaire JSON est un sous-ensemble de la grammaire de représentation d'objets JavaScript.

    • Les données sont dans des paires nom / valeur
    • Les données sont séparées par des virgules
    • Accolades {}Enregistrer l'objet
    • Les supports []sauvegardent le tableau, le tableau peut comprendre une pluralité d'objets

  2. Paires nom / valeur JSON

    key : value

  3. Valeur JSON

    1. Nombre (entier ou virgule flottante){ "age":30 }

    2. Chaîne (entre guillemets)

    3. Valeur logique (vrai ou faux){ "flag":true }

    4. Tableau (entre crochets)

      [{
        
         key1 : value1-1 , key2:value1-2 }, {
        
         key1 : value2-1 , key2:value2-2 }]

    5. Objet (entre accolades){key1 : value1, key2 : value2, ... keyN : valueN }

    6. nul { "runoob":null }

Cinq, utilisation JSON

5,1 Gson

Gson a été développé en réponse à Google. Il existe principalement deux fonctions de conversion toJson et fromJson. Gson peut convertir complètement des types complexes de json en bean ou bean en json.

utilisation:

  1. Sérialisation / désérialisation

    Gson gson = new Gson();
//序列化
String json = gson.toJson(object);
//反序列化
Object object = gson.fromJson(json, Object.class);

  2. Sérialisation / désérialisation d'objets imbriqués

    //对象也为嵌套关系可以直接进行

  3. Tableau

    String myJson = "['ASD131','DFS131','TER131']";

Gson gson = new Gson();

//序列化
String myJson = gson.toJson(myJson);

//反序列化
String[] myArray = gson.fromJson(myJson, String[].class);

  4. List, List doit fournir Type lors de la désérialisation

    String myJson = "";

Gson gson = new Gson();
//序列化
Type objectListType = new TypeToken<ArrayList<Object>>(){
      
      }.getType();
//反序列化
List<Object> myList = gson.fromJson(myJson, objectListType);

  5. Idem pour la carte et l'ensemble

  6. Sérialisation et désérialisation de la négligence de certaines variables à l'aide d' @Exposeannotations marquent les classes de propriété

    GsonBuilder gsonBuilder = new GsonBuilder();  
gsonBuilder.excludeFieldsWithoutExposeAnnotation();  
Gson gson = builder.create();

5.2 FastJson

Fastjson est un processeur JSON hautes performances écrit en langage Java, développé par Alibaba. FastJson aura quelques problèmes dans la conversion de types complexes, et le type de référence peut apparaître, ce qui conduit à des erreurs de conversion Json, et une référence doit être formulée. L'algorithme utilisé par FastJson accélère l'analyse.

  • JSONArray: équivalent à List
  • JSONObject: équivalent à Map <String, Object>

utilisation:

  1. Sérialisation / désérialisation

    //序列化
String objJson = JSON.toJSONString(Object object);
//反序列化
Object object = JSON.parseObject(objJson, Object.class);

  2. Mapper vers JSON

    Map<String, Object> map = new HashMap<String, Object>();
map.put("key1", "One");
map.put("key2", "Two");

//序列化
String mapJson = JSON.toJSONString(map);
//反序列化
Map<String, Object> map1 = JSON.parseObject(mapJson, new TypeReference<Map<String, Object>>(){
      
      });

  3. liste转JSON

    List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map1 = new HashMap<String, Object>();
map1.put("key1", "One");
map1.put("key2", "Two");     
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put("key1", "Three");
map2.put("key2", "Four");

list.add(map1);
list.add(map2);
//序列化
String listJson = JSON.toJSONString(list);
//反序列化
List<Map> list1 = JSON.parseArray(listJson, Map.class);

5.3 Jackson

Par rapport au framework json-lib, Jackson repose sur moins de packages jar, est simple à utiliser et a des performances relativement élevées. Et la communauté Jackson est relativement active et la vitesse de mise à jour est relativement rapide. Jackson aura des problèmes avec le type complexe de bean de conversion json et des problèmes de conversion de mappage et de liste de collection. Jackson convertit Json pour des types complexes de beans, et le format json converti n'est pas un format Json standard.

usage:

  1. Sérialisation et désérialisation

    ObjectMapper MAPPER = new ObjectMapper();

//反序列化
//T类型对象，beanType: Class<T>
T t = MAPPER.readValue(jsonData, beanType);

//序列化
String jsonString = MAPPER.writeValueAsString(object);

  2. Conversion de liste

    //序列化
String jsonData = MAPPER.writeValueAsString(object);

//反序列化
Class<T> beanType;
JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
List<T> list= MAPPER.readValue(jsonData, javaType);

  3. Sérialisation / désérialisation de carte

    //序列化
String jsonString = MAPPER.writeValueAsString(map);

//反序列化
LinkedHashMap<?, ?> map= new LinkedHashMap<>();
map = MAPPER.readValue(jsonData,LinkedHashMap.class);

  4. Notes communes

    • @JsonIgnoreProperties: Cette annotation est une annotation de classe, et sa fonction est d'ignorer certaines propriétés du bean java lorsque la sérialisation, la sérialisation et la désérialisation json sont affectées.
    • @JsonIgnore: Cette annotation est utilisée sur les propriétés ou les méthodes (de préférence sur les propriétés), et a le même effet que @JsonIgnoreProperties ci-dessus.
    • @JsonFormat: Cette annotation est utilisée sur les attributs ou méthodes (de préférence sur les attributs), qui peuvent facilement convertir le type Date directement dans le modèle que nous voulons, tel que @JsonFormat (pattern = "aaaa-MM-jj HH-mm- ss ")
    • @JsonSerialize: Cette annotation est utilisée sur les propriétés ou les méthodes getter ou les classes pour incorporer notre code personnalisé lors de la sérialisation, par exemple, lors de la sérialisation d'un double, elle limite deux décimales après lui.
    • @JsonDeserialize: cette annotation est utilisée sur les propriétés, les méthodes de définition ou les classes. Elle peut être utilisée pour incorporer notre code personnalisé lors de la désérialisation, comme @JsonSerialize ci-dessus.

5.4 Json-lib

Le début de json-lib est également l'outil d'analyse json le plus utilisé. L'inconvénient de json-lib est qu'il dépend de nombreux paquets tiers, y compris commons-beanutils.jar, commons-collections-3.2.jar, commons-lang- 2.6.jar, commons-logging-1.1.1.jar, ezmorph-1.0.6.jar, pour la conversion de types complexes, json-lib a des défauts dans la conversion de json en bean.

Mais après JDK8, json-lib a rarement été choisi pour être utilisé, et les performances ne sont pas élevées, il suffit de comprendre

méthode:

  1. JSONSerializer peut convertir n'importe quel objet java en JSON, afin qu'il puisse être utilisé par les méthodes JSONObject et JSONArray

    //序列化
JSON json = JSONSerializer.toJSON(book);

//反序列化
Object tempObj =  JSONSerializer.toJava(json);

  2. Objet JSON

    //序列化
JSONObject jsonObject = JSONObject.fromObject(object);

//反序列化
Object object = (Object)JSONObject.toBean(jsonObject,Object.class);

  3. Tableau JSONArray

    //将一个List对象转化为JSONArray
JSONArray jsonList = JSONArray.fromObject(list);

Je suppose que tu aimes

Origine blog.csdn.net/Sky_Coolssy/article/details/108924762
conseillé
Classement
du quotidien
Plus
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(2)
2024-06-03(0)
2024-06-02(1)
2024-06-01(0)
2024-05-31(0)

Code World

© 2018 codetd.com