解析JSON以在Dart中列出

我试图解析来自天气API的一些复杂JSON，并将其显示在列表视图中。我使用quickType为自己生成了一个模型，但似乎无法将数据解析为列表。我相当肯定，错误的主要部分是我在解析服务文件中的数据时的逻辑，因为来自API的数据是一个复杂的结构，我不知道如何解析。由于API数据的缘故，它被分成了两个映射或列表？小时和元。因此有一个额外的类。请帮帮我

以下是服务/解析文件：

  import 'weather_model.dart';
import 'package:http/http.dart' as http;
import 'dart:io';

class Service {
  static const lat = '-33.7506';
  static const lng = '18.4401';
  static const params =
      'swellDirection,windSpeed,windDirection,wavePeriod,waveHeight,airTemperature';

  static Future<List<Hour>> getConditions() async {
    try {
      final response = await http.get(
          Uri.encodeFull(
              'https://api.stormglass.io/v2/weather/point?lat=$lat&lng=$lng&params=$params&start=2020-12-11&end=2020-12-12'),
          headers: {
            HttpHeaders.authorizationHeader:
                'exampleapi'
          });

      if (200 == response.statusCode) {
        final conditions = conditionsFromJson(response.body);
        print(response.body);
        return conditions.hours;
      }
    } catch (e) {
      print('Not working');
      return List<Hour>();
    }
  }
}

导入'weather_model.dart'；
将“package:http/http.dart”导入为http；
导入“dart:io”；
班级服务{
静态常数lat='-33.7506'；
静态常数lng='18.4401'；
静态常量参数=
“膨胀、风速、风向、波周期、波高、气温”；
静态未来getConditions（）异步{
试一试{
最终响应=等待http.get(
Uri.encodeFull(
'https://api.stormglass.io/v2/weather/point?lat=$lat&lng=$lng¶ms=$params&start=2020-12-11&end=2020-12-12’，
标题：{
HttpHeaders.authorizationHeader：
“示例API”
});
if（200==响应.状态码）{
最终条件=conditionsFromJson（response.body）；
打印（响应.正文）；
返回条件。小时；
}
}捕获（e）{
打印（“不工作”）；
返回列表（）；
}
}
}

这是我的主要文件：

    import 'package:flutter/material.dart';
import 'package:moreapi_practise/weather_model.dart';
import 'Service.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'My API Practice'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key key, this.title}) : super(key: key);
  final String title;
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  List<Hour> _conditions;
  bool _loading;

  @override
  void initState() {
    super.initState();
    _loading = true;
    Service.getConditions().then((conditions) {
      _conditions = conditions;
      _loading = false;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(_loading ? 'Loading...' : 'Conditions'),
      ),
      body: Container(child: ListView.builder(itemBuilder: (context, index) {
        Hour condition = _conditions[index];
        return ListTile(
          title: Text('${condition.airTemperature}'),
        );
      })),
    );
  }
}

导入“包装：颤振/材料.省道”；
导入“package:moreapi_Practice/weather_model.dart”；
导入“Service.dart”；
void main（）{
runApp（MyApp（））；
}
类MyApp扩展了无状态小部件{
@凌驾
小部件构建（构建上下文）{
返回材料PP(
标题：“颤振演示”，
主题：主题数据(
主样本：颜色。蓝色，
),
主页：我的主页（标题：“我的API实践”），
);
}
}
类MyHomePage扩展StatefulWidget{
MyHomePage（{Key，this.title}）：超级（Key:Key）；
最后的字符串标题；
@凌驾
_MyHomePageState createState（）=>\u MyHomePageState（）；
}
类_MyHomePageState扩展状态{
列出条件；
bool_加载；
@凌驾
void initState（）{
super.initState（）；
_加载=真；
Service.getConditions（）然后（（条件）{
_条件=条件；
_加载=假；
});
}
@凌驾
小部件构建（构建上下文）{
返回脚手架(
appBar:appBar(
标题：文本（_loading？'loading…'：'Conditions'），
),
主体：容器（子：ListView.builder（itemBuilder:（上下文，索引）{
小时条件=_条件[索引]；
返回列表块(
标题：文本（“${condition.airTemperature}”），
);
})),
);
}
}

