Jackson 의 몇 가지 용법 에 대하 여 논 하 다.

잭 슨 소개
본문 에 사 용 된 잭 슨 버 전 은 2.9.6 이다.
잭 슨 은 JSON 과 XML 을 해석 하 는 하나의 프레임 으로 간단 하고 사용 하기 쉬 우 며 성능 이 높다 는 장점 이 있다.
잭 슨 이 JSON 을 처리 하 는 방식.
잭 슨 은 세 가지 JSON 의 처리 방식 을 제공 했다.각각 데이터 바 인 딩,트 리 모델,스 트림 API 입 니 다.다음은 이 세 가지 방식 을 각각 소개 한다.
JackSon 데이터 바 인 딩
데이터 바 인 딩 은 JSON 전환 에 사용 되 며 JSON 과 POJO 대상 을 전환 할 수 있 습 니 다.데이터 바 인 딩 은 두 가지 가 있 습 니 다.간단 한 데이터 바 인 딩 과 전체 데이터 바 인 딩 입 니 다.
전체 데이터 바 인 딩

package com.xymxyg.json;

import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;

/**
 * @author guangsheng.tang
 *          ， json        ，         json   。        。
   :        ，       ，          POJO  ，          。       ，  json  POJO     ，            null，         。  json        ，        UnrecognizedPropertyException  。    json      ，POJO         。
 */
public class CompleteDataBind {
  public static void main(String[] args) throws IOException {
    String s = "{\"id\": 1,\"name\": \"  \",\"array\": [\"1\", \"2\"]}";
    ObjectMapper mapper = new ObjectMapper();
    //Json     
    Student student = mapper.readValue(s, Student.class);
    //     Json
    String json = mapper.writeValueAsString(student);
    System.out.println(json);
    System.out.println(student.toString());
  }
}

package com.xymxyg.json;

/**
 * @author guangsheng.tang
 */
public class Student {
  private int id;
  private String name;
  private String sex;
  private ArrayList<String> array;
  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getSex() {
    return sex;
  }

  public void setSex(String sex) {
    this.sex = sex;
  }

  public ArrayList<String> getArray() {
    return array;
  }

  public void setArray(ArrayList<String> array) {
    this.array = array;
  }

  @Override
  public String toString() {
    return "Student{" +
        "id=" + id +
        ", name='" + name + '\'' +
        ", sex='" + sex + '\'' +
        ", array=" + Arrays.toString(array.toArray()) +
        '}';
  }
}

단순 데이터 바 인 딩
간단 한 데이터 바 인 딩 은 json 문자열 을 자바 핵심 데이터 형식 으로 표시 하 는 것 입 니 다.
json 형식
Java 형식
object
LinkedHashMap
array
ArrayList
string
String
number
Integer,Long,Double
true|false
Boolean
null
null
제 이 슨 을 맵 으로 바 꾸 는 예 를 보 여 드 리 겠 습 니 다.맵 을 통 해 읽 습 니 다.

package com.xymxyg.json;

import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @author guangsheng.tang
 *          ，  POJO  ，       Map，   Map   。
 */
public class SimpleDataBind {
  public static void main(String[] args) throws IOException {
    Map<String, Object> map = new HashMap<>(16);
    String s = "{\"id\": 1,\"name\": \"  \",\"array\": [\"1\", \"2\"]," +
        "\"test\":\"I'm test\",\"base\": {\"major\": \"   \",\"class\": \"3\"}}";
    ObjectMapper mapper = new ObjectMapper();
    map = mapper.readValue(s, map.getClass());
    //  id
    Integer studentId = (Integer) map.get("id");
    System.out.println(studentId);
    //    
    ArrayList list = (ArrayList) map.get("array");
    System.out.println(Arrays.toString(list.toArray()));
    //              
    String test = (String) map.get("test");
    System.out.println(test);
    //      null
    String notExist = (String) map.get("notExist");
    System.out.println(notExist);
    //       
    Map base = (Map) map.get("base");
    String major = (String) base.get("major");
    System.out.println(major);
  }
}

나무 모형
Jackson 의 나무 모형 구조 에 대해 저 는 비교적 완벽 한 예 를 썼 습 니 다.자바 트 리 모델 도 장점 도 있 고 단점 도 있다.

package com.xymxyg.json;

import com.fasterxml.jackson.core.JsonPointer;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.IOException;

/**
 * @author guangsheng.tang
 * JackSon     ，    get，JsonPointer     ，       Json    ，    。              ，
 *        。
 */
public class TreeModel {
  public static void main(String[] args) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    //        Json
    JsonNode root = mapper.createObjectNode();
    ((ObjectNode) root).putArray("array");
    ArrayNode arrayNode = (ArrayNode) root.get("array");
    ((ArrayNode) arrayNode).add("args1");
    ((ArrayNode) arrayNode).add("args2");
    ((ObjectNode) root).put("name", "  ");
    String json = mapper.writeValueAsString(root);
    System.out.println("         json:"+json);
    //         Json
    String s = "{\"id\": 1,\"name\": \"  \",\"array\": [\"1\", \"2\"]," +
        "\"test\":\"I'm test\",\"nullNode\":null,\"base\": {\"major\": \"   \",\"class\": \"3\"}}";
    //  rootNode
    JsonNode rootNode = mapper.readTree(s);
    //  path  
    System.out.println("  path   ：" + rootNode.path("name").asText());
    //  JsonPointer          
    JsonPointer pointer = JsonPointer.valueOf("/base/major");
    JsonNode node = rootNode.at(pointer);
    System.out.println("  at   :" + node.asText());
    //  get      value
    JsonNode classNode = rootNode.get("base");
    System.out.println("  get   ：" + classNode.get("major").asText());

