Go 파일/IO 완전 정리

Go code

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	// 파일 쓰기
	err := os.WriteFile("test.txt",
		[]byte("Hello\nGo\nWorld\n"), 0644)
	if err != nil { panic(err) }

	// 파일 읽기 (전체)
	data, err := os.ReadFile("test.txt")
	if err != nil { panic(err) }
	fmt.Print(string(data))

	// bufio로 줄 단위 읽기 (대용량 파일에 적합)
	f, err := os.Open("test.txt")
	if err != nil { panic(err) }
	defer f.Close()

	scanner := bufio.NewScanner(f)
	lineNum := 0
	for scanner.Scan() {
		lineNum++
		line := scanner.Text()
		fmt.Printf("%d: %s\n", lineNum, line)
	}
	if err := scanner.Err(); err != nil {
		fmt.Println("읽기 에러:", err)
	}

	// 파일 추가 쓰기 (append)
	af, err := os.OpenFile("test.txt",
		os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil { panic(err) }
	defer af.Close()
	fmt.Fprintln(af, "추가된 줄")

	// strings.NewReader — 문자열을 io.Reader로
	r := strings.NewReader("hello world")
	bufReader := bufio.NewReader(r)
	word, _ := bufReader.ReadString(' ')
	fmt.Printf("첫 단어: %q
", strings.TrimSpace(word))

	// 환경 변수
	home := os.Getenv("HOME")
	fmt.Println("홈 디렉토리:", home)

	// 임시 파일
	tmp, err := os.CreateTemp("", "myapp-*.txt")
	if err != nil { panic(err) }
	defer os.Remove(tmp.Name())
	fmt.Println("임시 파일:", tmp.Name())
	tmp.Close()
}

Go code

package main

import (
	"encoding/json"
	"fmt"
)

type Address struct {
	City    string `json:"city"`
	Country string `json:"country"`
}

type User struct {
	ID        int       `json:"id"`
	Name      string    `json:"name"`
	Email     string    `json:"email,omitempty"`  // 빈 값 생략
	Password  string    `json:"-"`                // JSON 제외
	Address   Address   `json:"address"`
	Tags      []string  `json:"tags,omitempty"`
}

func main() {
	// 인코딩 (Marshal)
	user := User{
		ID:    1,
		Name:  "Alice",
		Email: "alice@test.com",
		Address: Address{"Seoul", "Korea"},
		Tags:  []string{"admin", "dev"},
	}

	data, err := json.Marshal(user)
	if err != nil { panic(err) }
	fmt.Println(string(data))

	// 들여쓰기 있는 JSON
	pretty, _ := json.MarshalIndent(user, "", "  ")
	fmt.Println(string(pretty))

	// 디코딩 (Unmarshal)
	jsonStr := `{"id":2,"name":"Bob","address":{"city":"Busan","country":"Korea"}}`
	var decoded User
	if err := json.Unmarshal([]byte(jsonStr), &decoded); err != nil {
		panic(err)
	}
	fmt.Printf("이름: %s, 도시: %s
", decoded.Name, decoded.Address.City)

	// 동적 JSON — map 사용
	var dynamic map[string]interface{}
	json.Unmarshal([]byte(jsonStr), &dynamic)
	fmt.Println("name:", dynamic["name"])

	// json.Decoder — 스트림 디코딩
	// decoder := json.NewDecoder(r)
	// decoder.Decode(&obj)
}

Go code

package main

import (
	"embed"
	"fmt"
	"io/fs"
	"net/http"
	"text/template"
)

// 1. 단일 파일 임베딩 (문자열)
//go:embed config.txt
var configStr string

// 2. 단일 파일 임베딩 (바이트 슬라이스)
//go:embed logo.png
var logoBytes []byte

// 3. 디렉터리 임베딩
//go:embed templates/*
var templateFS embed.FS

// 4. 여러 패턴 임베딩
//go:embed static/*.css static/*.js
var staticFS embed.FS

// 실전 예: 템플릿 렌더링
func renderTemplate(name string, data interface{}) (string, error) {
	tmplData, err := templateFS.ReadFile("templates/" + name)
	if err != nil {
		return "", fmt.Errorf("템플릿 읽기 실패: %w", err)
	}
	tmpl, err := template.New(name).Parse(string(tmplData))
	if err != nil {
		return "", fmt.Errorf("템플릿 파싱 실패: %w", err)
	}
	var buf strings.Builder
	err = tmpl.Execute(&buf, data)
	return buf.String(), err
}

// 실전 예: 정적 파일 서버
func staticFileServer() http.Handler {
	// embed.FS에서 서브디렉터리 추출
	subFS, _ := fs.Sub(staticFS, "static")
	return http.FileServer(http.FS(subFS))
}

func main() {
	// 임베딩된 파일 정보
	fmt.Println("=== 설정 파일 ===")
	fmt.Println(configStr)

	fmt.Printf("\n=== 로고 크기: %d bytes ===\n", len(logoBytes))

	// 임베딩된 디렉터리 순회
	fmt.Println("\n=== 임베딩된 파일 목록 ===")
	fs.WalkDir(templateFS, ".", func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !d.IsDir() {
			info, _ := d.Info()
			fmt.Printf("  %s (%d bytes)\n", path, info.Size())
		}
		return nil
	})

	// HTTP 서버 예제
	fmt.Println("\n정적 파일 서버: http://localhost:8080/static/")
	// http.Handle("/static/", http.StripPrefix("/static/", staticFileServer()))
	// http.ListenAndServe(":8080", nil)
}

Go code

package main

import (
	"fmt"
	"os"
)

func main() {
	// 파일 쓰기 (간단한 방법)
	data := []byte("Hello, Go 파일!")
	err := os.WriteFile("test.txt", data, 0644)
	if err != nil { panic(err) }

	// 파일 읽기 (간단한 방법)
	content, err := os.ReadFile("test.txt")
	if err != nil { panic(err) }
	fmt.Println(string(content))

	// os.OpenFile로 세밀한 제어
	f, err := os.OpenFile("log.txt",
		os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil { panic(err) }
	defer f.Close()

	f.WriteString("로그 메시지\n")
	fmt.Println("파일 작성 완료")

	// 정리
	os.Remove("test.txt")
	os.Remove("log.txt")
}

Go code

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	// 문자열 리더로 데모
	input := "첫 번째 줄\n두 번째 줄\n세 번째 줄\n"
	reader := bufio.NewReader(strings.NewReader(input))

	for {
		line, err := reader.ReadString('\n')
		line = strings.TrimRight(line, "\n")
		if line != "" {
			fmt.Println("읽음:", line)
		}
		if err != nil { break }
	}

	// Scanner (줄 단위 읽기에 최적)
	scanner := bufio.NewScanner(strings.NewReader(input))
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024) // 최대 1MB
	lineNum := 0
	for scanner.Scan() {
		lineNum++
		fmt.Printf("%d: %s\n", lineNum, scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "읽기 에러:", err)
	}
}

