理论一:什么情况下要重构?到底重构什么?又该如何重构? 1. 重构的目的: 为什么重构(why)? 对于项目来言,重构可以保持代码质量持续处于一个可控状态,不至于腐化到无可救药的地步。
对于个人而言,重构非常锻炼一个人的代码能力,并且是一件非常有成就感的事情。它是我们学习的经典设计思想、原则、模式、编程规范等理论知识的练兵场。
2. 重构的对象: 重构什么(what)?按照重构的规模,我们可以将重构大致分为大规模高层次的重构和小规模低层次的重构。
大规模高层次重构包括对代码分层、模块化、解耦、梳理类之间的交互关系、抽象复用组件等等。这部分工作利用的更多的是比较抽象、比较顶层的设计思想、原则、模式。
小规模低层次的重构包括规范命名、注释、修正函数参数过多、消除超大类、提取重复代码等等编程细节问题,主要是针对类、函数级别的重构。小规模低层次的重构更多的是利用编码规范这一理论知识。
3. 重构的时机: 什么时候重构(when)?我反复强调,我们一定要建立持续重构意识,把重构作为开发必不可少的部分,融入到日常开发中,而不是等到代码出现很大问题的时候,再大刀阔斧地重构。
平时没有事情的时候,你可以看看项目中有哪些写得不够好的、可以优化的代码,主动去重构一下。或者,在修改、添加某个功能代码的时候,你也可以顺手把不符合编码规范、不好的设计重构一下。总之,就像把单元测试、Code Review 作为开发的一部分,我们如果能把持续重构也作为开发的一部分,成为一种开发习惯,对项目、对自己都会很有好处。
4. 重构的方法: 如何重构(how)?大规模高层次的重构难度比较大,需要组织、有计划地进行,分阶段地小步快跑,时刻让代码处于一个可运行的状态。每个阶段完成一小部分代码的重构,然后提交、测试、运行,发现没有问题之后,再继续进行下一阶段的重构,保证代码仓库中的代码一直处于可运行、逻辑正确的状态。每个阶段,我们都要控制好重构影响到的代码范围,考虑好如何兼容老的代码逻辑,必要的时候还需要写一些兼容过渡代码。只有这样,我们才能让每一阶段的重构都不至于耗时太长(最好一天就能完成),不至于与新的功能开发相冲突。
而小规模低层次的重构,因为影响范围小,改动耗时短,所以,只要你愿意并且有时间,随时随地都可以去做。平时没有事情的时候,你可以看看项目中有哪些写得不够好的、可以优化的代码,主动去重构一下。或者,在修改、添加某个功能代码的时候,你也可以顺手把不符合编码规范、不好的设计重构一下。除了人工去发现低层次的质量问题,我们还可以借助很多成熟的静态代码分析工具(比如 CheckStyle、FindBugs、PMD),来自动发现代码中的问题,然后针对性地进行重构优化。
idea 可以安装 Alibaba Java Coding Guidelines 来帮助解决一些规范的问题,重构解决一些低级别的错误https://www.cnblogs.com/DDgougou/p/9282554.html
评论区精彩评论 一个重构的案例(步骤) 前段时间刚重构了一个功能模块。该模块可以说是祖传代码。里面堆砌着各种判断条件,就是所谓的箭头型代码。我接手这个功能重构的 1.把代码读一遍和跑一遍,理解里面的需求。尽量画一个流程图。 2.建立防护网。将需求拆分之后,针对每个拆分的业务点写单元测试。 4.开始重构,解耦逻辑,设计方法的时候尽量让职业单一,类与类之间尽量符合迪米特原则,有依赖关系的类尽量只依赖类的特定方法。我觉得比较基础也是比较重要一点。不要有重复代码。命名要规范,类的各个职业要清晰。重构过程中,其实也要时不时的识别代码的坏味道。尽然是重构,那么肯定要比不重构之前肯定要更好。 5.重构完成之后,通过防护网的测试。
重构后的功能一定要可测试 代码中的坏味道,好比人的头疼脑热。“小病”不管的话,迟早会发展成大病,需要动大手术,甚至病入膏肓。 实际中的一些体会: 一、在完成一个新需求时,在时间允许的情况下,会经常改进代码,使代码更优雅。 二、“重构不改变外部的可见行为“,引入自动化测试非常重要,国内有些团队可能做的不好。因为改动代码可能引入bug,如果没有自动化测试,测起来就会非常费劲,改动的结果不确定。如果测试不方便,谁会愿意修改之前work的代码呢? 三、持续集成、自动化测试、持续重构都是很好的工程实践。即使工作的项目中暂时没有使用,也应该有所了解。
写单元测试很重要,谁写谁知道 最可落地执行、最有效的保证重构不出错的手段应该就是单元测试(Unit Testing)了。当重构完成之后,如果新的代码仍然能通过单元测试,那就说明代码原有逻辑的正确性未被破坏,原有的外部可见行为未变。
理论二:为了保证重构不出错,有哪些非常能落地的技术手段? 什么是单元测试?为什么要写单元测试?如何编写单元测试?如何在团队中推行单元测试?
那如何保证重构不出错呢?你需要熟练掌握各种设计原则、思想、模式,还需要对所重构的业务和代码有足够的了解。除了这些个人能力因素之外,最可落地执行、最有效的保证重构不出错的手段应该就是单元测试(Unit Testing)了。当重构完成之后,如果新的代码仍然能通过单元测试,那就说明代码原有逻辑的正确性未被破坏,原有的外部可见行为未变,符合上一节课中我们对重构的定义。
什么是单元测试? 单元测试由研发工程师自己来编写,用来测试自己写的代码的正确性。单元测试顾名思义是测试一个“单元”,有别于集成测试,这个“单元”一般是类或函数,而不是模块或者系统。
我们常常将它跟集成测试放到一块来对比。单元测试相对于集成测试(Integration Testing)来说,测试的粒度更小一些。集成测试的测试对象是整个系统或者某个功能模块,比如测试用户注册、登录功能是否正常,是一种端到端(end to end)的测试。而单元测试的测试对象是类或者函数,用来测试一个类和函数是否都按照预期的逻辑执行。这是代码层级的测试。
为什么要写单元测试? 写单元测试的过程本身就是代码 Code Review 和重构的过程,能有效地发现代码中的 bug 和代码设计上的问题。除此之外,单元测试还是对集成测试的有力补充,还能帮助我们快速熟悉代码,是 TDD 可落地执行的改进方案。
1.单元测试能有效地帮你发现代码中的 bug 坚持为自己提交的每一份代码,都编写完善的单元测试。可以减少很多 fix 低级 bug 的时间,能够有时间去做其他更有意义的事情,可以因此在工作上赢得了很多人的认可。可以这么说,坚持写单元测试是保证代码质量的一个“杀手锏”,也是帮助拉开与其他人差距的一个“小秘密”。
2.写单元测试能帮你发现代码设计上的问题 代码的可测试性是评判代码质量的一个重要标准。对于一段代码,如果很难为其编写单元测试,或者单元测试写起来很吃力,需要依靠单元测试框架里很高级的特性才能完成,那往往就意味着代码设计得不够合理,比如,没有使用依赖注入、大量使用静态函数、全局变量、代码高度耦合等。
3.单元测试是对集成测试的有力补充 尽管单元测试无法完全替代集成测试,但如果我们能保证每个类、每个函数都能按照我们的预期来执行,底层 bug 少了,那组装起来的整个系统,出问题的概率也就相应减少了。
4.写单元测试的过程本身就是代码重构的过程? 设计和实现代码的时候,我们很难把所有的问题都想清楚。而编写单元测试就相当于对代码的一次自我 Code Review,在这个过程中,我们可以发现一些设计上的问题(比如代码设计的不可测试)以及代码编写方面的问题(比如一些边界条件处理不当)等,然后针对性的进行重构。
5.阅读单元测试能帮助你快速熟悉代码 在没有文档和注释的情况下,单元测试就起了替代性作用。单元测试用例实际上就是用户用例,反映了代码的功能和如何使用。借助单元测试,我们不需要深入的阅读代码,便能知道代码实现了什么功能,有哪些特殊情况需要考虑,有哪些边界条件需要处理。
6.单元测试是 TDD 可落地执行的改进方案 单元测试正好是对 TDD 的一种改进方案,先写代码,紧接着写单元测试,最后根据单元测试反馈出来问题,再回过头去重构代码。这个开发流程更加容易被接受,更加容易落地执行,而且又兼顾了 TDD 的优点。
如何编写单元测试 写单元测试就是针对代码设计各种测试用例,以覆盖各种输入、异常、边界情况,并将其翻译成代码。我们可以利用一些测试框架来简化单元测试的编写。Java 中比较出名的单元测试框架有 Junit、TestNG、Spring Test 等。这些框架提供了通用的执行流程(比如执行测试用例的 TestCaseRunner)和工具类库(比如各种 Assert 判断函数)等。借助它们,我们在编写测试代码的时候,只需要关注测试用例本身的编写即可。
除此之外,对于单元测试,我们需要建立以下正确的认知:
编写单元测试尽管繁琐,但并不是太耗时;
我们可以稍微放低对单元测试代码质量的要求;
覆盖率作为衡量单元测试质量的唯一标准是不合理的;
单元测试不要依赖被测代码的具体实现逻辑;
单元测试框架无法测试,多半是因为代码的可测试性不好。
一个单元测试的例子 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public class Text { private String content; public Text(String content) { this.content = content; } /** * 将字符串转化成数字,忽略字符串中的首尾空格; * 如果字符串中包含除首尾空格之外的非数字字符,则返回null。 */ public Integer toNumber() { if (content == null || content.isEmpty()) { return null; } //...省略代码实现... return null; } }
如果我们要测试 一下Text 类中的 toNumber() 函数的正确性,应该如何编写单元测试呢?
写单元测试本身不需要什么高深技术。它更多的是考验程序员思维的缜密程度,看能否设计出覆盖各种正常及异常情况的测试用例,来保证代码在任何预期或非预期的情况下都能正确运行。
罗列出各种正常,异常,以及边界的测试用例
如果字符串只包含数字:“123”,toNumber() 函数输出对应的整数:123。
如果字符串是空或者 null,toNumber() 函数返回:null。
如果字符串包含首尾空格:“ 123”,“123 ”,“ 123 ”,toNumber() 返回对应的整数:123。
如果字符串包含多个首尾空格:“ 123 ”,toNumber() 返回对应的整数:123;
如果字符串包含非数字字符:“123a4”,“123 4”,toNumber() 返回 null;
将测试用例翻译成代码 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 public class Assert { public static void assertEquals(Integer expectedValue, Integer actualValue) { if (actualValue != expectedValue) { String message = String.format( "Test failed, expected: %d, actual: %d.", expectedValue, actualValue); System.out.println(message); } else { System.out.println("Test succeeded."); } } public static boolean assertNull(Integer actualValue) { boolean isNull = actualValue == null; if (isNull) { System.out.println("Test succeeded."); } else { System.out.println("Test failed, the value is not null:" + actualValue); } return isNull; } } import org.junit.Assert; import org.junit.Test; public class TextTest { @Test public void testToNumber() { Text text = new Text("123"); Assert.assertEquals(new Integer(123), text.toNumber()); } @Test public void testToNumber_nullorEmpty() { Text text1 = new Text(null); Assert.assertNull(text1.toNumber()); Text text2 = new Text(""); Assert.assertNull(text2.toNumber()); } @Test public void testToNumber_containsLeadingAndTrailingSpaces() { Text text1 = new Text(" 123"); Assert.assertEquals(new Integer(123), text1.toNumber()); Text text2 = new Text("123 "); Assert.assertEquals(new Integer(123), text2.toNumber()); Text text3 = new Text(" 123 "); Assert.assertEquals(new Integer(123), text3.toNumber()); } @Test public void testToNumber_containsMultiLeadingAndTrailingSpaces() { Text text1 = new Text(" 123"); Assert.assertEquals(new Integer(123), text1.toNumber()); Text text2 = new Text("123 "); Assert.assertEquals(new Integer(123), text2.toNumber()); Text text3 = new Text(" 123 "); Assert.assertEquals(new Integer(123), text3.toNumber()); } @Test public void testToNumber_containsInvalidCharaters() { Text text1 = new Text("123a4"); Assert.assertNull(text1.toNumber()); Text text2 = new Text("123 4"); Assert.assertNull(text2.toNumber()); } }
单元测试为何难落地执行?
一方面,写单元测试本身比较繁琐,技术挑战不大,很多程序员不愿意去写;
另一方面,国内研发比较偏向“快、糙、猛”,容易因为开发进度紧,导致单元测试的执行虎头蛇尾。最后,关键问题还是团队没有建立对单元测试正确的认识,觉得可有可无,单靠督促很难执行得很好。
重度依赖数据库的业务代码如何做单元测试
涉及到数据库的确实比较难写单元测试,而且如果重度依赖数据库,业务逻辑又不复杂,单元测试确实没有太大意义。这个时候,集成测试可能更有意义些。
涉及到数据库的项目,特别是重度依赖数据库的,确实比较难写单元测试。一种方式使用DBUNIT这样的测试框架来解耦合真正的数据库,另一种方式专门维护一个供单元测试用的数据库。
精彩评论 1.以前在开发中,没有写单元测试的意识。开发完功能后,直接去测试一个完整的流程。即前端发请求,服务端处理,看数据库数据。如果功能正确就过。这是从一个功能宏观去考虑测试。而单元测试是更细粒度的测试,它在保证各个“单元”都测试通过的情况下整个功能模块就测试通过了。这样的方式对于我们自己来说对代码可控粒度更细。更能比较清楚的理解某个“单元”在整个功能模块调用链路上的位置,承担什么职责,以及有什么行为。而不是一开始就站在模块宏观角度来思考。通过一个个单元测试的编写,将整个功能模块串联起来,最终达到整个功能模块的全局认知。 这也体现了任务分解的思想。通过单元测试,可以从另外一方面实现对已编写的代码的CodeReview,重新梳理流程。也为以后有重构需求打下基础。目前参与的项目中有单元测试,但是不够完备。可能由于某些原因(开发人员意识问题,团队对单元测试的执行落地程度不够等)。在写单元测试的过程中,遇到单元测试依赖数据库查询问题,因为存在多套环境,如开发环境,仿真环境,线上环境。对于依赖数据查询的单元测试,只能自己造假数据来解决。不知道还有什么好的解决办法。
作者回复:涉及到数据库的确实比较难写单元测试,而且如果重度依赖数据库,业务逻辑又不复杂,单元测试确实没有太大意义。这个时候,集成测试可能更有意义些。
2.如果到了具体的业务代码,该怎么写单元测试呢,单元测试正确标准是什么呢,以sql查询到的结果吗?
作者回复:涉及到数据库的项目,特别是重度依赖数据库的,确实比较难写单元测试。一种方式使用DBUNIT这样的测试框架来解耦合真正的数据库,另一种方式专门维护一个供单元测试用的数据库。
3.单元测试很重要,但是为什么大多人都会放弃?我个人觉得最主要的原因并不是代码量大,难以编写等,而是跑单元测试的次数少。很多单元测试都是为了写而写,写完一次可能都不去运行或者只偶尔运行一两次。如果是每次改完代码,都跑一遍单元测试,单元测试的效果会越来越显现。如果只是为了运行一两次或者干脆为了写而写,很容易就会放弃继续写单元测试。
作者回复:可以集成到代码管理仓库git中,强制跑单元测试成功之后才能提交
理论三:什么是代码的可测试性?如何写出可测试性好的代码? 写单元测试并不难,也不需要太多技巧,相反,写出可测试的代码反倒是件非常有挑战的事情。
1. 什么是代码的可测试性? 粗略地讲,所谓代码的可测试性,就是针对代码编写单元测试的难易程度。对于一段代码,如果很难为其编写单元测试,或者单元测试写起来很费劲,需要依靠单元测试框架中很高级的特性,那往往就意味着代码设计得不够合理,代码的可测试性不好。
2. 编写可测试性代码的最有效手段 依赖注入是编写可测试性代码的最有效手段。通过依赖注入,我们在编写单元测试的时候,可以通过 mock 的方法解依赖外部服务,这也是我们在编写单元测试的过程中最有技术挑战的地方
3. 常见的 Anti-Patterns 常见的测试不友好的代码有下面这 5 种:
代码中包含未决行为逻辑
滥用可变全局变量
滥用静态方法使用复杂的继承关系
高度耦合的代码
4.mock 用一个“假”的服务替换真正的服务 单元测试主要是测试程序员自己编写的代码逻辑的正确性,并非是端到端的集成测试,它不需要测试所依赖的外部系统(分布式锁、Wallet RPC 服务)的逻辑正确性。所以,如果代码中依赖了外部系统或者不可控组件,比如,需要依赖数据库、网络通信、文件系统等,那我们就需要将被测代码与外部系统解依赖,而这种解依赖的方法就叫作“mock”。所谓的 mock 就是用一个“假”的服务替换真正的服务。mock 的服务完全在我们的控制之下,模拟输出我们想要的数据。
那如何来 mock 服务呢?mock 的方式主要有两种,手动 mock 和利用框架 mock。
例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 public class Transaction { private String id; private Long buyerId; private Long sellerId; private Long productId; private String orderId; private Long createTimestamp; private Double amount; private STATUS status; private String walletTransactionId; // ...get() methods... public Transaction(String preAssignedId, Long buyerId, Long sellerId, Long productId, String orderId) { if (preAssignedId != null && !preAssignedId.isEmpty()) { this.id = preAssignedId; } else { this.id = IdGenerator.generateTransactionId(); } if (!this.id.startWith("t_")) { this.id = "t_" + preAssignedId; } this.buyerId = buyerId; this.sellerId = sellerId; this.productId = productId; this.orderId = orderId; this.status = STATUS.TO_BE_EXECUTD; this.createTimestamp = System.currentTimestamp(); } public boolean execute() throws InvalidTransactionException { if ((buyerId == null || (sellerId == null || amount < 0.0) { throw new InvalidTransactionException(...); } if (status == STATUS.EXECUTED) return true; boolean isLocked = false; try { isLocked = RedisDistributedLock.getSingletonIntance().lockTransction(id); if (!isLocked) { return false; // 锁定未成功,返回false,job兜底执行 } if (status == STATUS.EXECUTED) return true; // double check long executionInvokedTimestamp = System.currentTimestamp(); if (executionInvokedTimestamp - createdTimestap > 14days) { this.status = STATUS.EXPIRED; return false; } WalletRpcService walletRpcService = new WalletRpcService(); String walletTransactionId = walletRpcService.moveMoney(id, buyerId, sellerId, amount); if (walletTransactionId != null) { this.walletTransactionId = walletTransactionId; this.status = STATUS.EXECUTED; return true; } else { this.status = STATUS.FAILED; return false; } } finally { if (isLocked) { RedisDistributedLock.getSingletonIntance().unlockTransction(id); } } } }
Transaction 类中的 execute() 函数负责执行转账操作,将钱从买家的钱包转到卖家的钱包中。真正的转账操作是通过调用 WalletRpcService RPC 服务来完成的。除此之外,代码中还涉及一个分布式锁 DistributedLock 单例类,用来避免 Transaction 并发执行,导致用户的钱被重复转出。
1.当代码包含依赖第三方系统的RPC调用时怎么写 单元测试 我们通过继承 WalletRpcService 类,并且重写其中的 moveMoney() 函数的方式来实现 mock。具体的代码实现如下所示。通过 mock 的方式,我们可以让 moveMoney() 返回任意我们想要的数据,完全在我们的控制范围内,并且不需要真正进行网络通信。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 public class MockWalletRpcServiceOne extends WalletRpcService { public String moveMoney(Long id, Long fromUserId, Long toUserId, Double amount) { return "123bac"; } } public class MockWalletRpcServiceTwo extends WalletRpcService { public String moveMoney(Long id, Long fromUserId, Long toUserId, Double amount) { return null; } } public class Transaction { //... // 添加一个成员变量及其set方法 private WalletRpcService walletRpcService; public void setWalletRpcService(WalletRpcService walletRpcService) { this.walletRpcService = walletRpcService; } // ... public boolean execute() { // ... // 删除下面这一行代码 // WalletRpcService walletRpcService = new WalletRpcService(); // ... } } public void testExecute() { Long buyerId = 123L; Long sellerId = 234L; Long productId = 345L; Long orderId = 456L; Transction transaction = new Transaction(null, buyerId, sellerId, productId, orderId); // 使用mock对象来替代真正的RPC服务 transaction.setWalletRpcService(new MockWalletRpcServiceOne()): boolean executedResult = transaction.execute(); assertTrue(executedResult); assertEquals(STATUS.EXECUTED, transaction.getStatus()); }
当代码中包含一些不是我们维护的组件的调用时如何写单元测试
如果 RedisDistributedLock 是我们自己维护的,可以自由修改、重构,那我们可以将其改为非单例的模式,或者定义一个接口,比如 IDistributedLock,让 RedisDistributedLock 实现这个接口。这样我们就可以像前面 WalletRpcService 的替换方式那样,替换 RedisDistributedLock 为 MockRedisDistributedLock 了。但如果 RedisDistributedLock 不是我们维护的,我们无权去修改这部分代码,这个时候该怎么办呢?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 public class TransactionLock { public boolean lock(String id) { return RedisDistributedLock.getSingletonIntance().lockTransction(id); } public void unlock() { RedisDistributedLock.getSingletonIntance().unlockTransction(id); } } public class Transaction { //... private TransactionLock lock; public void setTransactionLock(TransactionLock lock) { this.lock = lock; } public boolean execute() { //... try { isLocked = lock.lock(); //... } finally { if (isLocked) { lock.unlock(); } } //... } } public void testExecute() { Long buyerId = 123L; Long sellerId = 234L; Long productId = 345L; Long orderId = 456L; TransactionLock mockLock = new TransactionLock() { public boolean lock(String id) { return true; } public void unlock() {} }; Transction transaction = new Transaction(null, buyerId, sellerId, productId, orderId); transaction.setWalletRpcService(new MockWalletRpcServiceOne()); transaction.setTransactionLock(mockLock); boolean executedResult = transaction.execute(); assertTrue(executedResult); assertEquals(STATUS.EXECUTED, transaction.getStatus()); }
小结 1.依赖注入是提高代码可测试性的最有效的手段。
2.可测试性差的代码,本身代码设计得也不够好,很多地方都没有遵守我们之前讲到的设计原则和思想,比如“基于接口而非实现编程”思想、依赖反转原则等。重构之后的代码,不仅可测试性更好,而且从代码设计的角度来说,也遵从了经典的设计原则和思想。这也印证了我们之前说过的,代码的可测试性可以从侧面上反应代码设计是否合理。除此之
3、未决行为:例时间、随机数。将未决行为重新封装,测试时mock,使用匿名类。
理论四:如何通过封装、抽象、模块化、中间层等解耦代码? 大型重构是对系统、模块、代码结构、类之间关系等顶层代码设计进行的重构。对于大型重构来说,今天我们重点讲解最有效的一个手段,那就是“解耦”。解耦的目的是实现代码高内聚、松耦合。
“解耦”为何如此重要? 过于复杂的代码往往在可读性、可维护性上都不友好。解耦保证代码松耦合、高内聚,是控制代码复杂度的有效手段。代码高内聚、松耦合,也就是意味着,代码结构清晰、分层模块化合理、依赖关系简单、模块或类之间的耦合小,那代码整体的质量就不会差。
如何判定代码是否需要“解耦”? 间接的衡量标准有很多,比如,看修改代码是否牵一发而动全身。直接的衡量标准是把模块与模块、类与类之间的依赖关系画出来,根据依赖关系图的复杂性来判断是否需要解耦重构。
如何给代码“解耦”? 给代码解耦的方法有:封装与抽象、中间层、模块化,以及一些其他的设计思想与原则,比如:单一职责原则、基于接口而非实现编程、依赖注入、多用组合少用继承、迪米特法则等。当然,还有一些设计模式,比如观察者模式。
设计原则回顾 单一职责原则 高内聚会让代码更加松耦合,而实现高内聚的重要指导原则就是单一职责原则。模块或者类的职责设计得单一,而不是大而全,那依赖它的类和它依赖的类就会比较少,代码耦合也就相应的降低了。
基于接口而非实现编程 基于接口而非实现编程能通过接口这样一个中间层,隔离变化和具体的实现。这样做的好处是,在有依赖关系的两个模块或类之间,一个模块或者类的改动,不会影响到另一个模块或类。实际上,这就相当于将一种强依赖关系(强耦合)解耦为了弱依赖关系(弱耦合)。
依赖注入 跟基于接口而非实现编程思想类似,依赖注入也是将代码之间的强耦合变为弱耦合。尽管依赖注入无法将本应该有依赖关系的两个类,解耦为没有依赖关系,但可以让耦合关系没那么紧密,容易做到插拔替换。
多用组合少用继承 继承是一种强依赖关系,父类与子类高度耦合,且这种耦合关系非常脆弱,牵一发而动全身,父类的每一次改动都会影响所有的子类。相反,组合关系是一种弱依赖关系,这种关系更加灵活,所以,对于继承结构比较复杂的代码,利用组合来替换继承,也是一种解耦的有效手段。
迪米特法则 迪米特法则讲的是,不该有直接依赖关系的类之间,不要有依赖;有依赖关系的类之间,尽量只依赖必要的接口。
理论五:让你最快速地改善代码质量的20条编程规范 1. 关于命名
命名的关键是能准确达意。对于不同作用域的命名,我们可以适当地选择不同的长度。作用域小的变量(比如临时变量),可以适当地选择短一些的命名方式。除此之外,命名中也可以使用一些耳熟能详的缩写。
我们可以借助类的信息来简化属性、函数的命名,利用函数的信息来简化函数参数的命名。
命名要可读、可搜索。不要使用生僻的、不好读的英文单词来命名。除此之外,命名要符合项目的统一规范,不要用些反直觉的命名。
接口有两种命名方式:一种是在接口中带前缀“I”;另一种是在接口的实现类中带后缀“Impl”。对于抽象类的命名,也有两种方式,一种是带上前缀“Abstract”,一种是不带前缀。这两种命名方式都可以,关键是要在项目中统一。
2. 关于注释
关于注释注释的目的就是让代码更容易看懂。只要符合这个要求的内容,你就可以将它写到注释里。总结一下,注释的内容主要包含这样三个方面:做什么、为什么、怎么做。对于一些复杂的类和接口,我们可能还需要写明“如何用”。
注释本身有一定的维护成本,所以并非越多越好。类和函数一定要写注释,而且要写得尽可能全面、详细,而函数内部的注释要相对少一些,一般都是靠好的命名、提炼函数、解释性变量、总结性注释来提高代码可读性。
3.关于代码风格 函数、类多大才合适? 函数的代码行数不要超过一屏幕的大小,比如 50 行。类的大小限制比较难确定。
一行代码多长最合适? 最好不要超过 IDE 显示的宽度。当然,限制也不能太小,太小会导致很多稍微长点的语句被折成两行,也会影响到代码的整洁,不利于阅读。
善用空行分割单元块 对于比较长的函数,为了让逻辑更加清晰,可以使用空行来分割各个代码块。在类内部,成员变量与函数之间、静态成员变量与普通成员变量之间、函数之间,甚至成员变量之间,都可以通过添加空行的方式,让不同模块的代码之间的界限更加明确。
四格缩进还是两格缩进? 我个人比较推荐使用两格缩进,这样可以节省空间,特别是在代码嵌套层次比较深的情况下。除此之外,值得强调的是,不管是用两格缩进还是四格缩进,一定不要用 tab 键缩进。
大括号是否要另起一行? 我个人还是比较推荐将大括号放到跟上一条语句同一行的风格,这样可以节省代码行数。但是,将大括号另起一行,也有它的优势,那就是,左右括号可以垂直对齐,哪些代码属于哪一个代码块,更加一目了然。6. 类中成员的排列顺序在 Google Java 编程规范中,依赖类按照字母序从小到大排列。类中先写成员变量后写函数。成员变量之间或函数之间,先写静态成员变量或函数,后写普通变量或函数,并且按照作用域大小依次排列。
类中成员的排列顺序 在 Google Java 编程规范中,依赖类按照字母序从小到大排列。类中先写成员变量后写函数。成员变量之间或函数之间,先写静态成员变量或函数,后写普通变量或函数,并且按照作用域大小依次排列。
4.关于变成技巧
将复杂的逻辑提炼拆分成函数和类。
通过拆分成多个函数或将参数封装为对象的方式,来处理参数过多的情况。
函数中不要使用参数来做代码执行逻辑的控制。
函数设计要职责单一。移
除过深的嵌套层次,方法包括:去掉多余的 if 或 else 语句,使用 continue、break、return 关键字提前退出嵌套,调整执行顺序来减少嵌套,将部分嵌套逻辑抽象成函数。
用字面常量取代魔法数。
用解释性变量来解释复杂表达式,以此提高代码可读性。
代码示例 1.用解释性变量来解释复杂表达式,以此提高代码可读性
1 2 3 4 5 6 7 8 9 10 11 12 13 if (date.after(SUMMER_START) && date.before(SUMMER_END)) { // ... } else { // ... } // 引入解释性变量后逻辑更加清晰 boolean isSummer = date.after(SUMMER_START)&&date.before(SUMMER_END); if (isSummer) { // ... } else { // ... }
2.常量替代魔法数字
1 2 3 4 5 6 7 8 9 public double CalculateCircularArea(double radius) { return (3.1415) * radius * radius; } // 常量替代魔法数字 public static final Double PI = 3.1415; public double CalculateCircularArea(double radius) { return PI * radius * radius; }
3.调整执行顺序来减少嵌套
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 // 重构前的代码 public List<String> matchStrings(List<String> strList,String substr) { List<String> matchedStrings = new ArrayList<>(); if (strList != null && substr != null) { for (String str : strList) { if (str != null) { if (str.contains(substr)) { matchedStrings.add(str); } } } } return matchedStrings; } // 重构后的代码:先执行判空逻辑,再执行正常逻辑 public List<String> matchStrings(List<String> strList,String substr) { if (strList == null || substr == null) { //先判空 return Collections.emptyList(); } List<String> matchedStrings = new ArrayList<>(); for (String str : strList) { if (str != null) { if (str.contains(substr)) { matchedStrings.add(str); } } } return matchedStrings; }
5.统一编码规范 除了这三节讲到的比较细节的知识点之外,最后,还有一条非常重要的,那就是,项目、团队,甚至公司,一定要制定统一的编码规范,并且通过 Code Review 督促执行,这对提高代码质量有立竿见影的效果。
代码分析工具推荐 代码中的很多低级质量问题不需要人工去审查,java开发有很多现成的工具可以使用,比如:checkstyle,findbugs, pmd, jacaco, sonar等。
Checkstyle,findbugs,pmd是静态代码分析工具,通过分析源代码或者字节码,找出代码的缺陷,比如参数不匹配,有歧义的嵌套语句,错误的递归,非法计算,可能出现的空指针引用等等。三者都可以集成到gradle等构建工具中。
Jacoco是一种单元测试覆盖率统计工具,也可以集成到gradle等构建工具中,可以生成漂亮的测试覆盖率统计报表,同时Eclipse提供了插件可以EclEmma可以直观的在IDE中查看单元测试的覆盖情况。
Sonar Sonar 是一个用于代码质量管理的平台。可以在一个统一的平台上显示管理静态分析,单元测试覆盖率等质量报告。
实战一(上):通过一段ID生成器代码,学习如何发现代码质量问题 如何发现代码质量问题-常规checkList
目录设置是否合理、模块划分是否清晰、代码结构是否满足“高内聚、松耦合”?
是否遵循经典的设计原则和设计思想(SOLID、DRY、KISS、YAGNI、LOD 等)?
设计模式是否应用得当?是否有过度设计?
代码是否容易扩展?如果要添加新功能,是否容易实现?
代码是否可以复用?是否可以复用已有的项目代码或类库?是否有重复造轮子?
代码是否容易测试?单元测试是否全面覆盖了各种正常和异常的情况?
代码是否易读?是否符合编码规范(比如命名和注释是否恰当、代码风格是否一致等)?
如何发现代码质量问题-业务需求checkList
代码是否实现了预期的业务需求?
逻辑是否正确?是否处理了各种异常情况?日
志打印是否得当?是否方便 debug 排查问题?
接口是否易用?是否支持幂等、事务等?
代码是否存在并发问题?是否线程安全?
性能是否有优化空间,比如,SQL、算法是否可以优化?
是否有安全漏洞?比如输入输出校验是否全面?
一段有很多问题的ID生成器代码 为了方便在请求出错时排查问题,我们在编写代码的时候会在关键路径上打印日志。某个请求出错之后,我们希望能搜索出这个请求对应的所有日志,以此来查找问题的原因。而实际情况是,在日志文件中,不同请求的日志会交织在一起。如果没有东西来标识哪些日志属于同一个请求,我们就无法关联同一个请求的所有日志。
借鉴微服务调用链追踪的实现思路,我们可以给每个请求分配一个唯一 ID,并且保存在请求的上下文(Context)中,比如,处理请求的工作线程的局部变量中。在 Java 语言中,我们可以将 ID 存储在 Servlet 线程的 ThreadLocal 中,或者利用 Slf4j 日志框架的 MDC(Mapped Diagnostic Contexts)来实现(实际上底层原理也是基于线程的 ThreadLocal)。每次打印日志的时候,我们从请求上下文中取出请求 ID,跟日志一块输出。这样,同一个请求的所有日志都包含同样的请求 ID 信息,我们就可以通过请求 ID 来搜索同一个请求的所有日志了。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 public class IdGenerator { private static final Logger logger = LoggerFactory.getLogger(IdGenerator.class); public static String generate() { String id = ""; try { String hostName = InetAddress.getLocalHost().getHostName(); String[] tokens = hostName.split("\\."); if (tokens.length > 0) { hostName = tokens[tokens.length - 1]; } char[] randomChars = new char[8]; int count = 0; Random random = new Random(); while (count < 8) { int randomAscii = random.nextInt(122); if (randomAscii >= 48 && randomAscii <= 57) { randomChars[count] = (char)('0' + (randomAscii - 48)); count++; } else if (randomAscii >= 65 && randomAscii <= 90) { randomChars[count] = (char)('A' + (randomAscii - 65)); count++; } else if (randomAscii >= 97 && randomAscii <= 122) { randomChars[count] = (char)('a' + (randomAscii - 97)); count++; } } id = String.format("%s-%d-%s", hostName, System.currentTimeMillis(), new String(randomChars)); } catch (UnknownHostException e) { logger.warn("Failed to get the host name.", e); } return id; } }
实战一(下):手把手带你将ID生成器代码从“能用”重构为“好用” 重构代码的过程也应该遵循这样的思路。每次改动一点点,改好之后,再进行下一轮的优化,保证每次对代码的改动不会过大,能在很短的时间内完成。
第一轮重构:提高代码的可读性
第二轮重构:提高代码的可测试性
第三轮重构:编写完善的单元测试
第四轮重构:所有重构完成之后添加注释
第一轮重构:提高代码的可读性 首先,我们要解决最明显、最急需改进的代码可读性问题。具体有下面几点:
hostName 变量不应该被重复使用,尤其当这两次使用时的含义还不同的时候;
将获取 hostName 的代码抽离出来,定义为 getLastfieldOfHostName() 函数;
删除代码中的魔法数,比如,57、90、97、122;
将随机数生成的代码抽离出来,定义为 generateRandomAlphameric() 函数;
generate() 函数中的三个 if 逻辑重复了,且实现过于复杂,我们要对其进行简化;对 IdGenerator 类重命名,并且抽象出对应的接口。
第一轮重构后的代码如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 public interface IdGenerator { String generate(); } public interface LogTraceIdGenerator extends IdGenerator { } public class RandomIdGenerator implements LogTraceIdGenerator { private static final Logger logger = LoggerFactory.getLogger(RandomIdGenerator.class); @Override public String generate() { String substrOfHostName = getLastfieldOfHostName(); long currentTimeMillis = System.currentTimeMillis(); String randomString = generateRandomAlphameric(8); String id = String.format("%s-%d-%s", substrOfHostName, currentTimeMillis, randomString); return id; } private String getLastfieldOfHostName() { String substrOfHostName = null; try { String hostName = InetAddress.getLocalHost().getHostName(); String[] tokens = hostName.split("\\."); substrOfHostName = tokens[tokens.length - 1]; return substrOfHostName; } catch (UnknownHostException e) { logger.warn("Failed to get the host name.", e); } return substrOfHostName; } private String generateRandomAlphameric(int length) { char[] randomChars = new char[length]; int count = 0; Random random = new Random(); while (count < length) { int maxAscii = 'z'; int randomAscii = random.nextInt(maxAscii); boolean isDigit= randomAscii >= '0' && randomAscii <= '9'; boolean isUppercase= randomAscii >= 'A' && randomAscii <= 'Z'; boolean isLowercase= randomAscii >= 'a' && randomAscii <= 'z'; if (isDigit|| isUppercase || isLowercase) { randomChars[count] = (char) (randomAscii); ++count; } } return new String(randomChars); } } //代码使用举例 LogTraceIdGenerator logTraceIdGenerator = new RandomIdGenerator();
第二轮重构:提高代码的可测试性 关于代码可测试性的问题,主要包含下面两个方面:
generate() 函数定义为静态函数,会影响使用该函数的代码的可测试性;
generate() 函数的代码实现依赖运行环境(本机名)、时间函数、随机函数,所以 generate() 函数本身的可测试性也不好。
对于第一点,我们已经在第一轮重构中解决了。我们将 RandomIdGenerator 类中的 generate() 静态函数重新定义成了普通函数。调用者可以通过依赖注入的方式,在外部创建好 RandomIdGenerator 对象后注入到自己的代码中,从而解决静态函数调用影响代码可测试性的问题。
对于第二点,我们需要在第一轮重构的基础之上再进行重构。
从 getLastfieldOfHostName() 函数中,将逻辑比较复杂的那部分代码剥离出来,定义为 getLastSubstrSplittedByDot() 函数。因为 getLastfieldOfHostName() 函数依赖本地主机名,所以,剥离出主要代码之后这个函数变得非常简单,可以不用测试。我们重点测试 getLastSubstrSplittedByDot() 函数即可。
将 generateRandomAlphameric() 和 getLastSubstrSplittedByDot() 这两个函数的访问权限设置为 protected。这样做的目的是,可以直接在单元测试中通过对象来调用两个函数进行测试。
给 generateRandomAlphameric() 和 getLastSubstrSplittedByDot() 两个函数添加 Google Guava 的 annotation @VisibleForTesting。这个 annotation 没有任何实际的作用,只起到标识的作用,告诉其他人说,这两个函数本该是 private 访问权限的,之所以提升访问权限到 protected,只是为了测试,只能用于单元测试中。
第二轮重构后代码如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 public class RandomIdGenerator implements LogTraceIdGenerator { private static final Logger logger = LoggerFactory.getLogger(RandomIdGenerator.class); @Override public String generate() { String substrOfHostName = getLastfieldOfHostName(); long currentTimeMillis = System.currentTimeMillis(); String randomString = generateRandomAlphameric(8); String id = String.format("%s-%d-%s", substrOfHostName, currentTimeMillis, randomString); return id; } private String getLastfieldOfHostName() { String substrOfHostName = null; try { String hostName = InetAddress.getLocalHost().getHostName(); substrOfHostName = getLastSubstrSplittedByDot(hostName); } catch (UnknownHostException e) { logger.warn("Failed to get the host name.", e); } return substrOfHostName; } @VisibleForTesting protected String getLastSubstrSplittedByDot(String hostName) { String[] tokens = hostName.split("\\."); String substrOfHostName = tokens[tokens.length - 1]; return substrOfHostName; } @VisibleForTesting protected String generateRandomAlphameric(int length) { char[] randomChars = new char[length]; int count = 0; Random random = new Random(); while (count < length) { int maxAscii = 'z'; int randomAscii = random.nextInt(maxAscii); boolean isDigit= randomAscii >= '0' && randomAscii <= '9'; boolean isUppercase= randomAscii >= 'A' && randomAscii <= 'Z'; boolean isLowercase= randomAscii >= 'a' && randomAscii <= 'z'; if (isDigit|| isUppercase || isLowercase) { randomChars[count] = (char) (randomAscii); ++count; } } return new String(randomChars); } }
第三轮重构:编写完善的单元测试 经过上面的重构之后,代码存在的比较明显的问题,基本上都已经解决了。我们现在为代码补全单元测试。RandomIdGenerator 类中有 4 个函数。
1 2 3 4 5 6 public String generate(); private String getLastfieldOfHostName(); @VisibleForTesting protected String getLastSubstrSplittedByDot(String hostName); @VisibleForTesting protected String generateRandomAlphameric(int length);
在上一步重构中,为了提高代码的可测试性,我们已经将这两个部分代码跟不可控的组件(本机名、随机函数、时间函数)进行了隔离。所以,我们只需要设计完备的单元测试用例即可。具体的代码实现如下所示
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 public class RandomIdGeneratorTest { @Test public void testGetLastSubstrSplittedByDot() { RandomIdGenerator idGenerator = new RandomIdGenerator(); String actualSubstr = idGenerator.getLastSubstrSplittedByDot("field1.field2.field3"); Assert.assertEquals("field3", actualSubstr); actualSubstr = idGenerator.getLastSubstrSplittedByDot("field1"); Assert.assertEquals("field1", actualSubstr); actualSubstr = idGenerator.getLastSubstrSplittedByDot("field1#field2$field3"); Assert.assertEquals("field1#field2#field3", actualSubstr); } // 此单元测试会失败,因为我们在代码中没有处理hostName为null或空字符串的情况 // 这部分优化留在第36、37节课中讲解 @Test public void testGetLastSubstrSplittedByDot_nullOrEmpty() { RandomIdGenerator idGenerator = new RandomIdGenerator(); String actualSubstr = idGenerator.getLastSubstrSplittedByDot(null); Assert.assertNull(actualSubstr); actualSubstr = idGenerator.getLastSubstrSplittedByDot(""); Assert.assertEquals("", actualSubstr); } @Test public void testGenerateRandomAlphameric() { RandomIdGenerator idGenerator = new RandomIdGenerator(); String actualRandomString = idGenerator.generateRandomAlphameric(6); Assert.assertNotNull(actualRandomString); Assert.assertEquals(6, actualRandomString.length()); for (char c : actualRandomString.toCharArray()) { Assert.assertTrue(('0' < c && c < '9') || ('a' < c && c < 'z') || ('A' < c && c < 'Z')); } } // 此单元测试会失败,因为我们在代码中没有处理length<=0的情况 // 这部分优化留在第36、37节课中讲解 @Test public void testGenerateRandomAlphameric_lengthEqualsOrLessThanZero() { RandomIdGenerator idGenerator = new RandomIdGenerator(); String actualRandomString = idGenerator.generateRandomAlphameric(0); Assert.assertEquals("", actualRandomString); actualRandomString = idGenerator.generateRandomAlphameric(-1); Assert.assertNull(actualRandomString); } }
添加注释 注释不能太多,也不能太少,主要添加在类和函数上
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 /** * Id Generator that is used to generate random IDs. * * <p> * The IDs generated by this class are not absolutely unique, * but the probability of duplication is very low. */ public class RandomIdGenerator implements LogTraceIdGenerator { private static final Logger logger = LoggerFactory.getLogger(RandomIdGenerator.class); /** * Generate the random ID. The IDs may be duplicated only in extreme situation. * * @return an random ID */ @Override public String generate() { //... } /** * Get the local hostname and * extract the last field of the name string splitted by delimiter '.'. * * @return the last field of hostname. Returns null if hostname is not obtained. */ private String getLastfieldOfHostName() { //... } /** * Get the last field of {@hostName} splitted by delemiter '.'. * * @param hostName should not be null * @return the last field of {@hostName}. Returns empty string if {@hostName} is empty string. */ @VisibleForTesting protected String getLastSubstrSplittedByDot(String hostName) { //... } /** * Generate random string which * only contains digits, uppercase letters and lowercase letters. * * @param length should not be less than 0 * @return the random string. Returns empty string if {@length} is 0 */ @VisibleForTesting protected String generateRandomAlphameric(int length) { //... } }
小结
即便是非常简单的需求,不同水平的人写出来的代码,差别可能会很大。我们要对代码质量有所追求,不能只是凑活能用就好。花点心思写一段高质量的代码,比写 100 段凑活能用的代码,对你的代码能力提高更有帮助。
知其然知其所以然,了解优秀代码设计的演变过程,比学习优秀设计本身更有价值。知道为什么这么做,比单纯地知道怎么做更重要,这样可以避免你过度使用设计模式、思想和原则。
设计思想、原则、模式本身并没有太多“高大上”的东西,都是一些简单的道理,而且知识点也并不多,关键还是锻炼具体代码具体分析的能力,把知识点恰当地用在项目中。
高手之间的竞争都是在细节。大的架构设计、分层、分模块思路实际上都差不多。没有项目是靠一些不为人知的设计来取胜的,即便有,很快也能被学习过去。所以,关键还是看代码细节处理得够不够好。这些细节的差别累积起来,会让代码质量有质的差别。所以,要想提高代码质量,还是要在细节处下功夫。
实战二(上):程序出错该返回啥?NULL、异常、错误码、空对象? 1. 返回错误码 C 语言没有异常这样的语法机制,返回错误码便是最常用的出错处理方式。而 Java、Python 等比较新的编程语言中,大部分情况下,我们都用异常来处理函数出错的情况,极少会用到错误码。
2. 返回 NULL 值 在多数编程语言中,我们用 NULL 来表示“不存在”这种语义。对于查找函数来说,数据不存在并非一种异常情况,是一种正常行为,所以返回表示不存在语义的 NULL 值比返回异常更加合理。
3. 返回空对象 返回 NULL 值有各种弊端,对此有一个比较经典的应对策略,那就是应用空对象设计模式。当函数返回的数据是字符串类型或者集合类型的时候,我们可以用空字符串或空集合替代 NULL 值,来表示不存在的情况。这样,我们在使用函数的时候,就可以不用做 NULL 值判断。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 // 使用空集合替代NULL public class UserService { private UserRepo userRepo; // 依赖注入 public List<User> getUsers(String telephonePrefix) { // 没有查找到数据 return Collections.emptyList(); } } // getUsers使用示例 List<User> users = userService.getUsers("189"); for (User user : users) { //这里不需要做NULL值判断 // ... } // 使用空字符串替代NULL public String retrieveUppercaseLetters(String text) { // 如果text中没有大写字母,返回空字符串,而非NULL值 return ""; } // retrieveUppercaseLetters()使用举例 String uppercaseLetters = retrieveUppercaseLetters("wangzheng"); int length = uppercaseLetters.length();// 不需要做NULL值判断 System.out.println("Contains " + length + " upper case letters.");
4. 抛出异常对象 尽管前面讲了很多函数出错的返回数据类型,但是,最常用的函数出错处理方式是抛出异常。异常有两种类型:受检异常和非受检异常。对于应该用受检异常还是非受检异常,网上的争论有很多,但也并没有一个非常强有力的理由,说明一个就一定比另一个更好。所以,我们只需要根据团队的开发习惯,在同一个项目中,制定统一的异常处理规范即可。
5.针对函数抛出异常的三种处理方式 对于函数抛出的异常,我们有三种处理方法:直接吞掉、直接往上抛出、包裹成新的异常抛出。
直接吞掉 1 2 3 4 5 6 7 8 9 10 11 12 13 public void func1() throws Exception1 { // ... } public void func2() { //... try { func1(); } catch(Exception1 e) { log.warn("...", e); //吐掉:try-catch打印日志 } //... }
直接往上抛出 (原封不动地 re-throw) 1 2 3 4 5 6 7 8 9 10 public void func1() throws Exception1 { // ... } public void func2() throws Exception1 {//原封不动的re-throw Exception1 //... func1(); //... }
包裹成新的异常抛出 re-throw 1 2 3 4 5 6 7 8 9 10 11 12 13 14 public void func1() throws Exception1 { // ... } public void func2() throws Exception2 { //... try { func1(); } catch(Exception1 e) { throw new Exception2("...", e); // wrap成新的Exception2然后re-throw } //... }
实战二(下):重构ID生成器项目中各函数的异常处理代码 异常处理代码重构 重构之前的代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 public class RandomIdGenerator implements IdGenerator { private static final Logger logger = LoggerFactory.getLogger(RandomIdGenerator.class); @Override public String generate() { String substrOfHostName = getLastFiledOfHostName(); long currentTimeMillis = System.currentTimeMillis(); String randomString = generateRandomAlphameric(8); String id = String.format("%s-%d-%s", substrOfHostName, currentTimeMillis, randomString); return id; } private String getLastFiledOfHostName() { String substrOfHostName = null; try { String hostName = InetAddress.getLocalHost().getHostName(); substrOfHostName = getLastSubstrSplittedByDot(hostName); } catch (UnknownHostException e) { logger.warn("Failed to get the host name.", e); } return substrOfHostName; } @VisibleForTesting protected String getLastSubstrSplittedByDot(String hostName) { String[] tokens = hostName.split("\\."); String substrOfHostName = tokens[tokens.length - 1]; return substrOfHostName; } @VisibleForTesting protected String generateRandomAlphameric(int length) { char[] randomChars = new char[length]; int count = 0; Random random = new Random(); while (count < length) { int maxAscii = 'z'; int randomAscii = random.nextInt(maxAscii); boolean isDigit= randomAscii >= '0' && randomAscii <= '9'; boolean isUppercase= randomAscii >= 'A' && randomAscii <= 'Z'; boolean isLowercase= randomAscii >= 'a' && randomAscii <= 'z'; if (isDigit|| isUppercase || isLowercase) { randomChars[count] = (char) (randomAscii); ++count; } } return new String(randomChars); } }
重构后的代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 public class RandomIdGenerator implements IdGenerator { private static final Logger logger = LoggerFactory.getLogger(RandomIdGenerator.class); @Override public String generate() throws IdGenerationFailureException { String substrOfHostName = null; try { substrOfHostName = getLastFieldOfHostName(); } catch (UnknownHostException e) { throw new IdGenerationFailureException("...", e); } long currentTimeMillis = System.currentTimeMillis(); String randomString = generateRandomAlphameric(8); String id = String.format("%s-%d-%s", substrOfHostName, currentTimeMillis, randomString); return id; } private String getLastFieldOfHostName() throws UnknownHostException{ String substrOfHostName = null; String hostName = InetAddress.getLocalHost().getHostName(); if (hostName == null || hostName.isEmpty()) { throw new UnknownHostException("..."); } substrOfHostName = getLastSubstrSplittedByDot(hostName); return substrOfHostName; } @VisibleForTesting protected String getLastSubstrSplittedByDot(String hostName) { if (hostName == null || hostName.isEmpty()) { throw new IllegalArgumentException("..."); } String[] tokens = hostName.split("\\."); String substrOfHostName = tokens[tokens.length - 1]; return substrOfHostName; } @VisibleForTesting protected String generateRandomAlphameric(int length) { if (length <= 0) { throw new IllegalArgumentException("..."); } char[] randomChars = new char[length]; int count = 0; Random random = new Random(); while (count < length) { int maxAscii = 'z'; int randomAscii = random.nextInt(maxAscii); boolean isDigit= randomAscii >= '0' && randomAscii <= '9'; boolean isUppercase= randomAscii >= 'A' && randomAscii <= 'Z'; boolean isLowercase= randomAscii >= 'a' && randomAscii <= 'z'; if (isDigit|| isUppercase || isLowercase) { randomChars[count] = (char) (randomAscii); ++count; } } return new String(randomChars); } }
1.在 generate() 函数中,我们需要捕获 UnknownHostException 异常,并重新包裹成新的异常 IdGenerationFailureException 往上抛出。之所以这么做,有下面三个原因。
调用者在使用 generate() 函数的时候,只需要知道它生成的是随机唯一 ID,并不关心 ID 是如何生成的。也就说是,这是依赖抽象而非实现编程。
如果 generate() 函数直接抛出 UnknownHostException 异常,实际上是暴露了实现细节。从代码封装的角度来讲,我们不希望将 UnknownHostException 这个比较底层的异常,暴露给更上层的代码,也就是调用 generate() 函数的代码。而且,调用者拿到这个异常的时候,并不能理解这个异常到底代表了什么,也不知道该如何处理。
UnknownHostException 异常跟 generate() 函数,在业务概念上没有相关性。
2.如果函数是 public 的,你无法掌控会被谁调用以及如何调用(有可能某个同事一时疏忽,传递进了 NULL 值,这种情况也是存在的),为了尽可能提高代码的健壮性,我们最好是在 public 函数中做 NULL 值或空字符串的判断。
小结 1.程序的 bug 往往都出现在一些边界条件和异常情况下,所以说,异常处理得好坏直接影响了代码的健壮性。
2.再简单的代码,看上去再完美的代码,只要我们下功夫去推敲,总有可以优化的空间,就看你愿不愿把事情做到极致。
3.内功不够深厚,理论知识不够扎实,那你就很难参透开源项目的代码到底优秀在哪里。
4.能用的代码和优质代码之间最大的区别就在于细节,这就是60分和100分的差别。