封装与抽象

封装和抽象作为两个非常通用的设计思想,可以应用在很多设计场景中,比如系统、模块、lib、组件、接口、类等等的设计。封装和抽象可以有效地隐藏实现的复杂性,隔离实现的易变性,给依赖的模块提供稳定且易用的抽象接口。

中间层

引入中间层能简化模块或类之间的依赖关系。下面这张图是引入中间层前后的依赖关系对比图。在引入数据存储中间层之前,A、B、C 三个模块都要依赖内存一级缓存、Redis 二级缓存、DB 持久化存储三个模块。在引入中间层之后,三个模块只需要依赖数据存储一个模块即可。从图上可以看出,中间层的引入明显地简化了依赖关系,让代码结构更加清晰。
image.png
除此之外,我们在进行重构的时候,引入中间层可以起到过渡的作用,能够让开发和重构同步进行,不互相干扰。比如,某个接口设计得有问题,我们需要修改它的定义,同时,所有调用这个接口的代码都要做相应的改动。如果新开发的代码也用到这个接口,那开发就跟重构冲突了。为了让重构能小步快跑,我们可以分下面四个阶段来完成接口的修改。

  • 第一阶段:引入一个中间层,包裹老的接口,提供新的接口定义。
  • 第二阶段:新开发的代码依赖中间层提供的新接口。
  • 第三阶段:将依赖老接口的代码改为调用新接口。
  • 第四阶段:确保所有的代码都调用新接口之后,删除掉老的接口。

    3. 模块化—分层,多层

    模块化是构建复杂系统常用的手段。不仅在软件行业,在建筑、机械制造等行业,这个手段也非常有用。对于一个大型复杂系统来说,没有人能掌控所有的细节。之所以我们能搭建出如此复杂的系统,并且能维护得了,最主要的原因就是将系统划分成各个独立的模块,让不同的人负责不同的模块,这样即便在不了解全部细节的情况下,管理者也能协调各个模块,让整个系统有效运转。
    聚焦到软件开发上面,很多大型软件(比如 Windows)之所以能做到几百、上千人有条不紊地协作开发,也归功于模块化做得好。不同的模块之间通过 API 来进行通信,每个模块之间耦合很小,每个小的团队聚焦于一个独立的高内聚模块来开发,最终像搭积木一样将各个模块组装起来,构建成一个超级复杂的系统。
    我们再聚焦到代码层面。合理地划分模块能有效地解耦代码,提高代码的可读性和可维护性。所以,我们在开发代码的时候,一定要有模块化意识,将每个模块都当作一个独立的 lib 一样来开发,只提供封装了内部实现细节的接口给其他模块使用,这样可以减少不同模块之间的耦合度。

    4. 其他设计思想和原则

    “高内聚、松耦合”是一个非常重要的设计思想,能够有效提高代码的可读性和可维护性,缩小功能改动导致的代码改动范围。实际上,在前面的章节中,我们已经多次提到过这个设计思想。很多设计原则都以实现代码的“高内聚、松耦合”为目的。我们来一块总结回顾一下都有哪些原则。

基于接口而非实现编程

基于接口而非实现编程能通过接口这样一个中间层,隔离变化和具体的实现。这样做的好处是,在有依赖关系的两个模块或类之间,一个模块或者类的改动,不会影响到另一个模块或类。实际上,这就相当于将一种强依赖关系(强耦合)解耦为了弱依赖关系(弱耦合)。

依赖注入

跟基于接口而非实现编程思想类似,依赖注入也是将代码之间的强耦合变为弱耦合。尽管依赖注入无法将本应该有依赖关系的两个类,解耦为没有依赖关系,但可以让耦合关系没那么紧密,容易做到插拔替换。

多用组合少用继承

我们知道,继承是一种强依赖关系,父类与子类高度耦合,且这种耦合关系非常脆弱,牵一发而动全身,父类的每一次改动都会影响所有的子类。相反,组合关系是一种弱依赖关系,这种关系更加灵活,所以,对于继承结构比较复杂的代码,利用组合来替换继承,也是一种解耦的有效手段。

迪米特法则

