Go 언어로 배우는 디자인 패턴 🚀

안녕하세요, 여러분! 오늘은 정말 흥미진진한 주제로 여러분과 함께할 거예요. 바로 "Go 언어로 배우는 디자인 패턴"! 😎 이거 완전 꿀잼 아니겠어요? ㅋㅋㅋ

Go 언어, 들어보셨죠? 구글에서 만든 이 쿨한 언어가 요즘 개발자들 사이에서 대세라고 해도 과언이 아니에요. 그런데 여기에 디자인 패턴까지 더하면? 와우, 그야말로 개발계의 핫한 조합이 탄생하는 거죠! 👏

이 글에서는 Go 언어의 특징을 살려가며 다양한 디자인 패턴을 적용하는 방법을 알아볼 거예요. 마치 레고 블록을 조립하듯, 코드의 구조를 탄탄하게 만들어가는 과정을 함께 경험해보시죠!

아! 그리고 잠깐, 여러분 혹시 재능넷이라는 사이트 아세요? 개발 관련 지식이나 스킬을 공유하고 싶으신 분들께 완전 강추예요! 이런 Go 언어나 디자인 패턴 관련 지식도 재능넷에서 공유하면 좋을 것 같아요. 함께 성장하는 개발자 커뮤니티, 어때요? 짱이지 않나요? 😉

자, 이제 본격적으로 Go 언어의 세계로 빠져볼까요? 준비되셨나요? 그럼 고고씽~! 🏃‍♂️💨

1. Go 언어, 너 도대체 뭐니? 🤔

자, 먼저 Go 언어에 대해 간단히 알아볼까요? Go는 구글에서 2009년에 만든 프로그래밍 언어예요. C언어의 단순함과 현대 언어의 편의성을 결합했다고 하는데, 이게 무슨 말일까요?

Go 언어의 특징:

심플한 문법 (C 스타일이지만 더 간결해요!)
빠른 컴파일 속도 (기다리다 지치신 분들 주목!)
가비지 컬렉션 (메모리 관리? 알아서 해줘요~)
동시성 지원 (goroutine과 channel, 이게 바로 Go의 매력!)
정적 타입 (타입 안정성 굿!)

이런 특징들 때문에 Go는 특히 서버 사이드 프로그래밍이나 네트워크 프로그래밍에서 인기 만점이에요. 성능도 좋고, 배우기도 쉽고, 코드 작성도 빠르니까 완전 개발자 친화적이죠! 👍

그런데 여기서 잠깐! Go 언어가 이렇게 좋다고 해서 다른 언어들은 버리라는 말은 절대 아니에요. 각 언어마다 장단점이 있고, 상황에 따라 적절한 도구를 선택하는 게 중요해요. 마치 재능넷에서 다양한 재능을 거래하듯이, 프로그래밍 세계에서도 다양성이 중요하답니다. 😊

자, 이제 Go 언어에 대해 조금은 감이 오시나요? 그럼 이제 본격적으로 디자인 패턴으로 넘어가볼까요? Go로 구현하는 디자인 패턴, 얼마나 멋질지 기대되지 않나요? ㅋㅋㅋ

이 그림을 보면 Go 언어의 특징이 한눈에 들어오죠? 간결하면서도 강력한, 그게 바로 Go예요! 😎

2. 디자인 패턴이 뭐길래? 🧐

자, 이제 디자인 패턴에 대해 알아볼 차례예요. 디자인 패턴이라고 하면 뭔가 어려울 것 같죠? 근데 사실 그렇게 어렵지 않아요! 쉽게 말해서 디자인 패턴은 코드를 작성할 때 자주 발생하는 문제들을 해결하기 위한 일종의 '레시피'라고 할 수 있어요.

