image.png

我不得不承认，在Flutter / Dart中使用JSON后，我错过了Android 的**gson **世界。当我开始使用Flutter中的API时，JSON解析确实让我很烦恼。而且我确定，它让很多初学者感到困惑。

我们将使用dart:convert的内置库。这是最基本的解析方法，只有在您开始使用Flutter或者您正在构建一个小项目时才建议使用它。然而，了解Flutter中JSON解析的基础知识非常重要。当你擅长这个，或者你需要使用更大的项目时，可以考虑像json_serializable等代码生成器库。如果可能的话，我将在以后的文章中介绍它们。

示例项目。它包含您可以试验的本文的所有代码。

JSON结构＃1：简单的地图

让我们从student.json的简单JSON结构开始

{
  "id":"487349",
  "name":"Pooja Bhaumik",
  "score" : 1000
}

规则＃1： 确定结构。Json字符串将具有Map（键值对）或List of Maps。

规则＃2：用花括号开始？这是Map。
用方括号开始？这是List of Map。

student.json显然是Map。（例如，id是一个Key，487349是id的值）

让我们为这个json结构制作一个PODO（Plain Old Dart Object？）文件。您可以在示例项目的[student_model.dart]

class Student{
  String studentId;
  String studentName;
  int studentScores;

  Student({
    this.studentId,
    this.studentName,
    this.studentScores
 });
}

好了！
因为json映射和此PODO文件之间没有映射。甚至实体名称也不匹配。 这个我知道。我们还没有完成。我们必须将这些类成员映射到json对象。为此，我们需要创建一个factory方法。根据Dart文档，我们factory在实现构造函数时使用关键字，该构造函数并不总是创建其类的新实例，而这正是我们现在所需要的。

factory Student.fromJson(Map<String, dynamic> parsedJson){
    return Student(
      studentId: parsedJson['id'],
      studentName : parsedJson['name'],
      studentScores : parsedJson ['score']
    );
  }

在这里，我们创建一个名为factory的工厂方法，Student.fromJson其目的是简单地反序列化你的json。

我是一个小菜鸟，你能告诉我关于反序列化的事吗？

当然。我们首先告诉您序列化和反序列化。序列化只是意味着将数据（可能在对象中）写为字符串，而反序列化则与此相反。它获取原始数据并重建对象模型。在本文中，我们主要讨论反序列化部分。在第一部分中，我们将json字符串反序列化student.json

因此我们的工厂方法可以称为我们的转换器方法。

还必须注意fromJson方法中的参数。这是一个Map<String, dynamic>意味着它用一个值映射一个String 键。这正是我们需要识别结构的原因。如果这个json结构是一个映射列表，那么这个参数会有所不同。dynamic

但为何(dynamic)动态？让我们先看看另一个json结构来回答你的问题。

image.png

name是Map <String，String>，majors是String和List <String> subjects的Map，是String和List <Object>的Map

由于key始终为 string且值可以是任何类型，因此我们将其保持为dynamic安全。

检查完整代码student_model.dart 在这里。

访问对象

让我们编写student_services.dart哪些代码可以调用Student.fromJson并从Student对象中检索值。

imports

import 'dart:async' show Future;
import 'package:flutter/services.dart' show rootBundle;
import 'dart:convert';
import 'package:flutter_json/student_model.dart';

最后一个导入是你的模型文件。

加载Json Asset（可选）**

Future<String> _loadAStudentAsset() async {
  return await rootBundle.loadString('assets/student.json');
}

在这个的项目中，我们将json文件放在assets文件夹中，因此我们必须以这种方式加载json。但是，如果您在云上拥有json文件，则可以进行通过网络读取。网络调用超出了本文的范围，这里不作介绍。

加载

Future loadStudent() async {
  String jsonString = await _loadAStudentAsset();
  final jsonResponse = json.decode(jsonString);
  Student student = new Student.fromJson(jsonResponse);
  print(student.studentScores);
}

在此loadStudent()方法中，
第1行 ：从Asset中加载原始json String。
第2行 ：解码我们得到的这个原始json字符串。
第3行 ：现在我们通过调用Student.fromJson方法对解码的json响应进行反序列化，以便我们现在可以使用Studentobject来访问我们的实体。
第4行 ：就像我们在这里做的那样，我们studentScores从Student实例上打印出来。

检查Flutter控制台查看所有打印值。（在Android Studio中，在“运行”Tab页面）

瞧！您刚刚进行了第一次JSON解析。
注意：请记住这里的3个片段，我们将使用它进行下一组json解析（仅更改文件名和方法名称），我不会在这里再次重复代码。但无论如何，您可以在示例项目中找到所有内容。

JSON结构＃2：具有数组的简单结构

