本文摘自网络，作者，侵删。

手撸golang 行为型设计模式状态模式

缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用golang练习之

状态模式

状态模式（State Pattern）也叫作状态机模式（State Machine Pattern），
允许对象在内部状态发生改变时改变它的行为，
对象看起来好像修改了它的类，
属于行为型设计模式。

状态模式主要包含3个角色。
（1）环境类角色（Context）：定义客户端需要的接口，内部维护一个当前状态实例，并负责具体状态的切换。
（2）抽象状态角色（IState）：定义该状态下的行为，可以有一个或多个行为。
（3）具体状态角色（ConcreteState）：具体实现该状态对应的行为，并且在需要的情况下进行状态切换。

(摘自 谭勇德 <<设计模式就该这样学>>)

场景

某业务系统, 需要对接某对象存储系统, 以统一管理大量的文件数据
由于该对象存储系统只提供了http api文档, 因此需要自行封装文件读写api
码农王二狗接到Leader张阿蛋下达的开发任务, 啃了几遍文档, 感觉胸有成竹
- 王二狗: 张哥, 这个读写api, 是不是就写一个门面, 一个方法封装一个api就行了, 感觉功能不复杂
- 张阿蛋: 基本上是这样的. 不过你有没有注意到, 文档上有注意事项, 就是打开文件的时候, 必须确定文件的使用方式?
- 王二狗: 啥? 哦...我看看, 还真是有这么一条, 不过这个有影响吗, 不就是多传一个参数吗?
- 张阿蛋: 当然有影响, 如果你以读方式打开, 那么后续是不接受写入的. 如果你以写方式打开, 后续是不能读取的.
- 王二狗: 哦, 那估计要好好封装一下http api的报错信息?
- 张阿蛋: 这个是肯定要的, 通讯难免有出错的时候. 但是, 也许我们可以用状态模式, 提前拒绝一些非法操作
- 王二狗: ...不明觉厉, 能对我直接点吗?
- 张阿蛋: 将文件流对象的方法委托给"未打开", "读取中", "写入中", 和"已关闭"四种状态. 每种状态只响应当前状态下允许的操作, 其他操作直接返回error.
- 王二狗: 张哥, 强!

设计

IFileStream: 文件流API接口
iFileStreamContext: 文件流上下文接口, 仅内部使用
iFileStreamState: 文件流状态接口, 仅内部使用
tMockFileStream: 虚拟的文件流API实现类, 实现iFileStream接口 + iFileStreamContext接口
tDefaultState: 默认状态 - 未打开状态. 该状态下只允许打开/关闭操作
tReadingState: 读取状态. 该状态下只允许读取/关闭操作
tWritingState: 写入状态. 该状态下只允许写入/关闭操作
tClosedState: 关闭状态. 该状态下只允许关闭操作

单元测试

state_pattern_test.go

package behavioral_patterns

import (
    "learning/gooop/behavioral_patterns/state"
    "testing"
)

func Test_StatePattern(t *testing.T) {
    fnTestFileStream := func(fs state.IFileStream, readonly bool) {
        if readonly {
            e := fs.OpenRead()
            if e != nil {
                t.Log(e)
            }

            e = fs.OpenWrite()
            if e != nil {
                t.Log(e)
            }
        } else {
            e := fs.OpenWrite()
            if e != nil {
                t.Log(e)
            }

            e = fs.OpenRead()
            if e != nil {
                t.Log(e)
            }
        }

        buffer := make([]byte, 8192)
        n,e := fs.Read(buffer)
        if e != nil {
            t.Log(e)
        } else {
            t.Logf("%v bytes read", n)
        }

        n, e = fs.Write(buffer)
        if e != nil {
            t.Log(e)
        } else {
            t.Logf("%v bytes written", n)
        }

        e = fs.Close()
        if e != nil {
            t.Log(e)
        }
    }

    fnTestFileStream(state.NewMockFileStream("read-only.txt"), true)
    fnTestFileStream(state.NewMockFileStream("write-only.txt"), false)
}

测试输出

$ go test -v state_pattern_test.go 
=== RUN   Test_StatePattern
tDefaultState.OpenRead, file=read-only.txt
tMockFileStream.Switch, *state.tDefaultState => *state.tReadingState
    state_pattern_test.go:18: tReadingState.OpenWrite, already reading read-only.txt
tReadingState.Read, file=read-only.txt, iBytesRead=8192
    state_pattern_test.go:37: 8192 bytes read
    state_pattern_test.go:42: tReadingState.Write, cannot write to read-only.txt