예를 들어볼까요? 여러분이 요리사라고 생각해보세요. 매번 음식을 만들 때마다 새로운 방법을 고민하지 않잖아요? 이미 검증된 레시피를 따라하면서 약간의 변형을 주는 식이죠. 디자인 패턴도 마찬가지예요. 선배 개발자들이 "아, 이런 상황에서는 이렇게 코드를 짜면 좋더라~"하고 정리해놓은 거예요.

디자인 패턴의 장점:

검증된 솔루션 제공 (선배들의 지혜를 빌리는 거죠!)
코드의 재사용성 증가 (반복작업? No thanks!)
유지보수 용이 (나중에 고치기 쉬워요~)
개발자 간 소통 개선 ("이거 싱글톤 패턴이야~" 하면 다들 알아듣죠)

그런데 여기서 주의할 점! 디자인 패턴이 만능은 아니에요. 과도하게 사용하면 오히려 코드가 복잡해질 수 있어요. 마치 요리에 양념을 너무 많이 넣으면 맛이 없어지는 것처럼요. 적재적소에 사용하는 게 중요해요!

디자인 패턴은 크게 세 가지 카테고리로 나눌 수 있어요:

생성 패턴 (Creational Patterns): 객체 생성과 관련된 패턴
구조 패턴 (Structural Patterns): 클래스나 객체를 조합해 더 큰 구조를 만드는 패턴
행동 패턴 (Behavioral Patterns): 객체들이 서로 상호작용하는 방법과 책임을 분산하는 방법을 다루는 패턴

이렇게 나누어져 있지만, 실제로는 이 패턴들이 서로 얽혀 사용되는 경우가 많아요. 마치 재능넷에서 다양한 재능들이 서로 연결되어 시너지를 내는 것처럼요! 😉

자, 이제 디자인 패턴에 대해 조금은 감이 오시나요? 그럼 이제 본격적으로 Go 언어로 이 디자인 패턴들을 어떻게 구현하는지 살펴볼까요? 준비되셨나요? Let's Go! (어떠세요, 이 언어유희? ㅋㅋㅋ)

이 그림을 보면 디자인 패턴의 세 가지 카테고리가 어떻게 연결되어 있는지 한눈에 볼 수 있죠? 각각의 패턴들이 서로 연결되어 더 큰 그림을 만들어내는 거예요. 멋지지 않나요? 😊

3. Go로 구현하는 생성 패턴 🏗️

자, 이제 본격적으로 Go 언어로 디자인 패턴을 구현해볼 거예요. 먼저 생성 패턴부터 시작해볼까요? 생성 패턴은 객체를 생성하는 다양한 방법을 제공하는 패턴이에요. 객체를 직접 new 키워드로 생성하는 대신, 더 유연하고 상황에 맞는 방식으로 객체를 만들 수 있게 해주죠.

Go에서 자주 사용되는 생성 패턴들을 하나씩 살펴볼게요. 준비되셨나요? 고고씽~! 🚀

3.1 싱글톤 패턴 (Singleton Pattern) 👑

싱글톤 패턴은 아마 가장 유명한 디자인 패턴 중 하나일 거예요. 이 패턴의 목적은 클래스의 인스턴스가 오직 하나만 생성되도록 보장하는 거예요. 전역 변수를 사용하지 않고도 객체를 어디서든 접근할 수 있게 해주죠.

Go에서는 싱글톤을 구현하는 방법이 여러 가지가 있어요. 그 중에서 가장 간단한 방법을 먼저 살펴볼게요.


package main

import (
    "fmt"
    "sync"
)

type singleton struct {
    data string
}

var instance *singleton
var once sync.Once

func getInstance() *singleton {
    once.Do(func() {
        instance = &singleton{data: "I am the one and only!"}
    })
    return instance
}

func main() {
    s1 := getInstance()
    s2 := getInstance()

    if s1 == s2 {
        fmt.Println("싱글톤이 제대로 작동합니다!")
        fmt.Println(s1.data)
    }
}

