🚀 Go 언어로 RESTful API 개발하기: 초보자도 쉽게 따라하는 완벽 가이드 🚀

안녕하세요, 개발자 여러분! 🙌 오늘은 2025년 3월 24일 기준으로 최신 트렌드를 반영한 Go 언어로 RESTful API 개발하기에 대해 알아볼게요. 요즘 백엔드 개발에서 Go(고 언어)가 진짜 핫하다는 거 다들 아시죠? 속도 빠르고, 동시성 처리 쩔고, 심플한 문법까지... 진짜 개발자들 사이에서 인기 폭발이에요! ㅋㅋㅋ

이 글을 통해 Go로 RESTful API를 개발하는 방법을 처음부터 끝까지 배워볼 건데요, 코드 한 줄 안 써본 초보자분들도 걱정 노노! 쉽게 설명해드릴게요. 실무에서 바로 써먹을 수 있는 꿀팁들도 가득 준비했답니다. 😎

1. Go 언어와 RESTful API: 찰떡궁합인 이유 💑

Go 언어(일명 Golang)는 2009년에 구글에서 만든 프로그래밍 언어인데, 2025년 현재 백엔드 개발에서 완전 대세로 자리잡았어요. 특히 마이크로서비스 아키텍처가 대세인 요즘, Go는 그 단순함과 뛰어난 성능으로 개발자들의 마음을 사로잡고 있죠.

RESTful API는 웹 서비스를 구축하는 가장 인기 있는 방식 중 하나로, HTTP 프로토콜을 기반으로 리소스에 접근하고 조작하는 인터페이스를 제공해요. Go 언어는 이런 RESTful API를 개발하기에 완벽한 언어랍니다!

Go 언어가 RESTful API 개발에 찰떡궁합인 이유는 다음과 같아요:

1. 빠른 실행 속도 - 컴파일 언어라서 인터프리터 언어보다 실행 속도가 빠르고, 서버 응답 시간이 짧아요.
2. 동시성 처리 - 고루틴(Goroutine)과 채널(Channel)을 통해 동시에 많은 요청을 처리할 수 있어요.
3. 표준 라이브러리의 강점 - HTTP 서버를 구현하는 데 필요한 기능들이 표준 라이브러리에 이미 포함되어 있어요.
4. 간결한 코드 - 적은 코드로 많은 기능을 구현할 수 있어 유지보수가 쉬워요.

이제 Go로 RESTful API를 개발하는 방법을 하나씩 알아볼게요. 진짜 실무에서 바로 써먹을 수 있는 내용으로 준비했으니 끝까지 따라와주세요! 😄

2. 개발 환경 설정하기 🛠️

Go 언어로 API를 개발하기 전에 먼저 개발 환경을 설정해야 해요. 2025년 기준 최신 버전은 Go 1.22.x이니 이 버전으로 설치해보도록 할게요!

2.1 Go 설치하기

운영체제별 설치 방법은 다음과 같아요:

brew install go

sudo apt-get update
sudo apt-get install golang-go

설치가 완료되면 터미널에서 다음 명령어로 설치 여부를 확인해보세요:

go version

이 명령어를 실행하면 "go version go1.22.x [OS/아키텍처]"와 같은 결과가 나와야 해요!

2.2 작업 디렉토리 설정하기

Go는 작업 디렉토리 구조가 중요해요. 2025년 현재는 Go Modules를 사용하는 것이 표준이 되었어요. 프로젝트 디렉토리를 만들고 모듈을 초기화해볼게요:

mkdir go-rest-api
cd go-rest-api
go mod init github.com/yourusername/go-rest-api

여기서 github.com/yourusername/go-rest-api 부분은 여러분의 프로젝트 경로로 바꿔주세요. 실제 GitHub 레포지토리가 없어도 괜찮아요. 그냥 모듈 식별자로 사용됩니다!

2.3 필요한 패키지 설치하기

Go로 RESTful API를 개발할 때 유용한 패키지들이 있어요. 2025년 현재 가장 인기 있는 패키지들을 설치해볼게요:

go get -u github.com/gin-gonic/gin
go get -u github.com/go-sql-driver/mysql
go get -u github.com/golang-jwt/jwt/v5
go get -u github.com/joho/godotenv

각 패키지의 역할은 다음과 같아요:

1. gin: 가볍고 빠른 HTTP 웹 프레임워크
2. go-sql-driver/mysql: MySQL 데이터베이스 드라이버
3. jwt: JSON Web Token 인증을 위한 패키지
4. godotenv: 환경 변수를 .env 파일에서 로드하는 패키지

이제 개발 환경 설정이 완료되었어요! 본격적으로 API 개발을 시작해볼까요? 😎

3. 첫 번째 Go API 서버 만들기 🌟

자, 이제 Go로 첫 번째 API 서버를 만들어볼게요! 진짜 간단한 "Hello, World!" API부터 시작해서 점점 기능을 추가해볼 거예요.

3.1 기본 서버 구현하기

프로젝트 루트 디렉토리에 main.go 파일을 만들고 다음 코드를 작성해보세요:

package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    // Gin 엔진 초기화
    r := gin.Default()
    
    // 루트 경로에 대한 핸들러 설정
    r.GET("/", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "Hello, RESTful World!",
        })
    })
    
    // 서버 시작
    r.Run(":8080")
}

이 코드는 정말 간단한 RESTful API 서버를 구현한 거예요. gin.Default()로 Gin 엔진을 초기화하고, 루트 경로("/")에 GET 요청이 오면 JSON 응답을 반환하도록 설정했어요.

이제 터미널에서 다음 명령어로 서버를 실행해보세요:

go run main.go

서버가 시작되면 브라우저에서 http://localhost:8080에 접속하거나, curl 명령어로 API를 테스트해볼 수 있어요:

curl http://localhost:8080

응답으로 {"message":"Hello, RESTful World!"}가 나오면 성공입니다! 짝짝짝 👏👏👏

3.2 API 구조 개선하기

실제 프로젝트에서는 모든 코드를 main.go에 작성하지 않고, 구조화된 디렉토리로 나누는 것이 좋아요. 다음과 같은 구조로 프로젝트를 개선해볼게요:

go-rest-api/
├── main.go
├── go.mod
├── go.sum
├── controllers/
│   └── user_controller.go
├── models/
│   └── user.go
├── routes/
│   └── routes.go
└── middleware/
    └── auth.go

이런 구조로 프로젝트를 나누면 코드 관리가 훨씬 쉬워져요. 각 디렉토리의 역할은 다음과 같아요:

1. controllers: 요청을 처리하는 핸들러 함수들
2. models: 데이터 구조와 데이터베이스 관련 코드
3. routes: API 라우트 정의
4. middleware: 인증 등의 미들웨어 함수들

이제 각 디렉토리와 파일을 만들고 코드를 작성해볼게요!

routes/routes.go

package routes

