Json Model

在实战中，后台接口往往会返回一些结构化数据，如JSON、XML等，如之前我们请求Github API的示例，它返回的数据就是JSON格式的字符串，为了方便我们在代码中操作JSON，我们先将JSON格式的字符串转为Dart对象，这个可以通过dart:convert中内置的JSON解码器json.decode() 来实现，该方法可以根据JSON字符串具体内容将其转为List或Map，这样我们就可以通过他们来查找所需的值，如：

  1. //一个JSON格式的用户列表字符串
  2. String jsonStr='[{"name":"Jack"},{"name":"Rose"}]';
  3. //将JSON字符串转为Dart对象(此处是List)
  4. List items=json.decode(jsonStr);
  5. //输出第一个用户的姓名
  6. print(items[0]["name"]);

通过json.decode() 将JSON字符串转为List/Map的方法比较简单，它没有外部依赖或其它的设置，对于小项目很方便。但当项目变大时，这种手动编写序列化逻辑可能变得难以管理且容易出错，例如有如下JSON:

  1. {
  2.   "name": "John Smith",
  3.   "email": "john@example.com"
  4. }

我们可以通过调用JSON.decode方法来解码JSON ，使用JSON字符串作为参数:

  1. Map<String, dynamic> user = JSON.decode(json);
  3. print('Howdy, ${user['name']}!');
  4. print('We sent the verification link to ${user['email']}.');

由于JSON.decode()仅返回一个Map<String, dynamic>，这意味着直到运行时我们才知道值的类型。 通过这种方法，我们失去了大部分静态类型语言特性：类型安全、自动补全和最重要的编译时异常。这样一来，我们的代码可能会变得非常容易出错。例如，当我们访问name或email字段时，我们输入的很快，导致字段名打错了。但由于这个JSON在map结构中，所以编译器不知道这个错误的字段名，所以编译时不会报错。

其实，这个问题在很多平台上都会遇到，而也早就有了好的解决方法即“Json Model化”，具体做法就是，通过预定义一些与Json结构对应的Model类，然后在请求到数据后再动态根据数据创建出Model类的实例。这样一来，在开发阶段我们使用的是Model类的实例，而不再是Map/List，这样访问内部属性时就不会发生拼写错误。例如，我们可以通过引入一个简单的模型类(Model class)来解决前面提到的问题，我们称之为User。在User类内部，我们有：

  • 一个User.fromJson 构造函数, 用于从一个map构造出一个 User实例 map structure
  • 一个toJson 方法, 将 User 实例转化为一个map.

这样，调用代码现在可以具有类型安全、自动补全字段（name和email）以及编译时异常。如果我们将拼写错误或字段视为int类型而不是String， 那么我们的代码就不会通过编译，而不是在运行时崩溃。

user.dart

  1. class User {
  2.   final String name;
  3.   final String email;
  5.   User(this.name, this.email);
  7.   User.fromJson(Map<String, dynamic> json)
  8.       : name = json['name'],
  9.         email = json['email'];
  11.   Map<String, dynamic> toJson() =>
  12.     {
  13.       'name': name,
  14.       'email': email,
  15.     };
  16. }

现在，序列化逻辑移到了模型本身内部。采用这种新方法，我们可以非常容易地反序列化user.

  1. Map userMap = JSON.decode(json);
  2. var user = new User.fromJson(userMap);
  4. print('Howdy, ${user.name}!');
  5. print('We sent the verification link to ${user.email}.');

