Go 에러처리 완전 정리

Go code

package main

import (
	"errors"
	"fmt"
)

// Sentinel error — 비교 가능한 에러 값
var (
	ErrNotFound   = errors.New("not found")
	ErrPermission = errors.New("permission denied")
)

// 커스텀 에러 타입
type NotFoundError struct {
	Resource string
	ID       int
}

func (e *NotFoundError) Error() string {
	return fmt.Sprintf("%s #%d를 찾을 수 없습니다", e.Resource, e.ID)
}

// 에러 래핑 (Go 1.13+)
func findUser(id int) (string, error) {
	if id <= 0 {
		return "", fmt.Errorf("잘못된 ID %d: %w", id, ErrNotFound)
	}
	if id > 100 {
		return "", &NotFoundError{"User", id}
	}
	return fmt.Sprintf("User#%d", id), nil
}

func main() {
	// 기본 에러 처리
	user, err := findUser(0)
	if err != nil {
		// errors.Is — Sentinel 에러 체인 검사
		if errors.Is(err, ErrNotFound) {
			fmt.Println("없음:", err)
		}
	} else {
		fmt.Println(user)
	}

	// errors.As — 특정 타입으로 언래핑
	_, err = findUser(999)
	var nfe *NotFoundError
	if errors.As(err, &nfe) {
		fmt.Printf("리소스: %s, ID: %d
", nfe.Resource, nfe.ID)
	}

	// 에러 무시 안 하기
	if _, err := findUser(1); err != nil {
		fmt.Println("예상치 못한 에러:", err)
	} else {
		fmt.Println("성공!")
	}

	// fmt.Errorf + %w로 컨텍스트 추가
	err = fmt.Errorf("서비스 레이어: %w",
		fmt.Errorf("저장소 레이어: %w", ErrNotFound))
	fmt.Println(err)
	fmt.Println(errors.Is(err, ErrNotFound)) // true (체인 탐색)
}

Go code

// go get golang.org/x/sync/errgroup
package main

import (
	"context"
	"fmt"
	"golang.org/x/sync/errgroup"
	"time"
)

func fetchURL(ctx context.Context, url string) (string, error) {
	// 컨텍스트 취소 확인
	select {
	case <-ctx.Done():
		return "", ctx.Err()
	case <-time.After(100 * time.Millisecond):
	}
	if url == "bad-url" {
		return "", fmt.Errorf("fetch 실패: %s", url)
	}
	return "data:" + url, nil
}

func main() {
	// 기본 errgroup
	g := new(errgroup.Group)
	results := make([]string, 3)
	urls := []string{"url1", "url2", "url3"}

	for i, url := range urls {
		i, url := i, url // 캡처
		g.Go(func() error {
			data, err := fetchURL(context.Background(), url)
			if err != nil { return err }
			results[i] = data
			return nil
		})
	}

	if err := g.Wait(); err != nil {
		fmt.Println("에러:", err)
	} else {
		fmt.Println("결과:", results)
	}

	// context와 함께 — 하나 실패 시 나머지 취소
	g2, ctx := errgroup.WithContext(context.Background())
	badURLs := []string{"url1", "bad-url", "url3"}

	for _, url := range badURLs {
		url := url
		g2.Go(func() error {
			_, err := fetchURL(ctx, url)
			return err
		})
	}

	if err := g2.Wait(); err != nil {
		fmt.Println("그룹 에러:", err)
	}
}

Go code

<span class="cm">// net/http ServeMux 개선 (1.22+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("net/http ServeMux 개선 (1.22+)") }

Go code

package main

import (
	"errors"
	"fmt"
)

var ErrDB = errors.New("데이터베이스 오류")

func queryDB() error {
	return ErrDB
}

func getUser(id int) error {
	if err := queryDB(); err != nil {
		return fmt.Errorf("getUser(%d): %w", id, err)
	}
	return nil
}

func handleRequest() error {
	if err := getUser(42); err != nil {
		return fmt.Errorf("handleRequest: %w", err)
	}
	return nil
}

func main() {
	err := handleRequest()
	fmt.Println(err)
	// handleRequest: getUser(42): 데이터베이스 오류

	// 체인을 따라 원인 추적
	fmt.Println(errors.Is(err, ErrDB)) // true

	// Unwrap 체인
	for err != nil {
		fmt.Println("→", err)
		err = errors.Unwrap(err)
	}
}

Go code

package main

import (
	"errors"
	"fmt"
)

func validateForm(name, email string, age int) error {
	var errs []error

	if name == "" {
		errs = append(errs, fmt.Errorf("이름은 필수입니다"))
	}
	if email == "" {
		errs = append(errs, fmt.Errorf("이메일은 필수입니다"))
	}
	if age < 0 {
		errs = append(errs, fmt.Errorf("나이는 0 이상이어야 합니다"))
	}

	return errors.Join(errs...)
}

var ErrRequired = errors.New("필수 필드 누락")

func main() {
	err := validateForm("", "", -1)
	if err != nil {
		fmt.Println("검증 에러:")
		fmt.Println(err)
		// 이름은 필수입니다
		// 이메일은 필수입니다
		// 나이는 0 이상이어야 합니다
	}

	// nil 에러는 무시됨
	err2 := errors.Join(nil, nil)
	fmt.Println(err2 == nil) // true
}

Go code

package main

import (
	"errors"
	"fmt"
)

// 센티널 에러 정의
var (
	ErrNotFound     = errors.New("리소스를 찾을 수 없음")
	ErrUnauthorized = errors.New("인증 실패")
	ErrForbidden    = errors.New("권한 없음")
	ErrConflict     = errors.New("리소스 충돌")
)

func findItem(id string) error {
	if id == "" {
		return fmt.Errorf("findItem: %w", ErrNotFound)
	}
	return nil
}

func handleError(err error) {
	switch {
	case errors.Is(err, ErrNotFound):
		fmt.Println("404: 찾을 수 없음")
	case errors.Is(err, ErrUnauthorized):
		fmt.Println("401: 인증 필요")
	case errors.Is(err, ErrForbidden):
		fmt.Println("403: 접근 거부")
	default:
		fmt.Println("500: 내부 서버 오류")
	}
}

func main() {
	err := findItem("")
	handleError(err) // 404: 찾을 수 없음
}

Go code

package main

import (
	"errors"
	"fmt"
	"time"
)

type AppError struct {
	Code    int
	Message string
	Op      string // 실패한 작업
	Time    time.Time
	Err     error // 원인 에러
}

func (e *AppError) Error() string {
	return fmt.Sprintf("[%d] %s: %s", e.Code, e.Op, e.Message)
}

func (e *AppError) Unwrap() error { return e.Err }

func newAppError(code int, op, msg string, err error) *AppError {
	return &AppError{
		Code: code, Message: msg,
		Op: op, Time: time.Now(), Err: err,
	}
}

func fetchData() error {
	return newAppError(503, "fetchData", "서비스 불가", nil)
}

func main() {
	err := fetchData()
	fmt.Println(err)

	var appErr *AppError
	if errors.As(err, &appErr) {
		fmt.Printf("코드: %d, 작업: %s, 시각: %s\n",
			appErr.Code, appErr.Op, appErr.Time.Format("15:04:05"))
	}
}

Go code

package main

import "fmt"

// recover는 반드시 defer에서 호출
func safeDiv(a, b int) (result int, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("패닉 복구: %v", r)
		}
	}()

	return a / b, nil // b==0이면 패닉
}