tReadingState.Close, file=read-only.txt, iBytesRead=8192
tMockFileStream.Switch, *state.tReadingState => *state.tClosedState
tDefaultState.OpenWrite, file=write-only.txt
tMockFileStream.Switch, *state.tDefaultState => *state.tWritingState
    state_pattern_test.go:28: tWritingState.OpenRead, already writing write-only.txt
    state_pattern_test.go:35: tWritingState.Read, cannot read write-only.txt
tWritingState.Write, file=write-only.txt, written=8192
    state_pattern_test.go:44: 8192 bytes written
tWritingState.Close, file=write-only.txt, written=8192
tMockFileStream.Switch, *state.tWritingState => *state.tClosedState
--- PASS: Test_StatePattern (0.00s)
PASS
ok      command-line-arguments  0.002s

IFileStream.go

文件流API接口

package state

import "io"

type IFileStream interface {
    io.ReadWriteCloser

    OpenRead() error
    OpenWrite() error
}

iFileStreamContext.go

文件流上下文接口, 仅内部使用

package state

type iFileStreamContext interface {
    File() string
    Switch(state iFileStreamState)
}

iFileStreamState.go

文件流状态接口, 仅内部使用

package state

type iFileStreamState interface {
    IFileStream
}

tMockFileStream.go

虚拟的文件流API实现类, 实现iFileStream接口 + iFileStreamContext接口

package state

import (
    "fmt"
    "reflect"
)

type tMockFileStream struct {
    state iFileStreamState
    file  string
}


func NewMockFileStream(file string) IFileStream {
    fs := &tMockFileStream{
        nil,
        file,
    }
    fs.state = newDefaultState(fs)
    return fs
}

func (me *tMockFileStream) File() string {
    return me.file
}

func (me *tMockFileStream) Switch(st iFileStreamState) {
    fmt.Printf("tMockFileStream.Switch, %s => %s\n", reflect.TypeOf(me.state).String(), reflect.TypeOf(st).String())
    me.state = st
}

func (me *tMockFileStream) OpenRead() error {
    return me.state.OpenRead()
}

func (me *tMockFileStream) OpenWrite() error {
    return me.state.OpenWrite()
}

func (me *tMockFileStream) Read(p []byte) (n int, e error) {
    return me.state.Read(p)
}

func (me *tMockFileStream) Write(p []byte) (n int, e error) {
    return me.state.Write(p)
}

func (me *tMockFileStream) Close() error {
    return me.state.Close()
}

tDefaultState.go

默认状态 - 未打开状态. 该状态下只允许打开/关闭操作

package state

import (
    "errors"
    "fmt"
)

type tDefaultState struct {
    context iFileStreamContext
}

func newDefaultState(context iFileStreamContext) iFileStreamState {
    return &tDefaultState{
        context,
    }
}

func (me *tDefaultState) OpenRead() error {
    fmt.Printf("tDefaultState.OpenRead, file=%s\n", me.context.File())
    me.context.Switch(newReadingState(me.context))
    return nil
}

func (me *tDefaultState) OpenWrite() error {
    fmt.Printf("tDefaultState.OpenWrite, file=%s\n", me.context.File())
    me.context.Switch(newWritingState(me.context))
    return nil
}


func (me *tDefaultState) Read(p []byte) (n int, err error) {
    return 0, errors.New(fmt.Sprintf("tDefaultState.Read, file not opened, %s", me.context.File()))
}

func (me *tDefaultState) Write(p []byte) (n int, err error) {
    return 0, errors.New(fmt.Sprintf("tDefaultState.Write, file not opened, %s", me.context.File()))
}

func (me *tDefaultState) Close() error {
    fmt.Printf("tDefaultState.Close, file=%s\n", me.context.File())
    me.context.Switch(newClosedState(me.context))
    return nil
}

tReadingState.go

读取状态. 该状态下只允许读取/关闭操作

package state

import (
    "errors"
    "fmt"
)

type tReadingState struct {
    context iFileStreamContext
    iBytesRead  int
}


func newReadingState(context iFileStreamContext) iFileStreamState {
    return &tReadingState{
        context,
        0,
    }
}

func (me *tReadingState) OpenRead() error {
    return errors.New(fmt.Sprintf("tReadingState.OpenRead, already reading %s", me.context.File()))
}

func (me *tReadingState) OpenWrite() error {
    return errors.New(fmt.Sprintf("tReadingState.OpenWrite, already reading %s", me.context.File()))
}

func (me *tReadingState) Read(p []byte) (n int, err error) {
    size := len(p)
    me.iBytesRead += size
    fmt.Printf("tReadingState.Read, file=%s, iBytesRead=%v\n", me.context.File(), me.iBytesRead)
    return size, nil
}

