Flutter 如何使用dart读取复杂的嵌套json文件

从我的API：

---

我想用省道阅读。我在线学习了如何读取带有列表的嵌套JSON文件，但我完全不知道如何读取如此复杂的文件。

您的JSON响应类应该类似于序列化和反序列化

class ResponseData {
  List<Item> items;

  ResponseData({
    this.items,
  });

  factory ResponseData.fromJson(Map<String, dynamic> json) =>
      ResponseData(
        items: List<Item>.from(json["items"].map((x) => Item.fromJson(x))),
      );

  Map<String, dynamic> toJson() =>
      {
        "items": List<dynamic>.from(items.map((x) => x.toJson())),
      };
}

class Item {
  DateTime timestamp;
  List<CarparkDatum> carparkData;

  Item({
    this.timestamp,
    this.carparkData,
  });

  factory Item.fromJson(Map<String, dynamic> json) =>
      Item(
        timestamp: DateTime.parse(json["timestamp"]),
        carparkData: List<CarparkDatum>.from(
            json["carpark_data"].map((x) => CarparkDatum.fromJson(x))),
      );

  Map<String, dynamic> toJson() =>
      {
        "timestamp": timestamp.toIso8601String(),
        "carpark_data": List<dynamic>.from(carparkData.map((x) => x.toJson())),
      };
}

class CarparkDatum {
  List<CarparkInfo> carparkInfo;
  String carparkNumber;
  DateTime updateDatetime;

  CarparkDatum({
    this.carparkInfo,
    this.carparkNumber,
    this.updateDatetime,
  });

  factory CarparkDatum.fromJson(Map<String, dynamic> json) =>
      CarparkDatum(
        carparkInfo: List<CarparkInfo>.from(
            json["carpark_info"].map((x) => CarparkInfo.fromJson(x))),
        carparkNumber: json["carpark_number"],
        updateDatetime: DateTime.parse(json["update_datetime"]),
      );

  Map<String, dynamic> toJson() =>
      {
        "carpark_info": List<dynamic>.from(carparkInfo.map((x) => x.toJson())),
        "carpark_number": carparkNumber,
        "update_datetime": updateDatetime.toIso8601String(),
      };
}

class CarparkInfo {
  String totalLots;
  LotType lotType;
  String lotsAvailable;

  CarparkInfo({
    this.totalLots,
    this.lotType,
    this.lotsAvailable,
  });

  factory CarparkInfo.fromJson(Map<String, dynamic> json) =>
      CarparkInfo(
        totalLots: json["total_lots"],
        lotType: lotTypeValues.map[json["lot_type"]],
        lotsAvailable: json["lots_available"],
      );

  Map<String, dynamic> toJson() =>
      {
        "total_lots": totalLots,
        "lot_type": lotTypeValues.reverse[lotType],
        "lots_available": lotsAvailable,
      };
}

enum LotType { C, H, Y, L }

final lotTypeValues = EnumValues({
  "C": LotType.C,
  "H": LotType.H,
  "L": LotType.L,
  "Y": LotType.Y
});

class EnumValues<T> {
  Map<String, T> map;
  Map<T, String> reverseMap;

  EnumValues(this.map);

  Map<T, String> get reverse {
    if (reverseMap == null) {
      reverseMap = map.map((k, v) => new MapEntry(v, k));
    }
    return reverseMap;
  }
}