이 코드를 보면, sync.Once를 사용해서 인스턴스가 한 번만 생성되도록 보장하고 있어요. 이렇게 하면 동시성 문제도 해결할 수 있죠. 완전 일석이조 아니에요? ㅋㅋㅋ

근데 여기서 잠깐! 싱글톤 패턴이 항상 좋은 건 아니에요. 전역 상태를 만들어내기 때문에 테스트하기 어려워질 수 있고, 모듈 간의 결합도를 높일 수 있어요. 마치 재능넷에서 한 사람이 모든 재능을 독점하려고 하는 것과 비슷하달까요? 그래서 사용할 때는 신중해야 해요!

3.2 팩토리 메서드 패턴 (Factory Method Pattern) 🏭

팩토리 메서드 패턴은 객체 생성을 서브클래스에 위임하는 패턴이에요. 이 패턴을 사용하면 객체 생성 로직을 캡슐화할 수 있어 코드의 유연성이 높아져요.

Go에서는 인터페이스를 사용해서 이 패턴을 구현할 수 있어요. 한번 볼까요?


package main

import "fmt"

type Pizza interface {
    getPrice() int
}

type HamAndMushroomPizza struct{}

func (p *HamAndMushroomPizza) getPrice() int {
    return 15
}

type DeluxePizza struct{}

func (p *DeluxePizza) getPrice() int {
    return 20
}

func createPizza(pizzaType string) Pizza {
    switch pizzaType {
    case "HamAndMushroom":
        return &HamAndMushroomPizza{}
    case "Deluxe":
        return &DeluxePizza{}
    default:
        return nil
    }
}

func main() {
    hamAndMushroom := createPizza("HamAndMushroom")
    deluxe := createPizza("Deluxe")

    fmt.Printf("Ham and Mushroom Pizza Price: $%d\n", hamAndMushroom.getPrice())
    fmt.Printf("Deluxe Pizza Price: $%d\n", deluxe.getPrice())
}

이 코드를 보면, createPizza 함수가 팩토리 메서드 역할을 하고 있어요. 피자 종류에 따라 다른 객체를 생성하고 있죠. 이렇게 하면 나중에 새로운 피자 종류를 추가하기도 쉬워요. 마치 재능넷에서 새로운 재능을 쉽게 추가할 수 있는 것처럼요! 😉

팩토리 메서드 패턴의 장점은 코드의 확장성을 높여준다는 거예요. 새로운 제품(여기서는 피자)을 추가할 때 기존 코드를 수정하지 않고도 할 수 있으니까요. 완전 개발자 친화적이죠? ㅋㅋㅋ

3.3 빌더 패턴 (Builder Pattern) 🏗️

빌더 패턴은 복잡한 객체의 생성 과정과 표현 방법을 분리하여 동일한 생성 절차에서 서로 다른 표현 결과를 만들 수 있게 하는 패턴이에요. 특히 선택적 매개변수가 많은 경우에 유용하죠.

Go에서 빌더 패턴을 구현하는 방법을 살펴볼까요?


package main

import "fmt"

type House struct {
    windowType string
    doorType   string
    floor      int
}

type HouseBuilder struct {
    house *House
}

func NewHouseBuilder() *HouseBuilder {
    return &HouseBuilder{house: &House{}}
}

func (b *HouseBuilder) WindowType(windowType string) *HouseBuilder {
    b.house.windowType = windowType
    return b
}

func (b *HouseBuilder) DoorType(doorType string) *HouseBuilder {
    b.house.doorType = doorType
    return b
}

func (b *HouseBuilder) Floor(floor int) *HouseBuilder {
    b.house.floor = floor
    return b
}

func (b *HouseBuilder) Build() *House {
    return b.house
}

func main() {
    house := NewHouseBuilder().
        WindowType("Wooden").
        DoorType("Iron").
        Floor(2).
        Build()

    fmt.Printf("House: %+v\n", house)
}

