重构（Refactoring）就是在不改变软件现有功能的基础上，通过调整程序代码改善软件的质量、性能，使其程序的设计模式和架构更趋合理，提高软件的扩展性和维护性。另有同名图书。

定义(重构的好处 什么时候进行重构 为什么重构有用 间接层和重构 重构的难题 什么时候不进行重构 重构与设计 重构与性能)

为什么要重构(持续偏纠和改进软件设计 使代码更易为人所理解 帮助发现隐藏的代码缺陷 有助于提高编程效率)

何时着手重构(代码中存在重复的代码 过大的类和过长的方法 牵一毛而需要动全身的修改 类之间需要过多的通讯 过度耦合的信息链 不完美的设计 缺少必要的注释)

难题

重构与设计

重构与性能

重构起源何处

图书《重构》（张锋强）(图书信息 编辑推荐 作者简介 目录)

图书《重构》（菲尔德斯）(图书信息 内容简介 作者简介 图书目录)

定义

重构（名词）：对软件内部结构的一种调整，目的是在不改变"软件之可察行为"前提下，提高其可理解性，降低其修改成本.

重构（动词）：使用一系列重构准则（手法），在不改变"软件之可察行为"前提下，调整其结构.

两种定义都强调是在不改变"软件的外部行为"前提下，不改变"软件之可察行为"就是说让修改不影响外部使用程序（程序员），在个外部来看，程序的行为和结果没有任何的变化.重构只是对程序内部结构进行调整，让代码更加容易理解，然后更容易维护.

重构的好处

能改进软件设计使软件更容易被理解

能帮你找到bug

提高软件的开发速度

什么时候进行重构

三次法则：事不过三，三则重构.意思是说，一件事情，第一次只管去做，第二次做类似的事情会产生反感，但无论如何还是做了，第三次再做类似的事情，你就应该重构.

在添加新功能时进行重构.

在修改bug时进行重构

在代码复审时进行重构.

为什么重构有用

难以修改的程序具有以下特征：

难以阅读的程序，难以修改

逻辑重复的程序，难以修改

添加新行为时需要修改现有的代码，难以修改

带复杂条件逻辑的程序，难以修改

好的程序应该是：

容易阅读

所有逻辑都只在唯一地点指定

新的改动不会危及现有的行为

尽可能简单的表达条件逻辑

间接层和重构

间接层的存在的价值：允许逻辑共享；分开解释意图和实现；将变化加以隔离；将条件逻辑加以编码

但是过多的间接层会导致代码的层次太深，使代码难以阅读.因些要权衡加入间接层的利弊.

重构的难题

关系数据库与面向对象编程的问题——在对象模型和数据库模型之间插入一个分隔层，这就可以隔离两个模型各自的变化.升级某一模型时只需同时升级上述的分隔层即可.这样的分隔层会增加系统复杂度.但是能增加灵活度.

修改接口的问题——修改已发布的接口，因为已发布的接口会供外部人员（其它公司）使用，因此，修改接口会导致引用接口的其它程序不修改程序就无法运行.修改接口的最好的办法是增加一个新的接口，让旧接口调用新接口.这样原来的程序就不用修改了.对于接口的另一个建议是尽量不要发布接口.

什么时候不进行重构

现有的程序无法运行，此时应该是重写程序，而不是重构程序

到了最后的交付期限

重构与设计

重构与设计是互补的，程序应该是先设计，而在开始编码后,设计上的不足可以用重构来弥补.设计应该是适度的设计，而不必过度的设计.如果能很容易的通过重构来适应需求的变化，那么就不必过度的设计，当需求改变时再重构代码.

重构与性能

提高性能的三种方法：

时间预算法——在设计时就对程序花费的时间进行预算，通常用于性能要求极高的实时系统.普通的企业应用程序一般对性能要求不高.只要不太慢就可以了.

持续关注法——要求程序员在任何时间都要设法保持系统的高性能.这个方法有个缺陷，就是大部分的程序90%的优化工作都是白费劲，这样会浪费大量的时间.

良好的分解方式——这个方式是在开发程序阶段不对性能投以任何关注，直到进入性能优化阶段，再分析程序中性能差的程序，然后对这些程序进分解，查出性能差的程序，进行优化.

为什么要重构

为什么要重构（Refactoring）在不改变系统功能的情况下，改变系统的实现方式。为什么要这么做？投入精力不用来满足客户关心的需求，而是仅仅改变了软件的实现方式，这是否是在浪费客户的投资呢？

重构的重要性要从软件的生命周期说起。软件不同与普通的产品，他是一种智力产品，没有具体的物理形态。一个软件不可能发生物理损耗，界面上的按钮永远不会因为按动次数太多而发生接触不良。那么为什么一个软件制造出来以后，却不能永远使用下去呢？

对软件的生命造成威胁的因素只有一个：需求的变更。一个软件总是为解决某种特定的需求而产生，时代在发展，客户的业务也在发生变化。有的需求相对稳定一些，有的需求变化的比较剧烈，还有的需求已经消失了，或者转化成了别的需求。在这种情况下，软件必须相应的改变。

考虑到成本和时间等因素，当然不是所有的需求变化都要在软件系统中实现。但是总的说来，软件要适应需求的变化，以保持自己的生命力。

这就产生了一种糟糕的现象：软件产品最初制造出来，是经过精心的设计，具有良好架构的。但是随着时间的发展、需求的变化，必须不断的修改原有的功能、追加新的功能，还免不了有一些缺陷需要修改。为了实现变更，不可避免的要违反最初的设计构架。经过一段时间以后，软件的架构就千疮百孔了。bug越来越多，越来越难维护，新的需求越来越难实现，软件的构架对新的需求渐渐的失去支持能力，而是成为一种制约。最后新需求的开发成本会超过开发一个新的软件的成本，这就是这个软件系统的生命走到尽头的时候。

重构就能够最大限度的避免这样一种现象。系统发展到一定阶段后，使用重构的方式，不改变系统的外部功能，只对内部的结构进行重新的整理。通过重构，不断的调整系统的结构，使系统对于需求的变更始终具有较强的适应能力。

通过重构可以达到以下的目标：

持续偏纠和改进软件设计

重构和设计是相辅相成的，它和设计彼此互补。有了重构，你仍然必须做预先的设计，但是不必是最优的设计，只需要一个合理的解决方案就够了，如果没有重构、程序设计会逐渐腐败变质，愈来愈像断线的风筝，脱缰的野马无法控制。重构其实就是整理代码，让所有带着发散倾向的代码回归本位。