类响应数据{
清单项目；
响应数据({
这个项目,，
});
factory ResponseData.fromJson（映射json）=>
响应数据(
items:List.from（json[“items”].map（（x）=>Item.fromJson（x）），
);
映射到JSON（）=>
{
“items”：List.from（items.map（（x）=>x.toJson（）），
};
}
类项目{
日期时间戳；
列出停车场资料；
项目({
这个时间戳，
这是停车场数据，
});
工厂项目.fromJson（映射json）=>
项目(
timestamp:DateTime.parse（json[“timestamp”]），
停车场数据：List.from(
json[“停车场数据”].map（（x）=>carparkdatam.fromJson（x）），
);
映射到JSON（）=>
{
“timestamp”：timestamp.toIso8601String（），
“停车场数据”：List.from（carparkData.map（（x）=>x.toJson（）），
};
}
等级停车场基准{
停车场信息列表；
字符串停车场编号；
DateTime updateDatetime；
停车场基准({
这是停车场信息，
这个停车场号码，
这个.updateDatetime，
});
工厂停车场数据.fromJson（映射json）=>
停车场基准(
停车场信息：List.from(
json[“停车场信息”].map（（x）=>CarparkInfo.fromJson（x）），
停车场编号：json[“停车场编号”]，
updateDatetime:DateTime.parse（json[“update_DateTime”]），
);
映射到JSON（）=>
{
“停车场信息”：List.from（carparkInfo.map（（x）=>x.toJson（）），
“停车场编号”：停车场编号，
“update_datetime”：updateDatetime.toIso8601String（），
};
}
等级停车场信息{
串珠；
乐透型；
字符串lotsavaailable；
停车场信息({
这个,这个,，
这是一张彩票，
这个，洛萨瓦利，
});
工厂停车场信息.fromJson（映射json）=>
停车场信息(
totalots:json[“total_lots”]，
lotType:lotTypeValues.map[json[“lot_type”]]，
lotsavaailable:json[“lots\u available”]，
);
映射到JSON（）=>
{
“总地块”：总地块，
“lot_type”：lotTypeValues.reverse[lotType]，
“地段可用”：地段可用，
};
}
枚举类型{C，H，Y，L}
最终lotTypeValues=枚举值({
“C”：LotType.C，
“H”：LotType.H，
“L”：LotType.L，
“Y”：LotType.Y
});
类枚举值{
地图；
地图反转地图；
枚举值（this.map）；
地图反转{
if（reverseMap==null）{
reverseMap=map.map（（k，v）=>newMapEntry（v，k））；
}
返回反向映射；
}
}

您始终可以导入dart:convert包并使用json.decode函数。

只需使用此网站将json响应转换为dart类即可

我强烈建议你用它来做这些事情

下面是关于网络呼叫的好教程

---

如果您尝试序列化或反序列化JSON负载，那应该是一个好的开始。但是，如果您很难很好地理解复杂模型的外观，那么可以尝试粘贴JSON负载

型号.省道

类响应{
清单项目；
响应（{this.items}）；
Response.fromJson（映射json）{
if（json['items']！=null）{
项目=新列表（）；
json['items'].forEach（（v）{
items.add（newitems.fromJson（v））；
});
}
}
映射到JSON（）{
最终地图数据=新地图（）；
如果（this.items！=null）{
data['items']=this.items.map（（v）=>v.toJson（））.toList（）；
}
返回数据；
}
}
类别项目{
字符串时间戳；
列出停车场资料；
项目（{this.timestamp，this.carparkData}）；
Items.fromJson（映射json）{
timestamp=json['timestamp']；
如果（json['carpark_data']！=null）{
停车场数据=新列表（）；
json['carpark_data'].forEach（（v）{
carparkData.add（newcarparkdata.fromJson（v））；
});
}
}
映射到JSON（）{
最终地图数据=新地图（）；
数据['timestamp']=此.timestamp；
如果（this.carparkData！=null）{
data['carpark_data']=this.carparkData.map（（v）=>v.toJson（））.toList（）；
}
返回数据；
}
}
类别停车场数据{
停车场信息列表；
字符串停车场编号；
字符串更新时间；
停车场数据（{this.carparkInfo，this.carparkNumber，this.updateDatetime}）；
CarparkData.fromJson（映射json）{
如果（json['carpark_info']！=null）{
停车场信息=新列表（）；
json['carpark_info'].forEach（（v）{
carparkInfo.add（新的carparkInfo.fromJson（v））；
});
}
停车场编号=json[“停车场编号”]；
updateDatetime=json['update_datetime']；
}
映射到JSON（）{
最终地图数据=新地图（）；
如果（this.carparkInfo！=null）{
data['carpark_info']=this.carparkInfo.map（（v）=>v.toJson（））.toList（）；
}
数据['carpark_number']=此.carpark编号；
数据['update_datetime']=this.updateDatetime；
返回数据；
}
}
等级停车场信息{
串珠；
字符串彩票；
字符串lotsavaailable；
停车场信息（{this.totalots，this.lotType，this.lotsavaailable}）；
CarparkInfo.fromJson（映射json）{
totalots=json['total_lots']；
lotType=json['lot_type']；
lotsavaailable=json['lots_available']；
}
映射到JSON（）{
最终地图数据=新地图（）；
数据['total_lots']=this.totalots；
数据['lot_type']=this.lotType；
数据['lots_available']=this.lotsavaailable；
返回数据；
}
}

虽然已经为您生成了这些模型，但最好检查每个字段是否与相应的数据类型和字段名称相对应

序列化和反序列化JSON负载有不同的策略。这是最基本的一个，但是对于小团队的小项目来说应该可以。Flatter团队创建了一个写得很好的工具，帮助您确定nee的套件