然后是我的模型：

   // To parse this JSON data, do
//
//     final conditions = conditionsFromJson(jsonString);

import 'dart:convert';

Conditions conditionsFromJson(String str) => Conditions.fromJson(json.decode(str));

String conditionsToJson(Conditions data) => json.encode(data.toJson());

class Conditions {
    Conditions({
        this.hours,
        this.meta,
    });

    List<Hour> hours;
    Meta meta;

    factory Conditions.fromJson(Map<String, dynamic> json) => Conditions(
        hours: List<Hour>.from(json["hours"].map((x) => Hour.fromJson(x))),
        meta: Meta.fromJson(json["meta"]),
    );

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

class Hour {
    Hour({
        this.airTemperature,
        this.swellDirection,
        this.time,
        this.waveHeight,
        this.wavePeriod,
        this.windDirection,
        this.windSpeed,
    });

    AirTemperature airTemperature;
    SwellDirection swellDirection;
    DateTime time;
    SwellDirection waveHeight;
    SwellDirection wavePeriod;
    SwellDirection windDirection;
    SwellDirection windSpeed;

    factory Hour.fromJson(Map<String, dynamic> json) => Hour(
        airTemperature: AirTemperature.fromJson(json["airTemperature"]),
        swellDirection: SwellDirection.fromJson(json["swellDirection"]),
        time: DateTime.parse(json["time"]),
        waveHeight: SwellDirection.fromJson(json["waveHeight"]),
        wavePeriod: SwellDirection.fromJson(json["wavePeriod"]),
        windDirection: SwellDirection.fromJson(json["windDirection"]),
        windSpeed: SwellDirection.fromJson(json["windSpeed"]),
    );

    Map<String, dynamic> toJson() => {
        "airTemperature": airTemperature.toJson(),
        "swellDirection": swellDirection.toJson(),
        "time": time.toIso8601String(),
        "waveHeight": waveHeight.toJson(),
        "wavePeriod": wavePeriod.toJson(),
        "windDirection": windDirection.toJson(),
        "windSpeed": windSpeed.toJson(),
    };
}

class AirTemperature {
    AirTemperature({
        this.noaa,
        this.sg,
    });

    double noaa;
    double sg;

    factory AirTemperature.fromJson(Map<String, dynamic> json) => AirTemperature(
        noaa: json["noaa"].toDouble(),
        sg: json["sg"].toDouble(),
    );

    Map<String, dynamic> toJson() => {
        "noaa": noaa,
        "sg": sg,
    };
}

class SwellDirection {
    SwellDirection({
        this.icon,
        this.meteo,
        this.noaa,
        this.sg,
    });

    double icon;
    double meteo;
    double noaa;
    double sg;

    factory SwellDirection.fromJson(Map<String, dynamic> json) => SwellDirection(
        icon: json["icon"].toDouble(),
        meteo: json["meteo"] == null ? null : json["meteo"].toDouble(),
        noaa: json["noaa"].toDouble(),
        sg: json["sg"].toDouble(),
    );

    Map<String, dynamic> toJson() => {
        "icon": icon,
        "meteo": meteo == null ? null : meteo,
        "noaa": noaa,
        "sg": sg,
    };
}

class Meta {
    Meta({
        this.cost,
        this.dailyQuota,
        this.end,
        this.lat,
        this.lng,
        this.params,
        this.requestCount,
        this.start,
    });

    int cost;
    int dailyQuota;
    String end;
    double lat;
    double lng;
    List<String> params;
    int requestCount;
    String start;

    factory Meta.fromJson(Map<String, dynamic> json) => Meta(
        cost: json["cost"],
        dailyQuota: json["dailyQuota"],
        end: json["end"],
        lat: json["lat"].toDouble(),
        lng: json["lng"].toDouble(),
        params: List<String>.from(json["params"].map((x) => x)),
        requestCount: json["requestCount"],
        start: json["start"],
    );

