当前位置:   article > 正文

论软件架构设计中被普遍误读误用的原则——分层_开闭原则 误用

开闭原则 误用

 在看到一个又一个的项目、一批又一批的程序员不断掉进同一个坑里以后,我决定写此文把这个问题好好梳理总结一下,很可能大多数人根本没有意识到这是一个问题,也就注定了不可避免的重复这样的错误。

被误解和滥用的分层原则,结局必然是API泥潭

自十多年前Spring Framework大范围流行以来,java项目的架构质量“看上去“有了巨大改善——组件化、分层架构、依赖注入、面向接口编程 这些优秀的实践实施起来 变得比过去容易很多也自然很多。

于是出现了一场“分层运动”,程序员们一窝蜂式的把代码分了层、层与层之间用interface隔离用Spring把组件装配成一个轻量级架构,

然后就宣称设计出了一个架构优良的系统——面向对象、松耦合、实现灵活可替换。。。

但是,事情并没有这么简单——OO强调的“高内聚 低耦合”,大家只记住了后半句——低耦合,高内聚的原则完全被违背了,或者说根本就没有被理解。

在这场一窝蜂的“分层解耦运动”中,很多没有经验的程序员从一个极端(上帝类 不分层 硬编码 硬连接 意大利面架构)走到了另一个极端(过度设计 过度分层 为了用接口而用接口);

最显著特征就是API泛滥,这是过度分层的必然结果,因为层与层之间不存在继承关系(因此protected不管用),只能是上层调用下层组件暴露的public方法——API,于是项目中很快就开始充斥大量啰嗦、雷同、含义模糊的接口和public方法。

合理的分层架构 应该呈现倒金字塔的形状——越接近顶层(前端展现)组件的数量越随项目规模线性增长,因此数量也越多;越往底层 组件数量会越精简——经过项目初期的增长后,后面就基本稳定不再增长;

所以,当你发现系统有两个相邻的层 组件数量和API数量基本相当,那说明这两个层可以合并,因为其中必然有一层很单薄 只做了传声筒和重复的工作;

传声筒不仅造成巨大的浪费(徒增了一层代码、大量重复的代码),而且这样的设计会不断的给开发者带来困惑——一个新的功能到底应该在哪层实现,最终必然会出现不一致的选择和编程风格——于是每一层都被放置了一部分逻辑——于是破坏了内聚性——一个level的逻辑散落在了多处!这个问题看似没什么大不了的,但是熟知“破窗效应”的人马上就会意识到,这个设计从一开始就制造了很多broken window,并且在鼓励后续开发维护人不断制造新的破窗。。。不夸张的说,无数项目就是死在这个慢性毒药上。

高内聚和低耦合是OO的基本原则,说白了就是通过合理的抽象设计将一个level的逻辑放在一处 不同level的逻辑分开放置

分开摆放只是体力活儿,真正重要和有技术含量的是前面的“合理抽象设计”这个技术活儿。

很多程序员用着spring 用着大量接口 用着分层设计,最终干的还是面向过程编程,这样做 甚至还不如不分层——不分层我维护起来还更方便些——在一个类能看到所有实现细节。很多人用了一堆接口搞出一堆组件,把逻辑毫无章法的随意摆放(其实是藏匿)在n多角落里,然后竟然得意的认为自己在解耦,其实tmd是在玩儿躲猫猫。这个躲猫猫一点都不好玩,因为软件开发是一项成人世界的严肃的商业活动!你要明白一个简单的事实——你写出的每一行代码都tmd是需要被你自己或其他接手项目的人无数次阅读无数次修改的!

解决方案:减少分层,在层内进行面向对象的分层抽象设计

为了避免API泛滥的泥潭,我们需要退一步,首先要避免过度分层,但是这并不是要大家退回到一个上帝class搞定一个业务模块的年代。我的解决方案简单归纳就是:

  • 在controller展现控制层 和db之间 只保留一个service层,消灭dao层,service直接依赖通用的dao utils,因为dao utils不随着业务线性增长 因此不算一个层,只能算lib,就好比你不会把string utils看作一个层。
  • 在这个丰满的service层内,通过合理使用design patterns进行分层抽象设计 开发出高内聚低耦合的业务逻辑组件。

听起来有点绕——分层抽象跟分层有什么不同,看下三段代码对比你就明白了,实现1是上帝类搞定一切,实现2是常见的service和dao分层架构,实现3应用template method设计模式以分层继承方式组织代码。

  1. /** 上帝类 模块化编程,毕业设计水平 */
  2. public class ServiceA{
  3. public void funA(){
  4. .....doSth
  5. this.funA1();
  6. .....doSth
  7. this.funA2();
  8. .....doSth
  9. }
  10. private void funA1(){.....doSth}
  11. private void funA2(){.....doSth}
  12. private void funA3(){.....doSth}
  13. }
  1. /** 分层架构,入门程序员水平 */
  2. @Service
  3. public class ServiceA{
  4. @Rersource
  5. ServiceB serviceB;
  6. @Resource
  7. RepositoryC repoC;
  8. public void funA () {
  9. repoC.funA1(); //.....doSth
  10. repoC.funA2();//.....doSth
  11. serviceB.funA3();//.....doSth
  12. }
  13. }
  1. /** 面向对象设计,专业程序员水平 */
  2. public abstract class AbstractServiceA{
  3. /** 不变的业务逻辑和步骤、算法,封装在父类public final,子类不可改 */
  4. public final void funA () {
  5. .....doSth
  6. this.funA1();
  7. .....doSth
  8. this.funA2();
  9. this.doSth();
  10. }
  11. /** 扩展点1:可变的实现细节1,供子类实现 */
  12. abstract protected void funA1();
  13. /** 扩展点2:可变的实现细节2,供子类实现 */
  14. abstract protected void funA2();
  15. /** 扩展点3:可变的实现细节3,父类给出默认实现,子类可扩展也可不扩展 */
  16. protected void funA3(){...}
  17. /** 不变的实现细节,封装在父类private,子类不可见不可扩展 */
  18. private void doSth(){...}
  19. }
  20. public class ServiceA extends AbstractServiceA{
  21. protected void funA1(){}
  22. protected void funA2(){}
  23. }

如上三个实现的质量优劣应该是显而易见的,实现3具有更高的扩展性 复用性,对熟悉设计模式的人来说 也具有最好的代码可读性,因此最终获得了最好的可维护性 最低的修改成本。

分层抽象 本质上是将不变或很少变的逻辑封装在顶层基类,将易变多变的逻辑(实现细节)下放到具体子类,因此对实现细节的改动变得容易很多。不变的部分封装在基类 平时无需关注 不会浪费维护人精力。

分层抽象能获得高内聚性低耦合——不同level的逻辑可以聚在一处,尤其是对于具体子类 ,所有实现细节聚在一个子类中 ,同时又被不同的override重载函数优雅的划分开来,既有高内聚的方便又有低耦合的灵活性。

所谓开闭原则——对修改关闭 对扩展开放,我认为说的就是这个方法——抽象父类的final方法封装核心逻辑 对修改关闭,abstract protected方法便于子类扩展具体实现 。

最后,父类与子类之间通过protected方法交互,避免了public方法的泛滥——API泥潭。

OO面向对象的好处再怎么强调也不过分,但是也实在没有必要在2018年再去鼓吹了,OO本就应该是所有JAVA程序员的本能,不是吗?当然 我指的是合格的JAVA程序员。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/2023面试高手/article/detail/699015
推荐阅读
相关标签
  

闽ICP备14008679号