MENU
  1. ホーム
  2. Go
  3. Go言語でのHTTPリクエスト非同期処理とレスポンス処理方法を徹底解説

Go言語でのHTTPリクエスト非同期処理とレスポンス処理方法を徹底解説

Go

Go言語は、シンプルで効率的なプログラミング言語として知られ、特にネットワークアプリケーションや並行処理に適しています。本記事では、Goを用いてHTTPリクエストを非同期で処理する方法に焦点を当てます。非同期処理は、複数のリクエストを同時に処理し、システムのパフォーマンスを最大限に引き出すために不可欠です。本記事を通じて、非同期処理の基礎から、レスポンスの適切な管理やエラーハンドリングの実装まで、実用的な技術を学びます。これにより、より効率的でスケーラブルなアプリケーションの開発を目指せるようになります。

目次

HTTPリクエストと非同期処理の基礎

HTTPリクエストは、クライアントとサーバー間でデータを送受信するための基本的な手段です。クライアントはサーバーにリソースの取得やデータの送信を要求し、サーバーはそのリクエストに応じたレスポンスを返します。Go言語では、このHTTP通信を簡潔に実装できる標準ライブラリnet/httpが提供されています。

同期処理と非同期処理の違い

同期処理では、1つのHTTPリクエストが完了するまでプログラムの他の部分が待機するため、時間がかかる場合があります。一方、非同期処理では、複数のリクエストを並行して実行し、それぞれの結果を待つことなく他のタスクを進めることができます。これにより、アプリケーションの応答性が向上し、高トラフィック環境でも効率的な動作が可能になります。

Goでの非同期処理の重要性

Go言語の強力な並行処理機能であるゴルーチンとチャネルを利用することで、非同期処理をシンプルかつ効果的に実現できます。ゴルーチンは軽量なスレッドのように機能し、システムリソースを効率的に使用します。また、チャネルを使用することで、ゴルーチン間のデータ通信が安全に行えます。

次章では、Goの並行処理を支えるゴルーチンの詳細と、その活用方法を解説します。

Goのゴルーチンによる並行処理

Go言語のゴルーチンは、軽量な並行処理を実現するための強力な機能です。ゴルーチンは、goキーワードを使って簡単に起動でき、システムリソースを効率的に使用します。

ゴルーチンの基本的な使い方

ゴルーチンは、既存の関数やメソッドを並行して実行するために使用します。以下はゴルーチンの基本的な例です。

package main

import (
    "fmt"
    "time"
)