    Map<String, dynamic> toJson() => {
        "cost": cost,
        "dailyQuota": dailyQuota,
        "end": end,
        "lat": lat,
        "lng": lng,
        "params": List<dynamic>.from(params.map((x) => x)),
        "requestCount": requestCount,
        "start": start,
    };
}

//要解析此JSON数据，请执行以下操作
//
//最终条件=conditionsFromJson（jsonString）；
导入“dart:convert”；
Conditions Conditions fromJson（String str）=>Conditions.fromJson（json.decode（str））；
字符串conditionsToJson（Conditions data）=>json.encode（data.toJson（））；
阶级条件{
条件({
这个时间，
这个.meta,，
});
列出时间；
元元；
工厂条件。fromJson（映射json）=>条件(
小时数：List.from（json[“hours”].map（（x）=>Hour.fromJson（x）），
meta:meta.fromJson（json[“meta”]），
);
映射到JSON（）=>{
“小时”：List.from（hours.map（（x）=>x.toJson（）），
“meta”：meta.toJson（），
};
}
课时{
时辰({
这个，气温，
这个，膨胀，
这次，
这个，波高，
这段时间,，
这个，风向，
这个，风速，
});
气温；
膨胀膨胀；
日期时间；
膨胀波高；
膨胀波期；
膨胀风向；
膨胀风速；
factory Hour.fromJson（映射json）=>Hour(
airtimperature:airtimperature.fromJson（json[“airtimperature”]），
sweldirection:sweldirection.fromJson（json[“sweldirection”]），
时间：DateTime.parse（json[“time”]），
waveHeight:sweldirection.fromJson（json[“waveHeight”]），
wavePeriod:sweldirection.fromJson（json[“wavePeriod”]），
windDirection:sweldirection.fromJson（json[“windDirection”]），
windSpeed:sweldirection.fromJson（json[“windSpeed”]），
);
映射到JSON（）=>{
“airtimperature”：airtimperature.toJson（），
“sweldirection”：sweldirection.toJson（），
“time”：time.toIso8601String（），
“waveHeight”：waveHeight.toJson（），
“wavePeriod”：wavePeriod.toJson（），
“windDirection”：windDirection.toJson（），
“windSpeed”：windSpeed.toJson（），
};
}
等级气温{
气温({
这是noaa，
这个是.sg，
});
双noaa；
双sg；
工厂空气温度.fromJson（映射json）=>空气温度(
noaa:json[“noaa”].toDouble（），
sg:json[“sg”].toDouble（），
);
映射到JSON（）=>{
“noaa”：noaa，
“sg”：sg，
};
}
阶级膨胀{
膨胀({
这个图标，
这个，梅托，
这是noaa，
这个是.sg，
});
双图标；
双表；
双noaa；
双sg；
工厂膨胀方向.fromJson（映射json）=>膨胀方向(
icon:json[“icon”].toDouble（），
meteo:json[“meteo”]==null？null:json[“meteo”].toDouble（），
noaa:json[“noaa”].toDouble（），
sg:json[“sg”].toDouble（），
);
映射到JSON（）=>{
“图标”：图标，
“meteo”：meteo==null？null:meteo，
“noaa”：noaa，
“sg”：sg，
};
}
类元{
元({
这是成本，
这是每日配额，
这,这,，
这个，拉特，
这是液化天然气，
这是params，
这是我的名字，
这个，开始，
});
国际成本；
国际每日配额；
弦端；
双洛杉矶
import 'package:flutter/material.dart';
import 'package:moreapi_practise/weather_model.dart';
import 'Service.dart';


void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(title: 'My API Practice'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key key, this.title}) : super(key: key);
  final String title;
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  List<Hour> _conditions;
  bool _loading;
  Future myFuture;

  Future _getService() async {
    await Service.getConditions().then((conditions) {
      setState(() {
        _conditions = conditions;
        _loading = false;
      });
    });
  }

  @override
  void initState() {
    super.initState();
    _loading = true;
    myFuture = _getService();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(_loading ? 'Loading...' : 'Conditions'),
      ),
      body: _loading
          ? const Center(
              child: CircularProgressIndicator(),
            )
          : Container(
              child: ListView.builder(
                itemCount: _conditions.length,
                itemBuilder: (context, index) {
                  final Hour condition = _conditions[index];
                  return ListTile(
                    title: Text(
                        '${condition.airTemperature.noaa} ${condition.airTemperature.sg}'),
                  );
                },
              ),
            ),
    );
  }
}