使代码更易为人所理解

Martin Flower在《重构》中有一句经典的话："任何一个傻瓜都能写出计算机可以理解的程序，只有写出人类容易理解的程序才是优秀的程序员。"对此，笔者感触很深，有些程序员总是能够快速编写出可运行的代码，但代码中晦涩的命名使人晕眩得需要紧握坐椅扶手，试想一个新兵到来接手这样的代码他会不会想当逃兵呢？

软件的生命周期往往需要多批程序员来维护，我们往往忽略了这些后来人。为了使代码容易被他人理解，需要在实现软件功能时做许多额外的事件，如清晰的排版布局，简明扼要的注释，其中命名也是一个重要的方面。一个很好的办法就是采用暗喻命名，即以对象实现的功能的依据，用形象化或拟人化的手法进行命名，一个很好的态度就是将每个代码元素像新生儿一样命名，也许笔者有点命名偏执狂的倾向，如能荣此雅号，将深以此为幸。

对于那些让人充满迷茫感甚至误导性的命名，需要果决地、大刀阔斧地整容，永远不要手下留情！

帮助发现隐藏的代码缺陷

孔子说过：温故而知新。重构代码时逼迫你加深理解原先所写的代码。笔者常有写下程序后，却发生对自己的程序逻辑不甚理解的情景，曾为此惊悚过，后来发现这种症状居然是许多程序员常患的"感冒"。当你也发生这样的情形时，通过重构代码可以加深对原设计的理解，发现其中的问题和隐患，构建出更好的代码。

有助于提高编程效率

从长远看，有助于提高编程效率。当你发现解决一个问题变得异常复杂时，往往不是问题本身造成的，而是你用错了方法，拙劣的设计往往导致臃肿的编码。

改善设计、提高可读性、减少缺陷都是为了稳住阵脚。良好的设计是成功的一半，停下来通过重构改进设计，或许会在当前减缓速度，但它带来的后发优势却是不可低估的。

何时着手重构

何时着手重构（Refactoring）

新官上任三把火，开始一个全新??、脚不停蹄、加班加点，一支声势浩大的千军万"码"夹裹着程序员激情和扣击键盘的鸣金奋力前行，势如破竹，攻城掠地，直指"黄龙府"。

开发经理是这支浩浩汤汤代码队伍的统帅，他负责这支队伍的命运，当齐恒公站在山顶上看到管仲训练的队伍整齐划一地前进时，他感叹说"我有这样一支军队哪里还怕没有胜利呢？"。但很遗憾，你手中的这支队伍原本只是散兵游勇，在前进中招兵买马，不断壮大，所以队伍变形在所难免。当开发经理发觉队伍变形时，也许就是克制住攻克前方山头的诱惑，停下脚步整顿队伍的时候了。

Kent Beck提出了"代码坏味道"的说法，和我们所提出的"队伍变形"是同样的意思，队伍变形的信号是什么呢？以下列述的代码症状就是"队伍变形"的强烈信号：

代码中存在重复的代码

中国有118 家整车生产企业，数量几乎等于美、日、欧所有汽车厂家数之和，但是全国的年产量却不及一个外国大汽车公司的产量。重复建设只会导致效率的低效和资源的浪费。

程序代码更是不能搞重复建设，如果同一个类中有相同的代码块，请把它提炼成类的一个独立方法，如果不同类中具有相同的代码，请把它提炼成一个新类，永远不要重复代码。

过大的类和过长的方法

过大的类往往是类抽象不合理的结果，类抽象不合理将降低了代码的复用率。方法是类王国中的诸侯国，诸侯国太大势必动摇中央集权。过长的方法由于包含的逻辑过于复杂，错误机率将直线上升，而可读性则直线下降，类的健壮性很容易被打破。当看到一个过长的方法时，需要想办法将其划分为多个小方法，以便于分而治之。

牵一毛而需要动全身的修改

当你发现修改一个小功能，或增加一个小功能时，就引发一次代码地震，也许是你的设计抽象度不够理想，功能代码太过分散所引起的。

类之间需要过多的通讯

A类需要调用B类的过多方法访问B的内部数据，在关系上这两个类显得有点狎昵，可能这两个类本应该在一起，而不应该分家。

过度耦合的信息链

"计算机是这样一门科学，它相信可以通过添加一个中间层解决任何问题"，所以往往中间层会被过多地追加到程序中。如果你在代码中看到需要获取一个信息，需要一个类的方法调用另一个类的方法，层层挂接，就象输油管一样节节相连。这往往是因为衔接层太多造成的，需要查看就否有可移除的中间层，或是否可以提供更直接的调用方法。

各立山头干革命

如果你发现有两个类或两个方法虽然命名不同但却拥有相似或相同的功能，你会发现往往是因为开发团队成员协调不够造成的。笔者曾经写了一个颇好用的字符串处理类，但因为没有及时通告团队其他人员，后来发现项目中居然有三个字符串处理类。革命资源是珍贵的，我们不应各立山头干革命。

不完美的设计

在笔者刚完成的一个比对报警项目中，曾安排阿朱开发报警模块，即通过Socket向指定的短信平台、语音平台及客户端报警器插件发送报警报文信息，阿朱出色地完成了这项任务。后来用户又提出了实时比对的需求，即要求第三方系统以报文形式向比对报警系统发送请求，比对报警系统接收并响应这个请求。这又需要用到Socket报文通讯，由于原来的设计没有将报文通讯模块独立出来，所以无法复用阿朱开发的代码。后来我及时调整了这个设计，新增了一个报文收发模块，使系统所有的对外通讯都复用这个模块，系统的整体设计也显得更加合理。

每个系统都或多或少存在不完美的设计，刚开始可能注意不到，到后来才会慢慢凸显出来，此时唯有勇于更改才是最好的出路。

缺少必要的注释

虽然许多软件工程的书籍常提醒程序员需要防止过多注释，但这个担心好象并没有什么必要。往往程序员更感兴趣的是功能实现而非代码注释，因为前者更能带来成就感，所以代码注释往往不是过多而是过少，过于简单。人的记忆曲线下降的坡度是陡得吓人的，当过了一段时间后再回头补注释时，很容易发生"提笔忘字，愈言且止"的情形。