现在我们征服一个类似于上面的json结构，但它不仅仅是单个值，它也可能有一个值数组。

{
  "city": "Mumbai",
  "streets": [
    "address1",
    "address2"
  ]
}

所以在这个address.json中，我们有一个city实体，它有一个简单的String值，但是streets是一个数组String。
据我所知，Dart没有数组数据类型，而是有一个List <datatype>所以这里streets将是一个List<String>。

现在我们必须检查规则＃1和规则＃2 。这绝对是Map，因为这是从花括号开始的。streets仍然是一个List，但我们稍后会进行讨论。

所以address_model.dart最初看起来会像这样

class Address {
  final String city;
  final List<String> streets;

  Address({
    this.city,
    this.streets
  });
}

既然这是Map，我们的Address.fromJson方法仍然会有一个Map<String, dynamic>参数。

factory Address.fromJson(Map<String, dynamic> parsedJson) {
  
  return new Address(
      city: parsedJson['city'],
      streets: parsedJson['streets'],
  );
}

现在address_services.dart通过添加我们上面提到的3个片段来构建。必须记住放入正确的文件名和方法名。示例项目已经*address_services.dart*为您构建。

现在当你运行它时，你会得到一个小错误。

type 'List<dynamic>' is not a subtype of type 'List<String>'

我告诉你，这些错误几乎出现在我与Dart开发的每一步中。你也会遇到。那么让我解释一下这意味着什么。我们正在申请，List<String>但我们正在List<dynamic>申请，因为我们的申请尚无法确定类型。

所以我们必须明确地将其转换为 List<String>

var streetsFromJson = parsedJson['streets'];
List<String> streetsList = new List<String>.from(streetsFromJson);

在这里，首先我们将变量映射streetsFromJson到streets实体。streetsFromJson还是一个List<dynamic>。现在，我们明确地创建一个新的List<String> streetsList包含所有元素的streetsFromJson。

在此处查看更新的方法。现在注意return语句。
现在你可以运行它，*address_services.dart*这将完美地运行。

Json结构＃3：简单的嵌套结构

现在如果我们有一个像shape.json这样的嵌套结构

{
  "shape_name":"rectangle",
  "property":{
    "width":5.0,
    "breadth":10.0
  }
}

这里，property包含一个对象而不是一个基本的原始数据类型。
那么PODO将会如何？

好吧，让我们分解一下。
在我们shape_model.dart 的类中，让我们定义一个Property得类。

class Property{
  double width;
  double breadth;

  Property({
    this.width,
    this.breadth
});
}

现在让我们构建一个类Shape。我将这两个类保存在同一个Dart文件中。

class Shape{
  String shapeName;
  Property property;

  Shape({
    this.shapeName,
    this.property
  });
}

注意第二个数据成员property基本上是我们上一个类的对象Property。

规则＃3：对于嵌套结构，首先创建类和构造函数，然后从底层添加工厂方法。

从底层来看，我们的意思是，首先我们解析*Property*类，然后我们进入*Shape*这一级。这只是我的建议，而不是Flutter规则。

factory Property.fromJson(Map<String, dynamic> json){
  return Property(
    width: json['width'],
    breadth: json['breadth']
  );
}

这是一个简单map。

但对于我们在Shape类的工厂方法，我们不能这样做。

factory Shape.fromJson(Map<String, dynamic> parsedJson){
  return Shape(
    shapeName: parsedJson['shape_name'],
    property : parsedJson['property']
  );
}

property : parsedJson['property'] 首先，这将抛出类型不匹配错误 -

type '_InternalLinkedHashMap<String, dynamic>' is not a subtype of type 'Property'

第二，我们刚刚为Property制作了这个漂亮的小类，我没有看到它在任何地方使用。

对。我们必须在这里映射我们的Property类。

factory Shape.fromJson(Map<String, dynamic> parsedJson){
  return Shape(
    shapeName: parsedJson['shape_name'],
    property: Property.fromJson(parsedJson['property'])
  );
}

所以基本上，我们Property.fromJson从我们的Property类中调用方法，无论我们得到什么，我们都将它映射到property实体。简单！在这里查看代码。

shape_services.dart和你一起跑吧，你很高兴。

JSON结构＃4：带有列表的嵌套结构

我们来看看我们的product.json

{
  "id":1,
  "name":"ProductName",
  "images":[
    {
      "id":11,
      "imageName":"xCh-rhy"
    },
    {
      "id":31,
      "imageName":"fjs-eun"
    }
  ]
}

好的，现在我们越来越深入了。我在里面看到了一个对象列表。

是的，所以这个结构有一个对象列表，但它本身仍然是一个Map。（参见规则＃1和规则＃2）。现在参考规则＃3，让我们构建我们的product_model.dart。

