写点什么

《代码重构》之方法到底多长算“长”

作者:Java高工P7
  • 2021 年 11 月 11 日
  • 本文字数:3561 字

    阅读完需:约 12 分钟

<property name="tokens" value="METHOD_DEF"/>


<property name="max" value="20"/>


<property name="countEmpty" value="false"/>


</module>


这样,在我们提交代码之前,执行本地的构建脚本,就可以把长函数检测出来。


即便以 20 行上限,这也已经超过很多人的认知,具体的函数行数可以结合团队的实际情况来制定。


非常不建议把这个数字放得很大,就像我前面说的那样,如果你放到 100 行,这个数字基本上是没有太多意义的,对团队也起不到什么约束作用。


  • 如果函数里面的行写得很长呢?还应不应该插入换行?如果插入换行的话就会增加行数,如果不差入换行,在看代码时就要经常移动水平滚动条


按代码行而非物理行计数。


长函数的产生


=====================================================================


限制函数长度,是一种简单粗暴的解决方案。最重要的是你要知道,长函数本身是一个结果,如果不理解长函数产生的原因,还是很难写出整洁的代码。


以性能为由




像 C 语言这种在今天已经是高性能的程序设计语言,在问世之初,也曾被人质疑性能不彰,尤其是函数调用。


在一些写汇编语言的人看来,调用函数涉及到入栈出栈的过程,显然不如直接执行来得性能高。这种想法经过各种演变流传到今天,任何一门新语言出现,还是会以同样的理由被质疑。


所以,在很多人看来,把函数写长是为了所谓性能。不过,这个观点在今天是站不住的。性能优化不该是写代码的第一考量:


  • 有活力的程序设计语言本身是不断优化的,无论是编译器,还是运行时,性能都会越来越好

  • 可维护性比性能优化要优先考虑,当性能不足以满足需要时,我们再来做相应的测量,找到焦点,进行特定的优化。这比在写代码时就考虑所谓性能要更能锁定焦点,优化才有意义。


平铺直叙




写代码平铺直叙,把自己想到的一点点罗列出来。比如下面这段代码(如果你不想仔细阅读,可以直接跳到后面):