曾在网上看到过微软的代码注释，其详尽程度让人叹为观止，也从中体悟到了微软成功的一个经验。

难题

重构（Refactoring）的难题

学习一种可以大幅提高生产力的新技术时，你总是难以察觉其不适用的场合。通常你在一个特定场景中学习它，这个场景往往是个项目。这种情况下你很难看出什么会造成这种新技术成效不彰或甚至形成危害。十年前，对象技术（object tech.）的情况也是如此。那时如果有人问我「何时不要使用对象」，我很难回答。并非我认为对象十全十美、没有局限性 — 我最反对这种盲目态度，而是尽管我知道它的好处，但确实不知道其局限性在哪儿。

现在，重构的处境也是如此。我们知道重构的好处，我们知道重构可以给我们的工作带来唾手可得的改变。但是我们还没有获得足够的经验，我们还看不到它的局限性。这一小节比我希望的要短。暂且如此吧。随着更多人学会重构技巧，我们也将对??你应该尝试一下重构，获得它所提供的利益，但在此同时，你也应该时时监控其过程，注意寻找重构可能引入的问题。请让我们知道你所遭遇的问题。随着对重构的了解日益增多，我们将找出更多解决办法，并清楚知道哪些问题是真正难以解决的。

数据库（Databases）

「重构」经常出问题的一个领域就是数据库。绝大多数商用程序都与它们背后的database schema（数据库表格结构）紧密耦合（coupled）在一起，这也是database schema如此难以修改的原因之一。另一个原因是数据迁移（migration）。就算你非常小心地将系统分层（layered），将database schema和对象模型（object model）间的依赖降至最低，但database schema的改变还是让你不得不迁移所有数据，这可能是件漫长而烦琐的工作。

在「非对象数据库」（nonobject databases）中，解决这个问题的办法之一就是：在对象模型（object model）和数据库模型（database model）之间插入一个分隔层（separate layer），这就可以隔离两个模型各自的变化。升级某一模型时无需同时升级另一模型，只需升级上述的分隔层即可。这样的分隔层会增加系统复杂度，但可以给你很大的灵活度。如果你同时拥有多个数据库，或如果数据库模型较为复杂使你难以控制，那么即使不进行重构，这分隔层也是很重要的。

你无需一开始就插入分隔层，可以在发现对象模型变得不稳定时再产生它。这样你就可以为你的改变找到最好的杠杆效应。

对开发者而言，对象数据库既有帮助也有妨碍。某些面向对象数据库提供不同版本的对象之间的自动迁移功能，这减少了数据迁移时的工作量，但还是会损失一定时间。如果各数据库之间的数据迁移并非自动进行，你就必须自行完成迁移工作，这个工作量可是很大的。这种情况下你必须更加留神classes内的数据结构变化。你仍然可以放心将classes的行为转移过去，但转移值域（field）时就必须格外小心。数据尚未被转移前你就得先运用访问函数（accessors）造成「数据已经转移」的假象。一旦你确定知道「数据应该在何处」时，就可以一次性地将数据迁移过去。这时唯一需要修改的只有访问函数（accessors），这也降低了错误风险。

修改接口（Changing Interfaces）

关于对象，另一件重要事情是：它们允许你分开修改软件模块的实现（implementation）和接口（interface）。你可以安全地修改某对象内部而不影响他人，但对于接口要特别谨慎 — 如果接口被修改了，任何事情都有可能发生。

一直对重构带来困扰的一件事就是：许多重构手法的确会修改接口。像Rename Method（273）这么简单的重构手法所做的一切就是修改接口。这对极为珍贵的封装概念会带来什么影响呢？

如果某个函数的所有调用动作都在你的控制之下，那么即使修改函数名称也不会有任何问题。哪怕面对一个public函数，只要能取得并修改其所有调用者，你也可以安心地将这个函数易名。只有当需要修改的接口系被那些「找不到，即使找到也不能修改」的代码使用时，接口的修改才会成为问题。如果情况真是如此，我就会说：这个接口是个「已发布接口」（published interface）— 比公开接口（public interface）更进一步。接口一旦发行，你就再也无法仅仅修改调用者而能够安全地修改接口了。你需要一个略为复杂的程序。

这个想法改变了我们的问题。如今的问题是：该如何面对那些必须修改「已发布接口」的重构手法？

简言之，如果重构手法改变了已发布接口（published interface），你必须同时维护新旧两个接口，直到你的所有用户都有时间对这个变化做出反应。幸运的是这不太困难。你通常都有办法把事情组织好，让旧接口继续工作。请尽量这么做：让旧接口调用新接口。当你要修改某个函数名称时，请留下旧函数，让它调用新函数。千万不要拷贝函数实现码，那会让你陷入「重复代码」（duplicated code）的泥淖中难以自拔。你还应该使用Java提供的 deprecation（反对）设施，将旧接口标记为 "deprecated"。这么一来你的调用者就会注意到它了。

这个过程的一个好例子就是Java容器类（collection classes）。Java 2的新容器取代了原先一些容器。当Java 2容器发布时，JavaSoft花了很大力气来为开发者提供一条顺利迁徙之路。

「保留旧接口」的办法通常可行，但很烦人。起码在一段时间里你必须建造（build）并维护一些额外的函数。它们会使接口变得复杂，使接口难以使用。还好我们有另一个选择：不要发布（publish）接口。当然我不是说要完全禁止，因为很明显你必得发布一些接口。如果你正在建造供外部使用的APIs，像Sun所做的那样，肯定你必得发布接口。我之所以说尽量不要发布，是因为我常常看到一些开发团队公开了太多接口。我曾经看到一支三人团队这么工作：每个人都向另外两人公开发布接口。这使他们不得不经常来回维护接口，而其实他们原本可以直接进入程序库，径行修改自己管理的那一部分，那会轻松许多。过度强调「代码拥有权」的团队常常会犯这种错误。发布接口很有用，但也有代价。所以除非真有必要，别发布接口。这可能意味需要改变你的代码拥有权观念，让每个人都可以修改别人的代码，以运应接口的改动。以搭档（成对）编程（Pair Programming）完成这一切通常是个好主意。

不要过早发布（published）接口。请修改你的代码拥有权政策，使重构更顺畅。

