代码整洁之道Clean|代码整洁之道Clean Code笔记代码整洁之道CleanCode笔记

@
目录

第 1 章 Clean Code 整洁代码（3星）
- ？为什么要整洁的代码
- ？什么叫做整洁代码
第 2 章 Meaningful Names 有意义的命名（3星）
第 3 章 Functions 函数（3星）
第 4 章 Comments 注释（2星）
第 5 章 Formatting 格式（1星）
第 6 章 Objects and Data Structures 对象和数据结构（4星）
第 7 章 Error Handling 错误处理（4星）
第 9 章 Unit Tests 单元测试(3星)
第 10 章 Classes 类(5星)
第 11 章 Systems 系统(5星)
第 12 章 Emergence 迭进
第 13 章 Concurrency 并发编程（5星）
- ? 为什么要并发
- 并发防御原则
- 了解 Java 库
- 了解执行模型
- 警惕同步方法之间的依赖
- 测试线程代码
第 15 章 JUnit Internals JUnit 内幕（2星）
第 16 章重构 SerialDate（4星）
第 17 章味道与启发（3星）
附录 A 并发编程 II（4星）
总结

在线阅读：书栈网：https://www.bookstack.cn/read/Clean-Code-zh/spilt.8.docs-ch1.md
每个章节都会做一个自己的总结，并为这个章节打一个重要性的参考分数，满分五星（仅个人的角度）。
如果想尽快的了解一些代码的规范，最好看一下阿里代码规范，idea也可以安装阿里代码规范插件。
阿里开发手册是实践，这本书本身更多的是作者理念引导。理念的引导必然少不了佐证、和一些看似冗余的语句，但这都是我们站在如今开发环境上的结果论，因为所有技术性文章都是具有很强的时效性。
第 1 章 Clean Code 整洁代码（3星）第一章主要介绍这本书的背景和意图，以及总结下整洁代码的理念
有的章节几节可以直接越过，但是看完的话既知所以然，又知其然
？为什么要整洁的代码
反证：糟糕代码的坏处
团队中各司其职，代码是代码人应有的责任，要主动维护，去说服那些阻碍我们优化的。。。
？什么叫做整洁代码
每个人对于整洁的定义都不同，这里只是作者代表的一些理念，要学会自我思考

意图明确：只做一件事，提高表达力
扩展性：提早构建小规模、简单抽象
简洁：减少重复代码，包括尽量少的实体，比如类、方法、函数等
正确性：能通过所有测试
体现系统中的全部设计理念
读与写花费时间的比例超过 10:1，代码阅读重要性，要对自己的读者负责
整洁代码需要从点滴做起

【代码整洁之道Clean|代码整洁之道Clean Code笔记】成功的案例并不能让你成为成功者，只能分享给别人成功的过程，技巧
第 2 章 Meaningful Names 有意义的命名（3星）语义明确，语境明确，不冗余

语义明确：最好通过变量名讲解变量的意义，而不是注释。例如：魔法值，就是不能明确意义的常量
避免误导：例如：缩写不明确；专有名词同名；命名类型不准确；相似命名放一起区分，明确注释；相似数字字母不明确
有意义的区分，废话都是冗余。比如：Table 一词永远不应当出现在表名中
使用可以读的出来的名称
使用可以搜索的名字：单字母名称和数字常量仅用在短方法中的本地变量，最好不要用
避免思维映射：不要你觉得，别人也会这样觉得
类名和对象名应该是名词或名词短语，不应当是动词
方法名应当是动词或动词短语

重载构造器时，使用描述了参数的静态工厂方法名。例如，

Complex fulcrumPoint = Complex.FromRealNumber(23.0);

通常好于

Complex fulcrumPoint = new Complex(23.0);

可以考虑将相应的构造器设置为 private，强制使用这种命名手段。

别用双关语
使用程序员熟悉的术语，或者所涉问题领域命名
添加有意义的语境：对字段进行补充说明

第 3 章 Functions 函数（3星）本章所讲述的是有关编写良好函数的机制

函数的第一规则是要短小
函数应该只做好这一件事
每个函数一个抽象层级

让代码读起来像是一系列自顶向下的 TO 起头段落是保持抽象层级协调一致的有效技巧

switch

利用多态来实现，确保每个 switch 都埋藏在较低的抽象层级，而且永远不重复
例子：所有的员工都有一样的流程，是否发薪日、计算薪水、发薪水，但是不同类型的员工具体流程动作不一样

public Money calculatePay(Employee e) throws InvalidEmployeeType { switch (e.type) { case COMMISSIONED: return calculateCommissionedPay(e); case HOURLY: return calculateHourlyPay(e); case SALARIED: return calculateSalariedPay(e); default: throw new InvalidEmployeeType(e.type); } }

