[Java] Gson 라이브러리 사용법 및 예제 ( Json 생성, 변환 )

 

이번에는 Gson 라이브러리로,

Java에서 Json을 다루는 방법을 알아보도록 하겠습니다.

 

1. Gson은
2. Gson 라이브러리 추가하기
3. Gson 객체 생성하기
4. Json 생성하기
5. Object -> Json 변환하기
6. Json -> Object 변환하기
7. Map -> Json 문자열 변환하기
8. Json 문자열 -> Map 변환하기
9. Json 문자열 예쁘게 출력하기
10. 값이 null인 field의 Json property 생성
11. Field 제외하고, Json 문자열 만들기
1. transient
2. @Expose Annotation
3. ExclusionStrategy
12. Field Naming
1. 특정 Field 이름 바꾸기 ( @SerializedName )
2. Field Naming Rule 적용하기 ( FieldNamingPolicy )
13. Json 문자열 Parsing

 

1. Gson은

Gson은 Java에서 Json을 파싱하고, 생성하기 위해 사용되는

구글에서 개발한 오픈소스입니다.

Java Object를 Json 문자열로 변환할 수 있고, Json 문자열을 Java Object로 변환할 수 있습니다.

 

 

 

2. Gson 라이브러리 추가하기 

  Maven  

JSON 파싱에 사용할 json-simple 라이브러리를 추가하기 위해

pom.xml 파일에 아래와 같이 dependency를 추가합니다.

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.8.7</version>
</dependency>

 

  Gradle  

dependencies {
  implementation 'com.google.code.gson:gson:2.8.7'
}

 

  직접 추가하기  

https://search.maven.org/artifact/com.google.code.gson/gson/2.8.7/jar

위 링크에서 jar를 직접 다운받아서, 라이브러리에 추가합니다.

 

 

 

3. Gson 객체 생성하기

Gson 객체를 생성하는 방법은 2가지가 있습니다.

• new Gson()
• new GsonBuilder.create()

new GsonBuilder()을 이용하여 Gson 객체를 생성하면, 몇 가지 옵션을 추가해서 객체를 생성할 수 있습니다.

 

  코드  

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class CreateGson {
    public static void main(String[] args) {
        
        // new
        Gson gson1 = new Gson();

        // GsonBuilder
        Gson gson2 = new GsonBuilder().create();
        Gson gson3 = new GsonBuilder().setPrettyPrinting().create();
        
    }
}

 

 

 

4. Json 생성하기

  코드  

import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class GsonExample {

    public static void main(String[] args) {

        Gson gson = new Gson();

        // Json key, value 추가
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("name", "anna");
        jsonObject.addProperty("id", 1);

        // JsonObject를 Json 문자열로 변환
        String jsonStr = gson.toJson(jsonObject);

        // 생성된 Json 문자열 출력
        System.out.println(jsonStr); // {"name":"anna","id":1}
        
    }
}

jsonObject.addProperty("name", "anna");

JsonObject 객체를 생성하여, 

이 객체에 프로퍼티를 추가하였습니다.

 

 

 

5. Object -> Json 변환하기

  Student 클래스  

public class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }

}

Json으로 변환한 클래스입니다.

id와 name, 이렇게 2개의 field를 가지고,

이 2개의 field의 값을 세팅하는 Constructor를 가지고 있습니다.

 

 

  Student 클래스를 Json 문자열로 변환  

import com.google.gson.Gson;

public class ObjectToJson {

    public static void main(String[] args) {

        // Student 객체 생성
        Student student = new Student(1, "Anna");

        // Gson 객체 생성
        Gson gson = new Gson();

        // Student 객체 -> Json 문자열
        String studentJson = gson.toJson(student);

        // Json 문자열 출력
        System.out.println(studentJson);  // {"id":1,"name":"Anna"}
    }
}

String studentJson = gson.toJson(student);

student 객체를 Json 문자열로 변환하였습니다.

Student 클래스는 id, name 이렇게 2개의 field를 가지고 있고,

student 객체는 id는 1, name은 "Anna"라는 값을 가지고 있습니다.

이를 이용하여, Json 객체가 생성되었습니다.

 

 

 

6. Json -> Object 변환하기

  Student 클래스  

public class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }

}

 

 

  Json 문자열을 Student 클래스로 변환  

import com.google.gson.Gson;

