大话重构之解决万恶之首“重复代码”

清疚 2022-03-22 10:40 242阅读 0赞

排在坏味道之首的是重复代码。为什么它如此臭名昭著？各位看客可以看《消除坏味道》系列的开篇文章《重构，企业级应用的圣经》，本文不再重复说明，仅引用其中的观点：

> 提示：对于任何事物，代码中只应该出现一次，而且是唯一的一次。

下面我们将介绍如何消除几种典型的重复代码，以及如何培养消除重复代码的习惯。

## 在同一个类中重复 ##

第一种是在同一个类中存在重复代码，它最容易识别，也最容易解决。看下面的例子：

try {
        executorService.runTasks(...)
        timer.scheduleAtFixedRate(
            () => saveProgress(getProgress()),
            period, period
        )
    } finally {
        executorService.shutdown()
        timer.cancel()
        saveProgress(getProgress())
    }

`saveProgress(getProgress())`出现在两个地方，可以通过 *提取方法* 来解决。

try {
        executorService.runTasks(...)
        timer.scheduleAtFixedRate(
            () => persistProgress(),
            period, period
        )
    } finally {
        executorService.shutdown()
        timer.cancel()
        persistProgress()
    }
    
    def persistProgress() {
        saveProgress(getProgress())
    }

如果一个类超级长，上千行，那即使在一个类中也很难识别重复。这涉及到另一个坏味道“超长类”，《消灭坏味道》后续会有专门的文章来解决它。

## 在同一个类树下重复 ##

第二种是在同一个类树下的不同子类中重复，比第一种识别起来困难些。

class Child1 extends Parent {
        def run() {
            init()
            process()
        }
        ...
    }
    
    class Child2 extends Parent {
        def run() {
            process()
        }
        ...
    }

可以通过 *上移方法* 和 *模板方法* 将公共部分上移到共同的父类。

class Parent {
        def run() { // 模板方法
            init()
            process()
        }
        
        def init() {}
        def process() //无函数体，等同于虚函数
    }
    
    class Child1 extends Parent {
        override def init() { ... }
        override def process() { ... }
    }
    
    class Child2 extends Parent {
        override def process() { ... }
    }

## 在不相干的类中重复 ##

第三种是在两个完全不相干的类中，如果不是专门地寻找很难发现。

class App1 {
        val last3 = scores.sort().take(3)
    }
    
    class App2 {
        val last10 = scores.sort().take(10)
    }

可以先 *提取方法* ，然后 *移动方法* 到新建的类，来消除重复。

class App1 {
        val last3 = Seqs.lastN(scores, 3)
    }
    
    class App2 {
        val last10 = Seqs.lastN(scores, 10)
    }
    
    object Seqs { // 新建的工具类
        def lastN[E](seq: Seq[E], n: Int)
            : Seq[E] = { // 返回值类型
            seq.sort().take(n)
        }
    }

上面的例子，是在业务上没有联系的两个类。

有可能是业务上有联系，或者直接就是类似的，这个时候应该 *抽取公共基类* ，然后按照第二种重复去重构。

细心的看官会发现，三种类型的重复有递进关系，离的越来越远，识别起来越来越难，解决起来也是。“在不相干的类中重复”可以通过重构转换成前两种，然后继续重构得以解决。

## 要培养好的编码习惯 ##

![good habit][]

解决重复并不困难，困难的是发现重复。发现重复并不困难，困难是培养发现重复的习惯。一码在写代码完成功能前，会习惯性地左右前后看看，别人是否已经做过相关的功能，和我要做的是否可以共用代码，这就很容易发现重复。

> 提示：如果你要动的是一个点，那么先了解她周围的一圈。

不仅解决了重复，而且经过一段时间，我就发现对整个系统的理解程度，在不知不觉中提高了不少。

其实和做人是一样的，著名的理财教练博多舍费尔在《小狗钱钱的爸爸 - 教你实现财务自由》一书中也强调：

> 不断将私人领域变成主导领域，这是你对未来的责任。

私人领域是生活中与我相关的，主导领域是由我直接或间接影响的。碰到事情不能光是自扫门前雪，需要积极地参与，变被动为主动，这样才会有更多的机会，让我们越来越好。

## 总结 ##

希望各位看官不只是学会了消除重复的技能，而且理解了文中的两个重要提示。

1.  对于任何事物，代码中只应该出现一次，而且是唯一的一次。
2.  如果你要动的是一个点，那么先了解她周围的一圈。

## 关于示例代码的说明 ##

一码觉得要讲如何写好代码，就得拿代码来说事。不过手机屏幕上代码的展示是个大问题。为了保证示例代码能让大家读得明白，一码做了些取舍：

1.  用片段，而不是完整可运行的代码，突出重点
2.  语言用Scala，因为她简洁易读

千万不要觉得不懂Scala，有压力，一码会用她里面最平易近人的部分，放心吧。

提示：Scala是JVM平台上的一种语言，拥有简洁和可扩展的特性，现在非常流行的大数据处理框架Spark就是用Scala开发的，学点Scala不会亏本的。

## 推荐 ##

[解决万恶之首“重复代码”][Link 1]

[消除过长方法][Link 2]

[消除巨无霸类][Link 3]

[答读者问][Link 4]

[你的参数列表像蚯蚓一样让人厌恶吗][Link 5]

[职责单一原则真的简单吗][Link 6]

查看《大话重构》系列文章，请进入YoyaProgrammer公众号，点击 核心技术，点击 大话重构。

[good habit]: /images/20220322/e210398ab7064de6b14ec50575ef514e.png
[Link 1]: http://www.cnblogs.com/yoyaprogrammer/p/eliminate_duplicate_code.html
[Link 2]: http://www.cnblogs.com/yoyaprogrammer/p/eliminate_long_method.html
[Link 3]: http://www.cnblogs.com/yoyaprogrammer/p/eliminate_long_class.html
[Link 4]: http://www.cnblogs.com/yoyaprogrammer/p/refactor_answer.html
[Link 5]: http://www.cnblogs.com/yoyaprogrammer/p/long_method_parameters.html
[Link 6]: http://www.cnblogs.com/yoyaprogrammer/p/srp.html