import (
    "github.com/gin-gonic/gin"
    "github.com/yourusername/go-rest-api/controllers"
)

// SetupRouter 함수는 모든 라우트를 설정합니다
func SetupRouter() *gin.Engine {
    r := gin.Default()
    
    // 기본 라우트
    r.GET("/", controllers.HelloWorld)
    
    // API v1 그룹
    v1 := r.Group("/api/v1")
    {
        v1.GET("/users", controllers.GetUsers)
        v1.GET("/users/:id", controllers.GetUser)
        v1.POST("/users", controllers.CreateUser)
        v1.PUT("/users/:id", controllers.UpdateUser)
        v1.DELETE("/users/:id", controllers.DeleteUser)
    }
    
    return r
}

controllers/user_controller.go

package controllers

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

// HelloWorld는 기본 인사 메시지를 반환합니다
func HelloWorld(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello, RESTful World!",
    })
}

// GetUsers는 모든 사용자 목록을 반환합니다
func GetUsers(c *gin.Context) {
    // 임시 데이터 (나중에 데이터베이스에서 가져올 예정)
    users := []gin.H{
        {"id": 1, "name": "고퍼", "email": "gopher@go.dev"},
        {"id": 2, "name": "고랭", "email": "golang@go.dev"},
    }
    
    c.JSON(http.StatusOK, gin.H{
        "users": users,
    })
}

// GetUser는 특정 ID의 사용자를 반환합니다
func GetUser(c *gin.Context) {
    id := c.Param("id")
    
    // 실제로는 DB에서 조회해야 함
    user := gin.H{"id": id, "name": "고퍼", "email": "gopher@go.dev"}
    
    c.JSON(http.StatusOK, user)
}

// CreateUser는 새 사용자를 생성합니다
func CreateUser(c *gin.Context) {
    var user struct {
        Name  string `json:"name" binding:"required"`
        Email string `json:"email" binding:"required"`
    }
    
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    // 실제로는 DB에 저장해야 함
    c.JSON(http.StatusCreated, gin.H{
        "id": 3,
        "name": user.Name,
        "email": user.Email,
    })
}

// UpdateUser는 특정 ID의 사용자 정보를 업데이트합니다
func UpdateUser(c *gin.Context) {
    id := c.Param("id")
    
    var user struct {
        Name  string `json:"name"`
        Email string `json:"email"`
    }
    
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    // 실제로는 DB에서 업데이트해야 함
    c.JSON(http.StatusOK, gin.H{
        "id": id,
        "name": user.Name,
        "email": user.Email,
        "message": "사용자 정보가 업데이트되었습니다",
    })
}

// DeleteUser는 특정 ID의 사용자를 삭제합니다
func DeleteUser(c *gin.Context) {
    id := c.Param("id")
    
    // 실제로는 DB에서 삭제해야 함
    c.JSON(http.StatusOK, gin.H{
        "message": "사용자 ID " + id + "가 삭제되었습니다",
    })
}

main.go (수정)

package main

import (
    "github.com/yourusername/go-rest-api/routes"
)

func main() {
    // 라우터 설정
    r := routes.SetupRouter()
    
    // 서버 시작
    r.Run(":8080")
}

이제 다시 서버를 실행해보세요:

go run main.go

이제 다음과 같은 엔드포인트를 테스트해볼 수 있어요:

1. GET /api/v1/users - 모든 사용자 목록 조회
2. GET /api/v1/users/1 - ID가 1인 사용자 조회
3. POST /api/v1/users - 새 사용자 생성
4. PUT /api/v1/users/1 - ID가 1인 사용자 정보 업데이트
5. DELETE /api/v1/users/1 - ID가 1인 사용자 삭제

이렇게 기본적인 CRUD(Create, Read, Update, Delete) 기능을 갖춘 RESTful API가 완성되었어요! 아직은 실제 데이터베이스 연동이 없지만, 기본 구조는 갖추었답니다. 👍

4. 라우팅과 핸들러 심화 학습 🔄

이제 라우팅과 핸들러에 대해 더 자세히 알아볼게요. RESTful API에서 라우팅은 클라이언트의 요청을 적절한 핸들러 함수로 연결해주는 중요한 역할을 해요.

4.1 라우트 그룹화하기

Gin에서는 라우트를 그룹화해서 관리할 수 있어요. 이렇게 하면 공통 경로를 가진 엔드포인트들을 더 깔끔하게 관리할 수 있죠. 예를 들어, API 버전별로 그룹화하거나 리소스별로 그룹화할 수 있어요.

routes/routes.go 파일을 다음과 같이 수정해볼게요:

package routes

import (
    "github.com/gin-gonic/gin"
    "github.com/yourusername/go-rest-api/controllers"
    "github.com/yourusername/go-rest-api/middleware"
)

// SetupRouter 함수는 모든 라우트를 설정합니다
func SetupRouter() *gin.Engine {
    r := gin.Default()
    
    // 기본 라우트
    r.GET("/", controllers.HelloWorld)
    
    // API v1 그룹
    v1 := r.Group("/api/v1")
    {
        // 사용자 관련 엔드포인트
        users := v1.Group("/users")
        {
            users.GET("", controllers.GetUsers)
            users.GET("/:id", controllers.GetUser)
            users.POST("", controllers.CreateUser)
            users.PUT("/:id", controllers.UpdateUser)
            users.DELETE("/:id", controllers.DeleteUser)
        }
        
        // 상품 관련 엔드포인트 (예시)
        products := v1.Group("/products")
        {
            products.GET("", controllers.GetProducts)
            products.GET("/:id", controllers.GetProduct)
            // 인증이 필요한 엔드포인트에는 미들웨어 적용
            products.POST("", middleware.AuthRequired(), controllers.CreateProduct)
            products.PUT("/:id", middleware.AuthRequired(), controllers.UpdateProduct)
            products.DELETE("/:id", middleware.AuthRequired(), controllers.DeleteProduct)
        }
    }
    
    return r
}

이런 식으로 라우트를 그룹화하면 코드가 더 깔끔해지고, 특정 그룹에만 미들웨어를 적용하기도 쉬워져요.

4.2 경로 매개변수와 쿼리 매개변수

RESTful API에서는 두 가지 주요 매개변수 유형을 사용해요:

1. 경로 매개변수(Path Parameters): URL 경로의 일부로 사용 (예: /users/:id)
2. 쿼리 매개변수(Query Parameters): URL의 ? 뒤에 오는 키-값 쌍 (예: /users?page=1&limit=10)

Gin에서 이 두 가지 매개변수를 처리하는 방법을 알아볼게요:

// 경로 매개변수 사용 예시
func GetUser(c *gin.Context) {
    // URL에서 :id 부분 추출
    id := c.Param("id")
    
    // 로직 처리...
    c.JSON(http.StatusOK, gin.H{"id": id, "name": "고퍼"})
}

