波纹效应

⼩波分解与重构基本原理_基本重构与详尽重构

⼩波分解与重构基本原理

两种结构

历史学家（曾写道：“所有⼤于原始村庄的社区都可以想象得到……”。

从某种意义上说，类依赖和包依赖也都可以想象到。他们不是真的在那⾥。但是，我们在管理它们上花费了巨⼤的精⼒。是什么促使我们

努⼒应对幻觉怪物？

好吧，这个博客的主要假设是源代码结构是有钱的。特别是，结构不良的软件会遭受涟漪效应的严重影响，从⽽在⼀处更改代码会触发许

多其他地⽅的更改，所有这些都会增加令⼈讨厌的更新成本。此外，结构不良的软件⾮常复杂，以⾄于很难预测更新成本，因为这些连锁

React会四处飞溅。

例如，图1在左侧显⽰了⼀个良好的程序包结构-清晰的依赖关系使更新成本分析变得毫⽆问题-在右侧显⽰了⼀个不正确的包装结构。

图1：两个系统，两个包装结构。

如果要检查这些样本的潜在波纹效应，则必须了解波纹效应如何从⼀个地⽅闪到另⼀个地⽅。考虑如下的Java⽅法链，其中a（）调

⽤b（），b（）调⽤c（），等等：

privateinta(intvalue){

returnb(value)*2;

}

privateintb(intvalue){

return金银花甘草茶 c(value)*3;

}

privateintc(intvalue){

returnd(value)*5;

}

privateintd(intvalue){

intstartValue=7;

returnvalue-startValue;

}

当有⼈决定将startValue更改为double的13.5时，就会发⽣连锁React，并决定必须保留此精度，因此需要将a（），

b（）和c（）从ints更新为doubles。

privatedoubled(doublevalue){

doublestartValue=13.5;

returnvalue-startValue;

}

程序员避免使⽤长距离传递依赖项，因为他们有更多的⽅法可以将任何随机更改波动回去。

旧消息。不重要的。这没东西看。

但是，当我们检查类依赖时，这会改变吗？让我们将a（）和b（）依附在⼀个类中，将c（）和d（）依附于另⼀个类中，同时仍然保留⽅羊汤的做法

法级的传递依赖项：a（）->b（）->c（）->d（）。

classHere{

Therethere=newThere();

privateinta(intvalue){

returnb(value)*2;

}

privateintb(intvalue){

returnthere.c(value)*3;

}

}

classThere{

intc(intvalue){

returnd(value)*5;

}

privateintd(intvalue){

intstartValue=7;

returnvalue-startValue;

}

}

同样，请考虑d（）的更改，从⽽触发所有其他更新。此⽰例与之前的⽰例有区别吗？

我们知道传递依赖长度是最⼤的敌⼈，在第⼆个⽰例中，在类级别上，只有两疫情防控观后感 个类的传递依赖较短。那么，与第⼀个⽰例的四种⽅法相

⽐，在这两种类型中纹波效应的可能性较⼩吗？

不，他们不是。因为这四种⽅法仍然存在。沿这四种⽅法产⽣波纹效应的可能性保持不变。（-voice）“课程什么都不做！”

什么是包依赖关系？让我们将这些幼⽝包装在单独的包装中：这是否有助于减少纹波效应的潜在成本？

packagex;

classHere{

Therethere=newThere();

privateinta(intvalue){

returnb(value)*2;

}

privateintb(intvalue){

returnthere.c(value)*3;

}

}

packagey;

publicclassThere{

publicintc(intvalue){

returnd(value)*5;

}

pr什么是专有名词 ivateintd(intvalue){

intstartValue=7;

returnvalue-startValue;

}

}

您会看到前进的⽅向。尽管将类封装在两个程序包中，但仍然有四个⽅法令⼈讨厌的传递依赖关系，并且涟漪效应从根本上遍历了⽅法依

赖关系。

