Wie integriert SpringBoot Jackson?

1. Einführung in Jackson

Anleitung: Dieser Artikel beschreibt die detaillierte Verwendung der Jackson-Tool-Klasse am Ende des Artikels. Sie können sie einfach kopieren und einfügen. Jackson ist eine der Komponenten, die im Unternehmen häufig verwendet werden müssen. Aus bestimmten Gründen gibt es jedoch zu viele Fehler und Lücken Gson (das ist nutzlos, aber ich weiß nicht viel darüber). Der Standard-JSON-Parser von Spring MVC ist Jackson. Jackson hat viele Stärken. Jackson ist auf weniger Glasverpackungen angewiesen und ist einfach und leicht zu verwenden. Im Vergleich zu anderen Java-JSON-Frameworks wie Gson analysiert Jackson große JSON-Dateien schneller; Jackson benötigt zur Laufzeit weniger Speicher und bietet eine bessere Leistung;

Zusätzliche Kenntnisse:
Der Paketname der 1.x-Version von Jackson lautet org.codehaus.jackson, org.codehaus.jackson ，
当升级到 2.x 版本时，包名变为com.fasterxml.jackson。

Jackson 有三个核心包，分别是 Streaming、Databid、Annotations，通过这些包可以方便的对 JSON 进行操作.

• jackson-core：核心包，提供基于"流模式"解析的相关 API，它包括 JsonPaser 和 JsonGenerator。 Jackson 内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json。

• jackson-annotations:注解包，提供标准注解功能.

• jackson-databind :数据绑定包， 提供基于"对象绑定" 解析的相关 API （ ObjectMapper ） 和"树模型" 解析的相关 API （JsonNode）；基于"对象绑定" 解析的 API 和"树模型"解析的 API 依赖基于"流模式"解析的 API。包含上面两个包，只导入这个坐标即可。

运行环境：

• idea2020.2

• jdk1.8

• springboot 2.7.9Beim Upgrade auf die 2.x-Version wird der Paketname zu com .fasterxml.jackson.

Jackson verfügt über drei Kernpakete, nämlich Streaming, Databid und Annotations. Über diese Pakete kann JSON einfach bedient werden

jackson-core: Das Kernpaket stellt verwandte APIs basierend auf der Analyse im „Stream-Modus“ bereit, einschließlich JsonPaser und JsonGenerator. Jacksons interne Implementierung generiert und analysiert JSON über JsonGenerator und JsonParser der Hochleistungs-Streaming-API.

jackson-annotations: Annotationspaket, das Standard-Annotationsfunktionen bereitstellt

jackson-databind: Datenbindungspaket, das basierend auf „ Die zugehörigen APIs, die von „Object Binding“ (ObjectMapper) analysiert werden, und die zugehörigen APIs, die von „Tree Model“ (JsonNode) analysiert werden; die APIs, die basierend auf „Object Binding“ analysiert werden, und die APIs, die von „Tree Model“ analysiert werden, hängen von den APIs ab, die basierend auf analysiert werden auf „Streaming-Modus“ . Enthält die beiden oben genannten Pakete. Importieren Sie einfach diese Koordinate.

Laufumgebung:

• idea2020.2

• jdk1.8 code>