public class JsonToObject {
    public static void main(String[] args) {

        // Json 문자열
        String jsonStr = "{\"id\":1,\"name\":\"Anna\"}";

        // Gson 객체 생성
        Gson gson = new Gson();

        // Json 문자열 -> Student 객체
        Student student = gson.fromJson(jsonStr, Student.class);

        // Student 객체 toString() 출력
        System.out.println(student); // Student [id=1, name=Anna]
    }
}

Student student = gson.fromJson(jsonStr, Student.class);

Json 문자열을 Student 클래스로 변환하였습니다.

 

 

 

7. Map -> Json 문자열 변환하기

  Map을 Json 문자열로 변환  

import com.google.gson.Gson;

public class MapToJson {
    public static void main(String[] args) {

        // Map
        Map<String, String> map = new HashMap<>();
        map.put("id", "1");
        map.put("name", "Anna");

        // Map -> Json 문자열
        Gson gson = new Gson();
        String jsonStr = gson.toJson(map);

        // Json 문자열 출력
        System.out.println(jsonStr); // {"name":"Anna","id":"1"}

    }
}

String jsonStr = gson.toJson(map);

Map을 Json 문자열로 변환하였습니다.

Object를 Json 문자열로 변환하는 방법과 같습니다.

 

 

 

8. Json 문자열 -> Map 변환하기

  Json 문자열을 Map으로 변환  

import java.util.Map;

import com.google.gson.Gson;

public class JsonToMap {
    public static void main(String[] args) {

        // Json 문자열
        String jsonStr = "{\"id\":\"1\",\"name\":\"Anna\"}";

        // Gson 객체 생성
        Gson gson = new Gson();

        // Json 문자열 -> Map
        Map<String, Object> map = gson.fromJson(jsonStr, Map.class);

        // Map 출력
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
    }
}

  결과  

id=1
name=Anna

Map<String, Object> map = gson.fromJson(jsonStr, Map.class);

Json 문자열을 Map으로 변환하였습니다.

Json 문자열을 Object로 변환하는 방법과 같습니다.

 

 

 

9. Json 문자열 예쁘게 출력하기

  코드  

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class PrettyPrinting {
    public static void main(String[] args) {

        // Json 문자열로 변환할 Student 객체
        Student student = new Student(1, "Anna");

        // PrettyPrinting 옵션을 추가하여 Gson 객체 생성
        Gson gson = new GsonBuilder().setPrettyPrinting().create();

        // Student 객체 -> Json 문자열
        String studentJson = gson.toJson(student);

        // Json 문자열 출력 ( 예쁘게 출력 )
        System.out.println(studentJson);

    }
}

  결과  

{
  "id": 1,
  "name": "Anna"
}

Gson gson = new GsonBuilder().setPrettyPrinting().create();

Json 문자열을 보기 좋게 출력하기 위해서,

Gson 객체를 생성할 때, PrettyPrinting 옵션을 추가하였습니다.

이 옵션을 적용하면, Json 문자열에 Indent, 줄바꿈이 적절이 적용되어

Json 문자열의 가독성이 높아집니다.

 

 

 

10. 값이 null인 field의 Json property 생성

  코드  

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class NullObject {
    public static void main(String[] args) {

        // 이름이 null인 Student 객체
        Student student = new Student(1, null);

        // 1. default
        // 값이 null인 field는, Json에 포함시키지 않습니다.
        Gson gsonWithoutNull = new Gson();
        String studentJson = gsonWithoutNull.toJson(student);

        System.out.println(studentJson); // {"id":1}

        
        // 2. serializeNulls 옵션
        // 값이 null인 field도, Json에 포함시킵니다.
        Gson gsonWithNull = new GsonBuilder().serializeNulls().create();
        String studentJsonWithNull = gsonWithNull.toJson(student);

        System.out.println(studentJsonWithNull); // {"id":1,"name":null}
        
    }
}

Gson gsonWithoutNull = new Gson();

Default로 Gson 객체를 생성하고, 이 객체로 Json 문자열을 생성하면,

Json 문자열로 변환될 객체(여기서는 student)의 field 값이 null일 경우,

null인 field는 Json의 property로 생성하지 않습니다.

 

Gson gsonWithNull = new GsonBuilder().serializeNulls().create();