// 쿼리 매개변수 사용 예시
func GetUsers(c *gin.Context) {
    // URL에서 ?page=1&limit=10 같은 쿼리 파라미터 추출
    page := c.DefaultQuery("page", "1")     // 기본값 1
    limit := c.DefaultQuery("limit", "10")  // 기본값 10
    
    // 로직 처리...
    c.JSON(http.StatusOK, gin.H{
        "page": page,
        "limit": limit,
        "users": []gin.H{
            {"id": 1, "name": "고퍼"},
            {"id": 2, "name": "고랭"},
        },
    })
}

4.3 요청 바디 처리하기

POST나 PUT 요청에서는 클라이언트가 요청 바디를 통해 데이터를 전송해요. Gin에서는 이런 데이터를 쉽게 처리할 수 있어요:

func CreateUser(c *gin.Context) {
    // 요청 바디를 구조체에 바인딩
    var user struct {
        Name     string `json:"name" binding:"required"`
        Email    string `json:"email" binding:"required,email"`
        Password string `json:"password" binding:"required,min=6"`
    }
    
    // 바인딩 시도
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    // 유효성 검사 통과 후 로직 처리...
    c.JSON(http.StatusCreated, gin.H{
        "message": "사용자가 생성되었습니다",
        "user": gin.H{
            "name": user.Name,
            "email": user.Email,
        },
    })
}

Gin의 바인딩 기능은 정말 강력해요! binding 태그를 사용하면 자동으로 유효성 검사까지 해줘서 개발자가 일일이 검사 코드를 작성할 필요가 없어요. 위 예시에서는 이름과 이메일이 필수이고, 이메일은 이메일 형식이어야 하며, 비밀번호는 최소 6자 이상이어야 한다는 조건을 설정했어요.

4.4 응답 형식 표준화하기

RESTful API에서는 일관된 응답 형식을 유지하는 것이 중요해요. 다음과 같은 표준 응답 형식을 만들어 사용해보세요:

// 성공 응답 헬퍼 함수
func ResponseSuccess(c *gin.Context, statusCode int, data interface{}) {
    c.JSON(statusCode, gin.H{
        "success": true,
        "data": data,
    })
}

// 오류 응답 헬퍼 함수
func ResponseError(c *gin.Context, statusCode int, message string) {
    c.JSON(statusCode, gin.H{
        "success": false,
        "error": message,
    })
}

// 사용 예시
func GetUser(c *gin.Context) {
    id := c.Param("id")
    
    // 사용자를 찾지 못한 경우
    if id == "999" {
        ResponseError(c, http.StatusNotFound, "사용자를 찾을 수 없습니다")
        return
    }
    
    // 사용자를 찾은 경우
    user := gin.H{"id": id, "name": "고퍼", "email": "gopher@go.dev"}
    ResponseSuccess(c, http.StatusOK, user)
}

이렇게 응답 형식을 표준화하면 클라이언트 측에서 응답을 처리하기가 훨씬 쉬워져요. 또한 API 문서화도 더 간결해지죠!

5. 데이터베이스 연동하기 💾

실제 API에서는 데이터를 영구적으로 저장하기 위해 데이터베이스를 사용해요. Go에서는 다양한 데이터베이스를 쉽게 연동할 수 있어요. 여기서는 MySQL을 예로 들어볼게요.

5.1 데이터베이스 연결 설정

먼저 models 디렉토리에 db.go 파일을 만들어 데이터베이스 연결을 설정해볼게요:

package models

import (
    "database/sql"
    "fmt"
    "log"
    "os"
    
    _ "github.com/go-sql-driver/mysql"
    "github.com/joho/godotenv"
)

var DB *sql.DB

// InitDB 함수는 데이터베이스 연결을 초기화합니다
func InitDB() {
    // .env 파일에서 환경 변수 로드
    err := godotenv.Load()
    if err != nil {
        log.Println("Warning: .env 파일을 찾을 수 없습니다")
    }
    
    // 환경 변수에서 데이터베이스 설정 가져오기
    dbUser := os.Getenv("DB_USER")
    dbPassword := os.Getenv("DB_PASSWORD")
    dbHost := os.Getenv("DB_HOST")
    dbName := os.Getenv("DB_NAME")
    
    // 기본값 설정
    if dbUser == "" {
        dbUser = "root"
    }
    if dbHost == "" {
        dbHost = "localhost:3306"
    }
    if dbName == "" {
        dbName = "go_api"
    }
    
    // 데이터베이스 연결 문자열 생성
    dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
        dbUser, dbPassword, dbHost, dbName)
    
    // 데이터베이스 연결
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatalf("데이터베이스 연결 실패: %v", err)
    }
    
    // 연결 테스트
    err = db.Ping()
    if err != nil {
        log.Fatalf("데이터베이스 Ping 실패: %v", err)
    }
    
    // 연결 풀 설정
    db.SetMaxIdleConns(10)
    db.SetMaxOpenConns(100)
    
    DB = db
    log.Println("데이터베이스 연결 성공!")
}

프로젝트 루트에 .env 파일을 만들고 다음과 같이 설정해주세요:

DB_USER=root
DB_PASSWORD=your_password
DB_HOST=localhost:3306
DB_NAME=go_api

5.2 사용자 모델 구현하기

이제 models 디렉토리에 user.go 파일을 만들어 사용자 모델을 구현해볼게요:

package models

import (
    "database/sql"
    "errors"
    "time"
)

// User 구조체는 사용자 정보를 나타냅니다
type User struct {
    ID        int       `json:"id"`
    Name      string    `json:"name"`
    Email     string    `json:"email"`
    Password  string    `json:"-"` // JSON 응답에서 제외
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}

// GetAllUsers 함수는 모든 사용자를 반환합니다
func GetAllUsers() ([]User, error) {
    query := `SELECT id, name, email, created_at, updated_at FROM users`
    
    rows, err := DB.Query(query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var users []User
    
    for rows.Next() {
        var user User
        err := rows.Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt)
        if err != nil {
            return nil, err
        }
        users = append(users, user)
    }
    
    return users, nil
}

// GetUserByID 함수는 ID로 사용자를 조회합니다
func GetUserByID(id int) (User, error) {
    query := `SELECT id, name, email, created_at, updated_at FROM users WHERE id = ?`
    
    var user User
    err := DB.QueryRow(query, id).Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt)
    
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return User{}, errors.New("사용자를 찾을 수 없습니다")
        }
        return User{}, err
    }
    
    return user, nil
}