// 미들웨어에서 패닉 복구
func withRecover(fn func()) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("복구됨: %v\n", r)
		}
	}()
	fn()
}

func main() {
	result, err := safeDiv(10, 0)
	if err != nil {
		fmt.Println(err) // 패닉 복구: runtime error: integer divide by zero
	} else {
		fmt.Println(result)
	}

	withRecover(func() {
		panic("의도적 패닉!")
	})

	fmt.Println("프로그램 계속 실행")
}

Go code

package main

import (
	"errors"
	"log/slog"
	"os"
)

func main() {
	// 구조화된 로거 생성
	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
		Level: slog.LevelDebug,
	}))

	// 레벨별 로깅
	logger.Debug("디버그 메시지", "module", "auth")
	logger.Info("사용자 로그인", "user_id", 42, "ip", "192.168.1.1")
	logger.Warn("느린 쿼리", "duration_ms", 500, "query", "SELECT...")

	// 에러 로깅
	err := errors.New("연결 실패")
	logger.Error("DB 에러", "error", err, "retry", 3)

	// 그룹 로깅
	logger.WithGroup("request").Info("요청 처리",
		"method", "POST",
		"path", "/api/users",
		"status", 201,
	)

	// 기본 로거 교체
	slog.SetDefault(logger)
	slog.Info("기본 로거 사용", "app", "myapp")
}

Go code

package main

import (
	"errors"
	"fmt"
	"log/slog"
)

type HTTPError struct {
	Code    int
	Message string
	Err     error
}

func (e *HTTPError) Error() string { return e.Message }
func (e *HTTPError) Unwrap() error { return e.Err }

var (
	ErrNotFound = &HTTPError{Code: 404, Message: "리소스 없음"}
	ErrBadReq   = &HTTPError{Code: 400, Message: "잘못된 요청"}
)

// 에러를 반환하는 핸들러 타입
type AppHandler func(req string) (string, error)