Go code

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Email    string   `json:"email,omitempty"`
	Password string   `json:"-"`          // JSON에서 제외
	Tags     []string `json:"tags,omitempty"`
}

func main() {
	// 마샬링 (구조체 → JSON)
	user := User{ID: 1, Name: "Gopher", Password: "secret"}
	data, _ := json.MarshalIndent(user, "", "  ")
	fmt.Println(string(data))

	// 언마샬링 (JSON → 구조체)
	jsonStr := `{"id":2,"name":"Rustacean","email":"r@go.dev","tags":["dev"]}`
	var u2 User
	json.Unmarshal([]byte(jsonStr), &u2)
	fmt.Printf("%+v\n", u2)

	// map으로 동적 JSON 처리
	var m map[string]any
	json.Unmarshal([]byte(jsonStr), &m)
	fmt.Println("동적:", m["name"])
}

Go code

package main

import "fmt"

// YAML 예시 (gopkg.in/yaml.v3 사용)
// import "gopkg.in/yaml.v3"
type Config struct {
	Server struct {
		Host string `yaml:"host"`
		Port int    `yaml:"port"`
	} `yaml:"server"`
	Database struct {
		DSN     string `yaml:"dsn"`
		MaxConn int    `yaml:"max_conn"`
	} `yaml:"database"`
}

func main() {
	// YAML 문자열 예시
	yamlData := `
server:
  host: localhost
  port: 8080
database:
  dsn: postgres://localhost/mydb
  max_conn: 10
`

	// TOML 문자열 예시
	tomlData := `
[server]
host = "localhost"
port = 8080

[database]
dsn = "postgres://localhost/mydb"
max_conn = 10
`

	fmt.Println("YAML 설정:", yamlData)
	fmt.Println("TOML 설정:", tomlData)
	// 실제 파싱: yaml.Unmarshal([]byte(yamlData), &config)
	// 실제 파싱: toml.Unmarshal([]byte(tomlData), &config)
}

