Java改写重构第2版第一个示例

写在前面

《重构：改善既有代码的设计》是一本经典的软件工程必读书籍。作者马丁·福勒强调重构技术是以微小的步伐修改程序。

但是，从国内的情况来而论，“重构”的概念表里分离。大家往往喜欢打着“重构”的名号，实际上却干的是“刀劈斧砍”的勾当。产生这种现象的原因，一方面是程序员希望写出可维护，可复用，可拓展，灵活性好的代码，使系统具长期生命力；另一方面，重构的扎实功夫要学起来、做起来，颇不是一件轻松的事，且不说详尽到近乎琐碎的重构手法，光是单元测试一事，怕是已有九成同行无法企及。所以，重构变质为重写，研发团队拿着公司的经费，干着“重复造轮子”的事儿，最终“重构”后的软件仍然不能使人满意，反倒是一堆问题，用户不愿意买单，程序员不愿意继续维护，管理人员也担着巨大的压力。痛苦的滋味在心底蔓延。

转头来看，Martin Fowler 时隔 20 年后的第 2 版，没有照搬第一版，而是把工夫做得更加扎实了，我有幸发现这本书，解我之惑，实属幸事一件。由于第 2 版中使用 javascript 作为展现重构手法的语言，可是本人惯用的语言却是 Java，因此本着 “实践出真知” 的原则，我想尝试用 Java 语言来对示例进行改写，在分享思路的同时，也希望能够有人与我讨论，甚至指出我的错误，在此深表感谢。

废话不多说了，我们赶紧开始

项目地址

Gitee 项目地址

git clone https://gitee.com/kendoziyu/code-refactoring-example.git

起点

有些看到文章的小伙伴，可能还没拿到这本《重构2》，所以我先把原文需求贴出来，另外在改写时，我会参考并结合《重构》第 1 版中的代码。

设想有一个戏剧演出团，演员们经常要去各种场合表演戏剧。通常客户（customer）会指定几出剧目，而剧团则根据观众（audience）人数及剧目类型向客户收费。该团目前出演两种戏剧：悲剧（tragedy）和喜剧（comedy）。给客户发出账单时，剧团还根据到场观众的数量给出“观众量积分”（volume credit）优惠，下次客户再请剧团表演时，可以使用积分获得折扣————你可以把它看作一种提升客户忠诚度的方式。

该剧团将 剧目 的数据存储在一个简单的 JSON 文件中。

plays.json...

{
"hamlet":{"name":"Hamlet", "type":"tragedy"},
"as-like":{"name":"As You Like It", "type":"comedy"},
"othello":{"name":"Othello", "type":"tragedy"}
}

他们开出的 账单 也存储在一个 JSON 文件里。

invoices.json...

{
    "customer":"BigCo",
    "performances":[
        {
            "playId":"hamlet",
            "audience":55
        },
        {
            "playId":"as-like",
            "audience":35
        },
        {
            "playId":"othello",
            "audience":40
        }
    ]
}

等下我要来解析这两组 JSON 对象，不妨先来分析一下实体类之间的关系：

发票（Invoice）

  
public class Invoice {
    private String customer;
    private List<Performance> performances;
    public String getCustomer() {
        return customer;
    }
    public void setCustomer(String customer) {
        this.customer = customer;
    }
    public List getPerformances() {
        return performances;
    }
    public void setPerformances(List performances) {
        this.performances = performances;
    }
}
  

表演（Performance）

  
public class Performance {
    private String playId;
    private int audience;
    public String getPlayId() {
        return playId;
    }
    public void setPlayId(String playId) {
        this.playId = playId;
    }
    public int getAudience() {
        return audience;
    }
    public void setAudience(int audience) {
        this.audience = audience;
    }
}
  

剧目（Play）

  
public class Play {
    private String name;
    private String type;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
}
  

接着，书中直接就给出了 打印账单信息 的函数 function statement(invoice, plays) {}。注意，《重构2》书中有提到，

当我在代码块上方使用了斜体（中文对应楷体）标记的题头 “function xxx” 时，表明该代码位于题头所在函数、文件或类的作用域内。

所以，结合《重构（第 1 版）》中的 Java 示例，我对第二版的示例做了一些改造：

Statement.java...

public class Statement {

    private Invoice invoice;
    private Map<String, Play> plays;

    public Statement(Invoice invoice, Map<String, Play> plays) {
        this.invoice = invoice;
        this.plays = plays;
    }