func say(message string) {
    for i := 0; i < 5; i++ {
        fmt.Println(message)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    go say("Hello") // ゴルーチンとして起動
    say("World")    // メインスレッドで実行
}

このプログラムでは、say("Hello")がゴルーチンとして並行実行され、say("World")と交互にメッセージが表示されます。

ゴルーチンの利点

  • 軽量性: ゴルーチンは非常に小さなメモリフットプリントを持ち、数千単位で起動してもパフォーマンスに影響を与えにくいです。
  • シンプルな記述: Goでは、複雑なスレッド管理を必要とせず、簡潔に並行処理を記述できます。

ゴルーチンの注意点

  • リソース競合: 複数のゴルーチンが同じリソースにアクセスすると、データ競合が発生する可能性があります。
  • 同期の必要性: リソース競合を防ぐために、適切な同期が必要です。Goではsyncパッケージやチャネルを利用してこれを管理します。

次章では、ゴルーチン間の安全なデータ通信を実現するためのチャネルの使い方について詳しく説明します。

Goのチャネルを用いたデータ通信

ゴルーチン間のデータ通信を安全に行うためには、Goのチャネル（channel）を使用します。チャネルは、ゴルーチン同士がデータを送受信するためのパイプラインのような役割を果たします。これにより、複雑なロック機構を使わずに、データの同期と共有を行うことができます。

チャネルの基本的な使い方

チャネルはmake関数を使って作成し、<-演算子でデータを送受信します。

package main

import "fmt"

func main() {
    ch := make(chan string) // チャネルの作成

    go func() {
        ch <- "Hello, Channel!" // データを送信
    }()

    message := <-ch // データを受信
    fmt.Println(message)
}

この例では、1つのゴルーチンがチャネルにメッセージを送り、別のゴルーチンがそのメッセージを受け取っています。

チャネルを使った非同期処理の例

チャネルは、非同期で複数のゴルーチン間の結果を収集する際にも役立ちます。

package main

import (
    "fmt"
    "time"
)

func worker(id int, ch chan string) {
    time.Sleep(time.Second) // 作業を模擬
    ch <- fmt.Sprintf("Worker %d done", id) // 結果をチャネルに送信
}

func main() {
    ch := make(chan string)

    for i := 1; i <= 3; i++ {
        go worker(i, ch) // 3つのゴルーチンを起動
    }

    for i := 1; i <= 3; i++ {
        fmt.Println(<-ch) // 結果を受信
    }
}

この例では、3つのゴルーチンが並行して作業を行い、それぞれの結果をチャネルを通じて受信しています。

チャネルの種類

  1. バッファなしチャネル: 送信と受信が同時に行われる必要があるチャネルです。シンプルな同期が可能です。
  2. バッファ付きチャネル: 一定の数のデータをバッファに蓄積できるチャネルです。非同期性が向上します。
ch := make(chan int, 3) // バッファ付きチャネルの例

チャネルの閉鎖

送信が完了したチャネルは、closeを使って閉じることができます。これにより、受信側がチャネルの終了を検知できます。

close(ch)

次章では、これらのゴルーチンとチャネルを組み合わせて、実際に非同期HTTPリクエストを処理する方法を詳しく解説します。

非同期HTTPリクエストの実装例

Go言語で非同期HTTPリクエストを実現するには、ゴルーチンとチャネルを活用します。これにより、複数のHTTPリクエストを並行して処理し、効率的にレスポンスを取得できます。

基本的な非同期HTTPリクエストのコード例

以下は、複数のHTTPリクエストを非同期に処理するシンプルな例です。

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

func fetchURL(url string, ch chan string) {
    start := time.Now()
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("Error fetching %s: %v", url, err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- fmt.Sprintf("Error reading response from %s: %v", url, err)
        return
    }

    elapsed := time.Since(start).Seconds()
    ch <- fmt.Sprintf("Fetched %s in %.2f seconds, bytes: %d", url, elapsed, len(body))
}

func main() {
    urls := []string{
        "https://example.com",
        "https://golang.org",
        "https://github.com",
    }

    ch := make(chan string)

    for _, url := range urls {
        go fetchURL(url, ch) // 非同期でHTTPリクエストを送信
    }

    for range urls {
        fmt.Println(<-ch) // チャネルから結果を受信
    }
}

コードの動作説明

  1. ゴルーチンでのリクエスト送信
    各URLに対してfetchURL関数をゴルーチンとして呼び出し、非同期でリクエストを送信します。
  2. チャネルでのレスポンス管理
    リクエストの結果はチャネルに送信され、メインスレッドが順次結果を受信します。
  3. 時間計測とエラーハンドリング
    リクエストの開始時間を記録し、リクエストにかかった時間をレスポンスに含めます。エラーが発生した場合も適切に処理されます。

応用: コンテキストを用いたタイムアウト設定

HTTPリクエストにタイムアウトを設定するには、Goのcontextパッケージを使用します。

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func fetchWithTimeout(url string, timeout time.Duration, ch chan string) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        ch <- fmt.Sprintf("Error creating request for %s: %v", url, err)
        return
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        ch <- fmt.Sprintf("Error fetching %s: %v", url, err)
        return
    }
    defer resp.Body.Close()

    ch <- fmt.Sprintf("Successfully fetched %s", url)
}