• springboot 2.7.9
  Laden Sie die Demo herunter:

  Gehen Sie direkt zu meinen Ressourcen zum Herunterladen (Jackson-Beispiel – mit Tool-Klasse)

  2. Json-Einführung

  Hinweis: Als Java-Entwickler müssen Sie Json lernen. In aktuellen Projekten mit Front-End- und Back-End-Trennung ist Json das am häufigsten verwendete Datenaustauschformat. Beispielsweise wird die Annotation @RequestBody in SpringBoot als Annotation zum Empfangen des Json-Formats verwendet. Bei der Verwendung von Postman zum Testen handelt es sich bei dem übertragenen Roh-JSON ebenfalls um Daten im Json-Format.

  JSON-Darstellungsstruktur:

  Objektarray

  : Die Objektstruktur beginnt mit „{“-Klammern und endet mit „}“-Klammern. Der mittlere Teil besteht aus 0 oder mehr Schlüsseln (Schlüsselwörtern), die durch ","/ Wert (Wert) getrennt sind )“ Paare, Schlüsselwörter und Werte werden durch „:“ getrennt und die Syntaxstruktur ist wie Code. Hier ist ein Beispiel.

  {
    "array": [1,2,3],
    "boolean": true,
    "name": "cllb",
    "null": null,
    "age": 12345,
    "object": {
      "height": 100,
      "color": "红色"
    },
    "string": "陈老老老板"
  }

  3. Springboot integriert Jackson
  1. Projekt erstellen

  Anleitung:

  Erstellen Sie ein leeres Springboot-Projekt (Version 2.7.9). Ich werde es hier nicht zu oft wiederholen. Es ist sehr praktisch, die Lombok-Komponente beim Erstellen auszuwählen, ohne die Get/Set-Methode schreiben zu müssen.
  Hinweis:

  Sie können sehen, dass beim Importieren des Databind-Pakets automatisch die verbleibenden zwei Pakete importiert werden.

  2. Koordinaten importieren

  Anleitung:

  Sie können sehen, dass beim Importieren des Databind-Pakets automatisch die verbleibenden zwei Pakete importiert werden.

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

  

  3. Konfigurationsdatei
  Eigenschaftenformat:

  #指定日期格式，比如yyyy-MM-dd HH:mm:ss，或者具体的格式化类的全限定名
  spring.jackson.date-format
  #指定日期格式化时区，比如America/Los_Angeles或者GMT+10.
  spring.jackson.time-zone
  #是否开启Jackson的反序列化
  spring.jackson.deserialization
  #是否开启json的generators.
  spring.jackson.generator
  #指定Joda date/time的格式，比如yyyy-MM-ddHH:mm:ss). 如果没有配置的话，dateformat会作为backup
  spring.jackson.joda-date-time-format
  #指定json使用的Locale.
  spring.jackson.locale
  #是否开启Jackson通用的特性.
  spring.jackson.mapper
  #是否开启jackson的parser特性.
  spring.jackson.parser
  #指定PropertyNamingStrategy(CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES)或者指定PropertyNamingStrategy子类的全限定类名.
  spring.jackson.property-naming-strategy
  #是否开启jackson的序列化.
  spring.jackson.serialization
  #指定序列化时属性的inclusion方式，具体查看JsonInclude.Include枚举.
  spring.jackson.serialization-inclusion

  b. Benutzerdefinierte Konfiguration

  Hier geben wir direkt Sie die Jackson-Werkzeugklasse , Benutzerdefinierte Konfiguration bezieht sich auf die festgelegte Zuweisung zu object_mapper in der Tool-Klasse. Es gibt alle Methoden und die Demonstration erfolgt direkt über die Tool-Klasse.

  spring:
    jackson:
      #日期格式化
      date-format: yyyy-MM-dd HH:mm:ss
      time-zone: GMT+8
      #设置空如何序列化
      default-property-inclusion: non_null    
      serialization:
         #格式化输出 
        indent_output: true
        #忽略无法转换的对象
        fail_on_empty_beans: false
      deserialization:
        #允许对象忽略json中不存在的属性
        fail_on_unknown_properties: false
      parser:
        #允许出现特殊字符和转义符
        allow_unquoted_control_chars: true
        #允许出现单引号
        allow_single_quotes: true

  4. Die Methode ist sehr einfach und die Ausgabeergebnisse sind beigefügt. a.object-Typkonvertierung in Json

  Anweisungen:

  WriteValueAsString-Methode verwenden

  package com.clllb.jackson.utils;
  
  import com.fasterxml.jackson.annotation.JsonInclude;
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.core.type.TypeReference;
  import com.fasterxml.jackson.databind.*;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.util.StringUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.text.SimpleDateFormat;
  import java.util.List;
  
  @Slf4j
  public class JacksonUtil {
  
      private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
  
      private static final ObjectMapper OBJECT_MAPPER_SNAKE_CASE = new ObjectMapper();
      // 日期格式化
      private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
  
      static {
          //对象的所有字段全部列入
          OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
          //取消默认转换timestamps形式
          OBJECT_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
          //忽略空Bean转json的错误
          OBJECT_MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
          //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
          OBJECT_MAPPER.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
          //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
          OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
      }
  
      static {
          //对象的所有字段全部列入
          OBJECT_MAPPER_SNAKE_CASE.setSerializationInclusion(JsonInclude.Include.ALWAYS);
          //取消默认转换timestamps形式
          OBJECT_MAPPER_SNAKE_CASE.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
          //忽略空Bean转json的错误
          OBJECT_MAPPER_SNAKE_CASE.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
          //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
          OBJECT_MAPPER_SNAKE_CASE.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
          //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
          OBJECT_MAPPER_SNAKE_CASE.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
          //转换为下划线
          OBJECT_MAPPER_SNAKE_CASE.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
      }
  
      private JacksonUtil() {
      }
  
      /**
       * 对象转Json格式字符串
       *
       * @param obj 对象
       * @return Json格式字符串
       */
      public static <T> String obj2String(T obj) {
          if (obj == null) {
              return null;
          }
          try {
              return obj instanceof String ? (String) obj : OBJECT_MAPPER.writeValueAsString(obj);
          } catch (JsonProcessingException e) {
              log.warn("Parse Object to String error : {}", e.getMessage());
              return null;
          }
      }
  
      /**
       * 对象转file
       * @param fileName
       * @param obj
       */
       public static void obj2File(String fileName,Object obj){
          if (obj == null){
              return;
          }
           try {
               OBJECT_MAPPER.writeValue(new File(fileName),obj);
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
  
      /**
       * 对象转Json格式字符串; 属性名从驼峰改为下划线形式
       *
       * @param obj 对象
       * @return Json格式字符串
       */
      public static <T> String obj2StringFieldSnakeCase(T obj) {
          if (obj == null) {
              return null;
          }
          try {
              ObjectMapper objectMapper = OBJECT_MAPPER_SNAKE_CASE;
              return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
          } catch (JsonProcessingException e) {
              log.warn("Parse Object to String error : {}", e.getMessage());
              return null;
          }
      }
  
      /**
       * 字符串转换为自定义对象； 属性名从下划线形式改为驼峰
       *
       * @param str   要转换的字符串
       * @param clazz 自定义对象的class对象
       * @return 自定义对象
       */
      public static <T> T string2ObjFieldLowerCamelCase(String str, Class<T> clazz) {
          if (StringUtils.isEmpty(str) || clazz == null) {
              return null;
          }
          try {
              ObjectMapper objectMapper = OBJECT_MAPPER_SNAKE_CASE;
              return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
          } catch (Exception e) {
              log.warn("Parse String to Object error : {}", e.getMessage());
              return null;
          }
      }
  
      /**
       * 字符串转换为自定义对象(List)； 属性名从下划线形式改为驼峰
       *
       * @param str           要转换的字符串
       * @param typeReference 自定义对象的typeReference List 对象
       * @return 自定义对象
       */
      public static <T> List<T> string2ListFieldLowerCamelCase(String str, TypeReference<List<T>> typeReference) {
          if (StringUtils.isEmpty(str) || typeReference == null) {
              return null;
          }
          try {
              ObjectMapper objectMapper = OBJECT_MAPPER_SNAKE_CASE;
              return objectMapper.readValue(str, typeReference);
          } catch (Exception e) {
              log.warn("Parse String to Object error : {}", e.getMessage());
              return null;
          }
      }
  
      /**
       * 对象转Json格式字符串(格式化的Json字符串)
       *
       * @param obj 对象
       * @return 美化的Json格式字符串
       */
      public static <T> String obj2StringPretty(T obj) {
          if (obj == null) {
              return null;
          }
          try {
              return obj instanceof String ? (String) obj : OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
          } catch (JsonProcessingException e) {
              log.warn("Parse Object to String error : {}", e.getMessage());
              return null;
          }
      }
  
      /**
       * 字符串转换为自定义对象
       *
       * @param str   要转换的字符串
       * @param clazz 自定义对象的class对象
       * @return 自定义对象
       */
      public static <T> T string2Obj(String str, Class<T> clazz) {
          if (StringUtils.isEmpty(str) || clazz == null) {
              return null;
          }
          try {
              return clazz.equals(String.class) ? (T) str : OBJECT_MAPPER.readValue(str, clazz);
          } catch (Exception e) {
              log.warn("Parse String to Object error : {}", e.getMessage());
              return null;
          }
      }
  
      /**
       * 字符串转换为自定义字段转为list
       * @param str
       * @param typeReference
       * @param <T>
       * @return
       */
      public static <T> T string2Obj(String str, TypeReference<T> typeReference) {
          if (StringUtils.isEmpty(str) || typeReference == null) {
              return null;
          }
          try {
              return (T) (typeReference.getType().equals(String.class) ? str : OBJECT_MAPPER.readValue(str, typeReference));
          } catch (IOException e) {
              log.warn("Parse String to Object error", e);
              return null;
          }
      }
  
      public static <T> T string2Obj(String str, Class<?> collectionClazz, Class<?>... elementClazzes) {
          JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(collectionClazz, elementClazzes);
          try {
              return OBJECT_MAPPER.readValue(str, javaType);
          } catch (IOException e) {
              log.warn("Parse String to Object error : {}" + e.getMessage());
              return null;
          }
      }
  }

  Ausgabeergebnis:

  {"username":"clllb","age":24,"info":["Es gibt einhundert Wan, „ein Vermögen machen“], „userId“:1}

  b.Objekttypkonvertierung in Datei

  Anweisungen:

  WriteValue-Methode verwenden

  package com.clllb.jackson.PO;
  
  import lombok.Data;
  
  import java.util.List;
  
  @Data
  public class User {
  
      private String username;
  
      private Integer age;
  
      private List<String> info;
  
  	private Long userId;
  }

  Ausgabeergebnis:

  c. Zeichenfolgentypkonvertierung Benutzerdefinierter Objekttyp

  🎜🎜Anweisungen:🎜 Verwenden Sie die readValue-Methode🎜

   @Test
      void string2obj(){
          String json = "{\"username\":\"clllb\",\"age\":24,\"info\":[\"有一百万\",\"发大财\"],\"userId\":11}";
          User user = JacksonUtil.string2Obj(json, User.class);
          System.out.println(user);
      }

  输出结果：

  User(username=clllb, age=24, info=[有一百万, 发大财], userId=11)

  d.string类型转Object自定义类型list

  说明： 使用readValue方法,传参变为TypeReference typeReference，这里工具类用的重载方法名是相同的。

  @Test
      void string2objList(){
          String json = "[{\"username\":\"clllb\",\"age\":24,\"info\":[\"有一百万\",\"发大财\"],\"userId\":11},\n" +
                  "{\"username\":\"陈老老老板\",\"age\":25,\"info\":[\"有一千万\",\"发大大财\"],\"userId\":12}]";
          List<User> user = JacksonUtil.string2Obj(json, new TypeReference<List<User>>(){});
          user.forEach(System.out::println);
      }

  输出结果：

  User(username=clllb, age=24, info=[有一百万, 发大财], userId=11)
  User(username=陈老老老板, age=25, info=[有一千万, 发大大财], userId=12)

  e.object类型转String(驼峰转下划线)

  说明： 使用writeValueAsString方法,这里区别看工具类就会发现，就是多了一个设置OBJECT_MAPPER_SNAKE_CASE.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);

   @Test
      void obj2sringSnakeCase(){
          User user = new User();
          user.setUsername("clllb");
          user.setAge(24);
          user.setUserId(11L);
          List<String> infoList = new ArrayList<>();
          infoList.add("有一百万");
          infoList.add("发大财");
          user.setInfo(infoList);
          String json = JacksonUtil.obj2StringFieldSnakeCase(user);
          System.out.println(json);
      }

  输出结果：

  {"username":"clllb","age":24,"info":["有一百万","发大财"],"user_id":11}

  f.string类型（下划线）转Object类型

  <font color = &#39;red&#39;><b>说明：</font> 使用readValue方法
  ```java
   @Test
      void string2obj(){
          String json = "{\"username\":\"clllb\",\"age\":24,\"info\":[\"有一百万\",\"发大财\"],\"user_id\":11}";
          User user = JacksonUtil.string2Obj(json, User.class);
          System.out.println(user);
      }

  输出结果：

  User(username=clllb, age=24, info=[有一百万, 发大财], userId=11)

  g.string类型(下划线)转Object自定义类型list

  说明： 使用readValue方法,传参变为TypeReference typeReference，这里工具类用的重载方法名是相同的。

   @Test
      void string2objSnakeCase(){
          String json = "[{\"username\":\"clllb\",\"age\":24,\"info\":[\"有一百万\",\"发大财\"],\"user_id\":11},\n" +
                  "{\"username\":\"陈老老老板\",\"age\":25,\"info\":[\"有一千万\",\"发大大财\"],\"user_id\":12}]";
          List<User> user = JacksonUtil.string2ListFieldLowerCamelCase(json, new TypeReference<List<User>>(){});
          user.forEach(System.out::println);
      }

  输出结果：

  User(username=clllb, age=24, info=[有一百万, 发大财], userId=11)
  User(username=陈老老老板, age=25, info=[有一千万, 发大大财], userId=12)

Das obige ist der detaillierte Inhalt vonWie integriert SpringBoot Jackson?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!