// 에러 미들웨어
func errorMiddleware(h AppHandler) func(string) string {
	return func(req string) string {
		result, err := h(req)
		if err != nil {
			var httpErr *HTTPError
			if errors.As(err, &httpErr) {
				slog.Error("HTTP 에러", "code", httpErr.Code, "msg", httpErr.Message)
				return fmt.Sprintf("%d: %s", httpErr.Code, httpErr.Message)
			}
			slog.Error("내부 에러", "error", err)
			return "500: 내부 서버 오류"
		}
		return result
	}
}

func main() {
	handler := func(req string) (string, error) {
		if req == "" { return "", fmt.Errorf("빈 요청: %w", ErrBadReq) }
		return "OK: " + req, nil
	}

	wrapped := errorMiddleware(handler)
	fmt.Println(wrapped("hello"))
	fmt.Println(wrapped(""))
}

Go code

package main

import (
	"fmt"
	"strings"
)

type FieldError struct {
	Field   string
	Message string
}

type ValidationErrors []FieldError

func (ve ValidationErrors) Error() string {
	msgs := make([]string, len(ve))
	for i, e := range ve {
		msgs[i] = fmt.Sprintf("%s: %s", e.Field, e.Message)
	}
	return strings.Join(msgs, "; ")
}

func (ve ValidationErrors) HasErrors() bool { return len(ve) > 0 }

type UserInput struct {
	Name  string
	Email string
	Age   int
}

func (u UserInput) Validate() error {
	var errs ValidationErrors
	if u.Name == "" {
		errs = append(errs, FieldError{"name", "필수 항목입니다"})
	}
	if !strings.Contains(u.Email, "@") {
		errs = append(errs, FieldError{"email", "유효한 이메일이 아닙니다"})
	}
	if u.Age < 0 || u.Age > 150 {
		errs = append(errs, FieldError{"age", "0~150 범위여야 합니다"})
	}
	if errs.HasErrors() { return errs }
	return nil
}

func main() {
	input := UserInput{Name: "", Email: "invalid", Age: -1}
	if err := input.Validate(); err != nil {
		fmt.Println(err)
		if ve, ok := err.(ValidationErrors); ok {
			for _, e := range ve {
				fmt.Printf("  필드 '%s': %s\n", e.Field, e.Message)
			}
		}
	}
}

Go code

package main

import (
	"fmt"
	"net"
)

// 재시도 가능한 에러 인터페이스
type Retryable interface {
	error
	IsRetryable() bool
}

type TempError struct{ Msg string }
func (e *TempError) Error() string   { return e.Msg }
func (e *TempError) IsRetryable() bool { return true }

type FatalError struct{ Msg string }
func (e *FatalError) Error() string   { return e.Msg }
func (e *FatalError) IsRetryable() bool { return false }

func handleWithRetry(err error, maxRetries int) {
	if r, ok := err.(Retryable); ok && r.IsRetryable() {
		fmt.Printf("재시도 가능: %s (최대 %d회)\n", err, maxRetries)
		return
	}
	fmt.Printf("치명적 에러: %s\n", err)
}

func main() {
	handleWithRetry(&TempError{"일시적 네트워크 오류"}, 3)
	handleWithRetry(&FatalError{"설정 파일 없음"}, 3)

	// 표준 라이브러리의 예: net.Error
	var netErr net.Error
	_ = netErr // Timeout() bool, Temporary() bool 메서드 보유
}

Go code

package main

import (
	"errors"
	"fmt"
)

var (
	ErrAuth = errors.New("인증 실패")
	ErrPerm = errors.New("권한 없음")
)

func main() {
	// 단일 래핑
	err1 := fmt.Errorf("로그인: %w", ErrAuth)
	fmt.Println(errors.Is(err1, ErrAuth)) // true

	// Go 1.20+: 다중 래핑
	err2 := fmt.Errorf("접근 거부: %w, %w", ErrAuth, ErrPerm)
	fmt.Println(errors.Is(err2, ErrAuth)) // true
	fmt.Println(errors.Is(err2, ErrPerm)) // true

	// %v vs %w
	err3 := fmt.Errorf("에러: %v", ErrAuth) // 래핑 안 됨
	fmt.Println(errors.Is(err3, ErrAuth))    // false

	err4 := fmt.Errorf("에러: %w", ErrAuth)  // 래핑됨
	fmt.Println(errors.Is(err4, ErrAuth))     // true

	// 중첩 래핑
	inner := fmt.Errorf("DB: %w", ErrAuth)
	outer := fmt.Errorf("서비스: %w", inner)
	fmt.Println(errors.Is(outer, ErrAuth)) // true (체인 탐색)
}