Framework de traitement de données JSON Jackson a expliqué la première utilisation du cœur de sérialisation et de désérialisation partielle

Jackson est le cadre de traitement de données JSON par défaut de Spring Boot, mais il ne dépend d'aucune bibliothèque Spring. Certains amis pensent que Jackson ne peut être utilisé que dans le framework Spring, mais ce n'est pas le cas. Il fournit de nombreuses méthodes et annotations de traitement de données JSON , ainsi que des fonctions telles que l' API de streaming, le modèle d'arbre, la liaison de données et la conversion de types de données complexes. Bien qu'il soit simple et facile à utiliser, ce n'est certainement pas un petit jouet. Cette section vous présente l'utilisation de base de Jackson. J'écrirai une série de 5 à 10 articles pour plus de contenu. Veuillez continuer à faire attention à moi .

1. Préparation de base

L'introduction du fichier jar suivant dans n'importe quel projet peut utiliser jackson pour effectuer la sérialisation et la désérialisation des données JSON.

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

Écrivez une classe d'entité PlayerStar. La classe d'entité reflète principalement le nom, l'âge, les loisirs, les amis, le revenu annuel et d'autres informations de la star du basket. Afin de démontrer autant que possible les fonctions de sérialisation et de désérialisation de Jackson, le tableau List , et Map sont tous intégrés dans cette classe. Et initialisez l'objet de la star du basket Jordan via getInstance.

@Data
public class PlayerStar {

  private String name;
  private Integer age;
  private String[] hobbies;    //业余爱好,数组
  private List<String> friends;   //  朋友
  private Map<String, BigDecimal> salary; //年收入 Map


  //初始化一个对象用于测试
  public static PlayerStar getInstance(){
    PlayerStar playerStar = new PlayerStar();

    playerStar.setName("乔丹");
    playerStar.setAge(45);
    playerStar.setHobbies(new String[]{"高尔夫球", "棒球"});
    Map<String, BigDecimal> salary = new HashMap<String, BigDecimal>() {
   
   {
      put("2000", new BigDecimal(10000000));
      put("2010", new BigDecimal(62000000));
      put("2020", new BigDecimal(112400000));
    }};
    playerStar.setSalary(salary);
    playerStar.setFriends(Arrays.asList("kobe", "curry", "james"));

    return playerStar;
  }

}

Deux, méthode de sérialisation

Le code suivant montre comment sérialiser l'objet PlayerStar dans une chaîne JSON.

writeValue peut recevoir File en tant que paramètre et enregistrer le résultat de la sérialisation JSON dans un fichier
writeValueAsString renvoie le résultat de la sérialisation JSON sous forme de chaîne
La méthode writerWithDefaultPrettyPrinter peut formater le résultat de la sérialisation JSON, qui a une meilleure structure d'affichage et est facile à visualiser

@Test
void testObject2JSON() throws IOException {
  //获取对象实例
  PlayerStar player = PlayerStar.getInstance();

  //ObjectMapper作为Jackson的API工具类存在
  ObjectMapper mapper = new ObjectMapper();
  //将player对象以JSON格式进行序列化，并将序列化结果写入文件
  mapper.writeValue(new File("d:\\data\\jackson\\player.json"), player);

  //将player对象以JSON格式进行序列化为String对象
  String jsonString = mapper.writeValueAsString(player);
  System.out.println(jsonString);

  //将player对象以JSON格式进行序列化为String对象(格式美化)
  String jsonInString2 = mapper.writerWithDefaultPrettyPrinter()
          .writeValueAsString(player);
  System.out.println(jsonInString2);
}

La sortie d'impression de la console de jsonString est également le contenu du fichier d: \ data \ jackson \ player.json


{"name":"乔丹","age":45,"hobbies":["高尔夫球","棒球"],"friends":["kobe","curry","james"],"salary":{"2000":10000000,"2010":62000000,"2020":112400000}}

La sortie d'impression de la console de jsonString2, le format est embelli, car la méthode writerWithDefaultPrettyPrinter () est utilisée

{
  "name" : "乔丹",
  "age" : 45,
  "hobbies" : [ "高尔夫球", "棒球" ],
  "friends" : [ "kobe", "curry", "james" ],
  "salary" : {
    "2000" : 10000000,
    "2010" : 62000000,
    "2020" : 112400000
  }
}

Trois, méthode de désérialisation

Le code suivant montre comment désérialiser une chaîne JSON en un objet Java

@Test
void testJSON2Object() throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  //从文件中读取JSON字符串，反序列化为java对象
  PlayerStar player = mapper.readValue(new File("d:\\data\\jackson\\player.json"), PlayerStar.class);
  System.out.println(player);

  //将JSON字符串反序列化为java对象
  String jsonInString = "{\"name\":\"乔丹\",\"age\":45,\"hobbies\":[\"高尔夫球\",\"棒球\"]}";
  PlayerStar jordan = mapper.readValue(jsonInString, PlayerStar.class);

  System.out.println(jordan);

}