多态实现：更改之后再增加职员类型，每种职工只需要做自己的事情，不需要所有的类型当方法都更改，只需更改实现工厂实现类

public abstract class Employee { public abstract boolean isPayday(); public abstract Money calculatePay(); public abstract void deliverPay(Money pay); } ----------------- public interface EmployeeFactory { public Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType; } ----------------- public class EmployeeFactoryImpl implements EmployeeFactory { public Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType { switch (r.type) { case COMMISSIONED: return new CommissionedEmployee(r); case HOURLY: return new HourlyEmployee(r); case SALARIED: return new SalariedEmploye(r); default: throw new InvalidEmployeeType(r.type); } } }

使用描述性的名称

别害怕长名称、别害怕花时间取名字、命名方式要保持一致

函数参数：最理想的参数数量是零
无副作用函数：不要把相关性不强的逻辑放进来，强调复用性
分隔指令与询问：避免混乱
使用异常替代返回错误码

if (deletePage(page) == E_OK) {if (registry.deleteReference(page.name) == E_OK) {if (configKeys.deleteKey(page.name.makeKey()) == E_OK) {logger.log("page deleted"); } else {logger.log("configKey not deleted"); }} else {logger.log("deleteReference from registry failed"); }} else {logger.log("delete failed"); return E_ERROR; }

On the other hand, if you use exceptions instead of returned error codes, then the error processing code can be separated from the happy path code and can be simplified:

另一方面，如果使用异常替代返回错误码，错误处理代码就能从主路径代码中分离出来，得到简化：

复制代码try {deletePage(page); registry.deleteReference(page.name); configKeys.deleteKey(page.name.makeKey()); } catch (Exception e) {logger.log(e.getMessage()); }

重复可能是软件中一切邪恶的根源
好的代码需要慢慢打磨，精简，优化(这正是我喜欢的过程，乐此不疲)

第 4 章 Comments 注释（2星）作者毕竟站在英语母语的基础上，还是要考虑下我们自己的环境

注释不能美化糟糕的代码，注释不能成为糟糕代码的发言人，代码才是核心
别误导，别废话，适时整理TODO、注释的代码块

第 5 章 Formatting 格式（1星）几乎不用看

垂直、横向格式：代码缩进

第 6 章 Objects and Data Structures 对象和数据结构（4星）对象曝露行为，隐藏数据。便于添加新对象类型而无需修改既有行为，同时也难以在既有对象中添加新行为。
数据结构曝露数据，没有明显的行为。便于向既有数据结构添加新行为，同时也难以向既有函数添加新数据结构。

数据抽象：数据封装，隐藏具体行为
数据、对象的反对称性

过程式代码（使用数据结构的代码）便于在不改动既有数据结构的前提下添加新函数。面向对象代码便于在不改动既有函数的前提下添加新类。

得墨忒耳律

方法不应调用由任何函数返回的对象的方法

下列代码违反了得墨忒耳律（除了违反其他规则之外），因为它调用了 getOptions( )返回值的 getScratchDir( )函数，又调用了 getScratchDir( )返回值的 getAbsolutePath( )方法。

final String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath();

第 7 章 Error Handling 错误处理（4星）在本章中，要列出编写既整洁又强固的代码——优雅地处理错误代码的一些技巧和思路
整洁代码是可读的，但也要强固。可读与强固并不冲突。如果将错误处理隔离看待，独立于主要逻辑之外，就能写出强固而整洁的代码

使用异常而非返回码，用统一异常处理处理异常
在编写可能抛出异常的代码时，先写 Try-Catch-Finally 语句
使用不可控异常，可控异常的代价就是违反开放/闭合原则
给出异常发生的环境说明
依调用者需要定义异常类

我们在应用程序中定义异常类时，最重要的考虑应该是它们如何被捕获，然后根据捕获规律去优化异常捕获

别返回 null 值
别传递 null 值

第 9 章 Unit Tests 单元测试(3星)

保持测试整洁，测试代码和生产代码一样重要
整洁的测试，最重要的要素是可读性
每个测试一个断言
测试应该有以下规则：快速、独立、可重复、自足验证、及时

第 10 章 Classes 类(5星) 代码组织的更高层面——Classes

将系统的构造与使用分开
类的组织

遵循标准的 Java 约定，类应该从一组变量列表开始。如果有公共静态常量，应该先出现。然后是私有静态变量，以及私有实体变量。很少会有公共变量。公共函数应跟在变量列表之后。封装

类应该短小