Gson 객체를 생성할 때, serializeNulls 옵션을 추가하면,

Json 문자열로 변환될 객체의 field 값이 null일 경우,

null인 field도 Json의 property로 생성합니다.

 

 

 

11. Field 제외하고, Json 문자열 만들기

11. 1 transient

transient는 객체를 직렬화(Serialize) 할 때, 특정 필드를 제외하고 싶을 때 사용합니다.

제외하려고 하는 필드에 transient를 붙이면,

해당 필드를 제외하고 Json 문자열이 생성됩니다.

 

  Student 클래스  

public class Student {
    private transient int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }

}

private transient int id;

id를 transient 했습니다.

 

 

  id 필드 제외  

import com.google.gson.Gson;

public class ExcludeTransient {
    public static void main(String[] args) {

        // Student 객체 생성
        Student student = new Student(1, "Anna");

        // Gson 객체 생성
        Gson gson = new Gson();

        // Student 객체 -> Json 문자열
        String studentJson = gson.toJson(student);

        // Json 문자열 출력
        System.out.println(studentJson); // {"name":"Anna"}
    }
}

생성된 Json 문자열에 'id' 항목이 포함되지 않았습니다.

 

 

11. 2 @Expose Annotation

객체가 Json 문자열로 변환되거나(Serialized), Json 문자열이 객체로 변환될 때(Deserialized)

Gson의 '@Expose' 어노테이션을 이용하여

특정 필드가 포함될지, 포함되지 않을지 결정 할 수 있습니다.

@Expose(serialize = true);
@Expose(serialize = false);
@Expose(deserialize = true);
@Expose(deserialize = false);
@Expose(serialize = true , deserialize = false);
@Expose(serialize = false, deserialize = true);

• 특정 필드의 serialize 값이 true이면, 객체가 Json 문자열로 변환될 때, 해당 필드가 포함됩니다.
• 특정 필드의 serialize 값이 false이면, 객체가 Json 문자열로 변환될 때, 해당 필드가 제외됩니다.
• 특정 필드의 deserialize 값이 true이면, Json 문자열이 객체로 변환될 때, 필드에 값이 세팅됩니다.
• 특정 필드의 deserialize 값이 false이면, Json 문자열이 객체로 변환될 때, 필드에 값이 세팅되지 않습니다.
• @Expose 어노테이션은, excludeFieldsWithoutExposeAnnotation 옵션이 적용된 Gson 객체로,
  Json을 생성하거나(toJson()), 객체를 생성할 때만(fromJson()) 유효합니다.
• excludeFieldsWithoutExposeAnnotation 옵션이 적용된 Gson 객체로,
  Json을 생성하거나(toJson()), 객체를 생성할 때(fromJson())
  @Expose 어노테이션이 없으면, 해당 필드는 무시됩니다.

 

  @Expose 가 적용된 Student 클래스  

import com.google.gson.annotations.Expose;

public class Student {
    @Expose(serialize = false, deserialize = true)
    private int id;

    @Expose(serialize = true, deserialize = false)
    private String name;

    private String major;

    public Student(int id, String name, String major) {
        this.id = id;
        this.name = name;
        this.major = major;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", major=" + major + ", name=" + name + "]";
    }
}

@Expose(serialize = false, deserialize = true)
private int id;

'id' field는

객체 -> Json 변환시에는 제외되고,

Json -> 객체 변환시에는 포함됩니다.

 

@Expose(serialize = true, deserialize = false)
private String name;

'name' field는

객체 -> Json 변환시에는 포함되고,

Json -> 객체 변환시에는 제외됩니다.

 

private String major;

@Expose 어노테이션이 명시되지 않은

'major' 필드는,

객체 -> Json 변환시에도 제외되고,

Json -> 객체 변환시에도 제외됩니다.

 

 

  객체 -> Json 변환  

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class ExcludeExposeSerialize {
    public static void main(String[] args) {
        // Student 객체 생성
        Student student = new Student(1, "Anna", "CS");

        // Gson 객체 생성
        Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

        // Student 객체 -> Json 문자열
        String studentJson = gson.toJson(student);

        // Json 문자열 출력
        System.out.println(studentJson); // {"name":"Anna"}

    }
}

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

@Expose 어노테이션을 적용하기 위해서

excludeFieldsWithoutExposeAnnotation 옵션을 적용하여

