概述

在实际开发中，我们经常遇到多层嵌套的复杂JSON结构。处理这些结构需要更精细的解析策略和类型安全保障。本文将详细介绍处理复杂JSON结构的技巧，结合实际案例帮助开发者掌握多层嵌套解析的方法。

1. 复杂JSON结构特点

1.1 常见复杂结构类型

• 多层嵌套对象：对象中包含对象，层次可能达到3-5层
• 嵌套数组：数组中包含对象，对象中又包含数组
• 混合结构：同时包含嵌套对象和嵌套数组
• 可选字段：部分字段可能缺失或为null
• 动态字段：字段名或结构可能根据数据类型变化

1.2 复杂JSON示例

{
  "status": "success",
  "data": {
    "city": "北京",
    "coordinates": {
      "latitude": 39.9042,
      "longitude": 116.4074
    },
    "current": {
      "temperature": 28,
      "humidity": 65,
      "condition": "晴朗",
      "wind": {
        "direction": "东南风",
        "speed": 3,
        "gust": 5
      },
      "pressure": 1013.25,
      "visibility": 10
    },
    "forecast": [
      {
        "date": "2024-07-22",
        "day": {
          "condition": "晴",
          "high": 30
        },
        "night": {
          "condition": "多云",
          "low": 22
        },
        "hours": [
          {"time": "08:00", "temp": 26},
          {"time": "12:00", "temp": 30},
          {"time": "18:00", "temp": 28}
        ]
      },
      {
        "date": "2024-07-23",
        "day": {"condition": "多云", "high": 29},
        "night": {"condition": "阴", "low": 21}
      }
    ],
    "alerts": null,
    "lastUpdated": "2024-07-22T14:30:00Z"
  }
}

2. 分步解析策略

2.1 逐层解析法

将复杂JSON拆分为多个简单步骤进行解析：

import 'dart:convert';

void parseComplexJson(String jsonString) {
  // 第一步：解析顶层对象
  Map<String, dynamic> topLevel = jsonDecode(jsonString);
  String status = topLevel['status'] as String;
  
  // 第二步：解析data对象
  Map<String, dynamic> data = topLevel['data'] as Map<String, dynamic>;
  String city = data['city'] as String;
  
  // 第三步：解析coordinates对象
  Map<String, dynamic> coordinates = data['coordinates'] as Map<String, dynamic>;
  double latitude = (coordinates['latitude'] as num).toDouble();
  double longitude = (coordinates['longitude'] as num).toDouble();
  
  // 第四步：解析current对象
  Map<String, dynamic> current = data['current'] as Map<String, dynamic>;
  int temperature = (current['temperature'] as num).toInt();
  
  // 第五步：解析嵌套的wind对象
  Map<String, dynamic> wind = current['wind'] as Map<String, dynamic>;
  String windDirection = wind['direction'] as String;
  
  print('城市: $city, 温度: ${temperature}°C');
}

2.2 数据模型分层法

创建层次分明的数据模型类：

class WeatherResponse {
  final String status;
  final WeatherData data;
  
  WeatherResponse({required this.status, required this.data});
  
  factory WeatherResponse.fromJson(Map<String, dynamic> json) {
    return WeatherResponse(
      status: json['status'] as String,
      data: WeatherData.fromJson(json['data'] as Map<String, dynamic>),
    );
  }
}

class WeatherData {
  final String city;
  final Coordinates coordinates;
  final CurrentWeather current;
  final List<Forecast> forecast;
  final String? lastUpdated;
  
  WeatherData({
    required this.city,
    required this.coordinates,
    required this.current,
    required this.forecast,
    this.lastUpdated,
  });
  
  factory WeatherData.fromJson(Map<String, dynamic> json) {
    return WeatherData(
      city: json['city'] as String,
      coordinates: Coordinates.fromJson(json['coordinates'] as Map<String, dynamic>),
      current: CurrentWeather.fromJson(json['current'] as Map<String, dynamic>),
      forecast: (json['forecast'] as List<dynamic>)
          .map((e) => Forecast.fromJson(e as Map<String, dynamic>))
          .toList(),
      lastUpdated: json['lastUpdated'] as String?,
    );
  }
}

class Coordinates {
  final double latitude;
  final double longitude;
  
  Coordinates({required this.latitude, required this.longitude});
  
  factory Coordinates.fromJson(Map<String, dynamic> json) {
    return Coordinates(
      latitude: (json['latitude'] as num).toDouble(),
      longitude: (json['longitude'] as num).toDouble(),
    );
  }
}

3. 处理嵌套数组

3.1 简单数组解析

Map<String, dynamic> data = jsonDecode(jsonString);
List<dynamic> forecastList = data['forecast'] as List<dynamic>;

for (var item in forecastList) {
  Map<String, dynamic> forecast = item as Map<String, dynamic>;
  String date = forecast['date'] as String;
  print(date);
}

3.2 数组中嵌套对象