func main() {
    urls := []string{"https://example.com", "https://golang.org"}
    ch := make(chan string)

    for _, url := range urls {
        go fetchWithTimeout(url, 2*time.Second, ch) // 2秒のタイムアウト設定
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

このコードでは、コンテキストを利用してHTTPリクエストにタイムアウトを設けています。

次章では、複数のHTTPリクエストを効率的にまとめて処理する方法を解説します。

複数のHTTPリクエストのレスポンスをまとめて処理する方法

複数のHTTPリクエストを効率的に処理するには、並行処理を活用し、取得したレスポンスをまとめて管理する仕組みが必要です。Go言語では、ゴルーチンとチャネルを組み合わせることでこれを簡単に実現できます。

WaitGroupを使ったレスポンスの一括処理

Goのsync.WaitGroupを使用することで、複数のゴルーチンが終了するまで待機し、全てのリクエストの処理が完了してから結果をまとめて扱うことが可能です。

以下はその具体例です。

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
)

func fetchURL(url string, wg *sync.WaitGroup, results chan string) {
    defer wg.Done() // 処理が終わったらWaitGroupを減算

    resp, err := http.Get(url)
    if err != nil {
        results <- fmt.Sprintf("Error fetching %s: %v", url, err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        results <- fmt.Sprintf("Error reading response from %s: %v", url, err)
        return
    }

    results <- fmt.Sprintf("Fetched %s, bytes: %d", url, len(body))
}

func main() {
    urls := []string{
        "https://example.com",
        "https://golang.org",
        "https://github.com",
    }

    var wg sync.WaitGroup
    results := make(chan string, len(urls)) // バッファ付きチャネルを使用

    for _, url := range urls {
        wg.Add(1)
        go fetchURL(url, &wg, results)
    }

    wg.Wait()       // 全てのゴルーチンの終了を待機
    close(results)  // チャネルを閉じる

    for result := range results { // チャネルから結果を取得
        fmt.Println(result)
    }
}

コードの動作説明

  1. WaitGroupの役割
    sync.WaitGroupは、複数のゴルーチンの終了を待機するための同期ツールです。wg.Add(1)でゴルーチンを追加し、ゴルーチン内でwg.Done()を呼び出すことで処理が終了したことを通知します。
  2. バッファ付きチャネル
    resultsはバッファ付きチャネルとして定義されています。これにより、全てのレスポンスを効率よく格納し、処理終了後にまとめて出力できます。
  3. チャネルのクローズ
    全てのゴルーチンが終了した後にチャネルを閉じることで、rangeを使った安全なループ処理が可能になります。

応用: 並列処理の制御

大量のリクエストを一度に処理するとシステムに負荷がかかるため、並列処理の上限を設けることが推奨されます。以下は、セマフォを利用して並列処理数を制御する例です。

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func fetchLimited(url string, sem chan struct{}, wg *sync.WaitGroup, results chan string) {
    defer wg.Done()
    sem <- struct{}{} // セマフォに追加

    resp, err := http.Get(url)
    if err != nil {
        results <- fmt.Sprintf("Error fetching %s: %v", url, err)
        <-sem // セマフォから削除
        return
    }
    defer resp.Body.Close()

    results <- fmt.Sprintf("Fetched %s", url)
    <-sem // セマフォから削除
}

func main() {
    urls := []string{
        "https://example.com",
        "https://golang.org",
        "https://github.com",
    }

    var wg sync.WaitGroup
    results := make(chan string, len(urls))
    sem := make(chan struct{}, 2) // 最大2つのゴルーチンを同時に実行

    for _, url := range urls {
        wg.Add(1)
        go fetchLimited(url, sem, &wg, results)
    }

    wg.Wait()
    close(results)

    for result := range results {
        fmt.Println(result)
    }
}

このコードでは、セマフォによって最大2つのゴルーチンが同時に実行されるよう制限されています。

次章では、非同期処理におけるエラーハンドリングのベストプラクティスについて詳しく解説します。

エラーハンドリングのベストプラクティス

非同期処理では、エラーが発生した場合に適切に処理を行うことが重要です。特にHTTPリクエストでは、ネットワーク障害やタイムアウトなど多くのエラーが発生する可能性があります。本章では、Go言語におけるエラーハンドリングのベストプラクティスを解説します。

エラーの収集と管理

非同期処理では、複数のゴルーチンがエラーを生成する可能性があります。これらを安全かつ効率的に収集するには、チャネルを使用する方法が有効です。

以下は、エラーをチャネルで収集する例です。

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func fetchWithErrorHandling(url string, wg *sync.WaitGroup, results chan string, errors chan error) {
    defer wg.Done()

    resp, err := http.Get(url)
    if err != nil {
        errors <- fmt.Errorf("failed to fetch %s: %v", url, err)
        return
    }
    defer resp.Body.Close()

    results <- fmt.Sprintf("Successfully fetched: %s", url)
}

func main() {
    urls := []string{
        "https://example.com",
        "https://golang.org",
        "https://invalid-url", // 不正なURL
    }

    var wg sync.WaitGroup
    results := make(chan string, len(urls))
    errors := make(chan error, len(urls))

    for _, url := range urls {
        wg.Add(1)
        go fetchWithErrorHandling(url, &wg, results, errors)
    }

    wg.Wait()
    close(results)
    close(errors)

    fmt.Println("Results:")
    for result := range results {
        fmt.Println(result)
    }

    fmt.Println("\nErrors:")
    for err := range errors {
        fmt.Println(err)
    }
}

コードの動作説明

  1. エラーのチャネル収集
    errorsチャネルにエラーを送信し、非同期処理の完了後にまとめて出力します。
  2. 安全な終了
    全てのゴルーチンが終了した後、resultsとerrorsチャネルを閉じることで、ループ処理を安全に実行します。

タイムアウトのエラーハンドリング

ネットワーク関連の処理では、リクエストが長時間応答しない場合にタイムアウトを設定することが重要です。Goでは、context.WithTimeoutを利用してタイムアウトを実装できます。

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func fetchWithTimeout(url string, timeout time.Duration, ch chan string, errCh chan error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        errCh <- fmt.Errorf("failed to create request for %s: %v", url, err)
        return
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        errCh <- fmt.Errorf("request failed for %s: %v", url, err)
        return
    }
    defer resp.Body.Close()

    ch <- fmt.Sprintf("Successfully fetched: %s", url)
}

func main() {
    urls := []string{
        "https://example.com",
        "https://golang.org",
    }

    results := make(chan string, len(urls))
    errors := make(chan error, len(urls))

    for _, url := range urls {
        go fetchWithTimeout(url, 2*time.Second, results, errors)
    }

    time.Sleep(3 * time.Second) // 処理完了までの待機

    close(results)
    close(errors)

    fmt.Println("Results:")
    for result := range results {
        fmt.Println(result)
    }

    fmt.Println("\nErrors:")
    for err := range errors {
        fmt.Println(err)
    }
}

この例では、タイムアウトを設定することで、応答が遅いリクエストを適切に終了できます。

エラーハンドリングのベストプラクティス

  1. エラーを明確にロギング
    エラーが発生した場合は、URLや詳細な原因をログに記録し、デバッグを容易にします。
  2. 再試行の仕組みを追加
    ネットワーク関連のエラーが一時的な場合が多いため、エラーが発生した場合に再試行するロジックを組み込むことが推奨されます。
  3. 重要なエラーの停止処理
    特定の致命的なエラーが発生した場合、全体の処理を停止する仕組みを導入します。

次章では、レスポンスデータの加工とアプリケーションでの利用方法について解説します。

レスポンスデータの加工と利用

HTTPリクエストで取得したレスポンスデータは、そのまま利用するだけでなく、アプリケーションの目的に合わせて加工する必要があります。Go言語では、レスポンスデータを柔軟に操作できるライブラリとツールが用意されています。本章では、レスポンスデータの読み取り、解析、加工、そして利用方法を解説します。

レスポンスデータの基本的な読み取り

HTTPレスポンスのボディデータはio.ReadCloserとして提供されます。データを読み取るにはioutil.ReadAllを使用するのが一般的です。

以下は、レスポンスデータを文字列として出力する例です。

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("https://api.github.com")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }

    fmt.Println("Response Body:", string(body))
}