Gson 객체를 생성하였습니다.

 

System.out.println(studentJson); // {"name":"Anna"}

객체 -> Json으로 변환하는 경우

serialize가 true로 선언된 'name' 필드만

Json 문자열에 포함되었습니다.

serialize가 false로 선언된 'id' 필드와

@Expose 어노테이션이 없는 'major' 필드는 제외되었습니다.

 

 

  Json -> 객체 변환  

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class ExcludeExposeDeserialize {
    public static void main(String[] args) {

        // Json 문자열
        String jsonStr = "{\"id\":1,\"name\":\"Anna\", \"major\":\"CS\"}";

        // Gson 객체 생성
        Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

        // Json 문자열 -> Student 객체
        Student student = gson.fromJson(jsonStr, Student.class);

        // Student 객체 toString() 출력
        System.out.println(student); // Student [id=1, major=null, name=null]

    }
}

System.out.println(student); // Student [id=1, major=null, name=null]

Json -> 객체로 변환하는 경우

deserialize가 true로 선언된 'id' 필드만

객체 필드에 값이 세팅되었습니다.

deserialize가 false로 선언된 'name' 필드와

@Expose 어노테이션이 없는 'major' 필드는 값이 세팅되지 않았습니다.

 

 

11. 3 ExclusionStrategy

ExclusionStrategy 인터페이스를 구현하고,

Gson에 ExclusionStrategy 인터페이스를 구현한 객체를 세팅하여

객체의 특정 필드를 제외할 수 있습니다.

 

  Student 클래스  

public class Student {

    private int id;
    private String name;
    private String major;

    public Student(int id, String name, String major) {
        this.id = id;
        this.name = name;
        this.major = major;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", major=" + major + ", name=" + name + "]";
    }
}

 

  객체 -> Json 변환  

import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class ExcludeExclusionStrategy {
    public static void main(String[] args) {

        // ExclusionStrategy 인터페이스 구현
        ExclusionStrategy exclusionStrategy = new ExclusionStrategy() {
            public boolean shouldSkipField(FieldAttributes fieldAttributes) {
                if ("id".equals(fieldAttributes.getName())) {
                    return true;
                }
                return false;
            }

            public boolean shouldSkipClass(Class aClass) {
                return false;
            }
        };

        // Student 객체 생성
        Student student = new Student(1, "Anna", "CS");

        // Gson 객체 생성 (ExclusionStrategies 옵션)
        Gson gson = new GsonBuilder().setExclusionStrategies(exclusionStrategy).create();

        // Student 객체 -> Json 문자열
        String studentJson = gson.toJson(student);

        // Json 문자열 출력
        System.out.println(studentJson); // {"name":"Anna","major":"CS"}
    }
}

ExclusionStrategy exclusionStrategy = new ExclusionStrategy() { ... }

Exclusionstrategy 인터페이스를 구현하고, 객체를 생성하였습니다.

shouldSkipField() 메소드 안에서 제외할 필드를 정의합니다.

shouldSkipField() 메소드는 필드를 파라미터로 받습니다.

shouldSkipField() 메소드에, 필드가 들어왔을 때, true를 리턴하면 해당 필드는 제외됩니다.

여기서는, "id" 필드가 제외됩니다.

 

Gson gson = new GsonBuilder().setExclusionStrategies(exclusionStrategy).create();

Gson 객체를 생성할 때,

ExclusionStrategy 인터페이스를 구현한 객체를 세팅하였습니다.

 

System.out.println(studentJson); // {"name":"Anna","major":"CS"}

exclusionStrategy 객체에서 제외된 'id' 항목이 제외된 Json 문자열이 생성되었습니다.

 

 

 

12. Field Naming

12. 1 특정 Field 이름 바꾸기 (@SerializedName)

객체로 Json 문자열을 생성하거나,

Json 문자열을 객체로 변경할 때,

@SerializedName 어노테이션을 사용하여,

특정 필드의 이름을 원하는 이름으로 바꾸어서 맵핑할 수 있습니다.

 

  Person.java (VO)  

import com.google.gson.annotations.SerializedName;

public class Person {

    @SerializedName("personId") private int id;
    private String krName;
    private String enName;

    public Person(int id, String krName, String enName) {
        this.id = id;
        this.krName = krName;
        this.enName = enName;
    }