对于函数，我们通过计算代码行数衡量大小。对于类，我们采用不同的衡量方法，计算权责（responsibility）。类的名称应当描述其权责，从命名开始规范。
单一权责原则（SRP）认为，类或模块应有且只有一条加以修改的理由。系统应该由许多短小的类而不是少量巨大的类组成。每个小类封装一个权责，只有一个修改的原因，并与少数其他类一起协同达成期望的系统行为。
内聚：类应该只有少量实体变量。类中的每个方法都应该操作一个或多个这种变量。通常而言，方法操作的变量越多，就越黏聚到类上。
扩展性：需求会改变，所以代码也会改变。具体类包含实现细节（代码），而抽象类则只呈现概念。依赖于具体细节的客户类，当细节改变时，就会有风险。我们可以借助接口和抽象类来隔离这些细节带来的影响。依赖倒置原则（Dependency Inversion Principle，DIP），DIP 认为类应当依赖于抽象而不是依赖于具体细节。
单一权责和内聚都是程度值，保证的他们平衡，逻辑内聚，权责解耦，这并不简单，SRP也充分考虑到了代码扩展性。
第 11 章 Systems 系统(5星) 本章将讨论如何在较高的抽象层级——系统层级——上保持整洁
无论是设计系统或单独的模块，别忘了使用大概可工作的最简单方案。

将系统的构造与使用分开(编译和运行，java的环境中Spring通过依赖注入（Dependency Injection，DI），控制反转（Inversion of Control，IoC）已经帮我们把这件事做了)。延后初始化的好处：这种手段在 DI 中也有其作用。首先，多数 DI 容器在需要对象之前并不构造对象。其次，许多这类容器提供调用工厂或构造代理的机制，而这种机制可为延迟赋值或类似的优化处理所用。
**AOP： **在 AOP 中，被称为方面（aspect）的模块构造指明了系统中哪些点的行为会以某种一致的方式被修改，从而支持某种特定的场景。这种说明是用某种简洁的声明或编程机制来实现的。
代理：使用代理，代码量和复杂度是代理的两大弱点，创建整洁代码变得很难！另外，代理也没有提供在系统范围内指定执行点的机制，而那正是真正的 AOP 解决方案所必须的
纯净的 Java AOP 框架：Bean工厂内，每个 bean 就像是嵌套“俄罗斯套娃”中的一个，每个由数据存取器对象（DAO）代理（包装）的 Bank 都有个域对象，而 bean 本身又是由 JDBC 驱动程序数据源代理。通过XML/注解的方式减少对代码的入侵，只留下纯POJO。
AspectJ ASPECTS AspectJ 的方面：AspectJ 却提供了一套用以切分关注面的丰富而强有力的工具。
测试驱动系统架构：大设计（Big Design Up Front，BDUF）——系统架构。最佳的系统架构由模块化的关注面领域组成，每个关注面均用纯 Java（或其他语言）对象实现。不同的领域之间用最不具有侵害性的方面或类方面工具整合起来。这种架构能测试驱动，就像代码一样。
优化决策：模块化和关注面切分成就了分散化管理和决策。拥有模块化关注面的 POJO 系统提供的敏捷能力，允许我们基于最新的知识做出优化的、时机刚好的决策。决策的复杂性也降低了。
选择合适的架构——标准
系统需要领域特定语言：领域特定语言（Domain-Specific Language，DSL）。DSL 是一种单独的小型脚本语言或以标准语言写就的 API，领域专家可以用它编写读起来像是组织严谨的散文一般的代码。领域特定语言允许所有抽象层级和应用程序中的所有领域，从高级策略到底层细节，使用 POJO 来表达。

第 12 章 Emergence 迭进本章中写到的实践来自于本书作者数十年经验的精练总结。遵循简单设计的实践手段，开发者不必经年学习就能掌握好的原则和模式。
提升内聚性，降低耦合度，切分关注面，模块化系统性关注面，缩小函数和类的尺寸，选用更好的名称，如此等等。这也是应用简单设计后三条规则的地方：消除重复，保证表达力，尽可能减少类和方法的数量。
通过迭进设计达到整洁目的，Kent Beck 关于简单设计的四条规则，据 Kent 所述，只要遵循以下规则，设计就能变得“简单”，以下规则按其重要程度降序排列：

运行所有测试；
不可重复；
表达了程序员的意图；
尽可能减少类和方法的数量；

第 13 章 Concurrency 并发编程（5星） “对象是过程的抽象。线程是调度的抽象。” ——James O
这个章节主要讲述了并发编程的来源、优势和劣势，以及如何避免、解决并发错误的方法和方向
? 为什么要并发

并发是一种解耦策略。
解耦目的与时机能明显地改进应用程序的吞吐量和结构。
并发会在性能和编写额外代码上增加一些开销；
正确的并发是复杂的，即便对于简单的问题也是如此；
并发缺陷并非总能重现，所以常被看做偶发事件而忽略，未被当做真的缺陷看待；
并发常常需要对设计策略的根本性修改。

并发防御原则

单一权责原则