Java之中还有一个特别关于「修改接口」的问题：在throws子句中增加一个异常。这并不是对签名式（signature）的修改，所以你无法以delegation（委托手法）隐藏它。但如果用户代码不作出相应修改，编译器不会让它通过。这个问题很难解决。你可以为这个函数选择一个新名tion（可控式异常）转换成一个unchecked exception（不可控异常）。你也可以抛出一个unchecked异常，不过这样你就会失去检验能力。如果你那么做，你可以警告调用者：这个unchecked异常日后会变成一个checked异常。这样他们就有时间在自己的代码中加上对此异常的处理。出于这个原因，我总是喜欢为整个package定义一个superclass异常（就像java.sql的SQLException），并确保所有public函数只在自己的throws子句中声明这个异常。这样我就可以随心所欲地定义subclass异常，不会影响调用者，因为调用者永远只知道那个更具一般性的superclass异常。

难以通过重构手法完成的设计改动

通过重构，可以排除所有设计错误吗？是否存在某些核心设计决策，无法以重构手法修改？在这个领域里，我们的统计数据尚不完整。当然某些情况下我们可以很有效地重构，这常常令我们倍感惊讶，但的确也有难以重构的地方。比如说在一个项目中，我们很难（但还是有可能）将「无安全需求（no security requirements）情况下构造起来的系统」重构为「安全性良好的（good security）系统」。

这种情况下我的办法就是「先想象重构的情况」。考虑候选设计方案时，我会问自己：将某个设计重构为另一个设计的难度有多大？如果看上去很简单，我就不必太担心选择是否得当，于是我就会选最简单的设计，哪怕它不能覆盖所有潜在需求也没关系。但如果预先看不到简单的重构办法，我就会在设计上投入更多力气。不过我发现，这种情况很少出现。

何时不该重构？

有时候你根本不应该重构 — 例如当你应该重新编写所有代码的时候。有时候既有代码实在太混乱，重构它还不如从新写一个来得简单。作出这种决定很困难，我承认我也没有什么好准则可以判断何时应该放弃重构。

重写（而非重构）的一个清楚讯号就是：现有代码根本不能正常运作。你可能只是试着做点测试，然后就发现代码中满是错误，根本无法稳定运作。记住，重构之前，代码必须起码能够在大部分情况下正常运作。

一个折衷办法就是：将「大块头软件」重构为「封装良好的小型组件」。然后你就可以逐一对组件作出「重构或重建」的决定。这是一个颇具希望的办法，但我还没有足够数据，所以也无法写出优秀的指导原则。对于一个重要的古老系统，这肯定会是一个很好的方向。

另外，如果项目已近最后期限，你也应该避免重构。在此时机，从重构过程赢得的生产力只有在最后期限过后才能体现出来，而那个时候已经时不我予。Ward Cunningham对此有一个很好的看法。他把未完成的重构工作形容为「债务」。很多公司都需要借债来使自己更有效地运转。但是借债就得付利息，过于复杂的代码所造成的「维护和扩展的额外开销」就是利息。你可以承受一定程度的利息，但如果利息太高你就会被压垮。把债务管理好是很重要的，你应该随时通过重构来偿还一部分债务。

如果项目已经非常接近最后期限，你不应该再分心于重构，因为已经没有时间了。不过多个项目经验显示：重构的确能够提高生产力。如果最后你没有足够时间，通常就表示你其实早该进行重构。

重构与设计

重构（Refactoring）与设计「重构」肩负一项特别任务：它和设计彼此互补。初学编程的时候，我埋头就写程序，浑浑噩噩地进行开发。然而很快我便发现，「事先设计」（upfront design）可以助我节省回头工的高昂成本。于是我很快加强这种「预先设计」风格。许多人都把设计看作软件开发的关键环节，而把编程（programming）看作只是机械式的低级劳动。他们认为设计就像画工程图而编码就像施工。但是你要知道，软件和真实器械有着很大的差异。软件的可塑性更强，而且完全是思想产品。正如Alistair Cockburn所说：『有了设计，我可以思考更快，但是其中充满小漏洞。』

有一种观点认为：重构可以成为「预先设计」的替代品。这意思是你根本不必做任何设计，只管按照最初想法开始编码，让代码有效运作，然后再将它重构成型。事实上这种办法真的可行。我的确看过有人这么做，最后获得设计良好的软件。极限编程（Extreme Programming）【Beck,XP】 的支持者极力提倡这种办法。

尽管如上所言，只运用重构也能收到效果，但这并不是最有效的途径。是的，即使极限编程（Extreme Programming）爱好者也会进行预先设计。他们会使用CRC卡或类似的东西来检验各种不同想法，然后才得到第一个可被接受的解决方案，然后才能开始编码，然后才能重构。关键在于：重构改变了「预先设计」的角色。如果没有重构，你就必须保证「预先设计」正确无误，这个压力太大了。这意味如果将来需要对原始设计做任何修改，代价都将非常高昂。因此你需要把更多时间和精力放在预先设计上，以避免日后修改。

如果你选择重构，问题的重点就转变了。你仍然做预先设计，但是不必一定找出正确的解决方案。此刻的你只需要得到一个足够合理的解决方案就够了。你很肯定地知道，在实现这个初始解决方案的时候，你对问题的理解也会逐渐加深，你可能会察觉最佳解决方案和你当初设想的有些不同。只要有重构这项武器在手，就不成问题，因为重构让日后的修改成本不再高昂。

这种转变导致一个重要结果：软件设计朝向简化前进了一大步。过去未曾运用重构时，我总是力求得到灵活的解决方案。任何一个需求都让我提心吊胆地猜疑：在系统寿命期间，这个需求会导致怎样的变化？由于变更设计的代价非常高昂，所以我希望建造一个足够灵活、足够强固的解决方案，希望它能承受我所能预见的所有需求变化。问题在于：要建造一个灵活的解决方案，所需的成本难以估算。灵活的解决方案比简单的解决方案复杂许多，所以最终得到的软件通常也会更难维护 — 虽然它在我预先设想的??方向上，你也必须理解如何修改设计。如果变化只出现在一两个地方，那不算大问题。然而变化其实可能出现在系统各处。如果在所有可能的变化出现地点都建立起灵活性，整个系统的复杂度和维护难度都会大大提高。当然，如果最后发现所有这些灵活性都毫无必要，这才是最大的失败。你知道，这其中肯定有些灵活性的确派不上用场，但你却无法预测到底是哪些派不上用场。为了获得自己想要的灵活性，你不得不加入比实际需要更多的灵活性。