// CreateUser 함수는 새 사용자를 생성합니다
func CreateUser(name, email, password string) (User, error) {
    // 이메일 중복 확인
    var count int
    err := DB.QueryRow("SELECT COUNT(*) FROM users WHERE email = ?", email).Scan(&count)
    if err != nil {
        return User{}, err
    }
    
    if count > 0 {
        return User{}, errors.New("이미 사용 중인 이메일입니다")
    }
    
    // 현재 시간
    now := time.Now()
    
    // 사용자 생성
    query := `INSERT INTO users (name, email, password, created_at, updated_at) 
              VALUES (?, ?, ?, ?, ?)`
    
    result, err := DB.Exec(query, name, email, password, now, now)
    if err != nil {
        return User{}, err
    }
    
    // 생성된 ID 가져오기
    id, err := result.LastInsertId()
    if err != nil {
        return User{}, err
    }
    
    // 생성된 사용자 반환
    return User{
        ID:        int(id),
        Name:      name,
        Email:     email,
        CreatedAt: now,
        UpdatedAt: now,
    }, nil
}

// UpdateUser 함수는 사용자 정보를 업데이트합니다
func UpdateUser(id int, name, email string) (User, error) {
    // 사용자 존재 확인
    _, err := GetUserByID(id)
    if err != nil {
        return User{}, err
    }
    
    // 현재 시간
    now := time.Now()
    
    // 사용자 업데이트
    query := `UPDATE users SET name = ?, email = ?, updated_at = ? WHERE id = ?`
    
    _, err = DB.Exec(query, name, email, now, id)
    if err != nil {
        return User{}, err
    }
    
    // 업데이트된 사용자 반환
    return GetUserByID(id)
}

// DeleteUser 함수는 사용자를 삭제합니다
func DeleteUser(id int) error {
    // 사용자 존재 확인
    _, err := GetUserByID(id)
    if err != nil {
        return err
    }
    
    // 사용자 삭제
    query := `DELETE FROM users WHERE id = ?`
    
    _, err = DB.Exec(query, id)
    return err
}

5.3 컨트롤러 업데이트하기

이제 컨트롤러를 업데이트해서 모델을 사용하도록 해볼게요:

package controllers

import (
    "github.com/gin-gonic/gin"
    "github.com/yourusername/go-rest-api/models"
    "net/http"
    "strconv"
)

// GetUsers는 모든 사용자 목록을 반환합니다
func GetUsers(c *gin.Context) {
    users, err := models.GetAllUsers()
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "success": true,
        "data": users,
    })
}

// GetUser는 특정 ID의 사용자를 반환합니다
func GetUser(c *gin.Context) {
    idStr := c.Param("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error": "잘못된 ID 형식입니다",
        })
        return
    }
    
    user, err := models.GetUserByID(id)
    if err != nil {
        c.JSON(http.StatusNotFound, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "success": true,
        "data": user,
    })
}

// CreateUser는 새 사용자를 생성합니다
func CreateUser(c *gin.Context) {
    var input struct {
        Name     string `json:"name" binding:"required"`
        Email    string `json:"email" binding:"required,email"`
        Password string `json:"password" binding:"required,min=6"`
    }
    
    if err := c.ShouldBindJSON(&input); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    user, err := models.CreateUser(input.Name, input.Email, input.Password)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusCreated, gin.H{
        "success": true,
        "data": user,
    })
}

// UpdateUser는 특정 ID의 사용자 정보를 업데이트합니다
func UpdateUser(c *gin.Context) {
    idStr := c.Param("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error": "잘못된 ID 형식입니다",
        })
        return
    }
    
    var input struct {
        Name  string `json:"name"`
        Email string `json:"email"`
    }
    
    if err := c.ShouldBindJSON(&input); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    user, err := models.UpdateUser(id, input.Name, input.Email)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "success": true,
        "data": user,
    })
}

// DeleteUser는 특정 ID의 사용자를 삭제합니다
func DeleteUser(c *gin.Context) {
    idStr := c.Param("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error": "잘못된 ID 형식입니다",
        })
        return
    }
    
    err = models.DeleteUser(id)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "success": true,
        "message": "사용자가 삭제되었습니다",
    })
}

5.4 main.go 업데이트하기

마지막으로 main.go 파일을 업데이트해서 데이터베이스 연결을 초기화하도록 해볼게요:

package main

import (
    "github.com/yourusername/go-rest-api/models"
    "github.com/yourusername/go-rest-api/routes"
)

func main() {
    // 데이터베이스 연결 초기화
    models.InitDB()
    
    // 라우터 설정
    r := routes.SetupRouter()
    
    // 서버 시작
    r.Run(":8080")
}

이제 데이터베이스와 연동된 완전한 RESTful API가 완성되었어요! 🎉

import "golang.org/x/crypto/bcrypt"

// 비밀번호 해싱
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
    return User{}, err
}

// 해시된 비밀번호 저장
// DB.Exec(query, name, email, string(hashedPassword), now, now)

6. 미들웨어와 인증 구현하기 🔒

RESTful API에서 인증과 권한 관리는 매우 중요해요. Gin의 미들웨어 기능을 사용하면 이를 쉽게 구현할 수 있어요.

6.1 JWT 인증 미들웨어 구현하기

JWT(JSON Web Token)는 웹 애플리케이션에서 인증을 처리하는 가장 인기 있는 방법 중 하나에요. middleware 디렉토리에 auth.go 파일을 만들어 JWT 인증 미들웨어를 구현해볼게요:

package middleware

import (
    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt/v5"
    "net/http"
    "os"
    "strings"
    "time"
)

// JWT 시크릿 키
var jwtSecret = []byte(getJWTSecret())

// getJWTSecret 함수는 환경 변수에서 JWT 시크릿 키를 가져옵니다
func getJWTSecret() string {
    secret := os.Getenv("JWT_SECRET")
    if secret == "" {
        return "your-secret-key" // 기본값 (실제 프로젝트에서는 안전한 방법으로 설정해야 함)
    }
    return secret
}

// Claims 구조체는 JWT 클레임을 정의합니다
type Claims struct {
    UserID int `json:"user_id"`
    jwt.RegisteredClaims
}

// GenerateToken 함수는 사용자 ID로 JWT 토큰을 생성합니다
func GenerateToken(userID int) (string, error) {
    // 토큰 만료 시간 설정 (예: 24시간)
    expirationTime := time.Now().Add(24 * time.Hour)
    
    // 클레임 생성
    claims := &Claims{
        UserID: userID,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(expirationTime),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
            NotBefore: jwt.NewNumericDate(time.Now()),
        },
    }
    
    // 토큰 생성
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    
    // 토큰 서명
    tokenString, err := token.SignedString(jwtSecret)
    if err != nil {
        return "", err
    }
    
    return tokenString, nil
}

// ValidateToken 함수는 JWT 토큰의 유효성을 검사합니다
func ValidateToken(tokenString string) (*Claims, error) {
    // 토큰 파싱
    claims := &Claims{}
    token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
        return jwtSecret, nil
    })
    
    if err != nil {
        return nil, err
    }
    
    // 토큰 유효성 검사
    if !token.Valid {
        return nil, jwt.ErrSignatureInvalid
    }
    
    return claims, nil
}

