Java Language
Java의 JSON

소개

비고

JSON으로 데이터 인코딩

JSONObject 를 작성하여 데이터를 넣어야하는 경우 다음 예제를 고려하십시오.

// Create a new javax.json.JSONObject instance.
JSONObject first = new JSONObject();

first.put("foo", "bar");
first.put("temperature", 21.5);
first.put("year", 2016);

// Add a second object.
JSONObject second = new JSONObject();
second.put("Hello", "world");
first.put("message", second);

// Create a new JSONArray with some values
JSONArray someMonths = new JSONArray(new String[] { "January", "February" });
someMonths.put("March");
// Add another month as the fifth element, leaving the 4th element unset.
someMonths.put(4, "May");

// Add the array to our object
object.put("months", someMonths);

// Encode
String json = object.toString();

// An exercise for the reader: Add pretty-printing!
/* {
       "foo":"bar",
       "temperature":21.5,
       "year":2016,
       "message":{"Hello":"world"},
       "months":["January","February","March",null,"May"]
   }
*/

JSON 데이터 디코딩

JSONObject 에서 데이터를 JSONObject 하는 경우 다음 예제를 고려하십시오.

String json = "{\"foo\":\"bar\",\"temperature\":21.5,\"year\":2016,\"message\":{\"Hello\":\"world\"},\"months\":[\"January\",\"February\",\"March\",null,\"May\"]}";

// Decode the JSON-encoded string
JSONObject object = new JSONObject(json);

// Retrieve some values
String foo = object.getString("foo");
double temperature = object.getDouble("temperature");
int year = object.getInt("year");

// Retrieve another object
JSONObject secondary = object.getJSONObject("message");
String world = secondary.getString("Hello");

// Retrieve an array
JSONArray someMonths = object.getJSONArray("months");
// Get some values from the array
int nMonths = someMonths.length();
String february = someMonths.getString(1);

optXXX 대 getXXX 메소드

JSONObject 및 JSONArray 에는 얻으려는 값이 존재하지 않거나 다른 유형의 가능성을 처리하는 동안 매우 유용한 몇 가지 메소드가 있습니다.

JSONObject obj = new JSONObject();
obj.putString("foo", "bar");

// For existing properties of the correct type, there is no difference
obj.getString("foo");        // returns "bar"
obj.optString("foo");        // returns "bar"
obj.optString("foo", "tux"); // returns "bar"

// However, if a value cannot be coerced to the required type, the behavior differs
obj.getInt("foo");      // throws JSONException
obj.optInt("foo");      // returns 0
obj.optInt("foo", 123); // returns 123

// Same if a property does not exist
obj.getString("undefined");        // throws JSONException
obj.optString("undefined");        // returns ""
obj.optString("undefined", "tux"); // returns "tux"

동일한 규칙이 JSONArray 의 getXXX / optXXX 메소드에도 적용됩니다.

JSON에 객체 (Gson 라이브러리)

name Person 클래스가 있다고 가정합니다.

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

암호:

Gson g = new Gson();

Person person = new Person("John");
System.out.println(g.toJson(person)); // {"name":"John"}

물론 Gson 항아리는 classpath에 있어야합니다.

JSON To Object (Gson 라이브러리)

name Person 클래스가 있다고 가정합니다.

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

암호:

Gson gson = new Gson();
String json = "{\"name\": \"John\"}";

Person person = gson.fromJson(json, Person.class);
System.out.println(person.name); //John

수업 경로에 gson 라이브러리 가 있어야합니다.

JSON에서 단일 요소 추출

String json = "{\"name\": \"John\", \"age\":21}";

JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();

System.out.println(jsonObject.get("name").getAsString()); //John
System.out.println(jsonObject.get("age").getAsInt()); //21

Jackson Object Mapper 사용하기

포조 모델

public class Model {
    private String firstName;
    private String lastName;
    private int age;
    /* Getters and setters not shown for brevity */        
}