迪米特法则讲的是,不该有直接依赖关系的类之间,不要有依赖;有依赖关系的类之间,尽量只依赖必要的接口。从定义上,我们明显可以看出,这条原则的目的就是为了实现代码的松耦合。至于如何应用这条原则来解耦代码,你可以回过头去阅读一下第 22 讲,这里我就不赘述了。

good rule

2. 避免函数参数过多

我个人觉得,函数包含 3、4 个参数的时候还是能接受的,大于等于 5 个的时候,我们就觉得参数有点过多了,会影响到代码的可读性,使用起来也不方便。针对参数过多的情况,一般有 2 种处理方法。

  • 考虑函数是否职责单一,是否能通过拆分成多个函数的方式来减少参数。示例代码如下所示 ```java

public User getUser(String username, String telephone, String email);

// 拆分成多个函数 public User getUserByUsername(String username); public User getUserByTelephone(String telephone); public User getUserByEmail(String email);

  1. - 函数的参数封装成对象。示例代码如下所示:
  2. ```java
  3. public void postBlog(String title, String summary, String keywords, String content, String category, long authorId);
  4. // 将参数封装成对象
  5. public class Blog {
  6. private String title;
  7. private String summary;
  8. private String keywords;
  9. private Strint content;
  10. private String category;
  11. private long authorId;
  12. }
  13. public void postBlog(Blog blog);

除此之外,如果函数是对外暴露的远程接口,将参数封装成对象,还可以提高接口的兼容性。在往接口中添加新的参数的时候,老的远程接口调用者有可能就不需要修改代码来兼容新的接口了

3. 勿用函数参数来控制逻辑

不要在函数中使用布尔类型的标识参数来控制内部逻辑,true 的时候走这块逻辑,false 的时候走另一块逻辑。这明显违背了单一职责原则和接口隔离原则。我建议将其拆成两个函数,可读性上也要更好。我举个例子来说明一下。

  1. public void buyCourse(long userId, long courseId, boolean isVip);
  2. // 将其拆分成两个函数
  3. public void buyCourse(long userId, long courseId);
  4. public void buyCourseForVip(long userId, long courseId);

不过,如果函数是 private 私有函数,影响范围有限,或者拆分之后的两个函数经常同时被调用,我们可以酌情考虑保留标识参数。示例代码如下所示:

  1. // 拆分成两个函数的调用方式
  2. boolean isVip = false;
  3. //...省略其他逻辑...
  4. if (isVip) {
  5. buyCourseForVip(userId, courseId);
  6. } else {
  7. buyCourse(userId, courseId);
  8. }
  9. // 保留标识参数的调用方式更加简洁
  10. boolean isVip = false;
  11. //...省略其他逻辑...
  12. buyCourse(userId, courseId, isVip);

不过,如果函数是 private 私有函数,影响范围有限,或者拆分之后的两个函数经常同时被调用,我们可以酌情考虑保留标识参数。示例代码如下所示:

  1. // 拆分成两个函数的调用方式
  2. boolean isVip = false;
  3. //...省略其他逻辑...
  4. if (isVip) {
  5. buyCourseForVip(userId, courseId);
  6. } else {
  7. buyCourse(userId, courseId);
  8. }
  9. // 保留标识参数的调用方式更加简洁
  10. boolean isVip = false;
  11. //...省略其他逻辑...
  12. buyCourse(userId, courseId, isVip);

除了布尔类型作为标识参数来控制逻辑的情况外,还有一种“根据参数是否为 null”来控制逻辑的情况。针对这种情况,我们也应该将其拆分成多个函数。拆分之后的函数职责更明确,不容易用错。具体代码示例如下所示:

  1. public List<Transaction> selectTransactions(Long userId, Date startDate, Date endDate) {
  2. if (startDate != null && endDate != null) {
  3. // 查询两个时间区间的transactions
  4. }
  5. if (startDate != null && endDate == null) {
  6. // 查询startDate之后的所有transactions
  7. }
  8. if (startDate == null && endDate != null) {
  9. // 查询endDate之前的所有transactions
  10. }
  11. if (startDate == null && endDate == null) {
  12. // 查询所有的transactions
  13. }
  14. }
  15. // 拆分成多个public函数,更加清晰、易用
  16. public List<Transaction> selectTransactionsBetween(Long userId, Date startDate, Date endDate) {
  17. return selectTransactions(userId, startDate, endDate);
  18. }
  19. public List<Transaction> selectTransactionsStartWith(Long userId, Date startDate) {
  20. return selectTransactions(userId, startDate, null);
  21. }
  22. public List<Transaction> selectTransactionsEndWith(Long userId, Date endDate) {
  23. return selectTransactions(userId, null, endDate);
  24. }
  25. public List<Transaction> selectAllTransactions(Long userId) {
  26. return selectTransactions(userId, null, null);
  27. }
  28. private List<Transaction> selectTransactions(Long userId, Date startDate, Date endDate) {
  29. // ...
  30. }