有了重构，你就可以通过一条不同的途径来应付变化带来的风险。你仍旧需要思考潜在的变化，仍旧需要考虑灵活的解决方案。但是你不必再逐一实现这些解决方案，而是应该问问自己：『把一个简单的解决方案重构成这个灵活的方案有多大难度？』如果答案是「相当容易」（大多数时候都如此），那么你就只需实现目前的简单方案就行了。重构可以带来更简单的设计，同时又不损失灵活性，这也降低了设计过程的难度，减轻了设计压力。一旦对重构带来的简单性有更多感受，你甚至可以不必再预先思考前述所谓的灵活方案 — 一旦需要它，你总有足够的信心去重构。是的，当下只管建造可运行的最简化系统，至于灵活而复杂的设计，唔，多数时候你都不会需要它。

劳而无获— Ron Jeffries

Chrysler Comprehensive Compensation（克莱斯勒综合薪资系统）的支付过程太慢了。虽然我们的开发还没结束，这个问题却已经开始困扰我们，因为它已经拖累了测试速度。

Kent Beck、Martin Fowler和我决定解决这个问题。等待大伙儿会合的时间里，凭着我对这个系统的全盘了解，我开始推测：到底是什么让系统变慢了？我想到数种可能，然后和伙伴们谈了几种可能的修改方案。最后，关于「如何让这个系统运行更快」，我们提出了一些真正的好点子。

然后，我们拿Kent的量测工具度量了系统性能。我一开始所想的可能性竟然全都不是问题肇因。我们发现：系统把一半时间用来创建「日期」实体（instance）。更有趣的是，所有这些实体都有相同的值。

于是我们观察日期的创建逻辑，发现有机会将它优化。日期原本是由字符串转换而生，即使无外部输入也是如此。之所以使用字符串转换方式，完全是为了方便键盘输入。好，也许我们可以将它优化。

于是我们观察日期怎样被这个程序运用。我们发现，很多日期对象都被用来产生「日期区间」实体（instance）。「日期区间」是个对象，由一个起始日期和一个结束日期组成。仔细追踪下去，我们发现绝大多数日期区间是空的！

处理日期区间时我们遵循这样一个规则：如果结束日期在起始日期之前，这个日期区间就该是空的。这是一条很好的规则，完全符合这个class的需要。采用此一规则后不久，我们意识到，创建一个「起始日期在结束日期之后」的日期区间，仍然不算是清晰的代码，于是我们把这个行为提炼到一个factory method（译注：一个著名的设计模式，见《Design Patterns》），由它专门创建「空的日期区间」。

我们做了上述修改，使代码更加清晰，却意外得到了一个惊喜。我们创建一个固定不变的「空日期区间」对象，并让上述调整后的factory method每次都返回该对象，而不再每次都创建新对象。这一修改把系统速度提升了几乎一倍，足以让测试速度达到可接受程度。这只花了我们大约五分钟。

我和团队成员（Kent和Martin谢绝参加）认真推测过：我们了若指掌的这个程序中可能有什么错误？我们甚至凭空做了些改进设计，却没有先对系统的真实情况进行量测。

我们完全错了。除了一场很有趣的交谈，我们什么好事都没做。

教训：哪怕你完全了解系统，也请实际量测它的性能，不要臆测。臆测会让你学到一些东西，但十有八九你是错的。

重构与性能

重构与性能（Performance）

译注：在我的接触经验中，performance一词被不同的人予以不同的解释和认知：效率、性能、效能。不同地区（例如台湾和大陆）的习惯用法亦不相同。本书一遇performance我便译为性能。efficient译为高效，effective译为有效。

关于重构，有一个常被提出的问题：它对程序的性能将造成怎样的影响？为了让软件易于理解，你常会作出一些使程序运行变慢的修改。这是个重要的问题。我并不赞成为了提高设计的纯洁性或把希望寄托于更快的硬件身上，而忽略了程序性能。已经有很多软件因为速度太慢而被用户拒绝，日益提高的机器速度亦只不过略微放宽了速度方面的限制而已。但是，换个角度说，虽然重构必然会使软件运行更慢，但它也使软件的性能优化更易进行。除了对性能有严格要求的实时（real time）系统，其它任何情况下「编写快速软件」的秘密就是：首先写出可调（tunable）软件，然后调整它以求获得足够速度。

我看过三种「编写快速软件」的方法。其中最严格的是「时间预算法」（time budgeting），这通常只用于性能要求极高的实时系统。如果使用这种方法，分解你的设计时就要做好预算，给每个组件预先分配一定资源 — 包括时间和执行轨迹（footprint）。每个组件绝对不能超出自己的预算，就算拥有「可在不同组件之间调度预配时间」的机制也不行。这种方法高度重视性能，对于心律调节器一类的系统是必须的，因为在这样的系统中迟来的数据就是错误的数据。但对其他类系统（例如我经常开发的企业信息系统）而言，如此追求高性能就有点过份了。

第二种方法是「持续关切法」（constant attention）。这种方法要求任何程序员在任何时间做任何事时，都要设法保持系统的高性能。这种方式很常见，感觉上很有吸引力，但通常不会起太大作用。任何修改如果是为了提高性能，通??终得到的软件的确更快了，那么这点损失尚有所值，可惜通常事与愿违，因为性能改善一旦被分散到程序各角落，每次改善都只不过是从「对程序行为的一个狭隘视角」出发而已。

关于性能，一件很有趣的事情是：如果你对大多数程序进行分析，你会发现它把大半时间都耗费在一小半代码身上。如果你一视同仁地优化所有代码，90% 的优化工作都是白费劲儿，因为被你优化的代码有许多难得被执行起来。你花时间做优化是为了让程序运行更快，但如果因为缺乏对程序的清楚认识而花费时间，那些时间都是被浪费掉了。

第三种性能提升法系利用上述的 "90%" 统计数据。采用这种方法时，你以一种「良好的分解方式」（well-factored manner）来建造自己的程序，不对性能投以任何关切，直至进入性能优化阶段 — 那通常是在开发后期。一旦进入该阶段，你再按照某个特定程序来调整程序性能。

