Google Gson - ดีซีเรียลไลซ์รายการ‹คลาส› วัตถุ? (ประเภททั่วไป)

วิธีการดีซีเรียลไลซ์คอลเลกชั่นทั่วไป:

import java.lang.reflect.Type;
import com.google.gson.reflect.TypeToken;

...

Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
List<YourClass> yourClassList = new Gson().fromJson(jsonArray, listType);

เนื่องจากมีหลายคนในความคิดเห็นกล่าวถึง ต่อไปนี้เป็นคำอธิบายว่าคลาส TypeToken ใช้งานอย่างไร โครงสร้าง new TypeToken<...>() {}.getType() รวบรวมประเภทเวลาคอมไพล์ (ระหว่าง < และ >) ลงในวัตถุรันไทม์ java.lang.reflect.Type ต่างจากอ็อบเจ็กต์ Class ซึ่งสามารถแสดงเฉพาะประเภท raw (ลบแล้ว) เท่านั้น อ็อบเจ็กต์ Type สามารถแสดงประเภทใดก็ได้ในภาษา Java รวมถึงการสร้างอินสแตนซ์แบบกำหนดพารามิเตอร์ของประเภททั่วไป

คลาส TypeToken นั้นไม่มีตัวสร้างสาธารณะ เนื่องจากคุณไม่ควรสร้างมันโดยตรง แต่คุณมักจะสร้างคลาสย่อยที่ไม่ระบุชื่อเสมอ (ดังนั้น {} ซึ่งเป็นส่วนที่จำเป็นของนิพจน์นี้)

เนื่องจากการลบประเภท คลาส TypeToken จึงสามารถบันทึกเฉพาะประเภทที่ทราบโดยสมบูรณ์ ณ เวลาคอมไพล์เท่านั้น (นั่นคือ คุณไม่สามารถดำเนินการ new TypeToken<List<T>>() {}.getType() สำหรับพารามิเตอร์ประเภท T ได้)

สำหรับข้อมูลเพิ่มเติม โปรดดูเอกสารประกอบสำหรับคลาส TypeToken.

อีกวิธีหนึ่งคือการใช้อาร์เรย์เป็นประเภท เช่น:

MyClass[] mcArray = gson.fromJson(jsonString, MyClass[].class);

วิธีนี้ช่วยให้คุณหลีกเลี่ยงความยุ่งยากกับออบเจ็กต์ Type และหากคุณต้องการรายการจริงๆ คุณสามารถแปลงอาร์เรย์เป็นรายการได้ตลอดเวลาโดย:

List<MyClass> mcList = Arrays.asList(mcArray);

IMHO นี่อ่านง่ายกว่ามาก

และเพื่อให้เป็นรายการจริง (ที่สามารถแก้ไขได้ โปรดดูข้อจำกัดของ Arrays.asList()) จากนั้นให้ดำเนินการดังต่อไปนี้:

List<MyClass> mcList = new ArrayList<>(Arrays.asList(mcArray));

ตั้งแต่ Gson 2.8 เราสามารถสร้างฟังก์ชัน util ได้ เช่น

public <T> List<T> getList(String jsonArray, Class<T> clazz) {
    Type typeOfT = TypeToken.getParameterized(List.class, clazz).getType();
    return new Gson().fromJson(jsonArray, typeOfT);
}

ตัวอย่างการใช้

String jsonArray = ...
List<User> user = getList(jsonArray, User.class);

อ้างถึงโพสต์นี้ ประเภท Java ทั่วไปเป็นอาร์กิวเมนต์สำหรับ GSON

ฉันมีทางออกที่ดีกว่าสำหรับเรื่องนี้ นี่คือคลาส wrapper สำหรับรายการเพื่อให้ wrapper สามารถจัดเก็บประเภทรายการได้อย่างแน่นอน

public class ListOfJson<T> implements ParameterizedType
{
  private Class<?> wrapped;

  public ListOfJson(Class<T> wrapper)
  {
    this.wrapped = wrapper;
  }

  @Override
  public Type[] getActualTypeArguments()
  {
      return new Type[] { wrapped };
  }

  @Override
  public Type getRawType()
  {
    return List.class;
  }

  @Override
  public Type getOwnerType()
  {
    return null;
  }
}

จากนั้นโค้ดก็สามารถทำได้ง่าย:

public static <T> List<T> toList(String json, Class<T> typeClass)
{
    return sGson.fromJson(json, new ListOfJson<T>(typeClass));
}

Wep อีกวิธีหนึ่งในการบรรลุผลเดียวกัน เราใช้มันเพื่อให้อ่านง่าย

แทนที่จะทำประโยคที่อ่านยากนี้:

Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
List<YourClass> list = new Gson().fromJson(jsonArray, listType);

สร้างคลาสว่างที่ขยายรายการวัตถุของคุณ:

public class YourClassList extends ArrayList<YourClass> {}

และใช้มันเมื่อแยกวิเคราะห์ JSON:

List<YourClass> list = new Gson().fromJson(jsonArray, YourClassList.class);

สำหรับ Kotlin เพียง:

import java.lang.reflect.Type
import com.google.gson.reflect.TypeToken
...
val type = object : TypeToken<List<T>>() {}.type

หรือนี่คือฟังก์ชันที่มีประโยชน์:

fun <T> typeOfList(): Type {
    return object : TypeToken<List<T>>() {}.type
}

จากนั้นเพื่อใช้:

val type = typeOfList<YourMagicObject>()

public static final <T> List<T> getList(final Class<T[]> clazz, final String json)
{
    final T[] jsonToObject = new Gson().fromJson(json, clazz);

    return Arrays.asList(jsonToObject);
}