JSONレスポンスの解析

APIのレスポンスデータは、JSON形式で提供されることが一般的です。Goでは、標準ライブラリencoding/jsonを使用してJSONを解析できます。

以下は、JSONレスポンスを解析する例です。

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type GitHubAPIResponse struct {
    CurrentUserURL string `json:"current_user_url"`
}

func main() {
    resp, err := http.Get("https://api.github.com")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    var apiResponse GitHubAPIResponse
    if err := json.NewDecoder(resp.Body).Decode(&apiResponse); err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }

    fmt.Println("Current User URL:", apiResponse.CurrentUserURL)
}

レスポンスデータの加工

レスポンスデータはアプリケーションで利用可能な形式に加工する必要があります。以下は、レスポンスデータをフィルタリングや変換する例です。

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type Post struct {
    ID    int    `json:"id"`
    Title string `json:"title"`
    Body  string `json:"body"`
}

func main() {
    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    var posts []Post
    if err := json.NewDecoder(resp.Body).Decode(&posts); err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }

    // タイトルのみを抽出
    for _, post := range posts {
        fmt.Println("Post Title:", post.Title)
    }
}

レスポンスデータの活用例

  1. データベースへの保存
    取得したデータを整形し、データベースに保存することで、後で簡単に再利用できます。
  2. UIのレンダリング
    レスポンスデータを加工し、フロントエンドやCLIのUIに適用します。
  3. ログやモニタリング
    重要なレスポンスデータをロギングして、システムのモニタリングやトラブルシューティングに利用します。