// AuthRequired 미들웨어는 요청에 유효한 JWT 토큰이 있는지 확인합니다
func AuthRequired() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Authorization 헤더에서 토큰 추출
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.JSON(http.StatusUnauthorized, gin.H{
                "success": false,
                "error": "인증 토큰이 필요합니다",
            })
            c.Abort()
            return
        }
        
        // "Bearer " 접두사 제거
        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
        
        // 토큰 유효성 검사
        claims, err := ValidateToken(tokenString)
        if err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{
                "success": false,
                "error": "유효하지 않은 토큰입니다",
            })
            c.Abort()
            return
        }
        
        // 사용자 ID를 컨텍스트에 저장
        c.Set("userID", claims.UserID)
        
        // 다음 핸들러로 진행
        c.Next()
    }
}

6.2 로그인 기능 구현하기

이제 사용자가 로그인할 수 있는 엔드포인트를 구현해볼게요. controllers 디렉토리에 auth_controller.go 파일을 만들어주세요:

package controllers

import (
    "github.com/gin-gonic/gin"
    "github.com/yourusername/go-rest-api/middleware"
    "github.com/yourusername/go-rest-api/models"
    "golang.org/x/crypto/bcrypt"
    "net/http"
)

// Login 함수는 사용자 로그인을 처리합니다
func Login(c *gin.Context) {
    var input struct {
        Email    string `json:"email" binding:"required,email"`
        Password string `json:"password" binding:"required"`
    }
    
    if err := c.ShouldBindJSON(&input); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error": err.Error(),
        })
        return
    }
    
    // 이메일로 사용자 조회
    user, err := models.GetUserByEmail(input.Email)
    if err != nil {
        c.JSON(http.StatusUnauthorized, gin.H{
            "success": false,
            "error": "이메일 또는 비밀번호가 올바르지 않습니다",
        })
        return
    }
    
    // 비밀번호 확인
    err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(input.Password))
    if err != nil {
        c.JSON(http.StatusUnauthorized, gin.H{
            "success": false,
            "error": "이메일 또는 비밀번호가 올바르지 않습니다",
        })
        return
    }
    
    // JWT 토큰 생성
    token, err := middleware.GenerateToken(user.ID)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "success": false,
            "error": "토큰 생성 실패",
        })
        return
    }
    
    // 응답
    c.JSON(http.StatusOK, gin.H{
        "success": true,
        "data": gin.H{
            "token": token,
            "user": gin.H{
                "id": user.ID,
                "name": user.Name,
                "email": user.Email,
            },
        },
    })
}

models/user.go 파일에 GetUserByEmail 함수를 추가해주세요:

// GetUserByEmail 함수는 이메일로 사용자를 조회합니다
func GetUserByEmail(email string) (User, error) {
    query := `SELECT id, name, email, password, created_at, updated_at FROM users WHERE email = ?`
    
    var user User
    err := DB.QueryRow(query, email).Scan(&user.ID, &user.Name, &user.Email, &user.Password, &user.CreatedAt, &user.UpdatedAt)
    
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return User{}, errors.New("사용자를 찾을 수 없습니다")
        }
        return User{}, err
    }
    
    return user, nil
}

6.3 라우트에 로그인 엔드포인트 추가하기

routes/routes.go 파일에 로그인 엔드포인트를 추가해주세요:

// SetupRouter 함수는 모든 라우트를 설정합니다
func SetupRouter() *gin.Engine {
    r := gin.Default()
    
    // 기본 라우트
    r.GET("/", controllers.HelloWorld)
    
    // 인증 관련 라우트
    r.POST("/login", controllers.Login)
    
    // API v1 그룹
    v1 := r.Group("/api/v1")
    {
        // 사용자 관련 엔드포인트
        users := v1.Group("/users")
        {
            users.GET("", controllers.GetUsers)
            users.GET("/:id", controllers.GetUser)
            users.POST("", controllers.CreateUser)
            
            // 인증이 필요한 엔드포인트
            authUsers := users.Group("")
            authUsers.Use(middleware.AuthRequired())
            {
                authUsers.PUT("/:id", controllers.UpdateUser)
                authUsers.DELETE("/:id", controllers.DeleteUser)
            }
        }
        
        // 다른 리소스...
    }
    
    return r
}

이제 인증 시스템이 구현되었어요! 사용자는 로그인해서 JWT 토큰을 받고, 이 토큰을 사용해 보호된 엔드포인트에 접근할 수 있어요. 🔐

7. 테스트와 배포 방법 🧪

API 개발이 완료되었다면 테스트와 배포 단계로 넘어가야 해요. Go는 테스트 도구가 내장되어 있어 쉽게 테스트를 작성할 수 있어요.

7.1 API 테스트 작성하기

Go의 테스트 파일은 *_test.go 형식으로 작성해요. controllers 디렉토리에 user_controller_test.go 파일을 만들어볼게요:

package controllers

import (
    "bytes"
    "encoding/json"
    "github.com/gin-gonic/gin"
    "github.com/yourusername/go-rest-api/models"
    "github.com/yourusername/go-rest-api/routes"
    "net/http"
    "net/http/httptest"
    "testing"
)

// 테스트 전에 Gin을 테스트 모드로 설정
func init() {
    gin.SetMode(gin.TestMode)
}

// TestGetUsers 함수는 GetUsers 핸들러를 테스트합니다
func TestGetUsers(t *testing.T) {
    // 테스트용 라우터 설정
    r := routes.SetupRouter()
    
    // 테스트용 HTTP 요청 생성
    req, err := http.NewRequest(http.MethodGet, "/api/v1/users", nil)
    if err != nil {
        t.Fatalf("요청 생성 실패: %v", err)
    }
    
    // 응답 레코더 생성
    w := httptest.NewRecorder()
    
    // 요청 실행
    r.ServeHTTP(w, req)
    
    // 응답 상태 코드 확인
    if w.Code != http.StatusOK {
        t.Errorf("예상 상태 코드 %d, 실제 %d", http.StatusOK, w.Code)
    }
    
    // 응답 본문 확인
    var response struct {
        Success bool           `json:"success"`
        Data    []models.User `json:"data"`
    }
    
    err = json.Unmarshal(w.Body.Bytes(), &response)
    if err != nil {
        t.Fatalf("응답 파싱 실패: %v", err)
    }
    
    // 성공 플래그 확인
    if !response.Success {
        t.Errorf("예상 성공 상태 true, 실제 %v", response.Success)
    }
}

