本文通过一个电商系统“限时折扣”功能从快速上线到逐渐演变为复杂黑箱的典型案例,深入剖析了软件系统为何越做越乱的根本原因——复杂性的累积。文章指出,复杂性并非源于重大错误,而是由无数看似合理的小妥协(如随意添加开关、复制逻辑、临时补丁)层层叠加所致,最终导致变更放大、认知负荷加重、未知的未知增多。在此基础上,文章对比了“战术性编程”(追求短期交付速度,忽视设计)与“战略性编程”(以长期可维护性为目标,持续投入10%–20%时间优化架构)的本质差异,并系统阐述了管理复杂性的核心方法。作者强调:真正的开发速度来自良好设计,而非侥幸“跑起来”;每一次对设计的轻视,都在为未来的瘫痪埋下伏笔。
前言小故事
文章的开始,首先来看一个AI帮忙写的小故事《限时折扣到“补丁风暴”的一年》。
第一周:破局的英雄
电商团队要在两周内上线“限时折扣”。产品经理说,这波活动成败在此。阿杰是团队里的“战术快枪手”,当晚就把需求“跑起来”了:他在订单服务里加了一个大开关,判断当前时间是否命中折扣时段,如果是,就在结算价上直接打一个比例折扣。没有新服务、没有抽象、测试也只有两条冒烟用例。第二天演示一切顺利,大家鼓掌,产品表扬“效率太高”。
第三周:再来一个
“团购”和“会员价”紧接着到来。阿杰把限时折扣的那段逻辑复制了一份,叠加两个if分支,再加上两个Feature Flag。因为赶时间,他把用户等级的查询直接打到了用户服务的同步接口里,并在超时的时候默认用户是普通会员,避免影响下单成功率。上线顺利,数字也漂亮,项目周会上,大家一致认为这套“战术打法”可复制。
第二个月:小问题,但能修
第一个诡异Bug出现:会员价和满减券叠加时,有时多打了一次折。回溯发现是一个分支顺序问题。阿杰十分钟修好了:他在优惠计算前面加了一个短路条件,遇到某些券就跳过后面的逻辑。为稳妥,他又加了一个保护开关,默认开启。产品问是否要重构?阿杰看了看排期表说:“等这波活动过了先,不然这个月目标完不成。”
第四个月:复杂悄悄长大
需求继续滚动:“新人礼金”“跨品类满减”“店铺券优先级”。每次都很紧,每次都能“跑起来”。订单服务里的折扣模块从两个文件长成了十几个文件,方法名里充满了and/or/byGroup/byMember的后缀。构建时间变长了,代码审查也越来越像形式走过场:大家都知道,真正的问题在于设计,但没人有时间停下来改。
第六个月:补丁叠补丁
有一天凌晨,线上报警:东八区和UTC时间换算错了,午夜跨天时部分订单重复计算折扣。阿杰拉起小团队开了个Zoom,二十分钟上线了一个临时补丁:在午夜前后5分钟内,把两个时间都计算一遍,取最小值。问题止住了,技术群里一片赞扬。第二天复盘,大家写下了“待重构”的卡片,又被新一轮活动排期盖过去。
第九个月:谁来重构?
一个关键需求来了:“跨店合并优惠”,而且要支持活动实时生效、规则热更新。阿杰说,这事儿用现在的代码堆不起来了,需要一个规则引擎,把“优惠规则”“应用顺序”“冲突解决”抽成模型,至少两个月。产品摇头:大促在即,必须四周上线。会议室陷入沉默。最终的决定是:先在旧逻辑上面再搭一层“适配器”,把新规则翻译成旧分支能理解的形式。上线勉强过了,但从那之后,任何一个小小的改动都会牵动三处地方,回归测试用例从20条涨到200条。
第十一个月:速度的假象
新来的同学花了一周才敢改第一行逻辑——因为一处看似无害的改动,可能触发四个开关下的三种叠加路径,线上又会冒出某个边角Bug。阿杰依旧很“快”,他熟悉每个旮旯,知道该在哪一层加一个临时判断,问题能被“快刀”切开。团队里的其他人看起来变“慢”了:他们需要读懂上下游的耦合、确认二十个开关的默认状态、跑几百条回归。这种对比让管理层误以为“还是战术有效”。
一年后:代价账单
系统的复杂性不是某个大错误造成的,而是无数小捷径的总和。每一个“合理的妥协”——多一个开关、复制一段逻辑、加一个短路条件——当时都像救命稻草,叠起来就是沼泽。现在,任何一次真正的重构都需要数月时间、跨四个服务、影响五条业务线,排期里根本挤不进去。团队开始习惯了补丁式思维:先把新功能“跑起来”,出了问题再补。补丁带来更多复杂性,更多复杂性产生更多补丁,系统变成了一个谁也不想碰的黑箱。
尾声:如果可以重来
回望最初的“限时折扣”,当时若花两三天把“优惠规则—应用顺序—冲突解决—时间模型”抽出个雏形,设立基本的用例与回归框架,后面每个需求的边际成本都会更低。战术并非不重要,但如果没有战略性设计作为地基,战术的每一次成功,都在为下一次失败埋雷。真正的速度来自良好的设计,而不是一次次“跑起来”的侥幸。
看完上述的小故事,不知道大家是否曾经亲身经历或者遇到过类似的场景。在开发生涯的早期阶段,很多开发者包括我都会犯“战术快枪手”的毛病。战术快枪手总是喜欢“战术编程”,即不为未来做考虑,只想快速地完成眼前的需求,哪怕引入一些复杂性或者bug。而多次的战术编程的代价就是系统变得格外复杂。
复杂性的本质
复杂性存在多种形式。例如,可能很难理解一段代码是如何工作的。可能需要花费很多精力才能实现较小的改进,或者可能不清楚必须修改系统的哪些部分才能完成新特性。如果一个软件系统难以理解和修改,那就很复杂。如果很容易理解和修改,那就很简单。
阅读代码的人比写代码的人更容易理解复杂性。如果你编写了一段代码,可能对你来说很简单,但是其他人则认为它很复杂,那么它就是复杂的。
▐复杂性的表现
复杂性一般有以下三种表现:
变更放大:看似简单的变更需要在许多不同地方进行代码修改。认知负荷:指开发者需要多少知识才能完成一项任务。较高的认知负担意味着开发者必须花更多的时间来学习所需的信息,并且可能错过重要的东西而导致引发bug的可能性也更大。未知的未知:必须修改哪些代码才能完成任务,或者开发者必须获得哪些信息才能成功地执行任务,这些信息不明显。
▐复杂性的原因
良好设计的最重要目标之一就是使系统显而易见。在一个显而易见的系统中,开发者可以快速了解现有代码的工作方式以及变更所需的内容。一个显而易见的系统是,开发者可以在不费力地思考的情况下快速猜测要做什么,同时又可以确信该猜测是正确的。
依赖
复杂性的第一个原因是依赖,依赖关系是软件的基本组成部分,无法完全消除。实际上,我们在软件设计过程中有意引入了依赖。每次编写新类时,都会围绕该类的API创建依赖关系。但是,软件设计的目标之一是减少依赖关系的数量,并使依赖关系保持尽可能简单和明显。
晦涩
复杂性的第二个原因是晦涩。当重要的信息不明显时,就会发生模糊。一个简单的例子是变量名称如果过于笼统就没有携带太多有用的信息。或者,某个变量的文档没有说明它的单位(秒还是毫秒?),所以找到它的唯一方法是扫描代码中使用该变量的位置。晦涩常常与依赖项相关联。
``
依赖和晦涩共同导致了上述描述的三种表现。依赖导致变化放大和高认知负荷。晦涩会产生未知的未知数,还会增加认知负担。如果能找到最小化依赖关系和模糊性的设计技巧,那么我们就可以降低软件的复杂性。
复杂性不是由单个致命性错误引起的;而是由很多小的错误堆积而成。之所以会出现复杂性,是因为随着时间的流逝,成千上万的小的依赖和晦涩问题层层堆叠。最终,这些小问题太多了,以至于对系统的每次可能更改都会受到其中几个问题的影响。
战术性编程 VS 战略性编程
前面提到了战术编程,即开发思路是“越快完成任务越好,之后的问题之后再说”。其代码特点是“不会花费太多时间来寻找最佳设计,每次增加一些复杂性或引入一两个小错误”。
几乎每个软件开发团队都有至少一个将战术编程发挥到极致的开发者:战术快枪手。战术快枪手是一位多产的开发者,他编写代码的速度比其他人快得多。实施新功能时,没有人能比战术快枪手更快地完成任务。在某些组织中,管理层将战术快枪手视为英雄。但是,战术快枪手留下了风卷残云般的痕迹。他们很少被将接手代码的开发者视为英雄。通常,其他开发者必须清理战术快枪手留下的混乱局面,这使得那些接手的开发者的开发速度好像比战术快枪手慢。
成为一名优秀的开发者的第一步是要意识到仅工作代码是不够的。引入不必要的复杂性以更快地完成当前任务不是长宜之计。最重要的是系统的长期架构。任何系统中的大多数代码都是通过扩展现有代码库编写的。因此,作为开发者,最重要的工作就是使得未来的架构易于扩展。因此,尽管眼前的需求很紧急、很重要,但不应将“完成需求”视为主要目标。我们的主要目标必须是设计出卓越的架构,并且这种架构也能满足当前的需求。这是战略。
战略性编程需要一种投资心态。我们必须花费时间来改进系统的设计,而不是采取最快的方式来完成当前的项目。这些投资会在短期内让我们放慢脚步,但从长远来看会加快我们的速度。
那么,正确的投资比例是多少?随着我们对系统和业务的不断了解,理想的设计会逐渐出现。因此,最好的方法是连续进行大量小额投资。建议我们将总开发时间的10%到20%用于投资。该比例足够小,不会对我们的日常安排产生重大影响,但又足够大,可以随着时间的推移产生重大收益。因此,虽然项目在开始时比纯战术方案多花费10-20%的时间。但是额外的时间将带来更好的软件设计,并且我们将在几个月内开始逐渐体现。不久之后,我们的开发速度将比战术编程快至少10–20%。最终,我们过去投资节省的时间足以抵消一开始做投入的时间。马上就可以收回初始投资的成本。
一种好的思维方式是将今天的事情今天解决。当遇到难题时,大家总是会想下次再去优化。但是,这是一个隐形的坑。一旦这次选择推迟优化,之后也基本会继续推迟优化,并且不知不觉中就变成了战术快枪手。总之,等待解决问题的时间越长,问题就会变得越大;解决方案变得更加令人生畏,这使得轻松推迟解决方案变得更加容易。
如何管理复杂性
管理软件复杂性最重要的技术之一就是对系统好好设计,以便开发者在任何规定时间只需要面对整体复杂性的一小部分。
▐抽象和细节
为了管理依赖关系,我们将每个模块分为两个部分:接口和实现。接口包含使用其他模块的开发者必须知道的所有内容,才能使用给定的模块。通常,接口描述模块做什么,而不描述模块如何做。该实现由执行接口所承诺的代码组成。在特定模块中工作的开发者必须了解该模块的接口和实现,以及由给定模块调用的任何其他模块的接口。除了正在使用的模块以外,开发者无需了解其他模块的实现。
最好的模块是那些其接口比其实现简单得多的模块。这样的模块具有两个优点。首先,一个简单的接口可以将模块强加于系统其余部分的复杂性降至最低。其次,如果以不更改其接口的方式修改了一个模块,则该修改不会影响其他模块。如果模块的接口比其实现简单得多,则可以在不影响其他模块的情况下更改模块的许多方面。
模块的接口包含两种信息:正式信息和非正式信息。接口的形式部分在代码中明确指定,并且其中一些可以通过编程语言检查其正确性。例如,方法的形式接口是其签名,其中包括其参数的名称和类型,其返回值的类型以及有关该方法引发的异常的信息。
每个接口还包括非正式元素。这些没有以编程语言可以理解或执行的方式指定。接口的非正式部分包括其高级行为,例如,函数删除由其参数之一命名的文件的事实。如果对类的使用在限制(比如必须先调用另一个方法),则这些约束也是类接口的一部分。通常,如果开发者需要了解特定信息才能使用模块,则该信息是模块接口的一部分。接口的非正式方面只能使用注释来描述,而编程语言不能确保描述是完整或准确的。对于大多数接口,非正式方面比正式方面更大,更复杂。
术语抽象与模块化设计的思想紧密相关。抽象是实体的简化视图,其中省略了不重要的细节。抽象是有用的,因为它们使我们更容易思考和操纵复杂的事物。
在抽象的定义中,“无关紧要”一词至关重要。从抽象中忽略的不重要的细节越多越好。但是,如果细节不重要,则只能将其从抽象中省略。抽象可以通过两种方式出错。首先,它可以包含并非真正重要的细节。当这种情况发生时,它会使抽象变得不必要的复杂,从而增加了使用抽象的开发者的认知负担。第二个错误是抽象忽略了真正重要的细节。这导致模糊不清:仅查看抽象的开发者将不会获得正确使用抽象所需的全部信息。忽略重要细节的抽象是错误的抽象:它可能看起来很简单,但实际上并非如此。
我们不仅依靠抽象来管理复杂性,而且不仅在编程中,而且在日常生活中无处不在。举个例子,汽车提供了一种简单的抽象概念,使我们可以在不了解电动机,电池电源管理,防抱死制动,巡航控制等机制的情况下驾驶它们。
▐深模块和浅模块
``
最好的模块是那些提供强大功能但具有简单接口的模块。本文用“深入”一词来描述这样的模块。为了形象化深度的概念,假设每个模块都由一个矩形表示。每个矩形的面积与模块实现的功能成比例。矩形的顶部边缘代表模块的接口;边缘的长度表示接口的复杂性。最好的模块很深:它们在简单的接口后隐藏了许多功能。深模块是一个很好的抽象,因为其内部复杂性的一小部分对其用户可见。
模块深度是考虑成本与收益的一种方式。模块提供的好处是其功能。模块的成本是其接口。模块的接口代表了模块强加给系统其余部分的复杂性:接口越小越简单,引入的复杂性就越小。最好的模块是那些收益最大,成本最低的模块。接口不错,但更多或更大的接口不一定更好。
深模块的另一个示例是诸如Go或Java之类的语言中的垃圾收集器。这个模块根本没有接口。它在后台进行隐形操作以回收未使用的内存。由于将垃圾收集消除了用于释放对象的接口,因此向系统中添加垃圾回收实际上会缩小其总体接口。垃圾收集器的实现非常复杂,但是使用该语言的开发者却无需关注这种复杂性。
▐信息隐藏和信息泄露
实现深层模块最重要的技术是信息隐藏。基本思想是每个模块应封装一些知识,这些知识代表设计决策。
比如如何实现TCP网络协议。如何在多核处理器上调度线程。如何解析JSON文档。这些知识都嵌入在模块的实现中,但不会出现在其接口中,因此其他模块不可见。
-
信息隐藏
信息隐藏在两个方面降低了复杂性。首先,它将接口简化为模块。接口反映了模块功能的更简单、更抽象的视图,并隐藏了细节;这减少了使用该模块的开发者的认知负担。其次,信息隐藏使系统更容易迭代。如果隐藏了一段信息,那么在包含该信息的模块之外就不再对该信息的依赖,因此与该信息相关的设计更改将只影响一个模块。设计新模块时,应仔细考虑可以在该模块中隐藏哪些信息。如果我们可以隐藏更多信息,则还应该能够简化模块的接口,这会使模块更深。
信息隐藏的最佳形式是将信息完全隐藏在模块中,从而使该信息对模块的用户无关且不可见。但是,部分信息隐藏也具有价值。例如,如果某个类的某些用户仅需要特定的功能或信息,并且可以通过单独的方法对其进行访问,以使其在最常见的用例中不可见,则该信息通常会被隐藏。与类的每个用户可见的信息相比,此类信息将创建更少的依赖项。
除此之外,信息隐藏也可以应用于系统中的其他级别,例如类级别。尝试在一个类中设计私有方法,以便每个方法都封装一些信息或功能,并将其隐藏在类的其余部分中。此外,请尽量减少使用每个实例变量的位置数量。有些变量可能需要在整个类中广泛使用,但是其他变量可能只需要在少数地方使用;如果可以减少使用变量的位置的数量,则将消除类内的依赖关系并降低其复杂性。
-
信息泄漏
信息隐藏的反面是信息泄漏。当一个设计决策反映在多个模块中时,就会发生信息泄漏。这在模块之间创建了依赖关系:对该设计决策的任何更改都将要求对所有涉及的模块进行更改。如果格式更改,则两个类都将需要修改。
信息泄漏是软件设计中最重要的危险信号之一。作为一个开发者,我们能学到的最好的技能之一就是对信息泄露的高度敏感性。如果我们在类之间发现信息泄漏,请自问“我如何才能重新组织这些类,使这些特定的知识只影响一个类?”如果受影响的类相对较小,并且与泄漏的信息紧密相关,那么将它们合并到一个类中是有意义的。另一种可能的方法是从所有受影响的类中提取信息,并创建一个只封装这些信息的新类。但是,这种方法只有在我们能够找到一个从细节中抽象出来的简单接口时才有效;如果新类通过其接口公开了大部分知识,那么它就不会提供太多的价值。
信息泄漏的一个常见原因称为时间分解的设计风格。在时间分解中,系统的结构对应于操作将发生的时间顺序。考虑一个应用程序,该应用程序以特定格式读取文件,修改文件内容,然后再次将文件写出。通过时间分解,该应用程序可以分为三类:一类用于读取文件,另一类用于执行修改,第三类用于写出新版本。文件读取和文件写入步骤都具有有关文件格式的知识,这会导致信息泄漏。解决方案是将用于读写文件的核心机制结合到一个类中。该类将在应用程序的读取和写入阶段使用。在日常开发过程中,我们很容易陷入时间分解的陷阱,因为在编写代码时通常会想到必须执行操作的顺序。但是,大多数设计决策会在应用程序的整个生命周期中的多个不同时刻表现出来。结果就是时间分解常常导致信息泄漏。
在时间分解中,执行顺序反映在代码结构中:在不同时间发生的操作在不同的方法或类中。如果在执行的不同点使用相同的知识,则会在多个位置对其进行编码,从而导致信息泄漏。
最后需要提醒的是,仅当在其模块外部不需要隐藏信息时,隐藏信息才有意义。如果模块外部需要该信息,则不得隐藏它。假设模块的性能受某些配置参数的影响,并且模块的不同用途将需要对参数进行不同的设置。在这种情况下,将参数暴露在模块的接口中很重要,以便可以对其进行适当的旋转。作为开发者,我们的目标应该是最大限度地减少模块外部所需的信息量。例如,如果模块可以自动调整其配置,那将比公开配置参数更好。但是,最重要的是要识别模块外部需要哪些信息,并确保将其公开。
专用好还是通用好
设计新模块时,我们面临的最普通的决策之一就是是以通用还是专用方式实现它。有人可能会说,不管什么情况下,我们都应该采用通用方法,我们应该追求一种可用于解决广泛问题的机制,而不仅是眼前重要的问题。在这种情况下,新机制可能会在将来发现意外用途,从而节省时间。
另一方面,我们知道很难预测软件系统的演变方向,因此通用解决方案可能包含从未真正需要的功能。此外,如果我们实现的东西过于通用,那么可能无法很好地解决我们今天遇到的特定问题。结果,另外一些人可能会说,最好只关注眼前的需求,完成我们所知道的需求,并针对我们今天打算使用的方式进行特殊处理。如果我们采用特殊处理并在以后发现更多用途,则始终可以对其进行重构以使其通用。专用方法似乎与软件开发的增量方法一致。
▐“有点”通用比较好
以笔者个人的经验,最有效的方法是有点通用的方式实现新模块。“有点通用”表示该模块的功能应反映我们当前的需求,但其接口则不应该这样。相反,该接口应该足够通用以支持多种用途。该接口应易于使用,以满足眼前的需求,而不必专门与它们联系在一起。“有点”这个词很重要:不要被带偏追求过于通用的东西,以至于反而很难满足当前的需求。
通用方法最重要的好处是,与专用方法相比,它产生了更简单,更深入的接口。如果我们将该类用于其他目的,则通用方法还可以节省将来的时间。但是,即使该模块仅用于其原始用途,由于其简单性,通用方法仍然更好。
满足我当前所有需求的最简单的接口是什么?
如果在不减少 API 整体功能的情况下减少其方法数量,那么很可能是创建了更加通用的方法。只有在每个方法的 API 保持简单的情况下,减少方法的数量才有意义。如果为了减少方法的数量而不得不引入大量额外的参数,那可能这不是真正的简化。
这个接口会在多少情况下使用?
如果一个方法是为专用而设计的,则意味着它可能过于专用。看看能否用一个通用方法取代几个专用方法。
这个接口是否已经满足我当前的需求?
这个问题可以帮助我们确定何时使接口变得简单而通用。如果我们必须编写许多其他代码才能将类用于当前用途,那么这是一个危险信号,即该接口未提供正确的功能。
通用接口比专用接口具有许多优点。它们往往更简单,使用的方法更少。它们还提供了类之间的更清晰的分隔,而专用接口则倾向于在类之间泄漏信息。使模块具有某种通用性是降低整体系统复杂性的最佳方法之一。
▐专用代码无法完全避免
但是大多数软件系统都不可避免地有一些专用代码。例如应用程序为其用户提供专用特性,这些特性通常是高度专用的。因此通常不可能完全消除专用性。不过专用代码应该与通用代码清晰的分离,这可以通过将专用代码在软件栈中向上推或者向向下推来实现。
分离专用代码的一种方法是向上推。应用程序的顶层类提供专用特性,必然会针对这些专用特性做一些优化。但这种专用并不会渗透到用于实现这些特性的底层类中。
有时最好的方法是向下推专用代码。设备驱动程序就是一个例子。操作系统通常必须支持成百上千种不同的设备类型。设备驱动程序模块使得使用该设备的专用特性来实现通用接口。这种方法将专用代码推向了设备驱动程序。因此在编写操作系统核心时,无需了解特定设备的特性。这种方法也让添加新设备变得更加容易。如果一个设备有足够的特性来实现设备驱动程序接口,就可以将其添加到系统中,而无需对主操作系统进行任何修改。
分层抽象
软件系统由层组成,其中较高的层使用较低层提供的功能。在设计良好的系统中,每一层都提供与其上、下两层不同的抽象。如果我们通过调用方法遵循单个操作在层中上下移动,则每个方法调用的抽象都会改变。如果系统包含具有相似抽象的相邻层,则这是一个危险信号,表明类分解存在问题。
下面讲述一些在分层抽象中我们当遇到的一些设计问题。
▐直通方法
当相邻的层具有相似的抽象时,问题通常以直通方法的形式表现出来。直通方法是一种很少执行的方法,除了调用另一个方法(其签名与调用方法的签名相似或相同)之外。
@Repository@Transactional(readOnly = true)public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> { // 直通方法:几乎直接委托给EntityManager @Override public List<T> findAll() { return getQuery(null, Sort.unsorted()).getResultList(); } @Override public List<T> findAll(Sort sort) { return getQuery(null, sort).getResultList(); } @Override public Page<T> findAll(Pageable pageable) { // 直通方法:只是添加分页逻辑后委托 if (isUnpaged(pageable)) { return new PageImpl<>(findAll()); } return findAll(pageable, null); } @Override public Optional<T> findById(ID id) { Assert.notNull(id, ID_MUST_NOT_BE_NULL); Class<T> domainType = getDomainClass(); if (metadata == null) { // 直通方法:直接委托给EntityManager.find() return Optional.ofNullable(em.find(domainType, id)); } // 稍微复杂一点但本质还是直通 LockModeType type = metadata.getLockModeType(); Map<String, Object> hints = getQueryHints().withFetchGraphs(em).asMap(); return Optional.ofNullable(type == null ? em.find(domainType, id, hints) : em.find(domainType, id, type, hints)); } @Transactional @Override public void deleteById(ID id) { Assert.notNull(id, ID_MUST_NOT_BE_NULL); // 直通方法:查找后删除 delete(findById(id).orElseThrow(() -> new EmptyResultDataAccessException( String.format("No %s entity with id %s exists!", entityInformation.getJavaType(), id), 1))); } @Transactional @Override public void delete(T entity) { Assert.notNull(entity, "Entity must not be null!"); // 直通方法:直接委托给EntityManager if (entityInformation.isNew(entity)) { return; } Class<?> type = ProxyUtils.getUserClass(entity); T existing = (T) em.find(type, entityInformation.getId(entity)); if (existing == null) { return; } em.remove(em.contains(entity) ? entity : em.merge(entity)); }}
直通方法使类变浅:它们增加了类的接口复杂性,从而增加了复杂性,但是并没有增加系统的整体功能。在上述CRUD相关的方法中,前面三个基本没有什么功能。直通方法还会在类之间创建依赖关系。
但是也不能一棒子打死直通方法,我们需要警惕的是尽量不要在一个类内,大部分都是直通方法。可以因为代码分层小部分是直通方法。如果真的遇到了一个类里大部分都是直通方法。那解决方案可以是重构这个类,以使每个类都有各自不同且连贯的职责。比如能不能把直通对应的关联类合并为一个类,或者索性可以让更上层直接依赖直通关联的两个类。
另外还需要警惕的就是滥用装饰器设计模式,装饰器的动机是将类的专用扩展与更通用的核心分开。但是,装饰器类往往很浅:它们引入了大量的样板,以实现少量的新功能。装饰器类通常包含许多直通方法。过度使用装饰器模式很容易,为每个小的新功能创建一个新类,但是会导致浅层类激增。
以org.springframework.data.repository.support.RepositoryComposition类举个例子:
public class RepositoryComposition { // 装饰器组合类,主要是样板代码 private final Fragments fragments; private RepositoryComposition(Fragments fragments) { this.fragments = fragments; } public static RepositoryComposition empty() { return new RepositoryComposition(Fragments.empty()); } public static RepositoryComposition just(RepositoryFragment fragment) { return new RepositoryComposition(Fragments.just(fragment)); } // 直通方法 public RepositoryComposition append(RepositoryFragment fragment) { return new RepositoryComposition(this.fragments.append(fragment)); } public RepositoryComposition prepend(RepositoryFragment fragment) { return new RepositoryComposition(this.fragments.prepend(fragment)); } // 更多直通方法 public Streamable<RepositoryFragment> getFragments() { return this.fragments; } public RepositoryFragment getFragment(Class<?> interfaceClass) { return this.fragments.getFragment(interfaceClass); } // 浅层装饰器的典型特征 static class Fragments implements Streamable<RepositoryFragment> { private final List<RepositoryFragment> fragments; private Fragments(List<RepositoryFragment> fragments) { this.fragments = fragments; } static Fragments empty() { return new Fragments(Collections.emptyList()); } static Fragments just(RepositoryFragment fragment) { return new Fragments(Collections.singletonList(fragment)); } // 大量样板装饰方法 Fragments append(RepositoryFragment fragment) { List<RepositoryFragment> newFragments = new ArrayList<>(this.fragments.size() + 1); newFragments.addAll(this.fragments); newFragments.add(fragment); return new Fragments(newFragments); } Fragments prepend(RepositoryFragment fragment) { List<RepositoryFragment> newFragments = new ArrayList<>(this.fragments.size() + 1); newFragments.add(fragment); newFragments.addAll(this.fragments); return new Fragments(newFragments); } }}
▐传递变量
传递变量是通过一长串方法向下传递的变量。传递变量增加了复杂性,因为它强制所有中间方法知道它们的存在,即使这些方法对变量没有用处。此外,如果存在一个新变量,则可能必须修改大量的接口和方法才能将变量传递给所有相关路径。以Apache Struts 1.x 的ActionContext为例,可以看到从起始execute方法到最终的checkUserInput,一路上所有方法都必须包含mapping, form, request, response四个变量。
public class UserAction extends Action { public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { return processUserAction(mapping, form, request, response); } private ActionForward processUserAction(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { validateInput(mapping, form, request, response); return performBusinessLogic(mapping, form, request, response); } private void validateInput(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { // 可能只需要form和request,但必须传递所有参数 checkUserInput(mapping, form, request, response); } private void checkUserInput(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) { // mapping和response在这里可能不需要,但必须传递 String username = ((LoginForm) form).getUsername(); // 验证逻辑... }}
但实际情况中,由于代码分层或业务逻辑的问题,又不可避免会存在从顶端到底层的变量,完全消除传递变量是不可能的,只能相对性地做一些优化。以下是几种解决方案:
- 查看最顶层和最底层方法之间是否已共享对象。
- 将信息存储在全局变量中,如果是串行处理的话也可以考虑用threadlocal(但threadlocal具有隐蔽性)。
- 引入一个上下文对象(context)。上下文对象专门从来存储所有全局状态。大多数应用程序在处理时都需要共享全局状态下具有多个变量,比如配置项,计数器之类的内容。
笔者现在最常用的解决方案是上下文对象方案,上下文对象的优点是统一了所有系统全局信息的处理,并且不需要传递变量。如果需要添加新变量,则可以将其添加到上下文对象;除了上下文的构造函数和析构函数外,现有代码均不受影响。由于上下文全部存储在一个位置,因此上下文可以轻松识别和管理系统的全局状态。上下文也便于测试:测试代码可以通过修改上下文中的字段来更改应用程序的全局配置。如果系统使用传递变量,则实施此类更改将更加困难。
上下文远非理想的解决方案。存储在上下文中的变量具有全局变量的大多数缺点。例如,哪些特定变量用在哪里的很不明显。与此同时,上下文容易逐步变成巨大的「大泥球」,从而在整个系统中创建不明显的依赖关系。上下文也可能产生线程安全问题(解决方法是让上下文中的一些变量不可变)。但是在较为复杂的业务场景下,上下文方案已经算是较好的解决方案了。
简单留给别人,复杂交给自己
假设我们正在开发一个新模块,并且发现存在不可避免的复杂性。那这个复杂性到底由谁承担更好:应该让模块使用者处理复杂性,还是应该在模块开发者处理复杂性?如果复杂度与模块提供的功能有关,那大多数情况下应该由模块开发者处理。因为大多数情况下,模块使用者多于开发者,因此开发者麻烦些总是比使用者麻烦些好。作为模块开发者,应该努力使模块使用者的开发尽可能轻松,即使这意味着开发者需要额外的工作。换句话说,模块具有简单的接口比简单的实现更为重要。
``
但是实际开发中,作为开发者却很容易做相反的事:把简单留给自己,把复杂交给别人。比如如果出现不确定如何处理的边界条件,最简单的方法是引发异常并让调用方处理它;再如果不确定要实施什么策略,就定义一些配置参数来控制该策略,然后由调用方自行确定最佳策略。这样的方法虽然短期内让模块的开发者轻松,但它们会增加复杂性,因为调用方必须处理这个被「抛」出来的问题(而且往往不止一个调用方)。例如,如果一个类抛出异常,则该类的每个调用者都必须处理该异常。如果一个类导出配置参数,则每个使用这个类的调用方都必须学习如何正确使用它们。
▐配置参数
配置参数是提高复杂度而不是降低复杂度的一个示例。类可以在内部输出一些控制其行为的参数,而不是在内部确定特定的行为,例如失败重试次数。然后,该类的用户必须为参数指定适当的值。在现在的系统中,配置参数非常流行,到处可见。但是,配置参数并不是一种很好的处理方式,它虽然提…