예 : String to Object

Model outputObject = objectMapper.readValue(
     "{\"firstName\":\"John\",\"lastName\":\"Doe\",\"age\":23}",
     Model.class);
System.out.println(outputObject.getFirstName());
//result: John

예 : Object to String

String jsonString = objectMapper.writeValueAsString(inputObject));
//result: {"firstName":"John","lastName":"Doe","age":23}

세부

필요한 import 문 :

import com.fasterxml.jackson.databind.ObjectMapper;

메이븐 종속성 : jackson-databind

ObjectMapper 인스턴스

//creating one
ObjectMapper objectMapper = new ObjectMapper();

• ObjectMapper 는 threadsafe입니다.
• 권장 : 공유 된 정적 인스턴스가 있어야합니다.

직렬화 복원 :

<T> T readValue(String content, Class<T> valueType)  

• valueType 을 지정해야합니다. 반환 값은이 유형입니다.
• 던지다
  • IOException - 저레벨의 입출력 문제가 발생했을 경우
  • JsonParseException - 기본이되는 입력이 무효 인 컨텐츠를 포함한 경우
  • JsonMappingException - 입력 JSON 구조체가 객체 구조체와 일치하지 않는 경우

사용 예제 (jsonString은 입력 문자열입니다.) :

Model fromJson = objectMapper.readValue(jsonString, Model.class);

직렬화 방법 :

문자열 writeValueAsString (객체 값)

• 던지다
  • JsonProcessingException 오류가 발생한 경우
  • 주 : 버젼 2.1보다 전은, IOException를 포함한 throws 절. 2.1에서 제거했습니다.

JSON 반복

JSONObject 속성 반복 수행

JSONObject obj = new JSONObject("{\"isMarried\":\"true\", \"name\":\"Nikita\", \"age\":\"30\"}");
Iterator<String> keys = obj.keys();//all keys: isMarried, name & age
while (keys.hasNext()) {                      //as long as there is another key
      String key = keys.next();               //get next key 
      Object value = obj.get(key);            //get next value by key
      System.out.println(key + " : " + value);//print key : value
}

JSONArray 값 반복 수행

JSONArray arr = new JSONArray();        //Initialize an empty array
//push (append) some values in:
arr.put("Stack");
arr.put("Over");
arr.put("Flow");
for (int i = 0; i < arr.length(); i++) {//iterate over all values
    Object value = arr.get(i);          //get value
    System.out.println(value);          //print each value
}

JSON Builder - 연결 방법

JSONObject 및 JSONArray 작업하는 동안 메소드 체인 을 사용할 수 있습니다.

JSONObject 예제

JSONObject obj = new JSONObject();//Initialize an empty JSON object 
//Before: {}
obj.put("name","Nikita").put("age","30").put("isMarried","true");
//After: {"name":"Nikita","age":30,"isMarried":true}

JSONArray

JSONArray arr = new JSONArray();//Initialize an empty array
//Before: []
arr.put("Stack").put("Over").put("Flow");
//After: ["Stack","Over","Flow"]

JSONObject.NULL

null 값을 가진 속성을 추가해야하는 경우 미리 정의 된 정적 JSONObject.NULL 사용해야하며 표준 Java null 참조는 사용하지 않아야합니다.

JSONObject.NULL 은 빈 값으로 속성을 명시 적으로 정의하는 데 사용되는 센티널 값입니다.

JSONObject obj = new JSONObject();
obj.put("some", JSONObject.NULL);   //Creates: {"some":null}
System.out.println(obj.get("some"));//prints: null

노트

JSONObject.NULL.equals(null); //returns true

Java.equals() 계약의 명확한 위반 사항 은 다음과 같습니다.

null 이외의 참조 치 x의 경우, x.equals (null)는 false를 돌려줍니다.

JsonArray에서 Java 목록으로 (Gson 라이브러리)