// TestCreateUser 함수는 CreateUser 핸들러를 테스트합니다
func TestCreateUser(t *testing.T) {
    // 테스트용 라우터 설정
    r := routes.SetupRouter()
    
    // 테스트용 사용자 데이터
    userData := map[string]string{
        "name":     "테스트 사용자",
        "email":    "test@example.com",
        "password": "password123",
    }
    
    // JSON으로 변환
    jsonData, err := json.Marshal(userData)
    if err != nil {
        t.Fatalf("JSON 변환 실패: %v", err)
    }
    
    // 테스트용 HTTP 요청 생성
    req, err := http.NewRequest(http.MethodPost, "/api/v1/users", bytes.NewBuffer(jsonData))
    if err != nil {
        t.Fatalf("요청 생성 실패: %v", err)
    }
    req.Header.Set("Content-Type", "application/json")
    
    // 응답 레코더 생성
    w := httptest.NewRecorder()
    
    // 요청 실행
    r.ServeHTTP(w, req)
    
    // 응답 상태 코드 확인
    if w.Code != http.StatusCreated {
        t.Errorf("예상 상태 코드 %d, 실제 %d", http.StatusCreated, w.Code)
    }
    
    // 응답 본문 확인
    var response struct {
        Success bool        `json:"success"`
        Data    models.User `json:"data"`
    }
    
    err = json.Unmarshal(w.Body.Bytes(), &response)
    if err != nil {
        t.Fatalf("응답 파싱 실패: %v", err)
    }
    
    // 성공 플래그 확인
    if !response.Success {
        t.Errorf("예상 성공 상태 true, 실제 %v", response.Success)
    }
    
    // 생성된 사용자 데이터 확인
    if response.Data.Name != userData["name"] {
        t.Errorf("예상 이름 %s, 실제 %s", userData["name"], response.Data.Name)
    }
    if response.Data.Email != userData["email"] {
        t.Errorf("예상 이메일 %s, 실제 %s", userData["email"], response.Data.Email)
    }
}

테스트를 실행하려면 다음 명령어를 사용하세요:

go test -v ./controllers

7.2 Docker를 사용한 배포

Go 애플리케이션은 단일 바이너리로 컴파일되어 배포가 매우 간단해요. Docker를 사용하면 더욱 편리하게 배포할 수 있어요. 프로젝트 루트에 Dockerfile을 만들어보세요:

FROM golang:1.22-alpine AS builder

WORKDIR /app

# 의존성 복사 및 다운로드
COPY go.mod go.sum ./
RUN go mod download

# 소스 코드 복사
COPY . .

# 애플리케이션 빌드
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

# 최종 이미지
FROM alpine:latest

WORKDIR /app

# 타임존 설정
RUN apk --no-cache add tzdata
ENV TZ=Asia/Seoul

# 빌드된 바이너리 복사
COPY --from=builder /app/main .
COPY .env .

# 포트 노출
EXPOSE 8080

# 애플리케이션 실행
CMD ["./main"]

Docker 이미지를 빌드하고 실행하려면 다음 명령어를 사용하세요:

# 이미지 빌드
docker build -t go-rest-api .

# 컨테이너 실행
docker run -p 8080:8080 go-rest-api

7.3 클라우드 서비스에 배포하기

2025년 현재 Go 애플리케이션을 배포할 수 있는 다양한 클라우드 서비스가 있어요. 몇 가지 인기 있는 옵션을 소개할게요:

1. AWS Elastic Beanstalk: Docker 컨테이너를 사용해 쉽게 배포할 수 있어요.
2. Google Cloud Run: 서버리스 컨테이너 플랫폼으로, 트래픽에 따라 자동으로 확장돼요.
3. Heroku: Go 애플리케이션을 쉽게 배포할 수 있는 PaaS 서비스에요.
4. DigitalOcean App Platform: 간단한 설정으로 Go 애플리케이션을 배포할 수 있어요.

각 서비스마다 배포 방법이 다르지만, 대부분 Git 저장소와 연동하거나 Docker 이미지를 사용해 배포할 수 있어요.

8. 실전 프로젝트: 완전한 RESTful API 구현 🚀

지금까지 배운 내용을 바탕으로 실전 프로젝트를 구현해볼게요. 이 프로젝트는 간단한 블로그 API로, 사용자가 글을 작성하고 댓글을 달 수 있는 기능을 제공해요.

8.1 프로젝트 구조

go-blog-api/
├── main.go
├── go.mod
├── go.sum
├── .env
├── controllers/
│   ├── auth_controller.go
│   ├── user_controller.go
│   ├── post_controller.go
│   └── comment_controller.go
├── models/
│   ├── db.go
│   ├── user.go
│   ├── post.go
│   └── comment.go
├── routes/
│   └── routes.go
├── middleware/
│   └── auth.go
└── utils/
    ├── response.go
    └── validator.go

8.2 데이터베이스 스키마

MySQL 데이터베이스를 사용한다고 가정하고, 다음과 같은 스키마를 설계해볼게요:

-- 사용자 테이블
CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

-- 게시글 테이블
CREATE TABLE posts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    title VARCHAR(200) NOT NULL,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

-- 댓글 테이블
CREATE TABLE comments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    post_id INT NOT NULL,
    user_id INT NOT NULL,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

8.3 API 엔드포인트 설계

블로그 API의 엔드포인트를 다음과 같이 설계해볼게요:

1. 인증
   • POST /register - 회원가입
   • POST /login - 로그인
2. 사용자
   • GET /api/v1/users - 모든 사용자 조회
   • GET /api/v1/users/:id - 특정 사용자 조회
   • PUT /api/v1/users/:id - 사용자 정보 업데이트 (인증 필요)
   • DELETE /api/v1/users/:id - 사용자 삭제 (인증 필요)
3. 게시글
   • GET /api/v1/posts - 모든 게시글 조회
   • GET /api/v1/posts/:id - 특정 게시글 조회
   • POST /api/v1/posts - 게시글 작성 (인증 필요)
   • PUT /api/v1/posts/:id - 게시글 수정 (인증 필요)
   • DELETE /api/v1/posts/:id - 게시글 삭제 (인증 필요)
4. 댓글
   • GET /api/v1/posts/:id/comments - 게시글의 모든 댓글 조회
   • POST /api/v1/posts/:id/comments - 댓글 작성 (인증 필요)
   • PUT /api/v1/comments/:id - 댓글 수정 (인증 필요)
   • DELETE /api/v1/comments/:id - 댓글 삭제 (인증 필요)

8.4 핵심 코드 구현

이 프로젝트의 핵심 코드 일부를 구현해볼게요. 먼저 게시글 모델부터 살펴볼게요:

models/post.go

package models

import (
    "database/sql"
    "errors"
    "time"
)