Go code

package main

import (
	"encoding/csv"
	"fmt"
	"strings"
)

func main() {
	// CSV 읽기
	csvData := "이름,나이,도시\n김철수,30,서울\n이영희,25,부산\n"
	reader := csv.NewReader(strings.NewReader(csvData))

	// 헤더 읽기
	header, _ := reader.Read()
	fmt.Println("헤더:", header)

	// 모든 레코드 읽기
	records, _ := reader.ReadAll()
	for _, record := range records {
		fmt.Printf("이름: %s, 나이: %s, 도시: %s\n",
			record[0], record[1], record[2])
	}

	// CSV 쓰기
	var buf strings.Builder
	writer := csv.NewWriter(&buf)
	writer.Write([]string{"제품", "가격", "수량"})
	writer.Write([]string{"Go 책", "35000", "10"})
	writer.Write([]string{"키보드", "89000", "5"})
	writer.Flush()

	fmt.Println("\n생성된 CSV:")
	fmt.Println(buf.String())
}

Go code

package main

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

func main() {
	// 커스텀 클라이언트 (타임아웃 필수!)
	client := &http.Client{
		Timeout: 10 * time.Second,
	}

	// GET 요청
	resp, err := client.Get("https://httpbin.org/get")
	if err != nil {
		fmt.Println("에러:", err)
		return
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Printf("상태: %d, 크기: %d bytes\n", resp.StatusCode, len(body))

	// context로 취소 가능한 요청
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	req, _ := http.NewRequestWithContext(ctx, "GET", "https://httpbin.org/get", nil)
	req.Header.Set("Accept", "application/json")

	resp2, err := client.Do(req)
	if err != nil {
		fmt.Println("에러:", err)
		return
	}
	defer resp2.Body.Close()
	fmt.Println("상태:", resp2.StatusCode)
}

Go code

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"os/signal"
	"syscall"
	"time"
)

func jsonResponse(w http.ResponseWriter, status int, data any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(data)
}

func main() {
	mux := http.NewServeMux()

	// Go 1.22+ 패턴 매칭
	mux.HandleFunc("GET /api/health", func(w http.ResponseWriter, r *http.Request) {
		jsonResponse(w, 200, map[string]string{"status": "ok"})
	})

	mux.HandleFunc("GET /api/users/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")
		jsonResponse(w, 200, map[string]string{"id": id})
	})

	srv := &http.Server{
		Addr:         ":8080",
		Handler:      mux,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}

	// 그레이스풀 셧다운
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	go func() { fmt.Println("서버 시작 :8080"); srv.ListenAndServe() }()
	<-ctx.Done()
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	srv.Shutdown(shutdownCtx)
	fmt.Println("서버 종료")
}

Go code

package main

import (
	"fmt"
	"log/slog"
	"net/http"
	"time"
)

type Middleware func(http.Handler) http.Handler

func Chain(h http.Handler, mws ...Middleware) http.Handler {
	for i := len(mws) - 1; i >= 0; i-- {
		h = mws[i](h)
	}
	return h
}

func Logger(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		next.ServeHTTP(w, r)
		slog.Info("요청", "method", r.Method,
			"path", r.URL.Path, "duration", time.Since(start))
	})
}

func CORS(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE")
		if r.Method == "OPTIONS" {
			w.WriteHeader(204)
			return
		}
		next.ServeHTTP(w, r)
	})
}

func Recovery(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				slog.Error("패닉 복구", "error", err)
				http.Error(w, "Internal Server Error", 500)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello!")
	})

	handler := Chain(mux, Recovery, Logger, CORS)
	fmt.Println("미들웨어 체인: Recovery → Logger → CORS → Handler")
	_ = handler // http.ListenAndServe(":8080", handler)
}

Go code

package main

import (
	"html/template"
	"os"
)

const tmpl = `<!DOCTYPE html>
<html>
<head><title>{{.Title}}</title></head>
<body>
  <h1>{{.Title}}</h1>
  {{range .Items}}
    <div class="item">
      <strong>{{.Name}}</strong>: {{.Price}}원
    </div>
  {{end}}
  {{if .ShowFooter}}
    <footer>© 2024</footer>
  {{end}}
  <!-- XSS 자동 이스케이프 -->
  <p>입력: {{.UserInput}}</p>
</body>
</html>`

