gof 23 클래스 모드 만 들 기 (golang 버 전)

블록 체인 의 여정 이 시작 되 었 습 니 다.
github 환영 스타
https://github.com/transienth...
단일 모드
자바 에서 의 단일 모델 의 실현 은 굶 주 린 사람 식, 게 으 른 사람 식, 더 블 잠 금, 정적 내부 류, 매 거 진 등 형식 이 있 을 수 있 습 니 다. go 에서 어떻게 단일 사례 를 실현 할 수 있 습 니까? 먼저 가장 간단 한 형식 으로 높 은 병발 을 고려 하지 않 고 어떻게 실현 해 야 합 니까?

package main

var m *Singleton

type Singleton struct {
}

func GetInstance() *Singleton {
    if m == nil {
        m = &Singleton{}
    }
    return m
}

문 제 는 동시 다발 할 때 여러 대상 을 찾 아 해결 방안 에 자 물 쇠 를 채 우 는 것 이다.

package main

import (
    "sync"
)

var instance *Singleton
var lock *sync.Mutex = &sync.Mutex{}

type Singleton struct {
}

func GetInstance() *Singleton {

    lock.Lock()
    defer lock.Unlock()

    if instance != nil {
        instance = &Singleton{}
    }
    return instance
}

go 언어 특성, 보다 편리 한 잠 금 추가 지원: sync. Once

package main

import (
    "sync"
)

var (
    instance *Singleton
    lock     *sync.Mutex = &sync.Mutex{}
    once sync.Once
)

type Singleton struct {
}