ตัวอย่าง:

getList(MyClass[].class, "[{...}]");

เนื่องจากเป็นการตอบคำถามเดิมของฉัน ฉันจึงยอมรับคำตอบของ doc_180 แล้ว แต่หากมีใครพบปัญหานี้อีก ฉันจะตอบคำถามครึ่งหลังของฉันด้วย:

NullPointerError ที่ฉันอธิบายไม่เกี่ยวข้องกับรายการเลย แต่มีเนื้อหาด้วย!

คลาส "MyClass" ไม่มีคอนสตรัคเตอร์ "no args" และไม่มีคลาสซูเปอร์คลาสด้วย เมื่อฉันเพิ่มตัวสร้าง "MyClass()" แบบธรรมดาให้กับ MyClass และซูเปอร์คลาสของมัน ทุกอย่างทำงานได้ดี รวมถึงรายการการทำให้เป็นอนุกรมและการดีซีเรียลไลซ์ตามที่แนะนำโดย doc_180

นี่คือโซลูชันที่ใช้งานได้กับประเภทที่กำหนดแบบไดนามิก เคล็ดลับคือการสร้างประเภทอาร์เรย์ที่เหมาะสมโดยใช้ Array.newInstance()

    public static <T> List<T> fromJsonList(String json, Class<T> clazz) {
    Object [] array = (Object[])java.lang.reflect.Array.newInstance(clazz, 0);
    array = gson.fromJson(json, array.getClass());
    List<T> list = new ArrayList<T>();
    for (int i=0 ; i<array.length ; i++)
        list.add(clazz.cast(array[i]));
    return list; 
}

ฉันต้องการเพิ่มความเป็นไปได้อีกอย่างหนึ่ง หากคุณไม่ต้องการใช้ TypeToken และต้องการแปลงอาร์เรย์อ็อบเจ็กต์ json เป็น ArrayList คุณสามารถดำเนินการดังนี้:

หากโครงสร้าง json ของคุณเป็นดังนี้:

{

"results": [
    {
        "a": 100,
        "b": "value1",
        "c": true
    },
    {
        "a": 200,
        "b": "value2",
        "c": false
    },
    {
        "a": 300,
        "b": "value3",
        "c": true
    }
]

}

และโครงสร้างชั้นเรียนของคุณเป็นดังนี้:

public class ClassName implements Parcelable {

    public ArrayList<InnerClassName> results = new ArrayList<InnerClassName>();
    public static class InnerClassName {
        int a;
        String b;
        boolean c;      
    }
}

จากนั้นคุณสามารถแยกวิเคราะห์ได้ดังนี้:

Gson gson = new Gson();
final ClassName className = gson.fromJson(data, ClassName.class);
int currentTotal = className.results.size();

ตอนนี้คุณสามารถเข้าถึงแต่ละองค์ประกอบของวัตถุ className

อ้างถึงตัวอย่างที่ 2 สำหรับความเข้าใจคลาส 'ประเภท' ของ Gson

ตัวอย่างที่ 1: ใน deserilizeResturant นี้ เราใช้อาร์เรย์ Employee[] และรับรายละเอียด

public static void deserializeResturant(){

       String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
       Gson gson = new Gson();
       Employee[] emp = gson.fromJson(empList, Employee[].class);
       int numberOfElementInJson = emp.length();
       System.out.println("Total JSON Elements" + numberOfElementInJson);
       for(Employee e: emp){
           System.out.println(e.getName());
           System.out.println(e.getEmpId());
       }
   }

ตัวอย่างที่ 2:

//Above deserilizeResturant used Employee[] array but what if we need to use List<Employee>
public static void deserializeResturantUsingList(){

    String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
    Gson gson = new Gson();

    // Additionally we need to se the Type then only it accepts List<Employee> which we sent here empTypeList
    Type empTypeList = new TypeToken<ArrayList<Employee>>(){}.getType();


    List<Employee> emp = gson.fromJson(empList, empTypeList);
    int numberOfElementInJson = emp.size();
    System.out.println("Total JSON Elements" + numberOfElementInJson);
    for(Employee e: emp){
        System.out.println(e.getName());
        System.out.println(e.getEmpId());
    }
}

ฉันชอบคำตอบจาก kays1 แต่ไม่สามารถนำไปใช้ได้ ดังนั้นฉันจึงสร้างเวอร์ชันของตัวเองโดยใช้แนวคิดของเขา

public class JsonListHelper{
    public static final <T> List<T> getList(String json) throws Exception {
        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        Type typeOfList = new TypeToken<List<T>>(){}.getType();
        return gson.fromJson(json, typeOfList);
    }
}

การใช้งาน:

List<MyClass> MyList= JsonListHelper.getList(jsonArrayString);

ในกรณีของฉัน คำตอบของ @uncaught_Exceptions ใช้งานไม่ได้ ฉันต้องใช้ List.class แทน java.lang.reflect.Type:

String jsonDuplicatedItems = request.getSession().getAttribute("jsonDuplicatedItems").toString();
List<Map.Entry<Product, Integer>> entries = gson.fromJson(jsonDuplicatedItems, List.class);

ฉันได้สร้าง GsonUtils lib สำหรับกรณีนี้ ฉันเพิ่มสิ่งนี้ลงในที่เก็บกลาง maven

Map<String, SimpleStructure> expected = new HashMap<>();
expected.put("foo", new SimpleStructure("peperoni"));

String json = GsonUtils.writeValue(expected);

Map<String, SimpleStructure> actual = GsonUtils.readMap(json, String.class, SimpleStructure.class);