エラーの考慮

  • レスポンスデータの形式エラー: 予期しない形式のデータが返される場合があるため、JSONの解析やデータの加工時にエラー処理を行います。
  • データの部分的欠落: レスポンスデータの一部が欠落している場合でも、他の部分を処理可能な設計にします。

次章では、非同期処理のパフォーマンスを最大限に引き出すためのチューニング技術について解説します。

非同期処理のパフォーマンスチューニング

非同期処理を効率化するためには、Go言語の特性を活かしたパフォーマンス最適化が重要です。非同期処理におけるボトルネックを排除し、システムリソースを最大限に活用する方法を解説します。

ボトルネックの特定

非同期処理のパフォーマンスを向上させるには、まずボトルネックを特定する必要があります。以下のツールや手法が役立ちます。

  1. pprofによるプロファイリング
    Goの標準ライブラリnet/http/pprofを使ってプロファイリングを行い、CPUやメモリ使用量を分析します。
import _ "net/http/pprof"
  1. ロギングによる追跡
    処理時間やエラー発生箇所をログで記録し、遅延の原因を特定します。

効率的なゴルーチン管理

ゴルーチンは軽量ですが、必要以上に生成するとメモリ消費が増加し、スケジューリングが非効率になることがあります。以下の方法でゴルーチン数を制御します。

  1. Worker Poolパターン
    Worker Poolを使って固定数のゴルーチンで処理を行います。
package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        time.Sleep(time.Second)
        results <- job * 2
    }
}

func main() {
    jobs := make(chan int, 5)
    results := make(chan int, 5)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 5; a++ {
        fmt.Println("Result:", <-results)
    }
}
  1. 並列数の動的制御
    大量のリクエストを処理する際、セマフォを使用して並列数を動的に制御します。

チャネルの最適化

チャネルの使い方を見直すことで、処理速度を向上させることができます。

  • バッファサイズの調整
    バッファ付きチャネルを利用し、ゴルーチン間の通信待ち時間を削減します。
ch := make(chan int, 100) // バッファ付きチャネル
  • 不要なブロッキングの回避
    処理の順序に依存せず、結果を即時処理する設計を心がけます。

HTTPリクエストの効率化

  1. HTTPクライアントの再利用
    HTTPクライアントを再利用することで、接続ごとのオーバーヘッドを削減します。
client := &http.Client{}
resp, err := client.Get("https://example.com")
  1. タイムアウトの適切な設定
    タイムアウトを短く設定し、長時間かかるリクエストをキャンセルします。

リソース使用の最適化

  • メモリ消費の抑制
    大規模なレスポンスデータを処理する際、ストリーム処理を採用してメモリ消費を抑えます。
  • CPU負荷の分散
    負荷が高い処理は、専用のゴルーチンやWorker Poolに分散させます。

実例: 高トラフィックAPIの非同期処理

高トラフィックなAPIを効率的に処理するコード例です。

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func fetchAPI(url string, wg *sync.WaitGroup, results chan<- string) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        results <- fmt.Sprintf("Error: %s", url)
        return
    }
    defer resp.Body.Close()
    results <- fmt.Sprintf("Success: %s", url)
}

func main() {
    urls := []string{"https://example.com", "https://golang.org", "https://github.com"}
    var wg sync.WaitGroup
    results := make(chan string, len(urls))

    for _, url := range urls {
        wg.Add(1)
        go fetchAPI(url, &wg, results)
    }

    wg.Wait()
    close(results)

    for result := range results {
        fmt.Println(result)
    }
}

まとめ

非同期処理のパフォーマンス向上には、ゴルーチン数の適切な管理、チャネルの最適化、HTTPクライアントの効率的な使用が鍵です。次章では、これらを活用した具体的なAPIクライアント設計例を紹介します。