func GetInstance() *Singleton {

    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

단순 공장 모드
간단 한 공장 모델 로 생산 되 는 제품 은 고정 적 이 고 사 과 를 생산 하려 면 MakeApple () 의 방법 이 있다.귤 을 생산 하려 면 메 이 크 오렌지 (MakeOrange) 방법 이 있어 요.

package creation

type FruitFactory interface {
    makeApple() Apple
    makeOrange() Orange
}

type Apple struct {
    desc string
}

type Orange struct {
    desc string
}

type Factory struct {
}

func (this Factory) MakeApple() Apple {
    return Apple{"      "}
}

func (this Factory) MakeOrange() Orange {
    return Orange{"      "}
}

client

package main

import (
    "gof23/creation"
    "fmt"
)

func main() {
    factory := creation.Factory{}

    apple := factory.MakeApple()
    orange := factory.MakeOrange()

    fmt.Println(apple)
    fmt.Println(orange)
}

공장 방법 모델
공장 방법 모델 (Factory Method Pattern) 은 공장 모델 이 라 고도 부 르 고 가상 구조 기 (Virtual Constructor) 모델 또는 다 중 공장 (Polymorphic Factory) 모델 이 라 고도 부 르 며 클래스 생 성 모델 에 속한다.공장 방법 모델 에서 공장 부 류 는 제품 대상 을 만 드 는 공공 인 터 페 이 스 를 정의 하고 공장 자 류 는 구체 적 인 제품 대상 을 생 성 하 는 것 을 책임 진다. 이렇게 하 는 목적 은 제품 류 의 정례 화 작업 을 공장 자 류 로 지연 시 키 는 것 이다. 즉, 공장 자 류 를 통 해 어떤 구체 적 인 제품 류 를 예화 해 야 하 는 지 확인 하 는 것 이다.

package creation

type FruitPicker interface {
    MakeFruit() Fruit
}
type Fruit interface {
}
type Banana struct {
    desc string
}

type BananaPicker struct {
}

func (this BananaPicker) MakeFruit(fruitName string) Fruit {
    switch fruitName {
    case "banana":
        return Banana{"      "}
    default:
        return Apple{"         "}
    }
}

client

package main

import (
    "gof23/creation"
    "fmt"
)

func main() {
    bananaPicker := creation.BananaPicker{}

    banana := bananaPicker.MakeFruit("banana")
    fmt.Println(banana)
}

추상 공장 모드
공장 방법 모델 에서 구체 적 인 공장 은 구체 적 인 제품 을 생산 하 는 것 을 책임 지고 모든 구체 적 인 공장 은 하나의 구체 적 인 제품 에 대응 하 며 공장 방법 도 유일 성 을 가진다. 일반적인 상황 에서 구체 적 인 공장 에는 하나의 공장 방법 이나 한 조 의 무 거 운 공장 방법 만 있다.그러나 때때로 우 리 는 하나의 공장 이 하나의 제품 대상 이 아니 라 여러 개의 제품 대상 을 제공 할 수 있어 야 한다.
공장 방법 모델 을 더욱 명확 하 게 이해 하기 위해 서 는 먼저 두 가지 개념 을 도입 해 야 한다.
제품 등급 구조: 제품 등급 구 조 는 바로 제품 의 계승 구조 이다. 예 를 들 어 추상 적 인 유형 은 텔레비전 이다. 그 하위 유형 은 하 이 얼 텔레비전, 하 이 신 텔레비전, TCL 텔레비전 이 있 으 면 추상 적 인 텔레비전 과 구체 적 인 브랜드 의 텔레비전 간 에 제품 등급 구 조 를 구성 했다. 추상 적 인 텔레비전 은 부류 이 고 구체 적 인 브랜드 의 텔레비전 은 그 부류 이다.제품 족: 추상 적 인 공장 모델 에서 제품 족 은 같은 공장 에서 생산 한 것 으로 서로 다른 제품 등급 구조 에 있 는 제품 을 말한다. 예 를 들 어 하 이 얼 전기 공장 에서 생산 한 하 이 얼 텔레비전, 하 이 얼 냉장고, 하 이 얼 텔레비전 은 텔레비전 제품 등급 구조 에 위치 하고 하 이 얼 냉장 고 는 냉장고 제품 등급 구조 에 있다.시스템 이 제공 하 는 공장 에서 생산 해 야 할 구체 적 인 제품 은 간단 한 대상 이 아니 라 서로 다른 제품 등급 구조 에서 서로 다른 유형의 구체 적 인 제품 에 속 할 때 추상 적 인 공장 모델 을 사용 해 야 한다.
추상 적 인 공장 모델 은 모든 형식의 공장 모델 중에서 가장 추상 적 이 고 일반적인 형태 이다.
추상 적 인 공장 모델 과 공장 방법 모델 의 가장 큰 차이 점 은 공장 방법 모델 은 하나의 제품 등급 구 조 를 대상 으로 하고 추상 적 인 공장 모델 은 여러 개의 제품 등급 구 조 를 직면 해 야 한다. 한 공장 등급 구 조 는 여러 개의 서로 다른 제품 등급 구조 중의 제품 대상 의 설립 을 책임 질 수 있다.한 공장 의 등급 구조 가 서로 다른 제품 등급 구조 에 속 하 는 한 제품 족 중의 모든 대상 을 만 들 수 있 을 때 추상 적 인 공장 모델 은 공장 방법 모델 보다 더욱 간단 하고 효율 적 이다.
추상 적 인 공장 모델 (Abstract Factory Pattern): 일련의 관련 되 거나 서로 의존 하 는 대상 을 만 드 는 인 터 페 이 스 를 제공 합 니 다. 구체 적 인 종 류 를 지정 하지 않 아 도 됩 니 다.추상 적 인 공장 모델 은 Kit 모델 이 라 고도 부 르 며 대상 생 성 모델 에 속한다.
추상 적 인 공장 모델 은 다음 과 같은 역할 을 포함한다.
추상 공장

추상 공장

Concrete Factory: 구체 적 인 공장

추상 제품: 추상 제품

제품: 세부 제품

추상 적 인 공장 모델 은 제품 족 에 치중 한다.

package creation

type PlantFactory interface {
    MakePlant() Plant
    MakePicker() Picker
}

type Plant interface {
}
type Picker interface {
}

type PearFactory struct {
}

type Pear struct {
    desc string
}

type PearPicker struct {
    desc string
}


func (this PearFactory) MakePlant() Plant {
    return Pear{"     "}
}

func (this PearFactory) MakePicker() Picker {
    return PearPicker{"     "}
}

client

package main

import (
    "gof23/creation"
    "fmt"
)

func main() {
    factory := creation.PearFactory{}
    pearPicker := factory.MakePicker()
    pear := factory.MakePlant()

    fmt.Println(pear)
    fmt.Println(pearPicker)
}

건설 자 모드
건설 자 모드 (Builder Pattern): 복잡 한 대상 의 구축 을 표시 와 분리 시 켜 같은 구축 과정 에서 서로 다른 표 시 를 만 들 수 있 습 니 다.
건설 자 모델 은 한 걸음 한 걸음 복잡 한 대상 을 만 드 는 것 으로 사용자 가 복잡 한 대상 의 유형 과 내용 만 지정 하면 구축 할 수 있 고 사용 자 는 내부 의 구체 적 인 구축 세부 사항 을 알 필요 가 없다.건설 자 모드 는 대상 생 성 모드 에 속 합 니 다.중국어 번역 에 따라 건설 자 모델 은 생 성기 모델 이 라 고도 할 수 있다.
건설 자 모드 는 다음 과 같은 역할 을 포함 합 니 다.

Builder: 추상 적 인 건축 자

ConcreteBuilder: 구체 적 인 건축 자

감독: 지휘자

제품: 제품 캐릭터

package creation

type Character struct {
    Name string
    Arms string
}

func (p *Character) SetName(name string) {
    p.Name = name
}

func (p *Character) SetArms(arms string) {
    p.Arms = arms
}

func (p Character) GetArms() string {
    return p.Arms
}

func (p Character) GetName() string {
    return p.Name
}

type Builder interface {
    SetName(name string) Builder
    SetArms(arms string) Builder
    Build() *Character
}

type CharacterBuilder struct {
    character *Character
}

func (p *CharacterBuilder) SetName(name string) Builder {
    if p.character == nil {
        p.character = &Character{}
    }
    p.character.SetName(name)
    return p
}

func (p *CharacterBuilder) SetArms(arms string) Builder {
    if p.character == nil {
        p.character = &Character{}
    }
    p.character.SetArms(arms)
    return p
}

func (p *CharacterBuilder) Build() *Character {
    return p.character
}

type Director struct {
    Builder Builder
}

func (p Director) Create(name string, arms string) *Character {
    return p.Builder.SetName(name).SetArms(arms).Build()
}

client

package main

import (
    "fmt"
    "gof23/creation"
)

func main() {
    var builder creation.Builder = &creation.CharacterBuilder{}
    var director *creation.Director = &creation.Director {builder}
    var character *creation.Character = director.Create("loader", "AK47")
    fmt.Println(character.GetName() + "," + character.GetArms())
}