在性能优化阶段中，你首先应该以一个量测工具监控程序的运行，让它告诉你程序中哪些地方大量消耗时间和空间。这样你就可以找出性能热点（hot spot）所在的一小段代码。然后你应该集中关切这些性能热点，并使用前述「持续关切法」中的优化手段来优化它们。由于你把注意力都集中在热点上，较少的工作量便可显现较好的成果。即便如此你还是必须保持谨慎。和重构一样，你应该小幅度进行修改。每走一步都需要编译、测试、再次量测。如果没能提高性能，就应该撤销此次修改。你应该继续这个「发现热点、去除热点」的过程，直到获得客户满意的性能为止。关于这项技术，McConnell 【McConnell】 为我们提供了更多信息。

一个被良好分解（well-factored）的程序可从两方面帮助此种优化形式。首先，它让你有比较充裕的时间进行性能调整（performance tuning），因为有分解良好的代码在手，你就能够更快速地添加功能，也就有更多时间用在性能问题上（准确的量测则保证你把这些时间投资在恰当地点）。其次，面对分解良好的程序，你在进行性能分析时便有较细的粒度（granularity），于是量测工具把你带入范围较小的程序段落中，而性能的调整也比较容易些。由于代码更加清晰，因此你能够更好地理解自己的选择，更清楚哪种调整起关键作用。

我发现重构可以帮助我写出更快的软件。短程看来，重构的确会使软件变慢，但它使优化阶段中的软件性能调整更容易。最终我还是有赚头。

重构起源何处

我曾经努力想找出重构（refactoring）一词的真正起源，但最终失败了。优秀程序员肯定至少会花一些时间来清理自己的代码。这么做是因为，他们知道简洁的代码比杂乱无章的代码更容易修改，而且他们知道自己几乎无法一开始就写出简洁的代码。

重构不止如此。本书中我把重构看作整个软件开发过程的一个关键环节。最早认识重构重要性的两个人是Ward Cunningham和Kent Beck，他们早在1980s之前就开始使用Smalltalk，那是个特别适合重构的环境。Smalltalk是一个十分动态的环境，你可以很快写出极具功能的软件。Smalltalk的「编译/连结/执行」周期非常短，因此很容易快速修改代码。它是面向对象，所以也能够提供强大工具，最大限度地将修改的影响隐藏于定义良好的接口背后。Ward和Kent努力发展出一套适合这类环境的软件开发过程（如今Kent把这种风格叫作极限编程 【Beck,XP】）。他们意识到：重构对于提高他们的生产力非常重要。从那时起他们就一直在工作中运用重构技术，在严肃而认真的软件项目中使用它，并不断精炼这个程序。

Ward和Kent的思想对Smalltalk社群产生了极大影响，重构概念也成为Smalltalk文化中的一个重要元素。Smalltalk社群的另一位领袖是Ralph Johnson，伊利诺斯大学乌尔班纳分校教授，著名的「四巨头」 【Gang of Four】 之一。Ralph最大的兴趣之一就是开发软件框架（framework）。他揭示了重构对于灵活高效框架的开发帮助。

Bill Opdyke是Ralph的博士研究生，对框架也很感兴趣。他看到重构的潜在价值，并看到重构应用于Smalltalk之外的其它语言的可能性。他的技术背景是电话交换系统的开发。在这种系统中，大量的复杂情况与时俱增，而且非常难以修改。Bill的博士研究就是从工具构筑者的角度来看待重构。通过研究，Bill发现：在C++ framework开发项目中，重构很有用。他也研究了极有必要的「语义保持性（semantics-preserving）重构」及其证明方式，以及如何以工具实现重构。时至今日，Bill的博士论文【Opdyke】 仍然是重构领域中最有价值、最丰硕的研究成果。此外他为本书撰写了第13章。

我还记得1992年OOPSLA大会上见到Bill的情景。我们坐在一间咖啡厅里，讨论当时我正为保健业务构筑的一个概念框架（conceptual framework）中的某些工作。Bill跟我谈起他的研究成果，我还记得自己当时的想法：『有趣，但并非真的那么重要』。唉，我完全错了。

John Brant和Don Roberts将重构中的「工具」构想发扬光大，开发了一个名为「重构浏览器」（Refactoring Browser）的Smalltalk重构工具。他们撰写了本书第14章，其中对重构工具做了更多介绍。

那么，我呢？我一直有清理代码的倾向，但从来没有想到这会有那么重要。后来我和Kent一起做了个项目，看到他使用重构手法，也看到重构对生产性能和产品质量带来的影响。这份体验让我相信：重构是一门非常重要的技术。但是，在重构的学习和推广过程中我遇到了挫折，因为我拿不出任何一本书给程序员看，也没有任何一位专家打算写出这样一本书。所以，在这些专家的帮助下，我写下了这本书。

优化一个薪资系统— Rich Garzaniti将Chrysler Comprehensive Compensation（克莱斯勒综合薪资系统）交给GemStone公司之前，我们用了相当长的时间开发它。开发过程中我们无可避免地发现程序不够快，于是找了Jim Haungs — GemSmith中的一位好手 — 请他帮我们优化这个系统。

Jim先用一点时间让他的团队了解系统运作方式，然后以GemStone的ProfMonitor特性编写出一个性能量测工具，将它插入我们的功能测试中。这个工具可以显示系统产生的对象数量，以及这些对象的诞生点。

令我们吃惊的是：创建量最大的对象竟是字符串。其中最大的工作量则是反复产生12,000-bytes的字符串。这很特别，因为这字符串实在太大了，连GemStone惯用的垃圾回收设施都无法处理它。由于它是如此巨大，每当被创建出来，GemStone都会将它分页（paging）至磁盘上。也就是说字符串的创建竟然用上了I/O子系统（译注：分页机制会动用I/O），而每次输出记录时都要产生这样的字符串三次﹗

我们的第一个解决办法是把一个12,000-bytes字符串缓存（cached）起来，这可解决一大半问题。后来我们又加以修改，将它直接写入一个file stream，从而避免产生字符串。

解决了「巨大字符串」问题后，Jim的量测工具又发现了一些类似问题，只不过字符串稍微小一些：800-bytes、500-bytes……等等，我们也都对它们改用file stream，于是问题都解决了。

使用这些技术，我们稳步提高了系统性能。开发过程中原本似乎需要1,000小时以上才能完成的薪资计算，实际运作时只花40小时。一个月后我们把时间缩短到18小时。正式投入运转时只花12小时。经过一年的运行和改善后，全部计算只需9小时。