// Post 구조체는 게시글 정보를 나타냅니다
type Post struct {
    ID        int       `json:"id"`
    UserID    int       `json:"user_id"`
    Title     string    `json:"title"`
    Content   string    `json:"content"`
    User      *User     `json:"user,omitempty"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}

// GetAllPosts 함수는 모든 게시글을 반환합니다
func GetAllPosts(page, limit int) ([]Post, error) {
    offset := (page - 1) * limit
    
    query := `
        SELECT p.id, p.user_id, p.title, p.content, p.created_at, p.updated_at,
               u.id, u.name, u.email, u.created_at, u.updated_at
        FROM posts p
        JOIN users u ON p.user_id = u.id
        ORDER BY p.created_at DESC
        LIMIT ? OFFSET ?
    `
    
    rows, err := DB.Query(query, limit, offset)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var posts []Post
    
    for rows.Next() {
        var post Post
        var user User
        
        err := rows.Scan(
            &post.ID, &post.UserID, &post.Title, &post.Content, &post.CreatedAt, &post.UpdatedAt,
            &user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt,
        )
        if err != nil {
            return nil, err
        }
        
        post.User = &user
        posts = append(posts, post)
    }
    
    return posts, nil
}

// GetPostByID 함수는 ID로 게시글을 조회합니다
func GetPostByID(id int) (Post, error) {
    query := `
        SELECT p.id, p.user_id, p.title, p.content, p.created_at, p.updated_at,
               u.id, u.name, u.email, u.created_at, u.updated_at
        FROM posts p
        JOIN users u ON p.user_id = u.id
        WHERE p.id = ?
    `
    
    var post Post
    var user User
    
    err := DB.QueryRow(query, id).Scan(
        &post.ID, &post.UserID, &post.Title, &post.Content, &post.CreatedAt, &post.UpdatedAt,
        &user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt,
    )
    
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return Post{}, errors.New("게시글을 찾을 수 없습니다")
        }
        return Post{}, err
    }
    
    post.User = &user
    return post, nil
}

// CreatePost 함수는 새 게시글을 생성합니다
func CreatePost(userID int, title, content string) (Post, error) {
    // 현재 시간
    now := time.Now()
    
    // 게시글 생성
    query := `INSERT INTO posts (user_id, title, content, created_at, updated_at) 
              VALUES (?, ?, ?, ?, ?)`
    
    result, err := DB.Exec(query, userID, title, content, now, now)
    if err != nil {
        return Post{}, err
    }
    
    // 생성된 ID 가져오기
    id, err := result.LastInsertId()
    if err != nil {
        return Post{}, err
    }
    
    // 생성된 게시글 반환
    return GetPostByID(int(id))
}

// UpdatePost 함수는 게시글 정보를 업데이트합니다
func UpdatePost(id, userID int, title, content string) (Post, error) {
    // 게시글 존재 및 소유권 확인
    post, err := GetPostByID(id)
    if err != nil {
        return Post{}, err
    }
    
    if post.UserID != userID {
        return Post{}, errors.New("이 게시글을 수정할 권한이 없습니다")
    }
    
    // 현재 시간
    now := time.Now()
    
    // 게시글 업데이트
    query := `UPDATE posts SET title = ?, content = ?, updated_at = ? WHERE id = ?`
    
    _, err = DB.Exec(query, title, content, now, id)
    if err != nil {
        return Post{}, err
    }
    
    // 업데이트된 게시글 반환
    return GetPostByID(id)
}

// DeletePost 함수는 게시글을 삭제합니다
func DeletePost(id, userID int) error {
    // 게시글 존재 및 소유권 확인
    post, err := GetPostByID(id)
    if err != nil {
        return err
    }
    
    if post.UserID != userID {
        return errors.New("이 게시글을 삭제할 권한이 없습니다")
    }
    
    // 게시글 삭제
    query := `DELETE FROM posts WHERE id = ?`
    
    _, err = DB.Exec(query, id)
    return err
}

controllers/post_controller.go

package controllers

import (
    "github.com/gin-gonic/gin"
    "github.com/yourusername/go-blog-api/models"
    "github.com/yourusername/go-blog-api/utils"
    "net/http"
    "strconv"
)

// GetPosts는 모든 게시글 목록을 반환합니다
func GetPosts(c *gin.Context) {
    // 페이지네이션 파라미터
    page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
    limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
    
    // 유효성 검사
    if page < 1 {
        page = 1
    }
    if limit < 1 || limit > 100 {
        limit = 10
    }
    
    posts, err := models.GetAllPosts(page, limit)
    if err != nil {
        utils.ResponseError(c, http.StatusInternalServerError, err.Error())
        return
    }
    
    utils.ResponseSuccess(c, http.StatusOK, gin.H{
        "posts": posts,
        "pagination": gin.H{
            "page":  page,
            "limit": limit,
        },
    })
}

// GetPost는 특정 ID의 게시글을 반환합니다
func GetPost(c *gin.Context) {
    idStr := c.Param("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        utils.ResponseError(c, http.StatusBadRequest, "잘못된 ID 형식입니다")
        return
    }
    
    post, err := models.GetPostByID(id)
    if err != nil {
        utils.ResponseError(c, http.StatusNotFound, err.Error())
        return
    }
    
    utils.ResponseSuccess(c, http.StatusOK, post)
}

// CreatePost는 새 게시글을 생성합니다
func CreatePost(c *gin.Context) {
    // 사용자 ID 가져오기 (미들웨어에서 설정됨)
    userID, exists := c.Get("userID")
    if !exists {
        utils.ResponseError(c, http.StatusUnauthorized, "인증이 필요합니다")
        return
    }
    
    var input struct {
        Title   string `json:"title" binding:"required,min=3,max=200"`
        Content string `json:"content" binding:"required"`
    }
    
    if err := c.ShouldBindJSON(&input); err != nil {
        utils.ResponseError(c, http.StatusBadRequest, err.Error())
        return
    }
    
    post, err := models.CreatePost(userID.(int), input.Title, input.Content)
    if err != nil {
        utils.ResponseError(c, http.StatusInternalServerError, err.Error())
        return
    }
    
    utils.ResponseSuccess(c, http.StatusCreated, post)
}

// UpdatePost는 특정 ID의 게시글 정보를 업데이트합니다
func UpdatePost(c *gin.Context) {
    // 사용자 ID 가져오기 (미들웨어에서 설정됨)
    userID, exists := c.Get("userID")
    if !exists {
        utils.ResponseError(c, http.StatusUnauthorized, "인증이 필요합니다")
        return
    }
    
    idStr := c.Param("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        utils.ResponseError(c, http.StatusBadRequest, "잘못된 ID 형식입니다")
        return
    }
    
    var input struct {
        Title   string `json:"title" binding:"required,min=3,max=200"`
        Content string `json:"content" binding:"required"`
    }
    
    if err := c.ShouldBindJSON(&input); err != nil {
        utils.ResponseError(c, http.StatusBadRequest, err.Error())
        return
    }
    
    post, err := models.UpdatePost(id, userID.(int), input.Title, input.Content)
    if err != nil {
        if err.Error() == "이 게시글을 수정할 권한이 없습니다" {
            utils.ResponseError(c, http.StatusForbidden, err.Error())
        } else if err.Error() == "게시글을 찾을 수 없습니다" {
            utils.ResponseError(c, http.StatusNotFound, err.Error())
        } else {
            utils.ResponseError(c, http.StatusInternalServerError, err.Error())
        }
        return
    }
    
    utils.ResponseSuccess(c, http.StatusOK, post)
}

// DeletePost는 특정 ID의 게시글을 삭제합니다
func DeletePost(c *gin.Context) {
    // 사용자 ID 가져오기 (미들웨어에서 설정됨)
    userID, exists := c.Get("userID")
    if !exists {
        utils.ResponseError(c, http.StatusUnauthorized, "인증이 필요합니다")
        return
    }
    
    idStr := c.Param("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        utils.ResponseError(c, http.StatusBadRequest, "잘못된 ID 형식입니다")
        return
    }
    
    err = models.DeletePost(id, userID.(int))
    if err != nil {
        if err.Error() == "이 게시글을 삭제할 권한이 없습니다" {
            utils.ResponseError(c, http.StatusForbidden, err.Error())
        } else if err.Error() == "게시글을 찾을 수 없습니다" {
            utils.ResponseError(c, http.StatusNotFound, err.Error())
        } else {
            utils.ResponseError(c, http.StatusInternalServerError, err.Error())
        }
        return
    }
    
    utils.ResponseSuccess(c, http.StatusOK, gin.H{
        "message": "게시글이 삭제되었습니다",
    })
}

utils/response.go

package utils

import (
    "github.com/gin-gonic/gin"
)

// ResponseSuccess 함수는 성공 응답을 반환합니다
func ResponseSuccess(c *gin.Context, statusCode int, data interface{}) {
    c.JSON(statusCode, gin.H{
        "success": true,
        "data":    data,
    })
}

// ResponseError 함수는 오류 응답을 반환합니다
func ResponseError(c *gin.Context, statusCode int, message string) {
    c.JSON(statusCode, gin.H{
        "success": false,
        "error":   message,
    })
}

routes/routes.go

package routes

import (
    "github.com/gin-gonic/gin"
    "github.com/yourusername/go-blog-api/controllers"
    "github.com/yourusername/go-blog-api/middleware"
)

// SetupRouter 함수는 모든 라우트를 설정합니다
func SetupRouter() *gin.Engine {
    r := gin.Default()
    
    // 기본 라우트
    r.GET("/", controllers.HelloWorld)
    
    // 인증 관련 라우트
    r.POST("/register", controllers.Register)
    r.POST("/login", controllers.Login)
    
    // API v1 그룹
    v1 := r.Group("/api/v1")
    {
        // 사용자 관련 엔드포인트
        users := v1.Group("/users")
        {
            users.GET("", controllers.GetUsers)
            users.GET("/:id", controllers.GetUser)
            
            // 인증이 필요한 엔드포인트
            authUsers := users.Group("")
            authUsers.Use(middleware.AuthRequired())
            {
                authUsers.PUT("/:id", controllers.UpdateUser)
                authUsers.DELETE("/:id", controllers.DeleteUser)
            }
        }
        
        // 게시글 관련 엔드포인트
        posts := v1.Group("/posts")
        {
            posts.GET("", controllers.GetPosts)
            posts.GET("/:id", controllers.GetPost)
            
            // 인증이 필요한 엔드포인트
            authPosts := posts.Group("")
            authPosts.Use(middleware.AuthRequired())
            {
                authPosts.POST("", controllers.CreatePost)
                authPosts.PUT("/:id", controllers.UpdatePost)
                authPosts.DELETE("/:id", controllers.DeletePost)
            }
            
            // 댓글 관련 엔드포인트
            comments := posts.Group("/:id/comments")
            {
                comments.GET("", controllers.GetComments)
                
                // 인증이 필요한 엔드포인트
                authComments := comments.Group("")
                authComments.Use(middleware.AuthRequired())
                {
                    authComments.POST("", controllers.CreateComment)
                }
            }
        }
        
        // 댓글 수정/삭제 엔드포인트
        comments := v1.Group("/comments")
        comments.Use(middleware.AuthRequired())
        {
            comments.PUT("/:id", controllers.UpdateComment)
            comments.DELETE("/:id", controllers.DeleteComment)
        }
    }
    
    return r
}

이렇게 하면 완전한 블로그 API가 구현되었어요! 이 API를 사용하면 사용자가 회원가입하고, 로그인하고, 게시글을 작성하고, 댓글을 달 수 있어요. 🎉

9. 마치며: Go로 RESTful API 개발의 장점 🏆

지금까지 Go 언어로 RESTful API를 개발하는 방법에 대해 알아봤어요. 마지막으로 Go로 API를 개발할 때의 장점을 정리해볼게요:

1. 뛰어난 성능 - Go는 컴파일 언어로, 인터프리터 언어보다 실행 속도가 빠르고 메모리 사용량이 적어요.
2. 간결한 문법 - Go의 문법은 단순하고 직관적이어서 배우기 쉽고 유지보수가 용이해요.
3. 강력한 동시성 처리 - 고루틴과 채널을 통해 동시에 많은 요청을 효율적으로 처리할 수 있어요.
4. 풍부한 표준 라이브러리 - HTTP 서버, JSON 처리 등 API 개발에 필요한 기능이 표준 라이브러리에 포함되어 있어요.
5. 정적 타입 시스템 - 컴파일 시점에 오류를 발견할 수 있어 런타임 오류를 줄일 수 있어요.
6. 크로스 플랫폼 지원 - 다양한 운영체제에서 실행 가능한 단일 바이너리로 컴파일되어 배포가 간편해요.
7. 활발한 커뮤니티 - 전 세계적으로 활발한 Go 커뮤니티가 있어 도움을 받기 쉬워요.

Go 언어는 특히 마이크로서비스 아키텍처와 클라우드 네이티브 애플리케이션 개발에 적합해요. Docker, Kubernetes, Prometheus 등 많은 클라우드 도구들이 Go로 작성되었다는 사실만 봐도 Go의 강점을 알 수 있죠!

여러분도 이제 Go로 RESTful API를 개발할 준비가 되었어요. 이 글에서 배운 내용을 바탕으로 자신만의 API를 만들어보세요. 혹시 프리랜서로 활동하고 싶다면, 재능넷(https://www.jaenung.net)에서 Go 개발 서비스를 제공해보는 것도 좋은 방법이에요! 😊

Go 언어의 마스코트인 고퍼(Gopher)처럼 열심히 코딩하다 보면 어느새 Go 전문가가 되어 있을 거예요. 화이팅! 💪

이 글이 여러분의 Go 언어 학습과 RESTful API 개발에 도움이 되었길 바라요. 궁금한 점이나 더 알고 싶은 내용이 있다면 언제든지 질문해주세요! 함께 성장하는 개발자 커뮤니티를 만들어가요. 👨‍💻👩‍💻

그럼 다음에 또 만나요! 안녕~ 👋