开闭原则：提高扩展性的小技巧

什么是开闭原则

开闭原则的英文全称是 Open Closed Principle，简写为 OCP。它的英文描述是: software entities (modules, classes, functions, etc.) should be open for extension , but closed for modification。我们把它翻译成中文就是:软件实体(模块、类、方法等) 应该"对扩展开放、对修改关闭"。

真实的开发场景是：添加一个新的功能应该是，在已有代码基础上扩展代码(新增模块、类、方法等)，而非修改已有代码(修改模块、类、方法等)。

为什么要遵守开闭原则

不知道大家有没有遇到过修改场景A的代码，却影响了场景B的功能，究其原因就是场景A的代码和场景B的代码耦合在一起了。

而开闭原则正是代码低耦合高内聚的利器，遵守开闭原则可以使代码更加可维护、可扩展和可重用。这是因为开闭原则强调了代码应该对扩展开放，对修改关闭，这意味着在修改已有代码时，不应该修改原本已经存在的代码，而是通过扩展现有代码的功能，来实现新的需求。这样可以减少代码的修改次数，从而减少引入新 bug 的风险，也避免了对其他代码逻辑的影响。同时，遵守开闭原则可以让代码更容易扩展和重用，因为它们是基于现有代码构建的，而不是对现有代码进行修改。总之，遵守开闭原则可以使代码更加灵活、可靠和易于维护。

如何做到"对扩展开放、修改关闭"?

我们已经知道开闭原则的定义，那我们如何遵守开闭原则呢？下面我会从思想层面和实际编码层面和大家分享一些小经验。

扩展意识、抽象意识、封装意识

扩展意识

在写代码的时候，我们要多花点时间往前多思考一下，这段代码未来可能有哪些需求变更、如何设计代码结构，事先留好扩展点，以便在未来需求变更的时候，不需要改动代码整体结构、做到最小代码改动的情况下，新的代码能够很灵活地插入到扩展点上，做到"对扩展开放、对修改关闭"。

例如我们现在要开发一个微信支付的功能，那我们就需要思考以后会不会出现支付宝支付、银行卡支付等其他的支付方式，如果出现其他支付方式那我们现在如和设计我们的代码来方便以后的扩展。

抽象意识、封装意识

抽象意识与代码扩展性有什么关系呢？

如果要回答这个问题，首先我们要知道抽象与具体实现之间的关系，个人理解抽象就是从更高级别的角度去看待一件事、一个物，举个例子：92式手枪、95式突击步枪、88式狙击枪这些武器在更高层面上都可以抽象成"能开火发射子弹的武器"，我们先把"能开火发射子弹的武器"暂且叫做"枪"，"枪"就是92式手枪、95式突击步枪、88式狙击枪等武器的抽象，而92式手枪、95式突击步枪、88式狙击枪就是"枪"的具体实现。

我们再以支付功能为例，进行支付就是一种抽象，具体是微信支付还是支付宝支付就是具体实现。

通常情况下抽象是简单稳定的，具体实现是复杂的、多变的。针对复杂多变的具体实现我们可以将其封装起来隔离复杂性和不确定性的扩散。

一个固定抽象支持不同的实现就是扩展性。

入参提高扩展性的技巧

将参数封装成一个对象

// 重构前
func A(a, b, c string) {
    // ...
}

// 重构后
type Args struct{
    a string
    b string
    c string
}

func A(args Args) {}

重构后的代码相对于重构前扩展性更好，当需要添加参数时只需要扩展Args结构体的字段就行，函数的签名不用改动，函数的调用者基本上也不用改动。

可变变量

func doSomething(arg ...interface{}) {
    switch len(arg) {
    case 0:
       // ...
    case 1:
       // ...
    case 2:
       // ...
    case 3:
       // ...
    case 4:
       // ...
    default:
       // ...
    }
}

使用可变参数，代码的灵活性和扩展性都能得到提高

函数选项模式（推荐）

type Connection struct{}

type stuffClient struct {
    conn    Connection
    timeout int
    retries int
}

type StuffClientOption func(*stuffClient)

func NewStuffClient(conn Connection, opts ...StuffClientOption) stuffClient {
    client := stuffClient{}
    for _, o := range opts {
       o(&client)
    }
    client.conn = conn
    return client
}

func WithRetries(r int) StuffClientOption {
    return func(o *stuffClient) {
       o.retries = r
    }
}
func WithTimeout(t int) StuffClientOption {
    return func(o *stuffClient) {
       o.timeout = t
    }
}

func main() {
    connection := Connection{}
    client := NewStuffClient(connection, WithRetries(3), WithTimeout(3))
}

选项模式：代码设计时，就考虑到扩展性，通过传递不同选项达到设置不同属性的目的。

出参提高扩展性的技巧

与入参提高扩展性的方法类似，提高出参的扩展性也可以将将返回值封装在一个对象里面：

// 重构前
func A() (a, b, c string) {
    return
}
a, b, c := A()

// 重构后
type Res struct{
    a string
    b string
    c string
}

func A() (res Res) {
    return
}
res := A()

当返回值添加字段和减少字段时，都不需要修改函数的声明，同样函数调用处的修改也是很少，甚至不需要修改。

代码逻辑扩展性的技巧

注册插件

type handler func(args ...interface{})
type EventBus struct {
    handlers map[string][]handler
}