type PageData struct {
	Title      string
	Items      []struct{ Name string; Price int }
	ShowFooter bool
	UserInput  string
}

func main() {
	t := template.Must(template.New("page").Parse(tmpl))

	data := PageData{
		Title: "상품 목록",
		Items: []struct{ Name string; Price int }{
			{"Go 책", 35000}, {"키보드", 89000},
		},
		ShowFooter: true,
		UserInput:  "<script>alert('xss')</script>",
	}

	t.Execute(os.Stdout, data)
}

Go code

package main

import (
	"context"
	"database/sql"
	"fmt"
	"time"
	// _ "github.com/lib/pq" // PostgreSQL 드라이버
)

func example(db *sql.DB) {
	ctx := context.Background()

	// 커넥션 풀 설정
	db.SetMaxOpenConns(25)
	db.SetMaxIdleConns(5)
	db.SetConnMaxLifetime(5 * time.Minute)

	// 단일 행 조회
	var name string
	err := db.QueryRowContext(ctx,
		"SELECT name FROM users WHERE id = $1", 1).Scan(&name)
	if err == sql.ErrNoRows {
		fmt.Println("사용자 없음")
	} else if err != nil {
		fmt.Println("에러:", err)
	}

	// 여러 행 조회
	rows, _ := db.QueryContext(ctx, "SELECT id, name FROM users")
	defer rows.Close()
	for rows.Next() {
		var id int
		var n string
		rows.Scan(&id, &n)
		fmt.Printf("ID: %d, Name: %s\n", id, n)
	}

	// 트랜잭션
	tx, _ := db.BeginTx(ctx, nil)
	defer tx.Rollback() // 커밋 안 되면 자동 롤백
	tx.ExecContext(ctx, "INSERT INTO users(name) VALUES($1)", "Gopher")
	tx.Commit()
}

func main() {
	// db, _ := sql.Open("postgres", "postgres://localhost/mydb?sslmode=disable")
	// defer db.Close()
	// example(db)
	fmt.Println("database/sql 패턴: 커넥션 풀, 쿼리, 트랜잭션")
}

Go code

package main

import (
	"embed"
	"fmt"
	"io/fs"
)

// 단일 파일 임베딩
//go:embed go.mod
var modFile string

// 여러 파일 임베딩
//go:embed data/*.sql
var sqlFiles embed.FS

// 전체 디렉토리
//go:embed static
var staticFS embed.FS

func main() {
	// 문자열로 직접 사용
	fmt.Println("go.mod 내용:")
	fmt.Println(modFile)

	// embed.FS로 파일 시스템 접근
	entries, _ := fs.ReadDir(sqlFiles, "data")
	for _, e := range entries {
		fmt.Println("SQL 파일:", e.Name())
		content, _ := sqlFiles.ReadFile("data/" + e.Name())
		fmt.Println(string(content))
	}

	// http.FS와 연동
	// http.Handle("/static/",
	//     http.StripPrefix("/static/",
	//         http.FileServer(http.FS(staticFS))))
	fmt.Println("embed.FS는 io/fs.FS 인터페이스를 구현합니다")
}

Go code

package main

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

// 에러를 반환하는 핸들러
type AppHandler func(w http.ResponseWriter, r *http.Request) error

func (fn AppHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if err := fn(w, r); err != nil {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(500)
		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
	}
}

// 핸들러 그룹 (의존성 주입)
type Handlers struct {
	// db *sql.DB  // 실제 의존성
}

func (h *Handlers) GetUser(w http.ResponseWriter, r *http.Request) error {
	id := r.PathValue("id")
	if id == "" {
		http.Error(w, "ID 필요", 400)
		return nil
	}
	w.Header().Set("Content-Type", "application/json")
	return json.NewEncoder(w).Encode(map[string]string{
		"id": id, "name": "Gopher",
	})
}

func (h *Handlers) CreateUser(w http.ResponseWriter, r *http.Request) error {
	var input struct{ Name string }
	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
		http.Error(w, "잘못된 JSON", 400)
		return nil
	}
	w.WriteHeader(201)
	return json.NewEncoder(w).Encode(input)
}

func main() {
	h := &Handlers{}
	mux := http.NewServeMux()
	mux.Handle("GET /api/users/{id}", AppHandler(h.GetUser))
	mux.Handle("POST /api/users", AppHandler(h.CreateUser))

	fmt.Println("구조화된 HTTP 서버 패턴")
	// http.ListenAndServe(":8080", mux)
}