이 코드를 보면, HouseBuilder를 통해 House 객체를 단계적으로 생성하고 있어요. 각 메서드가 HouseBuilder를 반환하기 때문에 메서드 체이닝이 가능하죠. 완전 스타일리시하지 않나요? ㅋㅋㅋ

빌더 패턴의 장점은 객체 생성 과정을 좀 더 통제할 수 있다는 거예요. 복잡한 객체를 생성할 때 특히 유용하죠. 마치 재능넷에서 여러 재능을 조합해서 하나의 큰 프로젝트를 만드는 것과 비슷해요!

자, 여기까지 Go로 구현한 주요 생성 패턴들을 살펴봤어요. 어때요? 생각보다 어렵지 않죠? Go의 특성을 잘 살려 패턴들을 구현할 수 있다는 게 정말 멋진 것 같아요. 👍

다음으로는 구조 패턴에 대해 알아볼 거예요. 구조 패턴은 어떻게 클래스와 객체를 조합해서 더 큰 구조를 만드는지에 대한 패턴이에요. 기대되지 않나요? 고고씽~! 🚀

4. Go로 구현하는 구조 패턴 🏗️

자, 이제 구조 패턴으로 넘어갈 차례예요! 구조 패턴은 클래스나 객체를 조합해 더 큰 구조를 만드는 패턴이에요. 이 패턴들은 시스템의 구조를 유연하고 효율적으로 만들어주죠. 마치 레고 블록을 조립하는 것처럼 말이에요! ㅋㅋㅋ

Go에서 자주 사용되는 구조 패턴들을 하나씩 살펴볼게요. 준비되셨나요? Let's Go! (또 언어유희ㅋㅋ)

4.1 어댑터 패턴 (Adapter Pattern) 🔌

어댑터 패턴은 호환되지 않는 인터페이스들을 함께 동작하도록 해주는 패턴이에요. 마치 110V 콘센트에 220V 기기를 사용할 수 있게 해주는 어댑터처럼 말이죠!

Go에서 어댑터 패턴을 구현하는 방법을 볼까요?


package main

import "fmt"

type OldPrinter interface {
    Print(s string) string
}

type NewPrinter interface {
    PrintStored() string
}

type OldConsolePrinter struct{}

func (p *OldConsolePrinter) Print(s string) string {
    return fmt.Sprintf("Old Printer: %s", s)
}

type NewConsolePrinter struct {
    Msg string
}

func (p *NewConsolePrinter) PrintStored() string {
    return fmt.Sprintf("New Printer: %s", p.Msg)
}

type PrinterAdapter struct {
    OldPrinter OldPrinter
    Msg        string
}

func (p *PrinterAdapter) PrintStored() string {
    return p.OldPrinter.Print(p.Msg)
}

func main() {
    oldPrinter := &OldConsolePrinter{}
    newPrinter := &NewConsolePrinter{Msg: "Hello World!"}

    fmt.Println(oldPrinter.Print("Hello World!"))
    fmt.Println(newPrinter.PrintStored())

    adapter := &PrinterAdapter{OldPrinter: oldPrinter, Msg: "Hello World!"}
    fmt.Println(adapter.PrintStored())
}

이 코드에서 PrinterAdapter는 OldPrinter를 NewPrinter 인터페이스에 맞게 변환해주고 있어요. 이렇게 하면 기존의 OldPrinter를 수정하지 않고도 새로운 시스템에서 사용할 수 있게 되는 거죠. 완전 꿀팁 아니에요? ㅋㅋㅋ

어댑터 패턴의 장점은 기존 코드를 변경하지 않고도 새로운 인터페이스와 호환되게 만들 수 있다는 거예요. 마치 재능넷에서 다양한 재능을 가진 사람들이 서로 협업할 수 있게 해주는 것과 비슷하죠! 😉

4.2 데코레이터 패턴 (Decorator Pattern) 🎀

