Hur hanterar du nätverk och API:er i Flutter?

Question

Accepted Answer

Flutter-appar kommunicerar ofta med **API:er** — genom att göra HTTP-förfrågningar, tolka JSON och hantera svar/fel. Med hjälp av paketen **http** eller **dio**, **async/await** och JSON-tolkning är nätverk en kärnedel i de flesta appar. ## Göra HTTP-förfrågningar ```dart import 'package:http/http.dart' as http; // GET request Future> fetchUsers() async { final response = await http.get(Uri.parse('https://api.example.com/users')); if (response.statusCode == 200) { final List data = jsonDecode(response.body); // parse JSON return data.map((json) => User.fromJson(json)).toList(); } else { throw Exception('Failed to load users'); // handle errors } } // POST request await http.post( Uri.parse('https://api.example.com/users'), headers: {'Content-Type': 'application/json'}, body: jsonEncode({'name': 'Ann'}), ); ``` ## JSON-tolkning (serialisering) ```dart // model class with fromJson/toJson (convert between JSON and Dart objects) class User { final String name; User(this.name); factory User.fromJson(Map json) => User(json['name']); Map toJson() => {'name': name}; } // → for many models, use code generation (json_serializable) to avoid boilerplate ``` ## Bästa praxis ```text ✓ Use a SERVICE/repository layer (separate networking from UI) — clean architecture ✓ Handle ERRORS (network failures, non-200 status, timeouts) gracefully → show UI feedback ✓ Show LOADING states (FutureBuilder / state management) ✓ Use DIO for advanced needs (interceptors, retries, better config) vs basic http ✓ Parse JSON into typed MODELS (not raw maps) — type safety ✓ Handle auth (tokens in headers), timeouts, and cancellation ``` ## Varför det spelar roll Att förstå nätverk och API:er i Flutter är väsentligt eftersom **de flesta appar kommunicerar med backends** — att hämta och skicka data via HTTP är en kärnedel i nästan varje verklig app, så det är kunskap du måste kunna. Appar behöver ständigt göra API-anrop (ladda data, skicka formulär, autentisering), och att förstå hur man gör detta korrekt är grundläggande. Att kunna **göra HTTP-förfrågningar** (GET, POST, etc. med paketen `http` eller `dio` tillsammans med async/await), **tolka JSON** (konvertera API-svar till typade Dart-modellobjekt via `fromJson`/`toJson`, helst med kodgenerering för många modeller) och **hantera svar och fel** (kontrollera statuskoder, kasta/hantera undantag) är den kärnmässiga praktiska färdigheten. Att förstå **bästa praxis** är särskilt värdefullt: använda ett **service/repository-lager** för att separera nätverk från gränssnittet (ren arkitektur, underhållbarhet), **hantera fel på ett användarvänligt sätt** (nätverksfel, icke-200-status, timeout — visa lämplig återkoppling i gränssnittet, eftersom nätverksanrop ofta misslyckas), **visa lässtillstånd** (via FutureBuilder eller tillståndshantering, för bra användarupplevelse), tolka JSON till **typade modeller** (för typsäkerhet snarare än råa maps) och hantera autentisering och timeout — dessa återspeglar byggandet av robust, underhållbar nätverkskod snarare än skör ad-hoc-anrop. Eftersom de flesta Flutter-appar kommunicerar med API:er (ett nästan universellt behov) och att göra det väl (korrekta förfrågningar, JSON-tolkning till modeller, felhantering, lässtillstånd och ren arkitektur) är väsentligt för funktionella, robusta appar, och eftersom förståelse av verktygen och bästa praxis är nödvändigt för denna kärnkapacitet, är förståelse av nätverk och API:er i Flutter väsentlig, ofta tillämpad praktisk kunskap — en grundläggande färdighet som behövs i praktiskt taget varje verklig Flutter-app som kommunicerar med ett backend, central för att bygga appar som hämtar och visar data på ett tillförlitligt sätt.