func (me *tReadingState) Write(p []byte) (n int, err error) {
    return 0, errors.New(fmt.Sprintf("tReadingState.Write, cannot write to %s", me.context.File()))
}

func (me *tReadingState) Close() error {
    fmt.Printf("tReadingState.Close, file=%s, iBytesRead=%v\n", me.context.File(), me.iBytesRead)
    me.context.Switch(newClosedState(me.context))
    return nil
}

tWritingState.go

写入状态. 该状态下只允许写入/关闭操作

package state

import (
    "errors"
    "fmt"
)

type tWritingState struct {
    context iFileStreamContext
    written int
}


func newWritingState(context iFileStreamContext) iFileStreamState {
    return &tWritingState{
        context,
        0,
    }
}

func (me *tWritingState) OpenRead() error {
    return errors.New(fmt.Sprintf("tWritingState.OpenRead, already writing %s", me.context.File()))
}

func (me *tWritingState) OpenWrite() error {
    return errors.New(fmt.Sprintf("tWritingState.OpenWrite, already writing %s", me.context.File()))
}

func (me *tWritingState) Read(p []byte) (n int, err error) {
    return 0, errors.New(fmt.Sprintf("tWritingState.Read, cannot read %s", me.context.File()))
}

func (me *tWritingState) Write(p []byte) (n int, err error) {
    size := len(p)
    me.written += size
    fmt.Printf("tWritingState.Write, file=%s, written=%v\n", me.context.File(), me.written)
    return size, nil
}

func (me *tWritingState) Close() error {
    fmt.Printf("tWritingState.Close, file=%s, written=%v\n", me.context.File(), me.written)
    me.context.Switch(newClosedState(me.context))
    return nil
}

tClosedState.go

关闭状态. 该状态下只允许关闭操作

package state

import (
    "errors"
    "fmt"
)

type tClosedState struct {
    context iFileStreamContext
}


func newClosedState(context iFileStreamContext) iFileStreamState {
    return &tClosedState{
        context,
    }
}

func (me *tClosedState) OpenRead() error {
    return errors.New(fmt.Sprintf("tClosedState.OpenRead, file(%s) already closed ", me.context.File()))
}

func (me *tClosedState) OpenWrite() error {
    return errors.New(fmt.Sprintf("tClosedState.OpenWrite, file(%s) already closed ", me.context.File()))
}

func (me *tClosedState) Read(p []byte) (n int, e error) {
    return 0, errors.New(fmt.Sprintf("tClosedState.Read, file(%s) already closed ", me.context.File()))
}

func (me *tClosedState) Write(p []byte) (n int, e error) {
    return 0, errors.New(fmt.Sprintf("tClosedState.Write, file(%s) already closed ", me.context.File()))
}

func (me *tClosedState) Close() error {
    return nil
}

状态模式小结

状态模式的优点
（1）结构清晰：将状态独立为类，消除了冗余的if...else或switch...case语句。
（2）将状态转换显示化：通常对象内部都是使用数值类型来定义状态的，
    状态的切换通过赋值进行表现，不够直观；
    而使用状态类，当切换状态时，是以不同的类进行表示的，转换目的更加明确。
（3）状态类职责明确且具备扩展性。

状态模式的缺点
（1）类膨胀：如果一个事物具备很多状态，则会造成状态类太多。
（2）状态模式的结构与实现都较为复杂，如果使用不当，将导致程序结构和代码的混乱。
（3）状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式，
    增加新的状态类需要修改那些负责状态转换的源码，否则无法切换到新增状态，
    而且修改某个状态类的行为也需要修改对应类的源码。
    
(摘自 谭勇德 <<设计模式就该这样学>>)

(end)

本文来自：Segmentfault

感谢作者：.container .card .information strong

查看原文：手撸golang 行为型设计模式状态模式

Go语言101

￥0元 老貘

一个与时俱进的Go编程知识库。

转载请注明出处：木庄网络博客 » 手撸golang 行为型设计模式状态模式

手撸golang 行为型设计模式状态模式

手撸golang 行为型设计模式状态模式

缘起

状态模式

场景

设计

单元测试

测试输出

IFileStream.go

iFileStreamContext.go

iFileStreamState.go

tMockFileStream.go

tDefaultState.go

tReadingState.go

tWritingState.go

tClosedState.go

状态模式小结

Go语言101

相关推荐

评论

手撸golang 行为型设计模式 状态模式

缘起

状态模式

场景

设计

单元测试

测试输出

IFileStream.go

iFileStreamContext.go

iFileStreamState.go

tMockFileStream.go

tDefaultState.go

tReadingState.go

tWritingState.go

tClosedState.go

状态模式小结

相关推荐

评论

手撸golang 行为型设计模式状态模式