Requête HTTP Flutter

Cette section présentera comment effectuer des requêtes réseau HTTP dans des applications Flutter, y compris les requêtes GET, POST et la gestion des données JSON.


Ajouter la dépendance HTTP

Ajoutez le paquet http dans pubspec.yaml :

dependencies:
  http: ^1.0.0

Puis exécutez :

$ flutter pub get

Envoyer une requête GET

Exemple : requête GET

import 'dart:convert';
import 'package:http/http.dart' as http;

// Requête GET simple
Future<void> fetchData() async {
  final response = await http.get(Uri.parse('https://jsonplaceholder.typicode.com/posts/1'));

  if (response.statusCode == 200) {
    // Analyser les données JSON
    final data = jsonDecode(response.body);
    print('Titre : ${data['title']}');
  } else {
    print('Échec de la requête : ${response.statusCode}');
  }
}

// Requête GET avec paramètres
Future<void> searchData(String query) async {
  final uri = Uri.parse('https://api.example.com/search')
      .replace(queryParameters: {'q': query, 'page': '1'});

  final response = await http.get(uri);

  if (response.statusCode == 200) {
    final data = jsonDecode(response.body);
    print(Résultat : $data);
  }
}

Envoyer une requête POST

Exemple : requête POST

import 'dart:convert';
import 'package:http/http.dart' as http;

// Requête POST - envoyer des données JSON
Future<void> postData() async {
  final uri = Uri.parse('https://jsonplaceholder.typicode.com/posts');

  final response = await http.post(
    uri,
    headers: {
      'Content-Type': 'application/json',  // Définir l'en-tête de requête
    },
    body: jsonEncode({  // Convertir un objet Dart en chaîne JSON
      'title': Tutoriel Flutter,
      'body': 'Apprentissage des requêtes réseau Flutter',
      'userId': 1,
    }),
  );

  if (response.statusCode == 201) {
    final data = jsonDecode(response.body);
    print('Créé avec succès : $data');
  } else {
    print('Échec de la requête : ${response.statusCode}');
  }
}

// Requête POST - envoyer les données du formulaire
Future<void> postFormData() async {
  final uri = Uri.parse('https://example.com/api/login');

  final response = await http.post(
    uri,
    body: {
      'username': 'admin',
      'password': '123456',
    },
  );

  print('Réponse : ${response.body}');
}

Traiter les données JSON

Exemple : analyse JSON

import 'dart:convert';

// Définir le modèle de données
class Article {
  final int id;
  final String title;
  final String body;
  final User user;

  Article({
    required this.id,
    required this.title,
    required this.body,
    required this.user,
  });

  // Analyser à partir de JSON
  factory Article.fromJson(Map<String, dynamic> json) {
    return Article(
      id: json['id'],
      title: json['title'],
      body: json['body'],
      user: User.fromJson(json['user']),
    );
  }

  // Convertir en JSON
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'title': title,
      'body': body,
      'user': user.toJson(),
    };
  }
}

class User {
  final int id;
  final String name;

  User({required this.id, required this.name});

  factory User.fromJson(Map<String, dynamic> json) {
    return User(id: json['id'], name: json['name']);
  }

  Map<String, dynamic> toJson() {
    return {'id': id, 'name': name};
  }
}

// Exemple d'utilisation
void parseJson() {
  final jsonString = '''
  {
    "id": 1,
"title": "Tutoriel Flutter",
"body": "Apprendre Flutter",
"user": {"id": 1, "name": "Zhang San"}
  }
  '
'';

  // Analyser la chaîne JSON
  final Map<String, dynamic> json = jsonDecode(jsonString);
  final article = Article.fromJson(json);

  print('ID de l’article : ${article.id}');
  print('Auteur: ${article.user.name}');
}

Gestion des erreurs

Exemple: Exemple complet de requête réseau

import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  // URL de base
  static const String baseUrl = 'https://jsonplaceholder.typicode.com';

  // Méthode de requête GET générique
  static Future<dynamic> get(String endpoint) async {
    try {
      final response = await http.get(
        Uri.parse('$baseUrl/$endpoint'),
      );
      return _handleResponse(response);
    } catch (e) {
      throw ApiException('Erreur réseau: $e');
    }
  }

  // Méthode de requête POST générique
  static Future<dynamic> post(
    String endpoint,
    Map<String, dynamic> data,
  ) async {
    try {
      final response = await http.post(
        Uri.parse('$baseUrl/$endpoint'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode(data),
      );
      return _handleResponse(response);
    } catch (e) {
      throw ApiException('Erreur réseau: $e');
    }
  }

  // Gérer la réponse
  static dynamic _handleResponse(http.Response response) {
    if (response.statusCode >= 200 && response.statusCode < 300) {
      // Réponse réussie
      if (response.body.isEmpty) {
        return null;
      }
      return jsonDecode(response.body);
    } else if (response.statusCode == 404) {
      throw ApiException(Ressource introuvable, statusCode: 404);
    } else if (response.statusCode >= 500) {
      throw ApiException('Erreur serveur', statusCode: response.statusCode);
    } else {
      throw ApiException(
        'Échec de la requête',
        statusCode: response.statusCode,
      );
    }
  }
}

// Classe d'exception personnalisée
class ApiException implements Exception {
  final String message;
  final int? statusCode;

  ApiException(this.message, {this.statusCode});

  @override
  String toString() => 'ApiException: $message (statut: $statusCode)';
}

// Exemple d'utilisation
Future<void> fetchArticles() async {
  try {
    final articles = await ApiService.get('posts');
    print('${articles.length} articles récupérés');
  } on ApiException catch (e) {
    print('Erreur API : $e');
  }
}

Dans les applications réelles, il est recommandé d'encapsuler les requêtes réseau dans des classes de service afin de gérer uniformément les erreurs, les états de chargement et la logique de mise en cache.

autres extensions