网站建设参数,photoshop网课培训,网站建设公司在哪里找资源,番禺网站建设开发什么是开闭原则
开闭原则的英文全称是 Open Closed Principle#xff0c;简写为 OCP。它的英文描述是: software entities (modules, classes, functions, etc.) should be open for extension , but closed for modification。我们把它翻译成中文就是:软件实体(模块、类、方…什么是开闭原则
开闭原则的英文全称是 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 stringb stringc 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 stringb stringc 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()}
}
上面的问题
违反开闭原则如果新加一种支付平台就要新写一个if-else分支扩展性非常低。
违背单一原则处理支付宝支付又处理微信支付。
面向过程略。。。
下面使用策率模式、工厂模式面向接口来重构上面的代码。
// 定义接口
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 {Overridepublic void send(String cellphone, String message) {//....}
}// 站内信发送类
public class InboxSender implements MessageSender {Overridepublic 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)
总结
开闭原则是面向对象设计中非常重要的一个原则它可以帮助我们编写更加可维护、可扩展和可重用的代码。要实现开闭原则我们可以使用抽象化、多态性和设计模式等方法。