要序列化一个user，我们只是将该User对象传递给该JSON.encode方法。我们不需要手动调用toJson这个方法，因为`JSON.encode内部会自动调用。

  1. String json = JSON.encode(user);

这样，调用代码就不用担心JSON序列化了，但是，Model类还是必须的。在实践中，User.fromJson和User.toJson方法都需要单元测试到位，以验证正确的行为。

另外，实际场景中，JSON对象很少会这么简单，嵌套的JSON对象并不罕见，如果有什么能为我们自动处理JSON序列化，那将会非常好。幸运的是，有！

自动生成Model

尽管还有其他库可用，但在本书中，我们介绍一下官方推荐的json_serializable package包。 它是一个自动化的源代码生成器，可以在开发阶段为我们生成JSON序列化模板，这样一来，由于序列化代码不再由我们手写和维护，我们将运行时产生JSON序列化异常的风险降至最低。

在项目中设置json_serializable

要包含json_serializable到我们的项目中，我们需要一个常规和两个开发依赖项。简而言之，开发依赖项是不包含在我们的应用程序源代码中的依赖项，它是开发过程中的一些辅助工具、脚本，和node中的开发依赖项相似。

pubspec.yaml

  1. dependencies:
  2.   # Your other regular dependencies here
  3.   json_annotation: ^2.0.0
  5. dev_dependencies:
  6.   # Your other dev_dependencies here
  7.   build_runner: ^1.0.0
  8.   json_serializable: ^2.0.0

在您的项目根文件夹中运行 flutter packages get (或者在编辑器中点击 “Packages Get”) 以在项目中使用这些新的依赖项.

以json_serializable的方式创建model类

让我们看看如何将我们的User类转换为一个json_serializable。为了简单起见，我们使用前面示例中的简化JSON model。

user.dart

  1. import 'package:json_annotation/json_annotation.dart';
  3. // user.g.dart 将在我们运行生成命令后自动生成
  4. part 'user.g.dart';
  6. ///这个标注是告诉生成器，这个类是需要生成Model类的
  7. @JsonSerializable()
  9. class User{
  10.   User(this.name, this.email);
  12.   String name;
  13.   String email;
  14.   //不同的类使用不同的mixin即可
  15.   factory User.fromJson(Map<String, dynamic> json) => _$UserFromJson(json);
  16.   Map<String, dynamic> toJson() => _$UserToJson(this);  
  17. }

有了上面的设置，源码生成器将生成用于序列化name和email字段的JSON代码。

如果需要，自定义命名策略也很容易。例如，如果我们正在使用的API返回带有snake_case的对象，但我们想在我们的模型中使用lowerCamelCase， 那么我们可以使用@JsonKey标注：

  1. //显式关联JSON字段名与Model属性的对应关系 
  2. @JsonKey(name: 'registration_date_millis')
  3. final int registrationDateMillis;

运行代码生成程序

json_serializable第一次创建类时，您会看到与下图类似的错误。

ide_warning

这些错误是完全正常的，这是因为Model类的生成代码还不存在。为了解决这个问题，我们必须运行代码生成器来为我们生成序列化模板。有两种运行代码生成器的方法：

一次性生成

通过在我们的项目根目录下运行:

  1. flutter packages pub run build_runner build

这触发了一次性构建，、我们可以在需要时为我们的Model生成json序列化代码，它通过我们的源文件，找出需要生成Model类的源文件（包含@JsonSerializable标注的）来生成对应的.g.dart文件。一个好的建议是将所有Model类放在一个单独的目录下，然后在该目录下执行命令。

虽然这非常方便，但如果我们不需要每次在Model类中进行更改时都要手动运行构建命令的话会更好。

持续生成

使用watcher可以使我们的源代码生成的过程更加方便。它会监视我们项目中文件的变化，并在需要时自动构建必要的文件，我们可以通过flutter packages pub run build_runner watch在项目根目录下运行来启动watcher。只需启动一次观察器，然后它就会在后台运行，这是安全的。

自动化生成模板

上面的方法有一个最大的问题就是要为每一个json写模板，这是比较枯燥的。如果有一个工具可以直接根据JSON文本生成模板，那我们就能彻底解放双手了。笔者自己用dart实现了一个脚本，它可以自动生成模板，并直接将JSON转为Model类，下面我们看看怎么做：

  1. 定义一个”模板的模板”，名为”template.dart”：

    1. import 'package:json_annotation/json_annotation.dart';
    2. %t
    3. part '%s.g.dart';
    4. @JsonSerializable()
    5. class %s {
    6.     %s();
    8.     %s
    9.     factory %s.fromJson(Map<String,dynamic> json) => _$%sFromJson(json);
    10.     Map<String, dynamic> toJson() => _$%sToJson(this);
    11. }

    模板中的“%t”、“%s”为占位符，将在脚本运行时动态被替换为合适的导入头和类名。

  2. 写一个自动生成模板的脚本(mo.dart)，它可以根据指定的JSON目录，遍历生成模板，在生成时我们定义一些规则：

    • 如果JSON文件名以下划线“_”开始，则忽略此JSON文件。
    • 复杂的JSON对象往往会出现嵌套，我们可以通过一个特殊标志来手动指定嵌套的对象（后面举例）。

    脚本我们通过Dart来写，源码如下：

    1. import 'dart:convert';
    2. import 'dart:io';
    3. import 'package:path/path.dart' as path;
    4. const TAG="\$";
    5. const SRC="./json"; //JSON 目录
    6. const DIST="lib/models/"; //输出model目录
    8. void walk() { //遍历JSON目录生成模板
    9.   var src = new Directory(SRC);
    10.   var list = src.listSync();
    11.   var template=new File("./template.dart").readAsStringSync();
    12.   File file;
    13.   list.forEach((f) {
    14.     if (FileSystemEntity.isFileSync(f.path)) {
    15.       file = new File(f.path);
    16.       var paths=path.basename(f.path).split(".");
    17.       String name=paths.first;
    18.       if(paths.last.toLowerCase()!="json"||name.startsWith("_")) return ;
    19.       if(name.startsWith("_")) return;
    20.       //下面生成模板
    21.       var map = json.decode(file.readAsStringSync());
    22.       //为了避免重复导入相同的包，我们用Set来保存生成的import语句。
    23.       var set= new Set<String>();
    24.       StringBuffer attrs= new StringBuffer();
    25.       (map as Map<String, dynamic>).forEach((key, v) {
    26.           if(key.startsWith("_")) return ;
    27.           attrs.write(getType(v,set,name));
    28.           attrs.write(" ");
    29.           attrs.write(key);
    30.           attrs.writeln(";");
    31.           attrs.write("    ");
    32.       });
    33.       String  className=name[0].toUpperCase()+name.substring(1);
    34.       var dist=format(template,[name,className,className,attrs.toString(),
    35.                                 className,className,className]);
    36.       var _import=set.join(";\r\n");
    37.       _import+=_import.isEmpty?"":";";
    38.       dist=dist.replaceFirst("%t",_import );
    39.       //将生成的模板输出
    40.       new File("$DIST$name.dart").writeAsStringSync(dist);
    41.     }
    42.   });
    43. }
    45. String changeFirstChar(String str, [bool upper=true] ){
    46.   return (upper?str[0].toUpperCase():str[0].toLowerCase())+str.substring(1);
    47. }
    49. //将JSON类型转为对应的dart类型
    50.  String getType(v,Set<String> set,String current){
    51.   current=current.toLowerCase();
    52.   if(v is bool){
    53.     return "bool";
    54.   }else if(v is num){
    55.     return "num";
    56.   }else if(v is Map){
    57.     return "Map<String,dynamic>";
    58.   }else if(v is List){
    59.     return "List";
    60.   }else if(v is String){ //处理特殊标志
    61.     if(v.startsWith("$TAG[]")){
    62.       var className=changeFirstChar(v.substring(3),false);
    63.       if(className.toLowerCase()!=current) {
    64.         set.add('import "$className.dart"');
    65.       }
    66.       return "List<${changeFirstChar(className)}>";
    68.     }else if(v.startsWith(TAG)){
    69.       var fileName=changeFirstChar(v.substring(1),false);
    70.       if(fileName.toLowerCase()!=current) {
    71.         set.add('import "$fileName.dart"');
    72.       }
    73.       return changeFirstChar(fileName);
    74.     }
    75.     return "String";
    76.   }else{
    77.     return "String";
    78.   }
    79.  }
    81. //替换模板占位符
    82. String format(String fmt, List<Object> params) {
    83.   int matchIndex = 0;
    84.   String replace(Match m) {
    85.     if (matchIndex < params.length) {
    86.       switch (m[0]) {
    87.         case "%s":
    88.           return params[matchIndex++].toString();
    89.       }
    90.     } else {
    91.       throw new Exception("Missing parameter for string format");
    92.     }
    93.     throw new Exception("Invalid format string: " + m[0].toString());
    94.   }
    95.   return fmt.replaceAllMapped("%s", replace);
    96. }
    98. void main(){
    99.   walk();
    100. }

  3. 写一个shell(mo.sh)，将生成末班和生成model串起来：

    1. dart mo.dart
    2. flutter packages pub run build_runner build --delete-conflicting-outputs

至此，我们的脚本写好了，我们在根目录下新建一个json目录，然后把user.json移进去，然后再lib目录下创建一个models目录，用于保存最终生成的Model类。现在我们只需要一句命令即可生成Model类了:

  1. ./mo.sh

运行后，一切都将自动执行，现在好多了，不是吗？

嵌套JSON

我们定义一个person.json内容修改为：

  1. {
  2.   "name": "John Smith",
  3.   "email": "john@example.com",
  4.   "mother":{
  5.     "name": "Alice",
  6.     "email":"alice@example.com"
  7.   },
  8.   "friends":[
  9.     {
  10.       "name": "Jack",
  11.       "email":"Jack@example.com"
  12.     },
  13.     {
  14.       "name": "Nancy",
  15.       "email":"Nancy@example.com"
  16.     }
  17.   ]
  18. }

每个Person都有name 、email 、 mother和friends四个字段，由于mother也是一个Person，朋友是多个Person(数组)，所以我们期望生成的Model是下面这样：

  1. import 'package:json_annotation/json_annotation.dart';
  2. part 'person.g.dart';
  4. @JsonSerializable()
  5. class Person {
  6.     Person();
  8.     String name;
  9.     String email;
  10.     Person mother;
  11.     List<Person> friends;
  13.     factory Person.fromJson(Map<String,dynamic> json) => _$PersonFromJson(json);
  14.     Map<String, dynamic> toJson() => _$PersonToJson(this);
  15. }

这时，我们只需要简单修改一下JSON，添加一些特殊标志，重新运行mo.sh即可：

  1. {
  2.   "name": "John Smith",
  3.   "email": "john@example.com",
  4.   "mother":"$person",
  5.   "friends":"$[]person"
  6. }

我们使用美元符“$”作为特殊标志符(如果与内容冲突，可以修改mo.dart中的TAG常量，自定义标志符)，脚本在遇到特殊标志符后会先把相应字段转为相应的对象或对象数组，对象数组需要在标志符后面添加数组符“[]”，符号后面接具体的类型名，此例中是person。其它类型同理，加入我们给User添加一个Person类型的 boss字段：

  1. {
  2.   "name": "John Smith",
  3.   "email": "john@example.com",
  4.   "boss":"$person"
  5. }

重新运行mo.sh，生成的user.dart如下：

  1. import 'package:json_annotation/json_annotation.dart';
  2. import "person.dart";
  3. part 'user.g.dart';
  5. @JsonSerializable()
  7. class User {
  8.     User();
  10.     String name;
  11.     String email;
  12.     Person boss;
  14.     factory User.fromJson(Map<String,dynamic> json) => _$UserFromJson(json);
  15.     Map<String, dynamic> toJson() => _$UserToJson(this);
  16. }

可以看到，boss字段已自动添加，并自动导入了“person.dart”。

很多人可能会问Flutter中有没有像Java开发中的Gson/Jackson一样的Json序列化类库？答案是没有！因为这样的库需要使用运行时反射，这在Flutter中是禁用的。运行时反射会干扰Dart的tree shaking，使用tree shaking，可以在release版中“去除”未使用的代码，这可以显著优化应用程序的大小。由于反射会默认应用到所有代码，因此tree shaking会很难工作，因为在启用反射时很难知道哪些代码未被使用，因此冗余代码很难剥离，所以Flutter中禁用了Dart的反射功能，而正因如此也就无法实现动态转化Model的功能。