데코레이터 패턴은 객체에 동적으로 새로운 책임을 추가할 수 있게 해주는 패턴이에요. 상속을 사용하지 않고도 기능을 확장할 수 있죠. 마치 케이크에 장식을 더하는 것처럼 말 이에요!

Go에서 데코레이터 패턴을 구현하는 방법을 살펴볼까요?


package main

import "fmt"

type Coffee interface {
    GetCost() int
    GetDescription() string
}

type SimpleCoffee struct{}

func (c *SimpleCoffee) GetCost() int {
    return 5
}

func (c *SimpleCoffee) GetDescription() string {
    return "Simple coffee"
}

type MilkDecorator struct {
    Coffee Coffee
}

func (m *MilkDecorator) GetCost() int {
    return m.Coffee.GetCost() + 2
}

func (m *MilkDecorator) GetDescription() string {
    return m.Coffee.GetDescription() + ", milk"
}

type WhipDecorator struct {
    Coffee Coffee
}

func (w *WhipDecorator) GetCost() int {
    return w.Coffee.GetCost() + 3
}

func (w *WhipDecorator) GetDescription() string {
    return w.Coffee.GetDescription() + ", whip"
}

func main() {
    coffee := &SimpleCoffee{}
    fmt.Printf("Cost: %d; Description: %s\n", coffee.GetCost(), coffee.GetDescription())

    coffeeWithMilk := &MilkDecorator{Coffee: coffee}
    fmt.Printf("Cost: %d; Description: %s\n", coffeeWithMilk.GetCost(), coffeeWithMilk.GetDescription())

    coffeeWithMilkAndWhip := &WhipDecorator{Coffee: coffeeWithMilk}
    fmt.Printf("Cost: %d; Description: %s\n", coffeeWithMilkAndWhip.GetCost(), coffeeWithMilkAndWhip.GetDescription())
}

이 코드에서 MilkDecorator와 WhipDecorator는 기본 커피에 새로운 기능(우유와 휘핑크림)을 추가하고 있어요. 이렇게 하면 기본 커피 객체를 변경하지 않고도 다양한 종류의 커피를 만들 수 있죠. 완전 바리스타 느낌 아니에요? ㅋㅋㅋ

데코레이터 패턴의 장점은 객체의 책임을 동적으로 추가할 수 있다는 거예요. 상속을 사용하지 않기 때문에 더 유연하고 확장성 있는 설계가 가능해져요. 마치 재능넷에서 기본 서비스에 추가 옵션을 붙여 나가는 것과 비슷하네요! 😊

4.3 프록시 패턴 (Proxy Pattern) 🕵️

프록시 패턴은 다른 객체에 대한 접근을 제어하기 위한 대리자 또는 자리표시자 역할을 하는 객체를 제공하는 패턴이에요. 이 패턴을 사용하면 객체에 대한 추가적인 기능(로깅, 접근 제어 등)을 제공할 수 있죠.

Go에서 프록시 패턴을 구현하는 방법을 볼까요?


package main

import "fmt"

type Server interface {
    HandleRequest(string) (int, string)
}

type Nginx struct {
    Application       *Application
    MaxAllowedRequest int
    RateLimiter       map[string]int
}

func NewNginxServer() *Nginx {
    return &Nginx{
        Application:       &Application{},
        MaxAllowedRequest: 2,
        RateLimiter:       make(map[string]int),
    }
}

func (n *Nginx) HandleRequest(url string) (int, string) {
    n.RateLimiter[url]++
    if n.RateLimiter[url] > n.MaxAllowedRequest {
        return 403, "Not Allowed"
    }
    return n.Application.HandleRequest(url)
}

type Application struct{}

func (a *Application) HandleRequest(url string) (int, string) {
    if url == "/app/status" {
        return 200, "Ok"
    }
    if url == "/app/hello" {
        return 200, "Hello"
    }
    return 404, "Not Found"
}