다음은 Java ArrayList 로 변환하려는 간단한 JsonArray입니다.

{
    "list": [
                "Test_String_1",
                "Test_String_2"
            ] 
}

이제 JsonArray 'list'를 해당 Java ArrayList 를 반환하는 다음 메서드로 전달합니다.

public ArrayList<String> getListString(String jsonList){
    Type listType = new TypeToken<List<String>>() {}.getType();
    //make sure the name 'list' matches the name of 'JsonArray' in your 'Json'.
    ArrayList<String> list = new Gson().fromJson(jsonList, listType);    
    return list;
}

POM.xml 파일에 다음과 같은 Maven 종속성을 추가해야합니다.

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.7</version>
</dependency>

또는 classpath에 com.google.code.gson:gson:jar:<version> 가 있어야합니다.

Jackson을 사용하여 JSON 컬렉션을 객체 컬렉션으로 비 직렬화

당신이 pojo 클래스 Person 을 가지고 있다고 가정하자.

public class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

JSON 배열이나 Person 객체의지도로 구문 분석하려고합니다. 타입 소거로 인해 런타임시 List<Person> 및 Map<String, Person> 클래스를 직접 생성 할 수 없기 때문에 (JSON을 deserialize하기 위해 사용) . 이 제한을 극복하기 위해 TypeFactory 와 TypeReference 두 가지 접근 방식을 제공합니다.

TypeFactory

여기서 취하는 접근법은 팩토리를 사용하여 유형을 구축하는 것입니다. 매개 변수는 사용할 컬렉션 (목록, 집합 등) 및 해당 컬렉션에 저장하려는 클래스입니다.

유형 참조

타입 참조 접근법은 타이핑을 좀 덜하고 깔끔하게 보일 수 있기 때문에 더 단순 해 보입니다. TypeReference는 원하는 형식 List<Person> 을 전달하는 형식 매개 변수를 허용합니다. 이 TypeReference 객체를 인스턴스화하고 유형 컨테이너로 사용하기 만하면됩니다.

이제 실제로 JSON을 Java 객체로 역 직렬화하는 방법을 살펴 보겠습니다. JSON을 배열로 포맷하면 목록으로 역 직렬화 할 수 있습니다. 보다 복잡한 중첩 구조가있는 경우지도에 직렬화를 해제해야합니다. 우리는 두 가지 예를 살펴볼 것입니다.

JSON 배열 비 직렬화

String jsonString = "[{\"name\": \"Alice\"}, {\"name\": \"Bob\"}]"

유형 접근 방식

CollectionType listType = 
    factory.constructCollectionType(List.class, Person.class);
List<Preson> list = mapper.readValue(jsonString, listType);

유형 참조 접근법

TypeReference<Person> listType = new TypeReference<List<Person>>() {};
List<Person> list = mapper.readValue(jsonString, listType);

JSON 맵의 비 직렬화

String jsonString = "{\"0\": {\"name\": \"Alice\"}, \"1\": {\"name\": \"Bob\"}}"

유형 접근 방식

CollectionType mapType = 
    factory.constructMapLikeType(Map.class, String.class, Person.class);
List<Person> list = mapper.readValue(jsonString, mapType);

유형 참조 접근법

TypeReference<Person> mapType = new TypeReference<Map<String, Person>>() {};
Map<String, Person> list = mapper.readValue(jsonString, mapType);

세부

사용 된 import 문 :

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;

사용 된 인스턴스 :

ObjectMapper mapper = new ObjectMapper();
TypeFactory factory = mapper.getTypeFactory();

노트

TypeReference 접근법은 더 좋게 보일 수 있지만 몇 가지 단점이 있습니다.

1. TypeReference 는 익명 클래스를 사용하여 인스턴스화해야합니다.
2. 일반적인 명확성을 제공해야합니다.

이렇게하지 않으면 제네릭 형식 인수가 손실되어 직렬화 해제 오류가 발생할 수 있습니다.