Flutter - 如何将嵌套的 json 解析为具有泛型的类？

Question

我想知道如何将嵌套的 json 解析为具有泛型类型的类。我的意图是用代码和消息包装来自后端的响应（例如包含令牌的 loginRespose）

我有

class BaseResponse<T>{
  int code;
  String message;
  T responseObject;

  BaseResponse.fromJson(Map<String, dynamic> parsedJson)
    : code = parsedJson['Code'],
      message = parsedJson['Message'],
      responseObject = T.fromJson(parsedJson['ResponseObject']); //This is what I'd like to do
}

显然最后一行会抛出一个错误，因为 T 没有命名构造函数“fromJson”。 我尝试向 Type 添加一些限制，但没有找到任何解决方案。您对如何实现这一点有任何想法吗？

Answer 1

你不能做这样的事情，至少不能颤抖。由于dart:mirror 被禁用并且类构造函数没有接口。

您将不得不采取不同的路线。

我建议改用 POO。您将在这里放弃从您的BaseResponse 反序列化responseObject。然后让BaseResponse 的子类处理这个反序列化

通常每个类型都有一个子类：

class IntResponse extends BaseResponse<int> {
  IntResponse.fromJson(Map<String, dynamic> json) : super._fromJson(json) {
    this.responseObject = int.parse(json["Hello"]);
  }
}

然后，您可以通过在 BaseResponse 上添加自定义工厂构造函数来隐藏这些混乱，以使其更方便使用。

class BaseResponse<T> {
  int code;
  String message;
  T responseObject;

  BaseResponse._fromJson(Map<String, dynamic> parsedJson)
      : code = parsedJson['Code'],
        message = parsedJson['Message'];

  factory BaseResponse.fromJson(Map<String, dynamic> json) {
    if (T == int) {
      return IntResponse.fromJson(json) as BaseResponse<T>;
    }
    throw UnimplementedError();
  }
}

然后要么直接实例化想要的类型，要么使用工厂构造函数：

final BaseResponse foo = BaseResponse.fromJson<int>({"Hello": "42", "Code": 42, "Message": "World"});

Answer 2

您可以使用built_value 包来实现这一点（您还需要built_value_generator 和build_runner）。您的课程将如下所示：

part 'base_response.g.dart';

abstract class BaseResponse<T> implements Built<BaseResponse<T>, BaseResponseBuilder<T>> {
  int code;
  String message;
  T responseObject;

  factory BaseResponse([updates(BaseResponseBuilder<T> b)]) = _$BaseResponse<T>;

  static Serializer<BaseResponse> get serializer => _$baseResponseSerializer;
}

您必须运行flutter packages pub run build_runner build 来生成生成的文件。然后你像这样使用它：

BaseResponse baseResponse = serializers.deserialize(
  json.decode(response.body),
  specifiedType: const FullType(BaseResponse, const [FullType(ConcreteTypeGoesHere)])
);

您还需要处理更多样板文件。您需要另一个名为 serializers.dart 的文件。您需要在此处手动添加要反序列化的所有类，还需要为每个接受类型参数的类以及要使用的每个具体类型添加一个 addBuilderFactory 函数。

part 'serializers.g.dart';

@SerializersFor(const [
  BaseResponse,
  ConcreteTypeGoesHere,
])
final Serializers serializers = (_$serializers.toBuilder()
      ..addBuilderFactory(
        FullType(BaseResponse, const [const FullType(ConcreteTypeGoesHere)]),
        () => new BaseResponseBuilder<ConcreteTypeGoesHere>()
      )
      ..addPlugin(StandardJsonPlugin()))
    .build();

然后重新运行flutter packages pub run build_runner build

让我希望 Gson... :S

Answer 3

这是我的方法：

class Wrapper<T, K> {
  bool? isSuccess;
  T? data;

  Wrapper({
    this.isSuccess,
    this.data,
  });

  factory Wrapper.fromJson(Map<String, dynamic> json) => _$WrapperFromJson(json);

  Map<String, dynamic> toJson() => _$WrapperToJson(this);
}

Wrapper<T, K> _$WrapperFromJson<T, K>(Map<String, dynamic> json) {
  return Wrapper<T, K>(
    isSuccess: json['isSuccess'] as bool?,
    data: json['data'] == null ? null : Generic.fromJson<T, K>(json['data']),
  );
}

class Generic {
  /// If T is a List, K is the subtype of the list.
  static T fromJson<T, K>(dynamic json) {
    if (json is Iterable) {
      return _fromJsonList<K>(json) as T;
    } else if (T == LoginDetails) {
      return LoginDetails.fromJson(json) as T;
    } else if (T == UserDetails) {
      return UserDetails.fromJson(json) as T;
    } else if (T == Message) {
      return Message.fromJson(json) as T;
    } else if (T == bool || T == String || T == int || T == double) { // primitives
      return json;
  } else {
      throw Exception("Unknown class");
    }
  }

  static List<K> _fromJsonList<K>(List<dynamic> jsonList) {
    return jsonList?.map<K>((dynamic json) => fromJson<K, void>(json))?.toList();
  }
}

为了添加对新数据模型的支持，只需将其添加到 Generic.fromJson：

else if (T == NewDataModel) {
  return NewDataModel.fromJson(json) as T;
}

这适用于任一通用对象：

Wrapper<Message, void>.fromJson(someJson)

或通用对象列表：

Wrapper<List<Message>, Message>.fromJson(someJson)