public void executeTask() {


ObjectMapper mapper = new ObjectMapper();


CloseableHttpClient client = HttpClients.createDefault();


List<Chapter> chapters = this.chapterService.getUntranslatedChapters();


for (Chapter chapter : chapters) {


// Send Chapter


SendChapterRequest sendChapterRequest = new SendChapterRequest();


sendChapterRequest.setTitle(chapter.getTitle());


sendChapterRequest.setContent(chapter.getContent());


HttpPost sendChapterPost = new HttpPost(sendChapterUrl);


CloseableHttpResponse sendChapterHttpResponse = null;


String chapterId = null;


try {


String sendChapterRequestText = mapper.writeValueAsString(sendChapterRequest);


sendChapterPost.setEntity(new StringEntity(sendChapterRequestText));


sendChapterHttpResponse = client.execute(sendChapterPost);


HttpEntity sendChapterEntity = sendChapterPost.getEntity();


SendChapterResponse sendChapterResponse = mapper.readValue(sendChapterEntity.getContent(), SendChapterResponse.class);


chapterId = sendChapterResponse.getChapterId();


} catch (IOException e) {


throw new RuntimeException(e);


} finally {


try {


if (sendChapterHttpResponse != null) {


sendChapterHttpResponse.close();


}


} catch (IOException e) {


// ignore


}


}


// Translate Chapter


HttpPost translateChapterPost = new HttpPost(translateChapterUrl);


CloseableHttpResponse translateChapterHttpResponse = null;


try {


TranslateChapterRequest translateChapterRequest = new TranslateChapterRequest();


translateChapterRequest.setChapterId(chapterId);


String translateChapterRequestText = mapper.writeValueAsString(translateChapterRequest);


translateChapterPost.setEntity(new StringEntity(translateChapterRequestText));


translateChapterHttpResponse = client.execute(translateChapterPost);


HttpEntity translateChapterEntity = translateChapterHttpResponse.getEntity();


TranslateChapterResponse translateChapterResponse = mapper.readValue(translateChapterEntity.getContent(), TranslateChapterResponse.class);


if (!translateChapterResponse.isSuccess()) {


logger.warn("Fail to start translate: {}", chapterId);


}


} catch (IOException e) {


throw new RuntimeException(e);


} finally {


if (translateChapterHttpResponse != null) {


try {


translateChapterHttpResponse.close();


} catch (IOException e) {


// ignore


}


}


}


}


把没有翻译过的章节发到翻译引擎,然后,启动翻译过程。


翻译引擎是另外一个服务,需通过 HTTP 的形式向它发送请求。相对而言,这段代码还算直白,当你知道了我上面所说的逻辑,你是很容易看懂这段代码。


这段代码之所以很长,主要原因就是把前面所说的逻辑全部平铺直叙地摆在那里了,这里既有业务处理的逻辑,比如,把章节发送给翻译引擎,然后,启动翻译过程;又有处理的细节,比如,把对象转成 JSON,然后,通过 HTTP 客户端发送出去。


从这段代码中,可看到平铺直叙的代码存在的两个典型问题:


  • 把多个业务处理流程放在一个函数里实现

  • 把不同层面的细节放到一个函数里实现


这里发送章节和启动翻译是两个过程,显然,这是可以放到两个不同的函数中去实现的,所以,我们只要做一下提取函数,就可以把这个看似庞大的函数拆开,而拆出来的几个函数规模都会小很多,像下面这样:


public void executeTask() {


ObjectMapper mapper = new ObjectMapper();


CloseableHttpClient client = HttpClients.createDefault();


List<Chapter> chapters = this.chapterService.getUntranslatedChapters();


for (Chapter chapter : chapters) {


String chapterId = sendChapter(mapper, client, chapter);


translateChapter(mapper, client, chapterId);


}


}


拆出来的部分,实际上就是把对象打包发送的过程,我们以发送章节为例,先来看拆出来的发送章节部分:


private String sendChapter(final ObjectMapper mapper,


final CloseableHttpClient client,


final Chapter chapter) {


SendChapterRequest request = asSendChapterRequest(chapter);


CloseableHttpResponse response = null;


【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开:qq.cn.hn/FTf 免费领取
复制代码


String chapterId = null;


try {


HttpPost post = sendChapterRequest(mapper, request);


response = client.execute(post);


chapterId = asChapterId(mapper, post);


} catch (IOException e) {


throw new RuntimeException(e);


} finally {


try {


if (response != null) {


response.close();


}


} catch (IOException e) {


// ignore


}


}


return chapterId;


}


private HttpPost sendChapterRequest(final ObjectMapper mapper, final SendChapterRequest sendChapterRequest) throws JsonProcessingException, UnsupportedEncodingException {


HttpPost post = new HttpPost(sendChapterUrl);


String requestText = mapper.writeValueAsString(sendChapterRequest);


post.setEntity(new StringEntity(requestText));


return post;


}


private String asChapterId(final ObjectMapper mapper, final HttpPost sendChapterPost) throws IOException {


String chapterId;


HttpEntity entity = sendChapterPost.getEntity();


SendChapterResponse response = mapper.readValue(entity.getContent(), SendChapterResponse.class);


chapterId = response.getChapterId();


return chapterId;


}


private SendChapterRequest asSendChapterRequest(final Chapter chapter) {


SendChapterRequest request = new SendChapterRequest();


request.setTitle(chapter.getTitle());


request.setContent(chapter.getContent());


return request


这个代码还算不上已经处理得很整洁了,但至少同之前相比,已经简洁了一些。我们只用了最简单的提取函数这个重构手法,就把一个大函数拆分成了若干的小函数。


长函数往往还隐含着一个命名问题。如果你看修改后的 sendChapter,其中的变量命名明显比之前要短,理解的成本也相应地会降低。因为变量都是在这个短小的上下文里,也就不会产生那么多的命名冲突,变量名当然就可以写短一些。


平铺直叙的代码,一个关键点就是没有把不同的东西分解出来。如果我们用设计的眼光衡量这段代码,这就是“分离关注点”没有做好,把不同层面的东西混在了一起,既有不同业务混在一起,也有不同层次的处理混在了一起。我在《软件设计之美》专栏中,也曾说过,关注点越多越好,粒度越小越好。


一次加一点


====================================================================


有时,一段代码一开始的时候并不长,就像下面这段代码,它根据返回的错误进行相应地错误处理:

用户头像

Java高工P7

关注

还未添加个人签名 2021.11.08 加入

还未添加个人简介

评论

发布
暂无评论
《代码重构》之方法到底多长算“长”