所以我们创建了两个新类Product和Image。
注意：*Product*将有一个List of*Image*

class Product {
  final int id;
  final String name;
  final List<Image> images;

  Product({this.id, this.name, this.images});
}

class Image {
  final int imageId;
  final String imageName;

  Image({this.imageId, this.imageName});
}

工厂方法Image非常简单和基本。

factory Image.fromJson(Map<String, dynamic> parsedJson){
 return Image(
   imageId:parsedJson['id'],
   imageName:parsedJson['imageName']
 );
}

现在为工厂实现方法 Product

factory Product.fromJson(Map<String, dynamic> parsedJson){

  return Product(
    id: parsedJson['id'],
    name: parsedJson['name'],
    images: parsedJson['images']
  );
}

这显然会引发运行时错误

type 'List<dynamic>' is not a subtype of type 'List<Image>'

如果我们这样做，

images: Image.fromJson(parsedJson['images'])

这也是绝对错误的，它会立即引发错误，因为你无法将Image对象分配给aList<Image>

所以我们必须创建一个List<Image>然后分配给它images

var list = parsedJson['images'] as List;
print(list.runtimeType); //returns List<dynamic>
List<Image> imagesList = list.map((i) => Image.fromJson(i)).toList();

list是List <dynamic>。现在，我们遍历列表，并在每个对象映射list到Image调用Image.fromJson，然后我们把每个地图对象与一个新的列表toList()并将其存储在List<Image> imagesList。在这里找到完整的代码。

JSON结构＃5：地图列表

现在让我们来看看photo.json

[
  {
    "albumId": 1,
    "id": 1,
    "title": "accusamus beatae ad facilis cum similique qui sunt",
    "url": "http://placehold.it/600/92c952",
    "thumbnailUrl": "http://placehold.it/150/92c952"
  },
  {
    "albumId": 1,
    "id": 2,
    "title": "reprehenderit est deserunt velit ipsam",
    "url": "http://placehold.it/600/771796",
    "thumbnailUrl": "http://placehold.it/150/771796"
  },
  {
    "albumId": 1,
    "id": 3,
    "title": "officia porro iure quia iusto qui ipsa ut modi",
    "url": "http://placehold.it/600/24f355",
    "thumbnailUrl": "http://placehold.it/150/24f355"
  }
]

哦，哦。规则＃1和规则＃2告诉我这不能是一个映射，因为json字符串以方括号开头。那么这是一个对象列表？是。这里的对象是Photo（或者你想称之为的任何东西）。

class Photo{
  final String id;
  final String title;
  final String url;

  Photo({
    this.id,
    this.url,
    this.title
}) ;

  factory Photo.fromJson(Map<String, dynamic> json){
    return new Photo(
      id: json['id'].toString(),
      title: json['title'],
      url: json['json'],
    );
  }
}

但它的列表*Photo** ，这是否意味着你必须建立一个包含？的类*List<Photo>*？*

是的，我会建议。

class PhotosList {
  final List<Photo> photos;

  PhotosList({
    this.photos,
  });
}

另请注意，此json字符串是一个映射列表。所以，在我们的工厂方法中，我们没有Map<String, dynamic>参数，因为它是一个List。这就是为什么首先确定结构很重要的原因。所以我们的新参数将是一个List<dynamic>。

factory PhotosList.fromJson(List<dynamic> parsedJson) {

    List<Photo> photos = new List<Photo>();

    return new PhotosList(
       photos: photos,
    );
  }

这会引发错误

Invalid value: Valid value range is empty: 0

因为我们永远不会使用这种Photo.fromJson方法。
如果我们在列表初始化之后添加这行代码怎么办？

photos = parsedJson.map((i)=>Photo.fromJson(i)).toList();

与之前相同的概念，我们不必将其映射到json字符串中的任何键，因为它是List而不是map。代码在这里。

JSON结构＃6：复杂的嵌套结构

这是page.json。

我会要求你解决这个问题。它已包含在示例项目中。您只需为此构建模型和服务文件。但是在给你提示和提示之前我不会总结（如果是的话，你需要任何提示）。

通常适用规则＃1和规则＃2。首先确定结构。这是Map。所以1-5的所有json结构都会有所帮助。

规则＃3要求您首先创建类和构造函数，然后从底层添加工厂方法。只是另一个提示。还要从深层/底层添加类。例如，对于这个JSON结构，使类Image，然后再Data和Author再主类Page。并以相同的顺序添加工厂方法。

对于类而言Image，Data请参考Json结构＃4。
对于类，Author请参阅Json结构＃3

初学者提示：在尝试任何新Asset时，请记住在pubspec.yaml文件中声明它。

本文出自
https://medium.com/flutter-community/parsing-complex-json-in-flutter-747c46655f51