func main() {
    nginxServer := NewNginxServer()
    appStatusURL := "/app/status"
    appHelloURL := "/app/hello"

    fmt.Printf("URL: %s\n", appStatusURL)
    code, body := nginxServer.HandleRequest(appStatusURL)
    fmt.Printf("Response Code: %d\n", code)
    fmt.Printf("Response Body: %s\n\n", body)

    fmt.Printf("URL: %s\n", appHelloURL)
    code, body = nginxServer.HandleRequest(appHelloURL)
    fmt.Printf("Response Code: %d\n", code)
    fmt.Printf("Response Body: %s\n\n", body)

    fmt.Printf("URL: %s\n", appHelloURL)
    code, body = nginxServer.HandleRequest(appHelloURL)
    fmt.Printf("Response Code: %d\n", code)
    fmt.Printf("Response Body: %s\n\n", body)

    fmt.Printf("URL: %s\n", appHelloURL)
    code, body = nginxServer.HandleRequest(appHelloURL)
    fmt.Printf("Response Code: %d\n", code)
    fmt.Printf("Response Body: %s\n\n", body)
}

이 코드에서 Nginx는 Application에 대한 프록시 역할을 하고 있어요. Nginx는 요청을 처리하기 전에 rate limiting을 수행하고 있죠. 이렇게 하면 실제 애플리케이션 서버를 수정하지 않고도 추가적인 기능을 제공할 수 있어요. 완전 보안 전문가 느낌 아니에요? ㅋㅋㅋ

프록시 패턴의 장점은 원래 객체의 동작을 변경하지 않고도 새로운 기능을 추가할 수 있다는 거예요. 또한 객체에 대한 접근을 제어할 수 있어 보안이나 성능 최적화에도 유용하죠. 마치 재능넷에서 중개자가 거래를 관리하는 것과 비슷해요! 😉

자, 여기까지 Go로 구현한 주요 구조 패턴들을 살펴봤어요. 어때요? 각 패턴마다 특징이 있고, 상황에 따라 적절히 사용하면 코드의 구조를 더욱 견고하고 유연하게 만들 수 있어요.

다음으로는 행동 패턴에 대해 알아볼 거예요. 행동 패턴은 객체들이 서로 상호작용하는 방법과 책임을 분산하는 방법을 다루는 패턴이에요. 기대되지 않나요? 고고씽~! 🚀

5. Go로 구현하는 행동 패턴 🕺💃

드디어 행동 패턴이에요! 행동 패턴은 객체들이 어떻게 협력하고 책임을 분배하는지에 대한 패턴이에요. 이 패턴들은 복잡한 제어 흐름을 더 관리하기 쉽게 만들어주죠. 마치 무도회장에서 춤추는 사람들의 움직임을 조율하는 것과 비슷해요! 🕺💃

Go에서 자주 사용되는 행동 패턴들을 하나씩 살펴볼게요. 준비되셨나요? Let's dance! (또 다른 언어유희ㅋㅋ)

5.1 옵저버 패턴 (Observer Pattern) 👀

옵저버 패턴은 객체의 상태 변화를 관찰하는 관찰자들을 객체에 등록하여 상태 변화가 있을 때마다 메서드 등을 통해 객체가 직접 목록의 각 관찰자에게 통지하도록 하는 패턴이에요. 마치 유튜브 채널을 구독하는 것과 비슷하죠!

Go에서 옵저버 패턴을 구현하는 방법을 볼까요?


package main

import "fmt"

type Subject interface {
    Register(Observer)
    Deregister(Observer)
    NotifyAll()
}

type Observer interface {
    Update(string)
}

type Item struct {
    observers []Observer
    name      string
    inStock   bool
}

func NewItem(name string) *Item {
    return &Item{
        name: name,
    }
}

func (i *Item) Register(o Observer) {
    i.observers = append(i.observers, o)
}