    //      
    System.out.print("      ：");
    JsonNode arrayNode2 = rootNode.get("array");
    for (int i = 0; i < arrayNode2.size(); i++) {
      System.out.print(arrayNode2.get(i).asText()+" ");
    }
    System.out.println();
    //path get        ，         ，get           ，   null。 path   
    //    "missing node"， "missing node" isMissingNode      true，     node asText    ，
    //          。
    System.out.println("get         ，  null:" + (rootNode.get("notExist") == null));
    JsonNode notExistNode = rootNode.path("notExist");
    System.out.println("notExistNode value：" + notExistNode.asText());
    System.out.println("isMissingNode    true:" + notExistNode.isMissingNode());

    // key  ， value null   ，get path      NullNode  。
    System.out.println(rootNode.get("nullNode") instanceof NullNode);
    System.out.println(rootNode.path("nullNode") instanceof NullNode);
  }
}

흐름 식 API
스 트림 API 는 바 텀 API 로 속도 가 빠 르 지만 사용 하기 가 매우 번거롭다.이것 은 주로 두 가지 핵심 클래스 가 있 는데 하 나 는 제 이 슨 제 너 레이 터 로 제 이 슨 을 만 들 고 다른 하 나 는 제 이 슨 파 서 로 제 이 슨 내용 을 읽 는 데 사용 된다.말 이 많 지 않 으 니 코드 로 직접 보 여 주세요.

package com.xymxyg.json;

import com.fasterxml.jackson.core.*;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author guangsheng.tang
 * JsonParser Generator       ，           。
 */
public class StreamApi {
  public static void main(String[] args) throws IOException {
    JsonFactory factory = new JsonFactory();
    String s = "{\"id\": 1,\"name\": \"  \",\"array\": [\"1\", \"2\"]," +
        "\"test\":\"I'm test\",\"nullNode\":null,\"base\": {\"major\": \"   \",\"class\": \"3\"}}";

    //             ，Generator         write  。
    File file = new File("/json.txt");
    JsonGenerator jsonGenerator = factory.createGenerator(file, JsonEncoding.UTF8);
    //    
    jsonGenerator.writeStartObject();
    //       
    jsonGenerator.writeStringField("name", "  ");
    //    
    jsonGenerator.writeEndObject();
    //  jsonGenerator
    jsonGenerator.close();
    //       json
    FileInputStream inputStream = new FileInputStream(file);
    int i = 0;
    final int SIZE = 1024;
    byte[] buf = new byte[SIZE];
    StringBuilder sb = new StringBuilder();
    while ((i = inputStream.read(buf)) != -1) {
      System.out.println(new String(buf,0,i));
    }
    inputStream.close();


    //JsonParser     ，    json              JsonToken，  JsonToken       。
    //       ，    JsonToken        。
    JsonParser parser = factory.createParser(s);
    while (!parser.isClosed()){
      JsonToken token = parser.currentToken();
      System.out.println(token);
      parser.nextToken();
    }

    JsonParser jsonParser = factory.createParser(s);
    //          
    while (!jsonParser.isClosed()) {
      JsonToken token = jsonParser.nextToken();
      if (JsonToken.FIELD_NAME.equals(token)) {
        String currentName = jsonParser.currentName();
        token = jsonParser.nextToken();
        if ("id".equals(currentName)) {
          System.out.println("id:" + jsonParser.getValueAsInt());
        } else if ("name".equals(currentName)) {
          System.out.println("name:" + jsonParser.getValueAsString());
        } else if ("array".equals(currentName)) {
          token = jsonParser.nextToken();
          while (!JsonToken.END_ARRAY.equals(token)) {
            System.out.println("array:" + jsonParser.getValueAsString());
            token = jsonParser.nextToken();
          }
        }
      }
    }
  }

}

Jackson
Jackson 은 클래스 나 필드 에 사용 할 수 있 는 주 해 를 제공 합 니 다.보통 데이터 바 인 딩 시 사용 합 니 다.다음 몇 개 는 가장 많이 쓰 는 몇 개 입 니 다.
@JsonInclude(Include.NON_EMPTY)
속성 이 비어 있 지 않 을 때 만 이 필드 를 정렬 합 니 다.문자열,즉 null 또는 빈 문자열 입 니 다.
@JsonIgnore
직렬 화 시 이 필드 무시
@JsonProperty(value = “user_name”)
직렬 화 된 필드 이름 을 지정 합 니 다.기본적으로 속성 이름 을 사용 합 니 다.
총결산
Jackson 은 사용 하기에 매우 편리 하고 제공 하 는 기능 도 많 습 니 다.사용 할 때 자신의 업무 장면 과 결합 하여 적당 한 해석 방식 을 선택해 야 합 니 다.
참고 자료
http://blog.lifw.org/post/63088058v
https://www.yiibai.com/jackson/
잭 슨 의 몇 가지 용법 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 잭 슨 의 용법 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 부탁드립니다!