応用例: 非同期HTTPリクエストを使ったAPIクライアント

非同期HTTPリクエストを効率的に利用することで、スケーラブルなAPIクライアントを設計できます。この章では、実際に利用可能なAPIクライアントの設計例を示し、非同期処理の応用例を具体化します。

設計概要

このAPIクライアントは、以下の要件を満たすよう設計されています。

  1. 複数のエンドポイントを並行して処理
    複数のAPIエンドポイントへのリクエストを同時に処理します。
  2. 効率的なエラーハンドリング
    発生したエラーを適切にロギングし、再試行を可能にします。
  3. 結果の集約
    全てのリクエスト結果を一元管理し、クライアントで活用できるようにします。

コード例

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "sync"
    "time"
)

// APIResponse represents a generic API response structure
type APIResponse struct {
    URL      string `json:"url"`
    Status   string `json:"status"`
    Response string `json:"response"`
    Error    string `json:"error,omitempty"`
}

// fetchEndpoint handles the API request and writes the response to a channel
func fetchEndpoint(url string, wg *sync.WaitGroup, results chan<- APIResponse) {
    defer wg.Done()

    client := &http.Client{Timeout: 5 * time.Second}
    resp, err := client.Get(url)
    if err != nil {
        results <- APIResponse{URL: url, Status: "Failed", Error: err.Error()}
        return
    }
    defer resp.Body.Close()

    var body map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
        results <- APIResponse{URL: url, Status: "Failed", Error: "Invalid JSON response"}
        return
    }

    responseString, _ := json.Marshal(body)
    results <- APIResponse{URL: url, Status: "Success", Response: string(responseString)}
}

func main() {
    urls := []string{
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://jsonplaceholder.typicode.com/posts/2",
        "https://jsonplaceholder.typicode.com/posts/3",
    }

    var wg sync.WaitGroup
    results := make(chan APIResponse, len(urls))

    for _, url := range urls {
        wg.Add(1)
        go fetchEndpoint(url, &wg, results)
    }

    wg.Wait()
    close(results)

    fmt.Println("Aggregated Results:")
    for result := range results {
        if result.Status == "Failed" {
            fmt.Printf("Error fetching %s: %s\n", result.URL, result.Error)
        } else {
            fmt.Printf("Fetched from %s: %s\n", result.URL, result.Response)
        }
    }
}

コードのポイント

  1. 非同期処理の統合
    各URLに対して非同期にリクエストを送り、チャネルで結果を集約します。
  2. エラーの記録と通知
    エラーレスポンスをAPIResponse構造体に保存し、結果としてクライアントに渡します。
  3. データの集約と利用
    全てのレスポンスデータを集約し、UIレンダリングやデータ保存などの後続処理に利用できます。

応用例

  1. ダッシュボードのバックエンド
    複数の外部APIからデータを取得し、ダッシュボードのリアルタイム更新を支援します。
  2. バッチデータ処理
    定期的に外部データを取得し、内部データベースに保存するバッチ処理に活用できます。
  3. リモートサービスモニタリング
    外部サービスのステータスやパフォーマンスを並行してモニタリングし、アラートを生成します。

ベストプラクティス

  • タイムアウト設定: リクエストが長時間ブロックしないように適切なタイムアウトを設定します。
  • リトライ機能: 一時的な障害に対して、リクエストを再試行する仕組みを導入します。
  • 結果のキャッシュ: 頻繁に変わらないデータをキャッシュすることで、リクエスト数を削減します。

次章では、これまでの内容をまとめ、実際のアプリケーションでの非同期処理の重要性を振り返ります。

まとめ

本記事では、Go言語を使用したHTTPリクエストの非同期処理とレスポンス管理について解説しました。ゴルーチンやチャネルを活用した効率的な非同期処理の方法から、レスポンスデータの加工、エラーハンドリング、さらにはパフォーマンスの最適化までを詳しく説明しました。また、実践的な応用例として、高トラフィック環境に対応可能なAPIクライアントの設計を紹介しました。

非同期処理は、現代の高速でスケーラブルなアプリケーションにとって不可欠な技術です。この記事を参考に、Goの並行処理機能を最大限に活用し、より効率的で信頼性の高いシステムを構築してください。

Go
非同期処理 HTTPリクエスト Go

コメント

コメントする

目次