    @Override
    public String toString() {
        return "Person [enName=" + enName + ", id=" + id + ", krName=" + krName + "]";
    }
}

@SerializedName("personId") private int id;

id 필드에 '@SerializedName' 어노테이션을 추가하였습니다.

Gson으로 이 객체를 Json으로 변환하면, 

'personId'라는 이름으로 프로퍼티가 생성될 것입니다.

 

 

  Person -> Json, Json -> Person  

import com.google.gson.Gson;

public class FieldNaming {
    public static void main(String[] args) {

        // Gson 객체 준비
        Gson gson = new Gson();


        
        // 1. Person 객체를 Json 문자열로 변환
        Person person = new Person(1, "애나", "Anna");
        String jsonStr = gson.toJson(person);

        // 결과 출력
        System.out.println(jsonStr); // {"personId":1,"krName":"애나","enName":"Anna"}



        // 2. Json 문자열을 Person 객체로 변환
        String str = "{\"personId\":2,\"krName\":\"김\",\"enName\":\"Kim\"}";
        Person person2 = gson.fromJson(str, Person.class);

        System.out.println(person2); // Person [enName=Kim, id=2, krName=김]

    }
}

line 11 ~ 16

Person 객체를 Json으로 변경하였습니다.

Person 클래스에서 @SerializedName 어노테이션으로 'id' 필드의 이름을 변경하였기 때문에,

Json 문자열에 'id' 프로퍼티 대신, 'personId'라는 이름의 프로퍼티가 생성되었습니다.

 

line 20 ~ 24

Json 문자열을 읽어서, Person 객체로 변환하였습니다.

Person 클래스에서 @SerializedName 어노테이션으로 'id' 필드의 이름을 변경하였기 때문에,

Json 문자열의 'personId' 프로퍼티 값을, Person 객체의 id 필드에 맵핑하였습니다.

 

12. 2 Field Naming Rule 적용하기 ( FieldNamingPolicy )

Gson 객체를 생성할 때 FieldNamingPolicy 옵션을 주면,

정해진 규칙에 따라서 Json 파일의 프로퍼티 이름을 생성하고, 읽을 수 있습니다.

 

  Person.java (VO)  

public class Person {

    private int id;
    private String krName;
    private String enName;

    public Person(int id, String krName, String enName) {
        this.id = id;
        this.krName = krName;
        this.enName = enName;
    }

    @Override
    public String toString() {
        return "Person [enName=" + enName + ", id=" + id + ", krName=" + krName + "]";
    }
}

각 필드의 이름이 Camel Case 로 작성되어 있습니다.

 

  Person -> Json, Json -> Person  

import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class FieldNamingPolicyExample {
    public static void main(String[] args) {
        // Person 객체 준비
        Person person = new Person(1, "애나", "Anna");

        // Gson 객체 준비
        // FieldNamingPolity 적용 (LOWER_CASE_WITH_UNDERSCORES)
        Gson gson = new GsonBuilder()
            .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
            .create();



        // 1. Person 객체를 Json 문자열로 변환
        String jsonStr = gson.toJson(person);

        // 결과 출력
        System.out.println(jsonStr); // {"id":1,"kr_name":"애나","en_name":"Anna"}



        // 2. Json 문자열을 Person 객체로 변환
        String str = "{\"id\":2,\"kr_name\":\"김\",\"en_name\":\"Kim\"}";
        Person person2 = gson.fromJson(str, Person.class);

        System.out.println(person2); // Person [enName=Kim, id=2, krName=김]
    }

}

Gson gson = new GsonBuilder()
       .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
       .create();

Gson 객체를 생성할 때, FieldNamingPolicy 옵션을 추가하였습니다.

파라미터로 전달된 'FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES'는

객체를 Json 문자열로 만들거나, Json 문자열의 프로퍼티를 객체의 필드와 맵핑할 때,

Camel Case로 작성된 객체의 필드를

각각의 단어를 '_'로 구분하는 소문자로 이름을 변경하여 맵핑합니다.

 

line 18 ~ 22

Person 객체를 Json으로 변경하였습니다.

생성된 Json 문자열의 프로퍼티명이 모두 '_'로 구분되는 소문자로 변경되었습니다.

 

line 26 ~ 30

Json 문자열을 읽어서, Person 객체로 변환하였습니다.

