手撸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)

有疑问加站长微信联系（非本文作者）