func (i *Item) Deregister(o Observer) {
    for index, observer := range i.observers {
        if observer == o {
            i.observers = append(i.observers[:index], i.observers[index+1:]...)
            break
        }
    }
}

func (i *Item) NotifyAll() {
    for _, observer := range i.observers {
        observer.Update(i.name)
    }
}

func (i *Item) UpdateAvailability() {
    fmt.Printf("Item %s is now in stock\n", i.name)
    i.inStock = true
    i.NotifyAll()
}

type EmailClient struct {
    email string
}

func (c *EmailClient) Update(itemName string) {
    fmt.Printf("Sending email to %s for item %s\n", c.email, itemName)
}

func main() {
    shirtItem := NewItem("Fancy Shirt")

    observerFirst := &EmailClient{email: "abc@gmail.com"}
    observerSecond := &EmailClient{email: "xyz@gmail.com"}

    shirtItem.Register(observerFirst)
    shirtItem.Register(observerSecond)

    shirtItem.UpdateAvailability()
}

이 코드에서 Item은 Subject 역할을, EmailClient는 Observer 역할을 하고 있어요. 아이템의 재고 상태가 변경되면 등록된 모든 관찰자들에게 알림이 가죠. 마치 재능넷에서 새로운 재능이 등록되면 관심 있는 사용자들에게 알림이 가는 것과 비슷해요! 😉

옵저버 패턴의 장점은 객체 간의 느슨한 결합을 유지하면서도 객체 간의 통신을 가능하게 한다는 거예요. 변경 사항을 자동으로 관련 객체들에게 전파할 수 있어 유용하죠.

5.2 전략 패턴 (Strategy Pattern) 🎯

전략 패턴은 알고리즘을 정의하고 각각을 캡슐화하여 교환해서 사용할 수 있도록 만드는 패턴이에요. 이 패턴을 사용하면 알고리즘을 사용하는 클라이언트와는 독립적으로 알고리즘을 변경할 수 있죠.

Go에서 전략 패턴을 구현하는 방법을 살펴볼까요?


package main

import "fmt"

type PaymentStrategy interface {
    Pay(amount float32) string
}

type CreditCardStrategy struct {
    Name     string
    CardNumber string
    Cvv      string
}

func (c *CreditCardStrategy) Pay(amount float32) string {
    return fmt.Sprintf("%s paid %.2f using Credit Card", c.Name, amount)
}

type PayPalStrategy struct {
    Email    string
    Password string
}

func (p *PayPalStrategy) Pay(amount float32) string {
    return fmt.Sprintf("%.2f paid using PayPal", amount)
}

type ShoppingCart struct {
    Amount float32
    PaymentStrategy PaymentStrategy
}

func (s *ShoppingCart) Pay() string {
    return s.PaymentStrategy.Pay(s.Amount)
}

func main() {
    shoppingCart := &ShoppingCart{Amount: 100}

    shoppingCart.PaymentStrategy = &CreditCardStrategy{Name: "John Doe", CardNumber: "0", Cvv: "123"}
    fmt.Println(shoppingCart.Pay())

    shoppingCart.PaymentStrategy = &PayPalStrategy{Email: "john@example.com", Password: "password"}
    fmt.Println(shoppingCart.Pay())
}

이 코드에서 PaymentStrategy는 전략 인터페이스 역할을 하고, CreditCardStrategy와 PayPalStrategy는 구체적인 전략들이에요. ShoppingCart는 이 전략들을 사용하는 컨텍스트 역할을 하죠. 이렇게 하면 새로운 결제 방식을 추가하거나 변경하기가 쉬워져요. 완전 결제 시스템의 신세계 아니에요? ㅋㅋㅋ

전략 패턴의 장점은 알고리즘을 쉽게 교체할 수 있다는 거예요. 또한 새로운 전략을 추가하기도 쉽죠. 마치 재능넷에서 다양한 결제 방식을 제공하는 것과 비슷해요! 😊