List<Forecast> forecasts = forecastList.map((item) {
  Map<String, dynamic> forecast = item as Map<String, dynamic>;
  
  // 解析day对象
  Map<String, dynamic> dayData = forecast['day'] as Map<String, dynamic>;
  DayWeather day = DayWeather(
    condition: dayData['condition'] as String,
    high: (dayData['high'] as num).toInt(),
  );
  
  // 解析night对象
  Map<String, dynamic> nightData = forecast['night'] as Map<String, dynamic>;
  NightWeather night = NightWeather(
    condition: nightData['condition'] as String,
    low: (nightData['low'] as num).toInt(),
  );
  
  // 解析hours数组
  List<HourlyForecast> hours = (forecast['hours'] as List<dynamic>?)
          ?.map((h) => HourlyForecast.fromJson(h as Map<String, dynamic>))
          .toList() ?? [];
  
  return Forecast(date: date, day: day, night: night, hours: hours);
}).toList();

4. 空值安全处理

4.1 使用as?进行安全转换

String? city = data['city'] as String?;
int? temperature = (data['temperature'] as num?)?.toInt();

4.2 使用??提供默认值

String safeCity = city ?? '未知城市';
int safeTemperature = temperature ?? 0;

4.3 处理可选嵌套对象

Map<String, dynamic>? windData = data['wind'] as Map<String, dynamic>?;
Wind? wind = windData != null ? Wind.fromJson(windData) : null;

4.4 处理可选数组

List<dynamic>? forecastList = data['forecast'] as List<dynamic>?;
List<Forecast> forecasts = forecastList != null
    ? forecastList.map((e) => Forecast.fromJson(e as Map<String, dynamic>)).toList()
    : [];

5. 完整示例：复杂天气数据解析

import 'dart:convert';

void main() {
  String jsonString = '''
    {
      "status": "success",
      "data": {
        "city": "北京",
        "coordinates": {"latitude": 39.9042, "longitude": 116.4074},
        "current": {
          "temperature": 28,
          "humidity": 65,
          "wind": {"direction": "东南风", "speed": 3}
        },
        "forecast": [
          {"date": "周一", "high": 30, "low": 22},
          {"date": "周二", "high": 29, "low": 21}
        ],
        "alerts": null
      }
    }
  ''';
  
  // 解析完整数据
  WeatherResponse response = WeatherResponse.fromJson(jsonDecode(jsonString));
  
  print('状态: ${response.status}');
  print('城市: ${response.data.city}');
  print('温度: ${response.data.current.temperature}°C');
  print('坐标: ${response.data.coordinates.latitude}, ${response.data.coordinates.longitude}');
}

6. 错误处理策略

6.1 完整错误处理

WeatherResponse? parseResponse(String jsonString) {
  try {
    Map<String, dynamic> jsonData = jsonDecode(jsonString);
    
    if (jsonData['status'] != 'success') {
      throw Exception('请求失败');
    }
    
    return WeatherResponse.fromJson(jsonData);
    
  } on FormatException catch (e) {
    print('JSON格式错误: $e');
    return null;
  } on TypeError catch (e) {
    print('类型转换错误: $e');
    return null;
  } catch (e) {
    print('未知错误: $e');
    return null;
  }
}

6.2 使用as?进行安全解析

factory WeatherData.fromJson(Map<String, dynamic> json) {
  return WeatherData(
    city: json['city'] as String? ?? '未知城市',
    coordinates: _parseCoordinates(json['coordinates']),
    current: _parseCurrent(json['current']),
    forecast: _parseForecast(json['forecast']),
  );
}

static Coordinates _parseCoordinates(dynamic json) {
  if (json is Map<String, dynamic>) {
    return Coordinates.fromJson(json);
  }
  return Coordinates(latitude: 0, longitude: 0);
}

7. 性能优化技巧

7.1 避免重复解析

// 缓存解析结果
WeatherResponse? _cachedResponse;

WeatherResponse? getWeather(String jsonString) {
  if (_cachedResponse != null) {
    return _cachedResponse;
  }
  _cachedResponse = WeatherResponse.fromJson(jsonDecode(jsonString));
  return _cachedResponse;
}

7.2 使用lazy loading

对于大型JSON，只在需要时解析特定部分：

class LazyWeatherData {
  final Map<String, dynamic> _rawData;
  
  LazyWeatherData(this._rawData);
  
  String get city => _rawData['city'] as String;
  
  CurrentWeather get current {
    return CurrentWeather.fromJson(_rawData['current'] as Map<String, dynamic>);
  }
}

8. 鸿蒙平台注意事项

8.1 内存管理

处理大型JSON时，注意内存使用：

// 及时释放不再需要的数据
Map<String, dynamic> jsonData = jsonDecode(jsonString);
WeatherResponse response = WeatherResponse.fromJson(jsonData);
// 使用完后可以置空引用
jsonData = {};

8.2 异步解析

对于超大JSON，考虑使用异步解析：

Future<WeatherResponse> parseWeatherAsync(String jsonString) async {
  return Future(() {
    return WeatherResponse.fromJson(jsonDecode(jsonString));
  });
}

9. 总结

处理复杂JSON结构需要合理的分层设计和空值安全处理。通过创建层次分明的数据模型类，可以将复杂解析逻辑分解为简单的步骤，提高代码的可读性和维护性。下一章将介绍JSON错误处理的详细策略。

核心知识点回顾

1. 复杂JSON通常包含多层嵌套对象和数组
2. 使用分步解析法逐层提取数据
3. 创建层次分明的数据模型类处理嵌套结构
4. 使用 as? 和 ?? 进行空值安全处理
5. 添加完整的错误处理逻辑，捕获 FormatException 和 TypeError
6. 对于可选字段和数组，提供默认值或空列表
7. 考虑性能优化，避免重复解析和内存浪费