Json 문자열의 프로퍼티 이름은 모두 소문자와 '_'로 이루어졌지만,

Camel Case를 따르는 Person 객체의 필드와 잘 맵핑되었습니다.

 

 

  FieldNamingPolicy 옵션  

옵션명	예제
IDENTITY	변경 없음
LOWER_CASE_WITH_DASHES	someFieldName ---> some-field-name _someFieldName ---> _some-field-name aStringField ---> a-string-field aURL ---> a-u-r-l
LOWER_CASE_WITH_DOTS	someFieldName ---> some.field.name _someFieldName ---> _some.field.name aStringField ---> a.string.field aURL ---> a.u.r.l
LOWER_CASE_WITH_UNDERSCORES	someFieldName ---> some_field_name _someFieldName ---> _some_field_name aStringField ---> a_string_field aURL ---> a_u_r_l
UPPER_CAMEL_CASE	someFieldName ---> SomeFieldName _someFieldName ---> _SomeFieldName
UPPER_CAMEL_CASE_WITH_SPACES	someFieldName ---> Some Field Name _someFieldName ---> _Some Field Name

 

 

 

13. Json 문자열 Parsing

  파싱할 Json  

{
    "id" : 1,
    "students": [
        "Anna", "Jerry"
    ],
    "subject": {
        "name" : "Java",
        "professor" : "Tony"
    }
}

 

  Json 파싱  

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class JsonStringParse {
    public static void main(String[] args) {
        String json = "{\"id\":1,\"students\": [\"Anna\", \"Jerry\"],\"subject\":{\"name\":\"Java\",\"professor\":\"Tony\"}}";

        // 문자열 parsing
        JsonElement element = JsonParser.parseString(json);

        // element가 Object 타입인 경우 JsonObject 타입으로 변환
        JsonObject object = element.getAsJsonObject();

        // id 값 확인 (primitive type)
        long id = object.get("id").getAsLong();
        System.out.println("id : " + id); // id : 1

        // students 값 확인 (배열)
        JsonArray studentsJsonArray = object.get("students").getAsJsonArray();
        // JsonArray studentsJsonArray = object.getAsJsonArray("students");
        for (int i = 0; i < studentsJsonArray.size(); i++) {
            String student = studentsJsonArray.get(i).getAsString();
            System.out.println("student[" + i + "] : " + student); // student[0] : Anna, student[1] : Jerry
        }

        // subject 값 확인 (Object)
        JsonObject subjectJsonObject = object.get("subject").getAsJsonObject();
        // JsonObject subjectJsonObject = object.getAsJsonObject("subject");
        String subjectName = subjectJsonObject.get("name").getAsString();
        String subjectProfessor = subjectJsonObject.get("professor").getAsString();
        System.out.println("subject.name : " + subjectName); // subject.name : Java
        System.out.println("subject.professor : " + subjectProfessor); // subject.professor : Tony

    }
}

위 코드는 JsonParser를 이용하여,

Json을 Parsing 하고, 

각 property의 값울 추출하는 코드입니다.

 

JsonElement element = JsonParser.parseString(json);

JsonParser.parseString() 메소드를 이용하여

Json 문자열을 parsing하고, JsonElement 객체를 리턴하였습니다.

( Gson 2.8.6 버전 이전에는 JsonParser의 parse() 메소드를 이용하여 파싱하였습니다.

그러나, Gson 2.8.6부터는

JsonParser의 생성자와 parse() 메소드가 deprecated 되었습니다. )

 

JsonObject object = element.getAsJsonObject();

JsonElement는 다음의 4가지 타입으로 변환될 수 있습니다.

• JsonObject
• JsonArray
• JsonNull
• JsonPrimitive

long id = object.get("id").getAsLong();

"id"에 해당하는 값을 Long 타입으로 가져옵니다.

 

JsonArray studentsJsonArray = object.get("students").getAsJsonArray();
JsonArray studentsJsonArray = object.getAsJsonArray("students");

"students"는 배열 값을 가지고 있으므로

JsonArray 타입으로 값을 가져옵니다.

 

JsonObject subjectJsonObject = object.get("subject").getAsJsonObject();

JsonObject subjectJsonObject = object.getAsJsonObject("subject");

"subject"는 객체 값을 가지고 있으므로,

JsonObject 타입으로 값을 가지고 옵니다.

 

---