5.3 템플릿 메서드 패턴 (Template Method Pattern) 📝

템플릿 메서드 패턴은 알고리즘의 구조를 메서드에 정의하고, 하위 클래스에서 알고리즘 구조의 변경없이 알고리즘을 재정의하는 패턴이에요. 이 패턴을 사용하면 코드 재사용과 알고리즘의 변경을 용이하게 할 수 있죠.

Go에서 템플릿 메서드 패턴을 구현하는 방법을 볼까요?


package main

import "fmt"

type Beverage interface {
    BoilWater()
    Brew()
    PourInCup()
    AddCondiments()
    Make()
}

type beverage struct{}

func (b *beverage) BoilWater() {
    fmt.Println("Boiling water")
}

func (b *beverage) PourInCup() {
    fmt.Println("Pouring into cup")
}

func (b *beverage) Make() {
    b.BoilWater()
    b.Brew()
    b.PourInCup()
    b.AddCondiments()
}

type Tea struct {
    beverage
}

func (t *Tea) Brew() {
    fmt.Println("Steeping the tea")
}

func (t *Tea) AddCondiments() {
    fmt.Println("Adding Lemon")
}

type Coffee struct {
    beverage
}

func (c *Coffee) Brew() {
    fmt.Println("Dripping Coffee through filter")
}

func (c *Coffee) AddCondiments() {
    fmt.Println("Adding Sugar and Milk")
}

func main() {
    tea := &Tea{}
    tea.Make()

    fmt.Println()

    coffee := &Coffee{}
    coffee.Make()
}

이 코드에서 beverage는 템플릿 메서드 Make()를 정의하고 있어요. Tea와 Coffee는 이를 상속받아 Brew()와 AddCondiments() 메서드를 각자의 방식으로 구현하고 있죠. 이렇게 하면 음료를 만드는 전체적인 과정은 동일하지만, 세부적인 단계는 각 음료에 맞게 조정할 수 있어요. 완전 바리스타의 비밀 레시피 같지 않나요? ㅋㅋㅋ

템플릿 메서드 패턴의 장점은 코드 재사용성을 높이고 알고리즘의 뼈대를 유지하면서 세부 구현을 변경할 수 있다는 거예요. 마치 재능넷에서 기본적인 서비스 프로세스는 유지하면서 각 재능별로 세부 내용을 조정하는 것과 비슷해요! 😉

자, 여기까지 Go로 구현한 주요 행동 패턴들을 살펴봤어요. 어때요? 각 패턴마다 특징이 있고, 상황에 따라 적절히 사용하면 객체들 간의 상호작용을 더욱 효율적으로 만들 수 있어요.

이렇게 해서 우리는 Go 언어로 주요 디자인 패턴들을 살펴봤어요. 생성 패턴, 구조 패턴, 행동 패턴까지! 각 패턴들이 어떻게 Go의 특성을 살려 구현되는지 보셨나요?

디자인 패턴을 잘 활용하면 코드의 재사용성, 유지보수성, 확장성을 크게 향상시킬 수 있어요. 하지만 주의할 점은 패턴을 위한 패턴 사용은 오히려 코드를 복잡하게 만들 수 있다는 거예요. 항상 상황에 맞는 적절한 패턴을 선택하는 게 중요해요.

여러분도 이제 Go로 멋진 프로젝트를 만들 때 이런 디자인 패턴들을 활용해보는 건 어떨까요? 마치 재능넷에서 다양한 재능들을 조합해 새로운 가치를 만들어내는 것처럼, 여러분의 코드도 더욱 가치 있고 멋진 모습으로 발전할 거예요!

자, 이제 우리의 Go 언어와 디자인 패턴 여행이 끝났어요. 어떠셨나요? 재미있고 유익한 시간이었길 바라요. 앞으로도 계속해서 코딩의 즐거움을 느끼며 성장해 나가시길 바랄게요. 화이팅! 👊😄