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

什么是开闭原则

开闭原则的英文全称是 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")

总结

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

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/186656.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Linux安装Java环境

处理安装环境 检查系统版本 [rootjeven ~]# cat /etc/centos-release CentOS Linux release 7.6.1810 (Core)检查系统内核版本 [rootjeven ~]# uname -r 6.1.8-1.el7.elrepo.x86_64清空卸载java环境(如果已经安装了) 查询java所在位置 [rootjeven …

node =》 path 模块的常用API

目录 简介 API path.join([...paths]):将所有给定的路径片段连接在一起,并规范化生成的路径。 path.resolve([...paths]):将路径或路径片段的序列解析为绝对路径。 path.basename(path[, ext]):返回路径的最后一部分&#xf…

什么是Anaconda?作用是?使用python必须要安装嘛?

一、什么是Anaconda以及其作用? 通俗来讲,Anaconda算是一个环境容器,也可以叫环境管理器。 作用:可以在Anaconda容器中为python项目创建不同的环境。在各个不同环境中可以安装不同版本的包并且各个环境互不影响。可以在使用不同项…

自动驾驶DCLC 功能规范

目录 1 概述Summary....................................................................................................... 4 1.1 目的Purpose....................................................................................................... 4 1.2 范围Ran…

每天学习一点点之 MySQL TINYINT

我已经不是第一次遇到关于 TINYINT 的问题了。在 MySQL 中,当我们将某个字段设置为 TINYINT,随着业务的扩展,我们可能会发现 TINYINT 的范围无法满足需求。这时需要修改字段属性。但如果表的数据量很大,或者由于分表导致涉及的表数…

ARM安全架构——为复杂软件提供保护

目录 一、概述 二、栈溢出和执行权限 三、面向返回的编程ROP 四、面向跳转的编程(JOP) 五、将这些技术应用于实际代码 七、检查你的知识

java+springboot物流管理系统设计与实现wl-ssmj+jsp

物流管理系统的开发和综合性的物流信息网站平台的建设。研究的重点是运输管理信息系统.本系统是一套基于运输作业流程的管理系统,该系统以运输任务、货品、商务三大线索设计开发。运输任务是该管理系统的核心,系统通过对运输任务中的接收、调…

Linux C语言 36-文件处理补充

Linux C语言 36-文件处理补充 本节关键字:C语言 文件操作,文件处理,文件创建,文件信息,文件删除,目录创建,目录信息,目录遍历,目录递归遍历 相关C库函数:acc…

[cocos creator]EditBox,editing-return事件,清空输入框

需求: 监听EditBox,editing-return 回车事件,在输入框内点击回车后,发送内容,并清空输入框 问题: 设置node.getComponent(EditBox).string ; 没有效果 解决办法: //设置string 为空 this.v…

应用程序APP制作用Vue3CreateApp打包有什么优势?有哪些好处?

在当代的前端开发领域,Vue.js作为一个领先的JavaScript框架,一直处于技术革新和发展的前沿。Vue3作为该框架的最新版本,带来了更多的新特性和优化。在这些新特性中,createApp方法是一个非常值得关注的变化。对于开发者而言&#x…

osg demo汇总

1.example_osganimate 演示了路径动画的使用(AnimationPath、AnimationPathCallback),路径动画回调能够做用在Camera、CameraView、MatrixTransform、PositionAttitudeTransform等四种类型的节点上。 演示了osgSim::OverlayNode的使用node 2…

[操作系统] 大厂必问~虚拟内存系列

文章目录 4.1 什么是虚拟内存(Virtual Memory)?4.2 局部性原理4.3 虚拟存储器4.4 虚拟内存的技术实现4.5 页面置换算法OPT 页面置换算法(最佳页面置换算法)FIFO(First In First Out) 页面置换算法(先进先出页面置换算…

MyBatis教程之逆向工程(十一)

正向工程:先创建Java实体类,由框架负责根据实体类生成数据库表。Hibernate是支持正向工程 的。逆向工程:先创建数据库表,由框架负责根据数据库表,反向生成如下资源: 1.Java实体类 2.Mapper…

使用easyExcel框架报错:服务器缺少字体

后台服务使用easyExcel框架生成表格,但是生成的时候报如下的错误: 这种报错其实就是部署服务的服务器缺少字体,正确的方法是安装字体。需要注意的是,测试环境服务器与生产环境服务器的在配置版本上可能存在差异,因此需…

初识Java 18-6 泛型

目录 潜在类型机制 支持潜在类型机制的语言 Python的潜在类型机制 C的潜在类型机制 Java中的直接潜在类型机制 潜在类型机制的替代方案 反射 将方法应用于序列中的每个元素 Java 8的潜在类型机制(间接实现) 潜在类型机制的使用例(S…

『 MySQL数据库 』CRUD之UD,表的数据更新(修改)及删除

文章目录 🥩 Update (更新/修改) 🦖🥚 修改单行数据的某个字段内的数据 🦕🥚 配合LIMIT分页与ORDER BY 对符合条件的多条数据进行修改 🦕🥚 对整表的某个数据字段进行修改 🦕 &#…

MySQL--锁

锁 锁是mysql在并发访问时,解决数据访问一致性、有效性的一种机制 mysq中的锁,按照锁的粒度分,分为以下三类: 全局锁:锁定数据库中的所有表 表级锁:每次操作锁住整张表 行级锁:每次操作锁住对…

Android 架构实战MVI进阶

MVI架构的原理和流程 MVI架构是一种基于响应式编程的架构模式,它将应用程序分为四个核心组件:模型(Model)、视图(View)、意图(Intent)和状态(State)。 原理&…

【AntDB数据库】国产数据库崛起之狂飙猛进的互联网技术

中国作为人口大国,也是重要的人才资源大国,人口大国带来了国外数据库厂商在世界其他国家不曾出现的高复杂高密度的需求场景,而人才资源大国则让我们在互联网尤其是移动互联网方面奋起直追,甚至达到了全球领先的水平,进…

JS的原生函数

JS的原生函数,包括:String()、Number()、Boolean()、Array()、Object()、Function()、RegExp(&…