乘风原创程序

  • 必须掌握的Golang23种设计模式之工厂方法模式
  • 2021/7/7 15:18:05
  • 设计模式(design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

    使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。

    项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是它能被广泛应用的原因。

    设计模式的分类

    创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。


     

    工厂方法模式使用子类的方式延迟生成对象到子类中实现。

    go中不存在继承 所以使用匿名组合来实现

    查看全部设计模式:

    factorymethod.go

    package factorymethod
    
    //operator 是被封装的实际类接口
    type operator interface {
        seta(int)
        setb(int)
        result() int
    }
    
    //operatorfactory 是工厂接口
    type operatorfactory interface {
        create() operator
    }
    
    //operatorbase 是operator 接口实现的基类,封装公用方法
    type operatorbase struct {
        a, b int
    }
    
    //seta 设置 a
    func (o *operatorbase) seta(a int) {
        o.a = a
    }
    
    //setb 设置 b
    func (o *operatorbase) setb(b int) {
        o.b = b
    }
    
    //plusoperatorfactory 是 plusoperator 的工厂类
    type plusoperatorfactory struct{}
    
    func (plusoperatorfactory) create() operator {
        return &plusoperator{
            operatorbase: &operatorbase{},
        }
    }
    
    //plusoperator operator 的实际加法实现
    type plusoperator struct {
        *operatorbase
    }
    
    //result 获取结果
    func (o plusoperator) result() int {
        return o.a + o.b
    }
    
    //minusoperatorfactory 是 minusoperator 的工厂类
    type minusoperatorfactory struct{}
    
    func (minusoperatorfactory) create() operator {
        return &minusoperator{
            operatorbase: &operatorbase{},
        }
    }
    
    //minusoperator operator 的实际减法实现
    type minusoperator struct {
        *operatorbase
    }
    
    //result 获取结果
    func (o minusoperator) result() int {
        return o.a - o.b
    }
    
    
    

     

    factorymethod_test.go

    package factorymethod
    
    import "testing"
    
    func compute(factory operatorfactory, a, b int) int {
        op := factory.create()
        op.seta(a)
        op.setb(b)
        return op.result()
    }
    
    func testoperator(t *testing.t) {
        var (
            factory operatorfactory
        )
    
        factory = plusoperatorfactory{}
        if compute(factory, 1, 2) != 3 {
            t.fatal("error with factory method pattern")
        }
    
        factory = minusoperatorfactory{}
        if compute(factory, 4, 2) != 2 {
            t.fatal("error with factory method pattern")
        }
    }