标签：style blog http color io os ar 使用 for
事情总是这样的：当我们对一个遗留系统一忍再忍，再忍，忍，还要忍……终于积攒到某一天，实在忍无可忍了，拍案而起，不能再忍了，重构！！！事情就这样发生了。然而，在这时你突然发现，重构的工作千头万绪，真不知从何开始。堆积如山的问题此起彼伏，期望修改的设计思绪万千。这里有个想法，那里有个思路，什么都想做，却什么都做不了，真是脑子里一团乱麻。这时候，没有一个合理的步骤，清晰的计划，瞎干蛮干是十分危险的，它会为你的重构带来不可预期的未来。无数次的经验告诉我，不论是什么系统，采用什么架构，从分解大函数开始，肯定没有错。
大函数，就是那些业务逻辑特别复杂、程序代码特别多、一提起就叫人头疼不已的超级方法。超级大函数，很难让人读懂，更难于维护与变更，毫无疑问是软件退化的重灾区。它起初可能并不复杂，也逻辑清晰、易于读懂，但随着业务逻辑的一次次变更，不停地往里面添加代码，再加上一些不合理的设计，经过天长日久，变得越来越臃肿，超级大函数就这样产生了。超级大函数的产生是有它内在的客观原因的。怎么这么说呢？前面我们谈过，软件发展的客观规律就是业务逻辑越来越复杂。随着业务逻辑越来越复杂，正确的办法就是适时地重构和优化我们的代码。但非常遗憾地是，几乎很少有人认识到这一点。这样的结果就是，随着业务逻辑越来越复杂，人们总是就着原有的程序结构不停地往里面添加新的代码。原有的清晰而简单的程序，随着新代码的不断添加，开始变得越来越复杂而难懂了。正因为如此，在大多数软件企业的遗留系统中，超级大函数就变成了一种通病。让我们用HelloWorld为例来演变一番它的历程吧。
如前面第三章所述，最开初的HelloWorld程序是这样的：
1 /** 2 * The Refactoring‘s hello-world program 3 * @author fangang 4 */ 5 public class HelloWorld { 6 /** 7 * Say hello to everyone 8 * @param now 9 * @param user 10 * @return the words what to say 11 */ 12 public String sayHello(Date now, String user){ 13 //Get current hour of day 14 Calendar calendar = Calendar.getInstance(); 15 calendar.setTime(now); 16 int hour = calendar.get(Calendar.HOUR_OF_DAY); 17 18 //Get the right words to say hello 19 String words = null; 20 if(hour>=6 && hour<12){ 21 words = "Good morning!"; 22 }else if(hour>=12 && hour<19){ 23 words = "Good afternoon!"; 24 }else{ 25 words = "Good night!"; 26 } 27 words = "Hi, "+user+". "+words; 28 return words; 29 } 30 }
了了数十行代码，简单明了。随后就开始变更了，首先是关于时间的问候变得复杂了，添加了一些特殊的节日的问题，如新年问候“Happy new year! ”、情人节问候“Happy valentine’s day! ”、三八妇女节问候“Happy women’s day! ”，等等。同时，对一天中的问候也变得更加精细。对于这样的需求，IT攻城狮们敲着键盘就开始改写了：
1 /** 2 * The Refactoring‘s hello-world program 3 * @author fangang 4 */ 5 public class HelloWorld { 6 /** 7 * Say hello to everyone 8 * @param now 9 * @param user 10 * @return the words what to say 11 */ 12 public String sayHello(Date now, String user){ 13 //Get current month, date and hour. 14 Calendar calendar = Calendar.getInstance(); 15 calendar.setTime(now); 16 int hour = calendar.get(Calendar.HOUR_OF_DAY); 17 int month = calendar.get(Calendar.MONTH); 18 int day = calendar.get(Calendar.DAY_OF_MONTH); 19 20 //Get the right words to say hello 21 String words = null; 22 if(month==1 && day==1){ 23 words = "Happy new year!"; 24 }else if(month==1 && day==14){ 25 words = "Happy valentine‘s day!"; 26 }else if(month==3 && day==8){ 27 words = "Happy women‘s day!"; 28 }else if(month==5 && day==1){ 29 words = "Happy Labor day!"; 30 31 …… 32 33 }else if(hour>=6 && hour<12){ 34 words = "Good morning!"; 35 }else if(hour==12){ 36 words = "Good noon!"; 37 }else if(hour>=12 && hour<19){ 38 words = "Good afternoon!"; 39 }else{ 40 words = "Good night!"; 41 } 42 words = "Hi, "+user+". "+words; 43 return words; 44 } 45 }
代码量开始翻倍。接着，客户要求所有的用户信息应当来源于数据库的用户表，同时设计了问候语规则表，所有关于时间的问候都应来源于对该表的查询。这时我们继续膨胀sayHello()这个方法：
1 /** 2 * The Refactoring‘s hello-world program 3 * @author fangang 4 */ 5 public class HelloWorld { 6 /** 7 * Say hello to everyone 8 * @param now 9 * @param user 10 * @return the words what to say 11 */ 12 public String sayHello(Date now, long userId){ 13 //Get database connection. 14 try { 15 Class.forName("oracle.jdbc.driver.OracleDriver"); 16 } catch (ClassNotFoundException e1) { 17 throw new RuntimeException("No found JDBC driver"); 18 } 19 String url = "jdbc:oracle:thin:@localhost:1521:helloworld"; 20 String username = "test"; 21 String password = "testpwd"; 22 Connection connection; 23 try { 24 connection = DriverManager.getConnection(url,username,password); 25 } catch (SQLException e1) { 26 throw new RuntimeException("Connect database failed!"); 27 } 28 29 //Get current month, date and hour. 30 Calendar calendar = Calendar.getInstance(); 31 calendar.setTime(now); 32 int hour = calendar.get(Calendar.HOUR_OF_DAY); 33 int month = calendar.get(Calendar.MONTH); 34 int day = calendar.get(Calendar.DAY_OF_MONTH); 35 36 //Get the right words to say hello 37 String words = null; 38 String greetingRuleSql = 39 "select words, month, day, hourLower, hourUpper from greeting_rules"; 40 try { 41 PreparedStatement statement = 42 connection.prepareStatement(greetingRuleSql); 43 ResultSet resultSet = statement.executeQuery(); 44 while(!resultSet.isLast()){ 45 int monthOfRule = resultSet.getInt("month"); 46 int dayOfRule = resultSet.getInt("day"); 47 if(month==monthOfRule && day==dayOfRule){ 48 words = resultSet.getString("words"); 49 break; 50 } 51 int hourLower = resultSet.getInt("hourLower"); 52 int hourUpper = resultSet.getInt("hourUpper"); 53 if(hour>=hourLower && hour<hourUpper){ 54 words = resultSet.getString("words"); 55 break; 56 } 57 } 58 if(words==null) 59 throw new RuntimeException("Error when searching greeting rules."); 60 } catch (SQLException e1) { 61 throw new RuntimeException("Error when getting greeting rules."); 62 } 63 64 //Get user‘s name 65 String user = ""; 66 String userSql = "select name from rms_user where user_id=?"; 67 try { 68 PreparedStatement statement = connection.prepareStatement(userSql); 69 statement.setLong(1, userId); 70 ResultSet resultSet = statement.executeQuery(); 71 user = resultSet.getString(1); 72 } catch (SQLException e) { 73 throw new RuntimeException("Error when getting user‘s name."); 74 } 75 76 words = "Hi, "+user+". "+words; 77 return words; 78 } 79 }
这是一个十分简单的示例，但我们可以看到它已经由短短十来行膨胀成了60多行，膨胀了4倍之多。在最后这个版本中，sayHello()既要负责连接数据库、查询数据，又要获得当前时间的月份、日期与小时，还要完成相应的业务逻辑的判断，使程序变得相当复杂。我们可以继续想象，如果继续提出新的需求，比如支持多语言、支持多数据库，程序质量将继续下滑，直到我们无法忍受。
解决超级大函数问题最有效的办法就是分解，按照功能一步一步分解，还原其应有的优化结构。在这个过程中我们常用的重构方法叫“抽取方法（Extract Method）”。重构是一个探索的过程，因为我们总是起初对要重构的系统并不了解，没有设计文档（即使有，对不对还是一说呢），没有熟悉系统的人（哪怕只是在不明白的时候问一问）。你，只是接到任务才开始接手这个系统，你对这个系统的了解简直就是一猫黑。而这时，抽取方法是我们开始这种探索，了解这个系统最有效的工具，它往往是这样进行的：
当我们在阅读一段大函数时，我们可以自觉不自觉地为这些代码分段，为一段功能相对独立的代码编写注释。有时我们可能还需要调整代码的先后顺序，将一些有更多关联的代码放在一起，如将变量的声明与变量真正使用的代码放在一起，或者将有明显前后关系的代码放在一起。这样的调整是一个好的开端，因为它让我们的代码开始变得有序，开始变得可读。
随后，我们就可以使用“抽取方法”了。将被我们分段、加上注释的代码从原函数中抽取出来，放在另外一个独立的函数中，为这个函数取个易懂的名称——这是一个非常重要的好习惯。我常常为了给一个函数取一个正确的名字而思索很长时间，甚至修改好几次。不要认为这是在浪费时间，它也是优化代码重要的一个环节。但起初我们对这段代码的理解可能不那么深，因此我们往往选择用结果变量为其命名。随着我们对这段代码理解的深入，可以运用重构中的“重命名方法（Rename Method）”，根据其代码意图重新为其命名（许多开发工具，如eclipse，都支持该重构方法，它们使你在重命名的同时，同步修改了所有对该方法的调用）。经过这样对代码段的抽取，原代码在这里就变成了对这个新函数的调用。
举一个例子吧，这时一段真实的遗留系统，原有程序是这样写的：
1 ...... 2 int iCtbz = -1; 3 ElecObj elecObj = null; 4 //获取办理时间 5 int iCzyf = Integer.valueOf(Stream[9]).intValue(); 6 String czMonth = String.valueOf(iCzyf % 20).toString().trim(); 7 String czYear = String.valueOf( (iCzyf - (iCzyf % 20)) / 20 + 2000). 8 toString(); 9 if (czMonth.length() == 1){ 10 czMonth = "0" + czMonth; 11 } 12 long lBlsj = Long.valueOf(czYear + czMonth).longValue(); 13 String dqyear = sysDate.toString().substring(0, 4); 14 ......
这段代码写得并不好，有许多需要我们优化的地方。但记住“小步快跑”原则，此时不是解决其它问题的时候，现在我们首先是运用抽取方法优化程序结构。经过抽取以后，将以上加粗的部分改为了这样：
1 ...... 2 int iCtbz = -1; 3 ElecObj elecObj = null; 4 //获取办理时间 5 int iCzyf = Integer.valueOf(Stream[9]).intValue(); 6 long lBlsj = getBlsj(iCzyf); 7 String dqyear = sysDate.toString().substring(0, 4); 8 ......
加粗的部分就是被改写的内容，同时将抽取的内容放进了一个独立的函数：
1 /** 2 *@param iCzyf 3 *@return 获取办理时间 4 */ 5 private long getBlsj(int iCzyf) { 6 String czMonth = String.valueOf(iCzyf % 20).toString().trim(); 7 String czYear = String.valueOf( (iCzyf - (iCzyf % 20)) / 20 + 2000). 8 toString(); 9 if (czMonth.length() == 1){ 10 czMonth = "0" + czMonth; 11 } 12 return Long.valueOf(czYear + czMonth).longValue(); 13 }
在给这个新创建的函数命名时，我们对这段代码的理解并不深刻。在原函数中，这段代码执行的结果是获得了lBlsj这个结果变量，即获得了办理时间。为此，我们先为该函数命名为getBlsj这个函数名。但在后续的工作中，我们逐渐理解到，它不仅可以获取办理时间，还可以获取很多时间。它实质是将时间由一种表示方式转换成另一种表示方式，因此我们运用开发工具的重命名功能，将该函数命名为transformDate，其它调用它的代码也随之修改了。重命名后的函数就不再仅仅运用在此处获取办理时间，还应用在其它业务代码的处理中。
抽取方法可大可小，你可以将一段数百行的代码抽取走，也可能只抽取了数行。但不论怎样，被抽取走的代码一定是功能内聚的，也就是说它们执行的是一个说得清道得明、清楚明确的功能。同时，被抽取走的代码一定是执行的一个清晰的功能，而不是多个。它可大可小，大也许还能分解为多个功能，但至少在逻辑上，这些功能是这个大的功能的组成部分。
抽取方法是一个探索的过程，最关键是那个红线划在哪里，即抽取代码的范围。多一行也对，少一行也对，关键在于我们抽取出来的这个函数，它的功能我们是怎样定义的。公说公有理，婆说婆有理，没有一个定论，所以方法的抽取常常是反反复复。开始我们按照一个思路抽取出来，后来想想觉得不对，因此又放回原函数，重新划分，重新抽取，反复多次。
有一次，我在重构一个Servlet的时候，抽取出来的函数是在执行一大段业务逻辑操作。但在完成了一系列业务操作以后，原程序要将返回值转换成二进制代码写入response中，返回前端。起初，我将整个这一段都抽取出来。但令人很别扭的是，传参的时候必须要把response传进去，这使得业务逻辑与Web应用环境耦合，不利于日后的优化，编写自动化测试。随后我还原了这段代码，重新进行抽取，将写response的部分留在了原函数中，而将红线画在了完成业务逻辑操作之后，写入response之前。新重构的函数得以与web应用解耦，为后面的进一步优化做好了准备。重构的过程，是考验开发人员能力的过程，需要大家反复练习与钻研。
另外，抽取方法就像核裂变，开始由一个函数裂变为几个函数。分解出来的函数又裂变为另外几个函数，不断这样往复下去。同时，抽取方法总是在一个类中发生裂变。而当这个类分解出来的方法达到一定程度以后，随之而来的就是类的裂变，由一个类分解成多个类，分解出来的类再分解……类的分解我们采用的是另一个方法——“抽取类（Extract Class）”，我们将在后面讲述。
重构是一系列的等量变换，抽取方法是这些等量变换中最典型的例子。将一段代码从原函数中抽取出来，代码依然是那些代码，只是程序结构发生了变换。正因为如此，才能保证我们的重构过程的安全可靠。
大话重构连载首页：http://www.cnblogs.com/mooodo/p/talkAboutRefactoringHome.html
特别说明：希望网友们在转载本文时，应当注明作者或出处，以示对作者的尊重，谢谢！
标签：style blog http color io os ar 使用 for
原文地址：http://www.cnblogs.com/mooodo/p/theSuperMethod.html