我们的最大改进就是：将程序放在多处理器（multi-processor）计算器上，以多线程（multiple threads）方式运行。最初这个系统并非按照多线程思维来设计，但由于代码有良好分解（well factored），所以我们只花三天时间就让它得以同时运行多个线程了。现在，薪资的计算只需2小时。

在Jim提供工具使我们得以在实际操作中量度系统性能之前，我们也猜测过问题所在。但如果只靠猜测，我们需要很长的时间才能试出真正的解法。真实的量测指出了一个完全不同的方向，并大大加快了我们的进度。

图书《重构》（张锋强）

图书信息

作　者：张锋强著

出 版 社：中国纺织出版社出版时间：2009-5-1

字　数：181000

页　数：217

开　本：16开

I S B N ：9787506451116

定价：36.00 元

编辑推荐

社会进步需要不同的危机推动，金融危机不过是全球化进程的第一场洗礼！

经济的全球化步伐超越了政治和心态的全球化，金融危机不过是对此加以均衡！

金融危机让世人财富观念重新回归效率之上，不再追逐泡沫中的财富效应！

全球经济的严重失衡源于维系国际间的全球资源配置链条的结构异化！

内容简介：全球化是新时代的经济生态，是全球配置资源，它是通过一条条优势互补、共生共荣的价值链交织起来的经济模型。这一模型不仅预示了经济体及微观经济单元面临的市场更博大，面临的问题更复杂多维，也预示将来面临的危机规模更大、更不可驾驭。

全球化的生命力在于它是“一个能让所有人受益的经济体系”。人们要问，如果不能通过协商去完成全球秩序的建设和游戏规则的确立，结果又会怎么样呢?那就一定会通过一场场摧枯拉朽的全球经济风暴来实现这一切。

全球经济失衡由来已久，积淀下来的矛盾正在激化。全球经济的严重失衡源于维系国际经济关系全球配置资源链条的特殊结构，这一特征正如美联储原主席格林斯潘所说的“新兴市场的生产要素和发达国家的消费市场相结合”。然而，一轮周期性调整让国际大循环的价值链条险象环生，虚拟经济极度膨胀，加上资本的天生逐利性，侵蚀着全球实体经济，已经让全球的经济风雨飘摇。

“从明而感、由感而得、得而致用”是此书的基本追求。希望能让理论探索者在学术之途有夜行得灯之惊喜；让经济管理者在经营管理获吹糠见米之感悟。

作者简介

张锋强，广东河源人，曾在多家集团企业任管理首席顾问。从事企业经营管理，理财投资研究。已出版多本专著。

目录

引言

第一章 正在来临的全球化第一场飓风

第二章 超级大国的失意与无奈

第三章 经济周期调整的中国之策

第四章 市场经济的过去、现在与将来

后记

图书《重构》（菲尔德斯）

图书信息

书 名： 重构

作　者：菲尔德斯（JayFields)

出版社：机械工业出版社

出版时间：2010年4月1日

ISBN: 9787111300786

开本：16开

定价： 49.00元

内容简介

《重构（Ruby版）》是一本专门为职业Ruby程序员编写的重构指导。它的目标是向你展示如何以一种既受到严格控制又高效的方式进行重构。你将学习到不在代码中引入bug并能按部就班改进结构的重构方式。《重构（Ruby版）》的主要内容：第1章指出重构是什么；第2章讨论进行重构的理由；第3章指出需要进行重构的信号；第4章讨论测试在重构中扮演的重要角色；第5章~第12章介绍了重构花名册，它包含了在重构领域里到目前为止的成果。当需要进行某项任务时，这份花名册可以手把手地提醒我们安全的做法。

《重构（Ruby版）》的目标读者是专业的Ruby程序员、资深设计师和架构师。

作者简介

Jay Fields 是DRW Trading公司的一名软件程序员，也是一位研讨会的常客。Jay对发现和成熟化创新式解决方案总是抱有激情。

Shane Harvie 在美国、印度和澳大利亚等国的敏捷公司中从事软件开发工作。他现在位于芝加哥的DRW Trading公司工作。

Martin Fowler 是ThoughtWorks公司的首席科学家，他是一位作家、演说家和咨询师，经常在软件开发活动中发表演讲。他关注的是企业软件设计——诸如什么能产生良好的设计，而良好的设计，而良好的设计有需要哪些实践等。他是面向对象技术、重构、模式、敏捷方法论、领域建模、统一建模语言（UML）和极限编程的先行者。近十年来他一直在ThoughtWorks公司工作，这是一家非常出色的系统开发和咨询公司。

图书目录

译者序

序

前言

致谢

第1章 重构初体验

1.1 起点

1.1.1 Movie

1.1.2 Rental

1.1.3 Customer

1.1.4 对起始程序的评价

1.2 重构第一步

1.3 Statement方法的分解和再组合

1.3.1 移动Amount的计算

1.3.2 提炼常客积分的计算

1.3.3 移除临时变量

1.4 用多态替换价格代码中的条件逻辑

1.5 小结

第2章 重构的基本原理

2.1 重构的起源

2.2 重构的定义

2.3 重构的理由

2.3.1 重构可以改进软件的设计

2.3.2 重构让软件变得易于理解

2.3.3 重构可以帮助你发现bug

2.3.4 重构可以帮助你更快地编程

2.4 重构的时机

2.4.1 事不过三

2.4.2 在添加功能时重构

2.4.3 在需要修复bug时重构

2.4.4 在进行代码复审时重构

2.4.5 为了更好地理解而重构（或者说，向着同一个目标进行重构）

2.5 为什么重构能起作用

2.6 我怎么跟经理说

2.7 抽象和重构

2.8 重构的问题

2.8.1 改变接口

2.8.2 数据库

2.8.3 难以重构的设计变化

2.8.4 什么时候不应该重构

2.9 重构和设计

2.10 竹篮打水一场空

2.11 重构和性能

2.12 优化薪资系统

第3章 代码里的坏味道

3.1 重复代码

3.2 方法过长

3.3 类太大

3.4 参数列表太长

3.5 发散型变化

3.6 霰弹型修改

3.7 特性依赖

3.8 数据泥团

3.9 基本类型偏执

3.10 case语句

3.11 平行继承体系

3.12 冗赘类

3.13 纯臆测的泛化

3.14 临时字段

3.15 消息链

3.16 中间人

