Natuurlijk! Hier is een uitleg en voorbeeldcode om een Go-programma te schrijven dat integreert met een RESTful API, inclusief HTTP-verzoeken, JSON-verwerking en foutafhandeling. 1. HTTP-requests maken: Gebruik de standaard `net/http` package om GET- en POST-verzoeken te doen. 2. JSON-gegevens verwerken: Gebruik de `encoding/json` package om JSON-gegevens te coderen en decoderen. 3. Foutafhandeling: Controleer altijd op fouten bij het maken van verzoeken, lezen van de respons en bij het decoderen van JSON. Voorbeeld: Ophalen weergegevens van OpenWeatherMap API Hier is een compleet voorbeeldprogramma dat de weergegevens ophaalt voor Amsterdam: ```go package main import ( "encoding/json" "fmt" "io/ioutil" "net/http" "os" ) const apiURL = "https://api.openweathermap.org/data/2.5/weather?q=Amsterdam&appid=yourapikey" type WeatherResponse struct { Name string `json:"name"` Main struct { Temp float64 `json:"temp"` Pressure int `json:"pressure"` Humidity int `json:"humidity"` } `json:"main"` Weather []struct { Description string `json:"description"` } `json:"weather"` } func main() { // Maak een GET-verzoek resp, err := http.Get(apiURL) if err != nil { fmt.Println("Fout bij het maken van het HTTP-verzoek:", err) os.Exit(1) } defer resp.Body.Close() // Controleer of de statuscode 200 OK is if resp.StatusCode != http.StatusOK { bodyBytes, _ := ioutil.ReadAll(resp.Body) fmt.Printf("Fout response: %s\n", string(bodyBytes)) os.Exit(1) } // Lees de responsbody body, err := ioutil.ReadAll(resp.Body) if err != nil { fmt.Println("Fout bij het lezen van de response body:", err) os.Exit(1) } // Decodeer JSON-gegevens var weatherData WeatherResponse err = json.Unmarshal(body, &weatherData) if err != nil { fmt.Println("Fout bij het decoderen van JSON:", err) os.Exit(1) } // Toon de gegevens fmt.Printf("Weer in %s:\n", weatherData.Name) if len(weatherData.Weather) > 0 { fmt.Printf("Omschrijving: %s\n", weatherData.Weather[0].Description) } // Temperatuur is in Kelvin, omzetten naar Celsius fmt.Printf("Temperatuur: %.2f°C\n", weatherData.Main.Temp-273.15) fmt.Printf("Luchtdruk: %d hPa\n", weatherData.Main.Pressure) fmt.Printf("Luchtvochtigheid: %d%%\n", weatherData.Main.Humidity) } ``` **Voor verzenden van data (POST):** Stel dat je data naar een API endpoint wilt sturen, doe je dat als volgt: ```go type Data struct { Naam string `json:"naam"` Waarde int `json:"waarde"` } func sendData() { data := Data{"voorbeeld", 123} jsonData, err := json.Marshal(data) if err != nil { fmt.Println("Fout bij het encoderen van JSON:", err) return } resp, err := http.Post("https://voorbeeld.com/api", "application/json", bytes.NewBuffer(jsonData)) if err != nil { fmt.Println("Fout bij het verzenden van POST:", err) return } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { bodyBytes, _ := ioutil.ReadAll(resp.Body) fmt.Printf("Fout response: %s\n", string(bodyBytes)) return } fmt.Println("Data succesvol verzonden") } ``` **Samenvatting:** - Gebruik `http.Get()` voor GET-verzoeken. - Lees de respons met `ioutil.ReadAll()`. - Decoderen van JSON met `json.Unmarshal()`. - Foutafhandeling door fouten te controleren na iedere stap. - Voor POST-verzoeken, gebruik `json.Marshal()` en `http.Post()`. Vervang `yourapikey` door je echte API-sleutel en pas de URL aan indien nodig.

