Go言語で始める高速バックエンド開発：実践的なWeb API構築と並行処理の基礎

mkdir my-go-api
cd my-go-api
go mod init my-go-api
go get github.com/gin-gonic/gin
go get gorm.io/gorm
go get gorm.io/driver/sqlite

// main.go
package main
import (
    "net/http"
    "github.com/gin-gonic/gin"
    gorm "gorm.io/gorm"
    "gorm.io/driver/sqlite"
)
// User モデルの定義
type User struct {
    gorm.Model
    Name  string `json:"name" binding:"required"`
    Email string `json:"email" binding:"required,email" gorm:"unique"`
}
var DB *gorm.DB
func initDB() {
    var err error
    DB, err = gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    // マイグレーション
    DB.AutoMigrate(&User{})
}
func main() {
    initDB()
    r := gin.Default()
    // 全ユーザー取得
    r.GET("/users", func(c *gin.Context) {
        var users []User
        DB.Find(&users)
        c.JSON(http.StatusOK, users)
    })
    // 新規ユーザー作成
    r.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        // メールアドレスの重複チェック
        var existingUser User
        DB.Where("email = ?", user.Email).First(&existingUser)
        if existingUser.ID != 0 {
            c.JSON(http.StatusBadRequest, gin.H{"error": "Email already exists"})
            return
        }
        DB.Create(&user)
        c.JSON(http.StatusCreated, user)
    })
    // 特定ユーザー取得
    r.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        var user User
        if err := DB.First(&user, id).Error; err != nil {
            c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
            return
        }
        c.JSON(http.StatusOK, user)
    })
    // ユーザー更新
    r.PUT("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        var user User
        if err := DB.First(&user, id).Error; err != nil {
            c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
            return
        }
        var updatedUser User
        if err := c.ShouldBindJSON(&updatedUser); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        // メールアドレスの重複チェック (自分自身を除く)
        var existingUserWithEmail User
        DB.Where("email = ? AND id <> ?", updatedUser.Email, user.ID).First(&existingUserWithEmail)
        if existingUserWithEmail.ID != 0 {
            c.JSON(http.StatusBadRequest, gin.H{"error": "Email already exists for another user"})
            return
        }
        DB.Model(&user).Updates(updatedUser)
        c.JSON(http.StatusOK, user)
    })
    // ユーザー削除
    r.DELETE("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        var user User
        if err := DB.First(&user, id).Error; err != nil {
            c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
            return
        }
        DB.Delete(&user)
        c.Status(http.StatusNoContent)
    })
    r.Run(":8080") // サーバーをポート8080で起動
}

package main
import (
    "fmt"
    "time"
)
func worker(id int) {
    fmt.Printf("Worker %d: started\n", id)
    time.Sleep(time.Second) // 1秒間作業をシミュレート
    fmt.Printf("Worker %d: finished\n", id)
}
func main() {
    for i := 1; i <= 5; i++ {
        go worker(i) // worker関数をGoルーチンとして実行
    }
    // Goルーチンが完了するのを待つために少し待機
    // 実際にはチャネルやsync.WaitGroupを使うべき
    time.Sleep(2 * time.Second)
    fmt.Println("Main function finished")
}

package main
import (
    "fmt"
    "time"
)
func producer(ch chan int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Producer: Sending %d\n", i)
        ch <- i // チャネルにデータを送信
        time.Sleep(100 * time.Millisecond)
    }
    close(ch) // 送信が完了したらチャネルを閉じる
}
func consumer(ch chan int) {
    for num := range ch { // チャネルからデータを受信
        fmt.Printf("Consumer: Received %d\n", num)
        time.Sleep(200 * time.Millisecond)
    }
    fmt.Println("Consumer: Channel closed")
}
func main() {
    // int型のチャネルを作成
    ch := make(chan int)
    // producerとconsumerをGoルーチンとして起動
    go producer(ch)
    go consumer(ch)
    // Goルーチンが完了するのを待つために少し待機
    // 実際にはsync.WaitGroupを使うべき
    time.Sleep(2 * time.Second)
    fmt.Println("Main function finished")
}

package main
import (
    "fmt"
    "net/http"
    "io/ioutil"
    "time"
)
type APIResponse struct {
    URL    string
    Status int
    Body   string
    Err    error
}
func fetchURL(url string, ch chan<- APIResponse) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- APIResponse{URL: url, Err: err}
        return
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- APIResponse{URL: url, Err: err}
        return
    }
    ch <- APIResponse{URL: url, Status: resp.StatusCode, Body: string(body)}
}
func main() {
    urls := []string{
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://jsonplaceholder.typicode.com/users/1",
        "https://jsonplaceholder.typicode.com/comments/1",
        "https://invalid.url.example.com", // エラーをシミュレート
    }
    // バッファ付きチャネルを作成 (URLの数だけバッファを持つ)
    ch := make(chan APIResponse, len(urls))
    // 各URLのフェッチをGoルーチンとして起動
    for _, url := range urls {
        go fetchURL(url, ch)
    }
    // 全てのGoルーチンからの結果を待機
    for i := 0; i < len(urls); i++ {
        resp := <-ch
        if resp.Err != nil {
            fmt.Printf("Error fetching %s: %v\n", resp.URL, resp.Err)
        } else {
            fmt.Printf("Fetched %s (Status: %d, Body Length: %d)\n", resp.URL, resp.Status, len(resp.Body))
        }
    }
    fmt.Println("All URLs fetched.")
    close(ch)
}