La sortie console de l'objet PlayerStar est la suivante ( notez que la sortie ici n'est pas au format JSON, mais la valeur de la méthode toString () de l'objet java ):

PlayerStar(name=乔丹, age=45, hobbies=[高尔夫球, 棒球], friends=[kobe, curry, james], salary={2000=10000000, 2010=62000000, 2020=112400000})
PlayerStar(name=乔丹, age=45, hobbies=[高尔夫球, 棒球], friends=null, salary=null)

Quatre, renommer le champ`@JsonProperty`

Vous pouvez utiliser @JsonProperty pour influencer le changement de nom des propriétés d'objets sérialisés et désérialisés.

@Data
public class PlayerStar {

  @JsonProperty("playerName")
  private String name;  //将属性name序列化为playerName，同时影响反序列化

Après avoir utilisé l'annotation du code ci-dessus, l'attribut name du résultat de la sérialisation JSON devient l'attribut playerName

{"playerName":"乔丹"  ……

En même temps, cela affecte la désérialisation. Le code de désérialisation suivant signalera une erreur car l'attribut de nom est utilisé. PlayerName doit être utilisé.

String jsonInString = "{\"name\":\"乔丹\",\"age\":45,\"hobbies\":[\"高尔夫球\",\"棒球\"]}";
PlayerStar jordan = mapper.readValue(jsonInString, PlayerStar.class);

Cinq, ignorez la sérialisation des champs nuls`@JsonInclude`

Lorsque nous n'affectons pas de valeurs aux variables membres de l'objet, par défaut, le résultat de la sérialisation de Jackson est le suivant.

{
  "age" : 45,
  "hobbies" : null,
  "friends" : null,
  "salary" : null,
  "playerName" : "乔丹"
}

Si nous ne voulons pas que la valeur null soit reflétée dans le résultat de la sérialisation JSON, nous pouvons utiliser la méthode suivante. Si vous souhaitez ignorer la variable membre null dans la portée globale d'une certaine sérialisation, vous pouvez utiliser l'API suivante

ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Ou ajoutez le commentaire suivant au-dessus du nom de la classe. Cette annotation prendra effet pour toutes les variables membres de la classe. Tant que la variable membre est nulle, elle ne sera pas incluse dans le résultat de la sérialisation.

@JsonInclude(JsonInclude.Include.NON_NULL)
public class PlayerStar {
   ......
}

Si nous voulons ignorer null séparément pour certaines variables membres de la classe PlayerStar, nous pouvons ajouter des annotations aux variables membres.

@JsonInclude(JsonInclude.Include.NON_NULL)
private String[] hobbies;    //业余爱好,数组
@JsonInclude(JsonInclude.Include.NON_NULL)
private List<String> friends;   //  朋友
@JsonInclude(JsonInclude.Include.NON_NULL)
private Map<String, BigDecimal> salary; //年收入 Map

Après avoir ignoré les variables de membre nulles, le résultat de la sérialisation JSON est le suivant

{
  "age" : 45,
  "playerName" : "乔丹"
}

Six, ignorez le champ spécifié

Par défaut, Jackson ne sérialisera pas et ne désérialisera pas les variables membres statiques et transitoires. On peut aussi passer

@JsonIgnoreAjouté à la variable membre de classe, la variable membre sera exclue du processus de sérialisation et de désérialisation
@JsonIgnorePropertiesAjoutez à la déclaration de classe pour spécifier quels champs de la classe sont exclus du processus de sérialisation et de désérialisation

Vous pouvez choisir l'une des deux annotations ci-dessus. J'ai utilisé les deux annotations dans le code ci-dessous et les fonctions sont répétées

@Data
@JsonIgnoreProperties({"hobbies", "friends","salary"})
public class PlayerStar {

  @JsonProperty("playerName")
  private String name;
  private Integer age;

  @JsonIgnore
  private String[] hobbies;    //业余爱好,数组
  @JsonIgnore
  private List<String> friends;   //  朋友
  @JsonIgnore
  private Map<String, BigDecimal> salary; //年收入 Map

......

Après avoir ajouté des annotations à la classe ou aux variables membres, les résultats de la sérialisation sont les suivants et les champs spécifiés sont ignorés.

{
  "age" : 45,
  "playerName" : "乔丹"
}

Il convient de noter que ces deux annotations affectent non seulement le processus de sérialisation en chaînes JSON, mais également le processus de désérialisation des chaînes JSON en objets java. Exemple: Si la chaîne JSON contient la valeur d'attribut hobbies de JsonIgnore dans la classe, elle ne sera pas désérialisée et affectée à la variable membre hobbies de l'objet java.

Bienvenue à suivre mon blog, il existe de nombreuses collections de boutique

Cet article est reproduit avec une indication de la source (la connexion doit être jointe, et le texte ne peut pas être reproduit uniquement): Le blog de Lettre Brother .

Si vous pensez que cela vous est utile, aimez-le et partagez-le pour moi! Votre soutien est ma motivation créative inépuisable! . De plus, l'auteur a récemment produit le contenu de haute qualité suivant, et j'attends avec impatience votre attention.