是的，课程也会受到连锁React的影响。上⾯，类There在这⾥由企业融资渠道 于类There的变化⽽受到重创，但这是底层⽅法级依赖关系的结果。没有

底层⽅法级别的依赖关系（假设您不直接访问字段变量，⽽您不是直接访问字段变量，对吗？），就不能存在任何类级别的依赖关系（因此

也就没有类级别的涟漪效应）。

从涟漪效应的⾓度来看，类和包级别的依赖关系仅仅是底层⽅法级别的依赖关系的指⽰性汇总。从这个意义上说，它们不存在，⾄少作为

独⽴的结构不存在。

因此，⽅法级别的源代码结构可以被视为基本结构基本结构，⽽类和包级别的结构可以被视为派⽣结构派⽣结构，因为它是从底层⽅法级别结构派⽣的。

那么我们可以不理会这种派⽣的结构⽽去喝啤酒吗？

不。书信的格式及范文 它只是为基本结构提供了不同但同样重要的⽬的。

再次考虑图1的好坏结构，在这⾥复制在图2中……因为滚动。

图2：再次是图1。

如果我们的理论是正确的，那么这两个派⽣包结构都不会告诉我们任何⼀个系统要花费多少更新，这些信息被冻结到⽅法级结构中。

但是，如果我们假设⽅法在包装上的典型分布（也就是说，没有⼀个包装包含所有⽅法的99％），那么图2告诉我们⼀些重要的事情：它告

诉我们可以预测美容的相对更新成本在左边⽐在右边的野兽更好。

我们可以预测，对左侧系统的最上层程序包进⾏更改的成本应⽐对底部系统上的程序包进⾏更改的成本低，因为对这些下层程序包的依赖性

更⼤。相对于蜡笔涂抹⽽⾔，这是⼀个巨⼤的好处，因为更改任何包装都可能会影响⼏乎所有其他包装。

正是这种派⽣的结构（⽽不是基本结构）才能实现这种粗粒度的可预测性，这对于任何⼤型商业软件项⽬都是必不可少的。

您可能会怀疑这种可预测性也源于基本的⽅法结构，左侧的系统必须源⾃⽐右侧的系统更好的⽅法结构。但不是。实际上，图2的两个包

结构都源⾃相同的⽅法结构：它们实际上是同⼀系统。

图3显⽰了邪恶的⿊客如何通过182重构对左侧的系统造成了折磨（使⽤的蛮⼒包耦合减少算法）。细节并不重要，但是该算法仅在包之间

移动类，翻译对ta（）->b（）->c（）->d（）毫⽆影响；⽆论所有四个⽅法都挤在⼀个类中，还是嬉戏在两个，三个或四个类或包

中，此传递依赖关系都保持不变。

图3：结构良好，被炸死。

两种类型的重构

给定这两种不同的结构，并且鉴于重构只是保留⾏为的重构，因此必须有两种类型的重构。

如果您更改程序的基本结构（例如，添加或合并⽅法，或者修剪长⽅法的可传递依赖项），那么您正在做第⼀种重构，那就叫它：基本重基本重

构。基本重构的⽬的是使程序的更新便宜。

如果更改程序的派⽣结构（例如，将⼀个类拆分为两个类，或将某些类移动到新包中），那么您正在执⾏第⼆种类型的重构，我们称之为：

精巧重构精巧重构。精细重构的⽬的不是使程序的更新成本降低，⽽是使更新成本更可预测（通过“阐述”系统的粗粒度性质）。

碰巧的是，改进这两种结构的⽅法是相同的：传递依赖项，⽆论它们是在⽅法级别，类级别还是程序包级别。

因此从某种意义上讲，这全是哲学上的。

所以……是的……对此感到抱歉。

摘要

博客⼀直在抱怨，良好的结构既可以帮助降低更新成本，⼜可以提⾼成本可预测性。

现在您知道了。

⼩波分解与重构基本原理