3.17 过分亲密

3.18 异曲同工的类

3.19 不完善的类库

3.20 数据类

3.21 被拒绝的遗赠

3.22 注释

3.23 狂热的元编程

3.24 脱节的API

3.25 不断重复的样板文本

第4章 构建测试

4.1 自我测试代码的价值

4.2 Test∷Unit测试框架

4.3 程序员测试和质量保证测试

4.4 添加更多的测试

第5章 重构花名册

5.1 重构的格式

5.2 查找引用

第6章 组织方法

6.1 提炼方法

6.1.1 动机

6.1.2 手法

6.1.3 示例：没有局部变量

6.1.4 示例：使用局部变量

6.1.5 示例：重新给局部变量赋值

6.2 内联化方法

6.2.1 动机

6.2.2 手法

6.3 内联化临时变量

6.3.1 动机

6.3.2 手法

6.4 使用查询替换临时变量

6.4.1 动机

6.4.2 手法

6.4.3 示例

6.5 使用链式调用替换临时变量

6.5.1 动机

6.5.2 手法

6.5.3 示例

6.6 引入解释性变量

6.6.1 动机

6.6.2 手法

6.6.3 示例

6.6.4 采用提炼方法的手法

6.7 分解临时变量

6.7.1 动机

6.7.2 手法

6.7.3 示例

6.8 移除对参数赋值

6.8.1 动机

6.8.2 手法

6.8.3 示例

6.9 使用方法对象替换方法

6.9.1 动机

6.9.2 手法

6.9.3示例

6.10 替换算法

6.10.1 动机

6.10.2 手法

6.11 使用集合闭包方法替换循环

6.11.1 动机

6.11.2 手法

6.11.3 示例

6.12 提炼环绕方法

6.12.1 动机

6.12.2 手法

6.12.3 示例

6.13 引入类标注

6.13.1 动机

6.13.2 手法

6.13.3 示例

6.14 引入命名参数

6.14.1 动机

6.14.2 手法

6.14.3 示例1：命名全部参数

6.14.4 示例2：只命名可选参数

6.15 移除命名参数

6.15.1 动机

6.15.2 手法

6.15.3 示例

6.16 移除未使用的默认参数

6.16.1 动机

6.16.2 手法

6.16.3 示例

6.17 动态方法定义

6.17.1 动机

6.17.2 手法

6.17.3 示例：通过def_each来定义相似的方法

6.17.4 instance_exec方法

6.17.5 示例：用类标注来定义实例方法

6.17.6 示例：通过扩展一个动态定义的模块来定义方法

6.18 使用动态方法定义替换动态接收器

6.18.1 动机

6.18.2 手法

6.18.3 示例：不用method_missing进行动态委托

6.18.4 示例：使用自定义数据来定义方法

6.19 隔离动态接收器

6.19.1 动机

6.19.2 手法

6.19.3 示例

6.20 把计算从运行时移到解析时

6.20.1 动机

6.20.2 手法

第7章 在对象之间移动特性

7.1 移动方法

7.1.1 动机

7.1.2 手法

7.1.3 示例

7.2 移动字段

7.2.1 动机

7.2.2 手法

7.2.3 示例

7.2.4 示例：使用自封装

7.3 提炼类

7.3.1 动机

7.3.2 手法

7.3.3 示例

7.4 内联化类

7.4.1 动机

7.4.2 手法

7.4.3 示例

7.5 隐藏委托

7.5.1 动机

7.5.2 手法

7.5.3 示例

7.6 移除中间人

7.6.1 动机

7.6.2 手法

7.6.3 示例

第8章 组织数据

8.1 自封装字段

8.1.1 动机

8.1.2 手法

8.1.3 示例

8.2 使用对象替换数据值

8.2.1 动机

8.2.2 手法

8.2.3 示例

8.3 将值对象改为引用对象

8.3.1 动机

8.3.2 手法

8.3.3 示例

8.4 将引用对象改为值对象

8.4.1 动机

8.4.2 手法

8.4.3 示例

8.5 使用对象替换数组

8.5.1 动机

8.5.2 手法

8.5.3 示例

8.5.4 使用Deprecation进行重构

8.6 使用对象替换Hash

8.6.1 动机

8.6.2 手法

8.6.3 示例

8.7 将单向关联改为双向关联

8.7.1 动机

8.7.2 手法

8.7.3 示例

8.8 将双向关联改为单向关联

8.8.1 动机

8.8.2 手法

8.8.3 示例

8.9 使用符号常数代替魔法数

8.9.1 动机

8.9.2 手法

8.10 封装集合

8.10.1 动机

8.10.2 手法

8.10.3 示例

8.10.4 将行为移入类里

8.11 使用数据类替换记录

8.11.1 动机

8.11.2 手法

8.12 使用多态替换类型码

8.12.1 动机

8.12.2 移除条件逻辑

8.12.3 手法

8.12.4 示例

8.13 使用模块扩展替换类型码

8.13.1 动机

8.13.2 手法

8.13.3 示例

8.14 使用状态或策略模式替换类型码

8.14.1 动机

8.14.2 手法

8.14.3 示例

8.15 使用字段替换子类

8.15.1 动机

8.15.2 手法

8.15.3 示例

8.16 惰性初始化的属性

8.16.1 动机

8.16.2 手法

8.16.3 以II=为例

8.16.4 以instance-variable_defined？为例

8.17 及早初始化的属性

8.17.1 动机

8.17.2 讨论

8.17.3 手法

8.17.4 示例

第9章 简化条件表达式

9.1 分解条件语句

9.1.1 动机

9.1.2 手法

9.1.3 示例

9.2 重组条件语句

9.2.1 动机

9.2.2 示例：使用“0r”赋值替换=三元操作符

9.2.3 示例：使用显式返回替换条件语句

9.3 合并条件表达式

9.3.1 动机

9.3.2 手法

9.3.3 示例：Ors

9.3.4 示例：Ands

9.4 合并重复的条件片段

9.4.1 动机

9.4.2 手法

9.4.3 示例

9.5 移除控制位

9.5.1 动机

9.5.2 手法

9.5.3 示例：使用break替换简单的控制位

9.5.4 示例：返回控制位的结果

9.6 使用守卫子句替换嵌套条件语句

……

第10章 简化方法调用

第11章 处理通用化

第12章 大型重构

第13章 总结

参考文献

重构手法列表