单一权责原则（SRP）认为，方法/类/组件应当只有一个修改的理由。并发设计自身足够复杂到成为修改的理由，所以也该从其他代码中分离出来。不幸的是，并发实现细节常常直接嵌入到其他生产代码中。
需要考虑的问题：

并发相关代码有自己的开发、修改和调优生命周期；
开发相关代码有自己要对付的挑战，和非并发相关代码不同，而且往往更为困难；
即便没有周边应用程序增加的负担，写得不好的并发代码可能的出错方式数量也已经足具挑战性。

建议：分离并发相关代码与其他代码。

限制数据作用域

两个线程修改共享对象的同一字段时，可能互相干扰，导致未预期的行为。解决方案之一是采用 synchronized 关键字在代码中保护一块使用共享对象的临界区（critical section）。限制临界区的数量很重要。更新共享数据的地方越多，就越可能：
谨记数据封装；严格限制对可能被共享的数据的访问。
避免共享数据的好方法之一就是一开始就避免共享数据。
线程应尽可能地独立，让每个线程在自己的世界中存在，不与其他线程共享数据。
了解 Java 库
学习类库，了解基本算法。理解类库提供的与基础算法类似的解决问题的特性。
了解执行模型
学习这些基础算法，理解其解决方案。

Producer-Consumer 生产者-消费者模型
Readers-Writers 读者-作者模型
Dining Philosophers 哲学家用餐模式

警惕同步方法之间的依赖

避免使用一个共享对象的多个方法
有时必须使用一个共享对象的多个方法，有 3 种应对手段：

基于客户端的锁定——客户端代码在调用第一个方法前锁定服务端，确保锁的范围覆盖了调用最后一个方法的代码；

基于服务端的锁定——在服务端内创建锁定服务端的方法，调用所有方法，然后解锁。让客户端代码调用新方法；

适配服务端——创建执行锁定的中间层。这是一种基于服务端的锁定的例子，但不修改原始服务端代码。

尽可能减小同步区域
尽早考虑关闭问题，尽早令其工作正常。
测试线程代码
编写有潜力曝露问题的测试，在不同的编程配置、系统配置和负载条件下频繁运行。如果测试失败，跟踪错误。别因为后来测试通过了后来的运行就忽略失败。
有一大堆问题要考虑。下面是一些精练的建议：

将伪失败看作可能的线程问题，不要将系统错误归咎于偶发事件
先使非线程代码可工作，不要同时追踪非线程缺陷和线程缺陷。确保代码在线程之外可工作。
编写可插拔的线程代码，这样就能在不同的配置环境下运行。
编写可调整的线程代码，要获得良好的线程平衡，常常需要试错。一开始，在不同的配置环境下监测系统性能。要允许线程数量可调整。在系统运行时允许线程发生变动。允许线程依据吞吐量和系统使用率自我调整。
运行多于处理器数量的线程，系统在切换任务时会发生一些事。为了促使任务交换的发生，运行多于处理器或处理器核心数量的线程。任务交换越频繁，越有可能找到错过临界区或导致死锁的代码。
在不同平台上运行
装置试错代码，并强迫错误发生：有两种装置代码的方法：硬编码、自动化

第 15 章 JUnit Internals JUnit 内幕（2星）本章介绍了JUnit的一些简单的模块
第 16 章重构 SerialDate（4星）本章详解对 org.jfree.date库中的SerialDate日期类进行重构，简化的过程。增加了测试覆盖率，修复了一些错误，澄清并缩小了代码。
第 17 章味道与启发（3星）本章又列举了作者之前列出过的，一些不好的习惯，并把这些比作难闻的气味
干净的代码不是通过遵循一组规则来编写的。
附录 A 并发编程 II（4星）并发编程的一些扩充信息，多了很多的示例讲解
在本章中，我们谈到并发更新，还有清理及避免同步的规程。我们谈到线程如何提升与 I/O 有关的系统的吞吐量，展示了获得这种提升的整洁技术。我们谈到死锁及干净地避免死锁的规程。最后，我们谈到通过装置代码暴露并发问题的策略。

死锁

死锁的发生需要 4 个条件：
互斥：无法在同一时间为多个线程所用；数量上有限制
这种资源的常见例子是数据库连接、打开后用于写入的文件、记录锁或是信号量。
上锁及等待：当某个线程获取一个资源，在获取到其他全部所需资源并完成其工作之前，不会释放这个资源。
无抢先机制：线程无法从其他线程处夺取资源。一个线程持有资源时，其他线程获得这个资源的唯一手段就是等待该线程释放资源。
循环等待：这也被称为“死命拥抱”。想象两个线程，T1 和 T2，还有两个资源，R1 和 R2。T1 拥有 R1，T2 拥有 R2。T1 需要 R2，T2 需要 R1。
这 4 种条件都是死锁所必需的。只要其中一个不满足，死锁就不会发生。
避免死锁的一种策略是规避互斥条件。你可以：