// 注册事件，提供事件名和回调函数
func (e *EventBus) RegisterEvent(name string, eventHandle handler) (err error) {
    // ...
    if _, ok := e.handlers[name]; ok {
       e.handlers[name] = append(e.handlers[name], eventHandle)
    } else {
       e.handlers[name] = []handler{eventHandle}
    }
    return nil
}

// 触发事件
func (e *EventBus) TriggerEvent(name, requestId string, param ...interface{}) (err error) {
    // ....
    handlers, ok := e.handlers[name]
    if !ok {
       log.Error(requestId, "RegisterEvent_err", err, name)
       return
    }
    for _, handler := range handlers {
       handler()
    }

    return nil
}

// 支付成功事件
var e = &EventBus{}

func EventInit() {
    e.RegisterEvent("pay_ok", func(args ...interface{}) {
       // 支付成功通知保单
    })
    e.RegisterEvent("pay_ok", func(args ...interface{}) {
       // 支付成功发送支付成功事件
    })
    e.RegisterEvent("pay_ok", func(args ...interface{}) {
       // 支付成功给用户发送短信
    })
}

func NewEventBus() *EventBus {
    return e
}

func main() {
    eb := NewEventBus()
    EventInit()
    eb.TriggerEvent("pay_ok", "requestId", 1, 2, 3)
}

如果支付成功时想添加其他的业务逻辑，例如返现、添加积分等，我们只需要在注册一个handler就行了。

策略模式

以支付为例，下边例子是支付宝支付和微信支付的支付流程，使用的是典型面向过程的写法。

// 反例
func Pay(arg) {
    // ...
    if arg.Type == "alipay" {
       // 创建订单
       CreateAlipayOrder()
       // 调用RPC进行支付
       AlipayPayRpc()
       // 更新订单
       UpdateAlipayOrder()
    } else if arg.Type == "weixin" {
       // 创建订单
       CreateWXOrder()
       // 调用RPC进行支付
       WXPayRpc()
       // 更新订单
       UpdateWXOrder()
    }
}

上面的问题：

1. 违反开闭原则：如果新加一种支付平台就要新写一个if-else分支，扩展性非常低。

2. 违背单一原则：处理支付宝支付又处理微信支付。

3. 面向过程：略。。。

下面使用策率模式、工厂模式+面向接口来重构上面的代码。

// 定义接口
type Payer interface {
    CreateOrder()
    PayRpc()
    UpdateOrder()
}

// 支付宝支付实现
type Alipay struct {}
func (a *Alipay)CreateOrder(){
    // ...
}
func (a *Alipay)PayRpc(){
    // ...
}
func (a *Alipay)UpdateOrder(){
    // ...
}

// 微信支付实现
type Wxpay struct {}
func (w *Wxpay)CreateOrder(){
// ...
}
func (w *Wxpay)PayRpc(){
// ...
}
func (w *Wxpay)UpdateOrder(){/
/ ...
}

// 工厂+策略模式
func NewPayer(PayType string) Payer {
    switch PayType {
    case "alipay":return &Alipay{}
    case "weixin":return &Wxpay{}
    // case "other":
            // retrun &OtherPay{}
    }
}
    
func Pay(arg) {
    payer := NewPayer(arg.type)
    
    payer.CreateOrder()

    payer.PayRpc()

    payer.UpdateOrder()
}

由面向过程编程改成面向接口编程，支付逻辑更加简洁，同时扩展性也得到了提升，如果需要增加新的支付平台Pay函数的代码基本不用改，只需要增加一个其他平台支付的实现，并在工厂里面添加一个case。

依赖注入

以发送通知为例，下面Notification类直接在代码里通过new MessageSender();直接依赖了MessageSender类，所以Notification只能发送MessageSender类消息。

// 非依赖注入实现方式
public class Notification {
    private MessageSender messageSender;
    public Notification() {
        this.messageSender = new MessageSender(); // 此处有点像 hardcode
    }
    public void sendMessage(String cellphone, String message) { //... 省略校验逻辑等...
        this.messageSender.send(cellphone, message);
    } 
}

public class MessageSender {
    public void send(String cellphone, String message) {
        //....
    } 
}
// 使用 Notification
Notification notification = new Notification();
notification.sendMessage("10086", "hello world")

如果通过依赖注入的方式，Notification类就可以发送任何通过依赖注入传进来的消息。

// 依赖注入
public class Notification {
    private MessageSender messageSender;
    public Notification(MessageSender messageSender) {
        this.messageSender = messageSender;
    } 
    public void sendMessage(String cellphone, String message) {
        this.messageSender.send(cellphone, message);
    } 
}

public interface MessageSender {
    void send(String cellphone, String message);
}

// 短信发送类
public class SmsSender implements MessageSender {
    @Override
    public void send(String cellphone, String message) {
        //....
    } 
}

// 站内信发送类
public class InboxSender implements MessageSender {
    @Override
    public void send(String cellphone, String message) {
        //....
    } 
}

// 短信
MessageSender messageSender = new SmsSender();
Notification notification = new Notification(messageSender);
notification.sendMessage("10086", "hello world")
// 站内信
MessageSender messageSender = new InboxSender();
Notification notification = new Notification(messageSender);
notification.sendMessage("10086", "hello world")

总结

开闭原则是面向对象设计中非常重要的一个原则，它可以帮助我们编写更加可维护、可扩展和可重用的代码。要实现开闭原则，我们可以使用抽象化、多态性和设计模式等方法。