• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

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

开发技术 开发技术 2天前 8次浏览

写在前面

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

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

转头来看,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 对象,不妨先来分析一下实体类之间的关系:

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

发票(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 %sn", 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)n", play.getName(), format.format(thisAmount/100), performance.getAudience()));
            totalAmount += thisAmount;
        }
        stringBuilder.append(String.format("Amount owed is %sn", format.format(totalAmount/100)));
        stringBuilder.append(String.format("You earned %s creditsn", 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 BigCon" +
                " Hamlet: $650.00 (55 seats)n" +
                " As You Like It: $580.00 (35 seats)n" +
                " Othello: $500.00 (40 seats)n" +
                "Amount owed is $1,730.00n" +
                "You earned 47 creditsn";
        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<map> typeReference = new TypeReference<map>(){};
        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);
    }
}
  mapmap

接下来的可以照着书上的要求执行,以微小的步伐开始你的重构之旅了,如果有不明白的也可以参考一下我的例子 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 %sn", data.getCustomer());
        StringBuilder stringBuilder = new StringBuilder(result);

        for (Performance performance : data.getPerformances()) {
            stringBuilder.append(String.format(" %s: %s (%d seats)n", performance.getPlay().getName(), usd(performance.getAmount()), performance.getAudience()));
        }
        stringBuilder.append(String.format("Amount owed is %sn", usd(data.getTotalAmount())));
        stringBuilder.append(String.format("You earned %s creditsn", 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;
    }
}

总结

以一张图总结本文内容:

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

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

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

与君共勉

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


喜欢 (0)