    public String show() {
        int totalAmount = 0;
        int volumeCredits = 0;
        String result = String.format("Statement for %s
", invoice.getCustomer());
        StringBuilder stringBuilder = new StringBuilder(result);

        Locale locale = new Locale("en", "US");
        NumberFormat format = NumberFormat.getCurrencyInstance(locale);

        for (Performance performance : invoice.getPerformances()) {
            Play play = plays.get(performance.getPlayId());
            int thisAmount = 0;
            switch (play.getType()) {
                case "tragedy":
                    thisAmount = 40000;
                    if (performance.getAudience() > 30) {
                        thisAmount += 1000 * (performance.getAudience() - 30);
                    }
                    break;
                case "comedy":
                    thisAmount = 30000;
                    if (performance.getAudience() > 20) {
                        thisAmount += 10000 + 500 *(performance.getAudience() - 20);
                    }
                    thisAmount += 300 * performance.getAudience();
                    break;
                default:
                    throw new RuntimeException("unknown type:" + play.getType());
            }

            volumeCredits += Math.max(performance.getAudience() - 30, 0);

            if ("comedy".equals(play.getType())) {
                volumeCredits += Math.floor(performance.getAudience() / 5);
            }

            stringBuilder.append(String.format(" %s: %s (%d seats)
", play.getName(), format.format(thisAmount/100), performance.getAudience()));
            totalAmount += thisAmount;
        }
        stringBuilder.append(String.format("Amount owed is %s
", format.format(totalAmount/100)));
        stringBuilder.append(String.format("You earned %s credits
", volumeCredits));
        return stringBuilder.toString();
    }
}

值得一提的有：

1. 从 Java 1.7 开始，switch 开始支持字符串了

2. NumberFormat.getCurrencyInstance 这个 API，可以为我们打印货币信息

Main.java...

public class Main {

    static final String plays = "{" +
            ""hamlet":{"name":"Hamlet","type":"tragedy"}," +
            ""as-like":{"name":"As You Like It","type":"comedy"}," +
            ""othello":{"name":"Othello","type":"tragedy"}" +
            "}";

    static final String invoices = "[{" +
            ""customer":"BigCo","performances":[" +
            "{"playId":"hamlet","audience":55}" +
            "{"playId":"as-like","audience":35}" +
            "{"playId":"othello","audience":40}" +
            "]" +
            "}]";
    public static void main(String[] args) {
        TypeReference<Map<String, Play>> typeReference = new TypeReference<Map<String, Play>>(){};
        Map<String, Play> playMap = JSONObject.parseObject(plays, typeReference);
        List<Invoice> invoiceList = JSONObject.parseArray(invoices, Invoice.class);
        for (Invoice invoice : invoiceList) {
            Statement statement = new Statement(invoice, playMap);
            String result = statement.show();
            System.out.println(result);
        }
    }
}

运行上面的 Main 主类，会得到如下输出：

Statement for BigCo
 Hamlet: $650.00 (55 seats)
 As You Like It: $580.00 (35 seats)
 Othello: $500.00 (40 seats)
Amount owed is $1,730.00
You earned 47 credits

新需求

在这个例子里，我们的用户希望对系统做几个修改。首先，他们希望以 HTML 格式输出详单。另外，他们还希望增加表演（Play）的类型，虽然还没决定增加哪种以及何时试演。这对戏剧场次的计费方式、积分方式都有影响。在这样的需求前提下，如果你不想以后面对一堆莫名奇妙的 BUG，被逼着各种加班，那我们现在就要着手重构上面的示例了。

如果你要给程序增加一个特性，但是发现代码因缺乏良好的结构而不易于进行更改，那就先重构哪个程序，使其比较容易添加该特性，然后再添加该特性。

重构第一步

重构前，先检查自己是否有一套可靠的测试集。这些测试必须有自我检验能力。

所以，我把 Main.java 稍微改变了一下，设计成了一个简单的测试：

点击查看 StatementTest.java

- 基于 Junit 的单元测试

  
public class StatementTest {
    @Test
    public void test() {
        String expected = "Statement for BigCo
" +
                " Hamlet: $650.00 (55 seats)
" +
                " As You Like It: $580.00 (35 seats)
" +
                " Othello: $500.00 (40 seats)
" +
                "Amount owed is $1,730.00
" +
                "You earned 47 credits
";
        final String plays = "{" +
                ""hamlet":{"name":"Hamlet","type":"tragedy"}," +
                ""as-like":{"name":"As You Like It","type":"comedy"}," +
                ""othello":{"name":"Othello","type":"tragedy"}" +
                "}";
        final String invoices = "{" +
                ""customer":"BigCo","performances":[" +
                "{"playId":"hamlet","audience":55}" +
                "{"playId":"as-like","audience":35}" +
                "{"playId":"othello","audience":40}" +
                "]" +
                "}";
        TypeReference> typeReference = new TypeReference>(){};
        Map playMap = JSONObject.parseObject(plays, typeReference);
        Invoice invoice = JSONObject.parseObject(invoices, Invoice.class);
        Statement statement = new Statement(invoice, playMap);
        String result = statement.show();
        Assert.assertEquals(expected, result);
    }
}
  

接下来的可以照着书上的要求执行，以微小的步伐开始你的重构之旅了，如果有不明白的也可以参考一下我的例子 code-refactoring-example

拆分计算阶段和格式化阶段

我们希望同样的计算函数可以被 文本版 详单和 HTML版 详单共用。
实现复用有许多种方法，而我最喜欢的技术是 拆分阶段。这里我们的目标是将逻辑分成两部分：一部分计算详单所需的数据，另一部分将数据渲染成文本或者HTML。第一阶段会创建一个中转数据结构，再它传递给第二阶段。

我们可以创建一个 StatementData 作为两个阶段间传递的中间数据结构。建议大家根据书上的讲解实际操练，这里仅仅提供一种思路，我的实操过程已经放在了 Gitee 上面，有兴趣的可以参考和修改。

我们这里拆分函数时有一个目标：让 renderPlainText 只操作通过 data 传递进来的数据（data 就是 StatementData 的实例对象），经过一系列搬移函数之后，我们可以达成这个目标：

    /**
     * 使用纯文本渲染
     * @param data 详单数据
     * @return
     */
    private String renderPlainText(StatementData data) {
        String result = String.format("Statement for %s
", data.getCustomer());
        StringBuilder stringBuilder = new StringBuilder(result);

        for (Performance performance : data.getPerformances()) {
            stringBuilder.append(String.format(" %s: %s (%d seats)
", performance.getPlay().getName(), usd(performance.getAmount()), performance.getAudience()));
        }
        stringBuilder.append(String.format("Amount owed is %s
", usd(data.getTotalAmount())));
        stringBuilder.append(String.format("You earned %s credits
", data.getTotalVolumeCredits()));
        return stringBuilder.toString();
    }

按计算过程重组计算过程

接下来我们将注意力集中到下一个特性改动：支持更多类型的戏剧，以及支持他们各自的价格计算和观众量积分计算。而改动的核心在 enrichPerformance 函数就是关键所在，因为正是它用每场演出的数据来填充中转数据结构。目前它直接调用了计算价格函数 amountFor，和计算观众量积分函数 volumeCreditsFor 。我们需要创建一个类，通过这个类来调用这些函数。由于这个类存放了与每场演出相关数据的计算函数，于是我们把它称为演出计算器 PerformanceCalculator。

我们把 amountFor, volumeCredits 都搬到了 PerformanceCalculator 中。play 字段严格来说，是不需要搬移的，因为它并未体现出多态性。但是这样可以把所有数据转换集中到一处地方，保证了代码的一致性和清晰度。改动后如下：

private Performance enrichPerformance(Performance performance) {
      PerformanceCalculator calculator = new PerformanceCalculator(performance, playFor(performance));
      performance.setPlay(calculator.play());
      performance.setAmount(calculator.amount());
      performance.setVolumeCredits(calculator.volumeCredits());
      return performance;
}

以工厂函数取代构造函数

private Performance enrichPerformance(Performance performance) {
      PerformanceCalculator calculator = createPerformanceCalculator(performance, playFor(performance));
      ...(同上)
      return performance;
}

private PerformanceCalculator createPerformanceCalculator(Performance performance, Play play) {
      return new PerformanceCalculator(performance, play);
}

以子类取代类型码，新建 ComedyCalculator 和 TragedyCalculator 并且让他们继承 PerformanceCalculator

private PerformanceCalculator createPerformanceCalculator(Performance performance, Play play) {
      switch (play.getType()) {
            case "tragedy": return new TragedyCalculator(performance, play);
            case "comedy": return new ComedyCalculator(performance, play);
            default:
                throw new RuntimeException("unknown type:" + play.getType());
      }
}

以多态取代条件表达式

public class ComedyCalculator extends PerformanceCalculator {

    public ComedyCalculator(Performance performance, Play play) {
        super(performance, play);
    }

    @Override
    public int amount() {
        int result = 30000;
        if (performance.getAudience() > 20) {
            result += 10000 + 500 *(performance.getAudience() - 20);
        }
        result += 300 * performance.getAudience();
        return result;
    }

    @Override
    public int volumeCredits() {
        return (int) (super.volumeCredits() + Math.floor(performance.getAudience() / 5));
    }
}

public class TragedyCalculator extends PerformanceCalculator {

    public TragedyCalculator(Performance performance, Play play) {
        super(performance, play);
    }

    @Override
    public int amount() {
        int result = 40000;
        if (performance.getAudience() > 30) {
            result += 1000 * (performance.getAudience() - 30);
        }
        return result;
    }
}

总结

以一张图总结本文内容：

1. 例中我们用到了数种重构手法。包括提炼函数，内联变量，搬移函数，以多态取代条件表达式等。
2. 我们用 拆分阶段 的技术分离计算逻辑与输出格式化的逻辑。

好代码的检验标准就是人们能否轻而易举地修改它！

与君共勉

编程时，需要遵循营地法则：希望我们都可以“保证你离开时的代码库一定比你来时更健康”。