Zeker! Ik leg uit hoe je HTTP-requests maakt, JSON verwerkt en foutafhandeling implementeert in Go. ## Vereiste packages ```go import ( "encoding/json" "fmt" "io" "net/http" "time" ) ``` ## Data structuur voor JSON response ```go type WeatherData struct { Name string `json:"name"` Main struct { Temp float64 `json:"temp"` FeelsLike float64 `json:"feels_like"` Humidity int `json:"humidity"` } `json:"main"` Weather []struct { Description string `json:"description"` } `json:"weather"` } ``` ## HTTP Client met timeout ```go var client = &http.Client{ Timeout: 10 * time.Second, } ``` ## GET Request functie met foutafhandeling ```go func getWeatherData(apiURL string) (*WeatherData, error) { // HTTP GET request resp, err := client.Get(apiURL) if err != nil { return nil, fmt.Errorf("HTTP request mislukt: %v", err) } defer resp.Body.Close() // Controleer statuscode if resp.StatusCode != http.StatusOK { return nil, fmt.Errorf("API returned status: %s", resp.Status) } // Lees response body body, err := io.ReadAll(resp.Body) if err != nil { return nil, fmt.Errorf("kan response niet lezen: %v", err) } // Parse JSON var weather WeatherData if err := json.Unmarshal(body, &weather); err != nil { return nil, fmt.Errorf("kan JSON niet parsen: %v", err) } return &weather, nil } ``` ## POST Request voorbeeld ```go func postWeatherData(apiURL string, data map[string]interface{}) error { // Maak JSON van data jsonData, err := json.Marshal(data) if err != nil { return fmt.Errorf("kan data niet marshallen: %v", err) } // Maak POST request resp, err := client.Post(apiURL, "application/json", bytes.NewBuffer(jsonData)) if err != nil { return fmt.Errorf("POST request mislukt: %v", err) } defer resp.Body.Close() if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated { return fmt.Errorf("API returned status: %s", resp.Status) } fmt.Println("Data succesvol verzonden!") return nil } ``` ## Hoofdfunctie met complete implementatie ```go func main() { apiKey := "yourapikey" // Vervang met je eigen API key city := "Amsterdam" apiURL := fmt.Sprintf("https://api.openweathermap.org/data/2.5/weather?q=%s&appid=%s&units=metric", city, apiKey) // GET request weather, err := getWeatherData(apiURL) if err != nil { fmt.Printf("Fout: %v\n", err) return } // Toon resultaten fmt.Printf("Weer in %s:\n", weather.Name) fmt.Printf("Temperatuur: %.1f°C\n", weather.Main.Temp) fmt.Printf("Gevoelstemperatuur: %.1f°C\n", weather.Main.FeelsLike) fmt.Printf("Vochtigheid: %d%%\n", weather.Main.Humidity) fmt.Printf("Beschrijving: %s\n", weather.Weather[0].Description) // Voorbeeld POST request (indien API dit ondersteunt) /* postData := map[string]interface{}{ "city": "Amsterdam", "temp": weather.Main.Temp, "humidity": weather.Main.Humidity, } if err := postWeatherData("https://api.example.com/data", postData); err != nil { fmt.Printf("POST fout: %v\n", err) } */ } ``` ## Belangrijke punten: 1. **Foutafhandeling**: Elke functie retourneert errors voor propere afhandeling 2. **Timeouts**: HTTP client heeft timeout om hanging requests te voorkomen 3. **Resource management**: `defer resp.Body.Close()` zorgt voor proper cleanup 4. **Status checking**: Controleer altijd HTTP statuscodes 5. **JSON parsing**: Gebruik struct tags voor automatische mapping ## Gebruik: ```bash # Vervang eerst yourapikey met je eigen OpenWeatherMap API key go run main.go ``` Vergeet niet om een gratis API key aan te vragen op [OpenWeatherMap](https://openweathermap.org/api)! Dit voorbeeld demonstreert complete HTTP communicatie met robuuste foutafhandeling in Go.