回顾下

  1. 关于命名
  • 命名的关键是能准确达意。对于不同作用域的命名,我们可以适当地选择不同的长度。
  • 我们可以借助类的信息来简化属性、函数的命名,利用函数的信息来简化函数参数的命名。
  • 命名要可读、可搜索。不要使用生僻的、不好读的英文单词来命名。命名要符合项目的统一规范,也不要用些反直觉的命名。
  • 接口有两种命名方式:一种是在接口中带前缀“I”;另一种是在接口的实现类中带后缀“Impl”。对于抽象类的命名,也有两种方式,一种是带上前缀“Abstract”,一种是不带前缀。这两种命名方式都可以,关键是要在项目中统一。

2 关于注释

  • 注释的内容主要包含这样三个方面:做什么、为什么、怎么做。对于一些复杂的类和接口,我们可能还需要写明“如何用”。
  • 类和函数一定要写注释,而且要写得尽可能全面详细。函数内部的注释要相对少一些,一般都是靠好的命名、提炼函数、解释性变量、总结性注释来提高代码可读性。

3 关于代码风格

  • 函数、类多大才合适?函数的代码行数不要超过一屏幕的大小,比如 50 行。类的大小限制比较难确定。
  • 一行代码多长最合适?最好不要超过 IDE 的显示宽度。当然,也不能太小,否则会导致很多稍微长点的语句被折成两行,也会影响到代码的整洁,不利于阅读。
  • 善用空行分割单元块。对于比较长的函数,为了让逻辑更加清晰,可以使用空行来分割各个代码块。四格缩进还是两格缩进?我个人比较推荐使用两格缩进,这样可以节省空间,尤其是在代码嵌套层次比较深的情况下。不管是用两格缩进还是四格缩进,一定不要用 tab 键缩进。
  • 大括号是否要另起一行?将大括号放到跟上一条语句同一行,可以节省代码行数。但是将大括号另起新的一行的方式,左右括号可以垂直对齐,哪些代码属于哪一个代码块,更加一目了然。
  • 类中成员怎么排列?在 Google Java 编程规范中,依赖类按照字母序从小到大排列。类中先写成员变量后写函数。成员变量之间或函数之间,先写静态成员变量或函数,后写普通变量或函数,并且按照作用域大小依次排列。

4 关于编码技巧

  • 将复杂的逻辑提炼拆分成函数和类。
  • 通过拆分成多个函数或将参数封装为对象的方式,来处理参数过多的情况。
  • 函数中不要使用参数来做代码执行逻辑的控制。
  • 函数设计要职责单一。
  • 移除过深的嵌套层次,方法包括:去掉多余的 if 或 else 语句,使用 continue、break、return 关键字提前退出嵌套,调整执行顺序来减少嵌套,将部分嵌套逻辑抽象成函数。
  • 用字面常量取代魔法数。
  • 用解释性变量来解释复杂表达式,以此提高代码可读性。
  1. 统一编码规范
    最后,还有一条非常重要的,那就是,项目、团队,甚至公司,一定要制定统一的编码规范,并且通过 Code Review 督促执行,这对提高代码质量有立竿见影的效果。

实际上,技术驱动的公司很少,即便像 Google 这样公认的技术驱动的公司,里面 90% 的项目都是业务、产品驱动的。真正高精尖的技术也只集中在某一小撮项目中。你可能会说,Google 的很多产品的用户、访问量都很高,这些高性能、高并发的要求不是很考验程序员的技术吗?实际上,这些有挑战的技术问题,都是比较有共性的,大部分都通过底层系统解决了,比如 MapReduce、BigTable、GFS 等。业务研发工程师只需要恰当地使用这些高精尖的系统来实现业务就可以了。