来源书籍

Java程序员修炼之道

Skill 版本:v24 工程实践 515 张卡片

Benjamin J. Evans;Martijn Verburg · 吴海星 译 · 人民邮电出版社 · 2016-06-15(OPF数字版日期) · ISBN 978-7-115-32195-4

全书导读

本书回答的是:熟悉Java语法之后,怎样理解支撑程序运行的机制,并把它们组织为可测试、可交付的系统?它采用Java7时代的JVM作为共同平台,把语言表达、资源管理、并发、运行时、性能和多语言实践放在同一张知识地图上。Java语言描述源码规则,JVM负责加载和执行类文件,库与框架又提供更高层的协作方式;这三者的职责不能混为一谈。

阅读可以先循前两部分理解基础机制,再用第三部分比较Groovy、Scala与Clojure的表达和状态模型,最后看第四部分怎样用测试、构建与Web原型连接这些能力。附录补足示例项目的历史环境与配置。笔记保留全部实质正文项,章节讲解可独立阅读,卡片则用于定位具体机制、比较与边界。

这也是一本版本依赖很强的书。Java7、旧框架API和最后一章对Java8的预测均按时代背景解释;已识别的教材错误在相应内容中注明,并在必要时用正式规范核对。代码与截图的输出属于教材,不代表本次已运行、部署或通过测试。轻量模式保留全文阅读和来源核验,未执行生成后的笔记复核、独立审查及审查结果优化。

全书主线

全书先减少“写得出源码”与“理解真实执行”之间的距离,再讨论如何选择更合适的表达和交付方式。第一部分的Coin语言改进与NIO.2说明,语法便利和资源/文件系统语义是不同层面的变化。资源自动关闭仍需正确登记,路径对象也不证明物理文件存在。

第二部分把注意力移到组织对象与运行行为。依赖注入让协作者从对象外部提供,便于组合与隔离测试;并发要求明确共享状态、原子边界和可见性;类文件与方法句柄解释平台怎样连接不同语言;性能分析再把这些机制放回测量、硬件、GC与JIT的现实条件。它们相互影响,但不是一条固定执行流水线。

第三部分比较三门语言如何在共同平台上表达工作:Groovy突出动态表达与DSL,Scala组合类型与函数式能力,Clojure突出不可变数据及受控状态转换。语言改变的是表达与约束方式,并不会自动消除互操作、并发和维护成本。第四部分再用TDD、测试替身、可重复构建、CI和Web框架建立反馈,使技术选择能在具体任务中被检验;最后一章提醒继续跟踪平台演进,同时分清提案与正式规范。

flowchart TD
 A[区分语言 平台 类库] --> B[理解资源和运行机制]
 B --> C[组织对象与共享状态]
 B --> D[测量性能与定位约束]
 C --> E[比较语言表达和互操作]
 D --> E
 E --> F[测试 构建 CI与Web反馈]
 F --> G[依据证据调整设计与学习路线]
 G -.持续反馈.-> C

图表达学习依赖与反馈关系,不表示每个程序都依次经过这些阶段。

序

推荐序用Java语言演进、并发、类加载、性能、多语言与交付实践串联本书的价值,尤其强调优化应基于测量。对作者的赞誉与加油站轶事只提供推荐背景,不构成技术结论。有关排序算法的短例未给推导,不据此给所有Arrays.sort重载作统一性能保证。

性能调优首先要用测量找出时间花在哪里,再决定改动对象。凭经验猜测热点,可能优化了对总耗时几乎没有影响的代码。推荐序用“测量,别猜”概括第6章,强调硬件与缓存开销也应进入分析。该原则要求先获得证据,而不是把某个编码技巧预先当作通用性能答案。 详见性能优化先测量。

原书依据 · 2 处

前言

前言从外汇IT团队的培训需求讲起,说明作者相遇及技术教学兴趣,进而提出开发的社会属性。全书意在提供继续探索的入口,涵盖语言更新、平台关键机制和多语言,不是穷尽接口的参考大全。

软件开发既包含技术工作,也依赖人与人之间的沟通和交互。技术选择与代码实现并不能独自完成整个协作过程。前言将本书定位为激发学习、帮助开发者继续探索的旅程,而非封闭的百科知识灌输。学习路线因此既应考虑技能,也应考虑参与讨论和获得反馈的条件。 详见软件开发的社会属性。

原书依据 · 1 处

致谢

总致谢说明书稿依赖朋友、同事和批评者共同贡献,以下条目分别感谢社区、出版社、审稿人及亲友。此处为制作背景,不另推导一套协作机制。

伦敦Java社区

伦敦Java社区提供相遇、审校与跨语言指导的环境。本项主要列出贡献者并表达感谢;社区规模是出版语境中的历史陈述,不作今日规模判断。

www.coderanch.com

本项感谢coderanch社区参与者的详细评论和反馈,记录的是书稿协助来源,未展开论坛机制或具体技术。

Manning出版社

出版社致谢列出从选题接受、制作到营销及技术审校的参与者,展示书稿制作背景;没有可独立展开的出版流程方法。

特别致谢

特别致谢按网站与代码示例、Web框架选择、NIO.2、硬件计时、Maven资料及性能反馈列明贡献来源。它提供引用与协助关系,具体技术留给相应正文。

Ben Evans的致谢

Ben Evans感谢出版指导、共同作者及家庭支持,是个人写作经历说明;未对技术概念或方法作进一步展开。

Martijn Verburg的致谢

Martijn Verburg回顾童年计算机与编程兴趣、亲人和合作者支持,并把把小事做对的经验带入日常编码;其余人物经历保留为写作背景。

复杂工作由许多小部分组成,认真把小事做对,是建立整体质量的一个基础。致谢中的个人经历将这一经验迁移到编码和日常工作;它鼓励对基本动作保持注意,并不证明局部全部正确就足以保证系统整体正确。把它作为工作习惯,可以提醒自己不要因任务细小就放弃核对。 详见小事正确与整体质量。

原书依据 · 1 处

关于本书

本项以幽默的语言史引入Java为何继续演进,归纳自动运行时管理、简洁语言核心、保守演进、类库扩展和生态复用的共同路线,再引出非Java语言同用JVM的多语言方向。Java8展望仅按出版时背景理解。

Java的设计路线把相对简单、谨慎演进的语言核心,与丰富类库和开放生态结合起来。运行时管理垃圾收集和即时编译,更多功能与复杂性由类库承载。这样既降低基础学习门槛,又允许开发者复用组件。理解这一路线有助于判断需求应通过库解决还是需要语言或平台变化,不能把“核心少变”误解为整个平台没有演进。 详见简洁核心与生态扩展。

原书依据 · 1 处

阅读须知

阅读须知先给四部分结构,再说明第1章语言基础与第7章语言比较对后续内容的支撑。三种备选语言可按兴趣读,但后续项目实践可能依赖前面的知识;本工作流仍逐项完整读取。

读者对象

读者对象包括希望更新Java7知识、补齐依赖注入并发测试等能力、以及开始学习JVM多语言与函数式编程的开发者。此处定义受众,没有展开这些技术机制。

路线图

路线图把14章放进四部分:语言和I/O,注入并发字节码性能,三种备选语言,测试构建与Web实践,最后讨论未来演进。各技术的深入解释由相应正文承接。

代码约定及下载

代码约定说明示例字体、注解、长行续行和编号用法,列出Manning与图灵社区的源码获取入口,并指向附录A。入口是出版时信息,尚未宣称当前已成功下载。

软件需求

软件需求记录示例采用Java7,列举当时支持的系统及IDE版本,并说明作者实际使用NetBeans7.1与Eclipse3.7.1。它是复现实例的历史环境记录,不是当前安装推荐。

作者在线

作者在线说明Manning论坛为读者间及作者交流提供场所,作者参与自愿,建议提出有挑战的问题。访问及在售条件按出版时说明保留,不保证今日服务状态。

关于作者

作者简介解释两位作者在Java社区、标准化、性能并发及技术团队方面的背景,为书的选题提供语境;职务均视为出版时信息。

关于封面图片

封面说明介绍19世纪地域服饰图集及其在出版社封面中的使用,将地域差异和现代技术多样性作文化联想。它不是Java技术说明,但包含独立的视觉文化解读。

地域服饰可以成为辨识生活场所、职业和社会处境的线索。封面说明借19世纪服饰图集讨论过去地域文化差异,解释出版社如何借多样图像象征技术创新。它属于特定图集和时代语境下的文化解读,不能推广成只看当代着装就能可靠判断身份的规则。 详见服饰作为身份线索。

原书依据 · 1 处

第一部分 用Java 7做开发

第一部分导读将Coin的小型语言改进与NIO.2类库变化并列,说明理解语法之外还要理解动机和语义。已展开的资源、路径、目录与异步主题由第1和第2章承接。

第1章 初识Java 7:语言、平台与演进

Java语言定义人可读源码的语法和语义;Java平台提供装载与执行类文件的运行环境。二者通过统一的.class格式连接:javac把源码转换为类文件,JVM再加载和执行。JLS与JVM规范分别约束两个层面,因此支持JVM并不意味着源语言必须是Java。判断某项特性属于哪一层,有助于区分源码表达能力与运行时支持要求。 详见语言与平台分工.

字节码是源码到机器码之间的中间表示,不是处理器直接执行的本机指令。javac生成.class文件,与运行时JIT将代码编译为机器码,是不同阶段。Java执行既可能解释字节码,也可能进行即时编译;问它是“编译型还是解释型”时,要先说明讨论的是源码转换还是运行时执行,不能用一次编译概括整个过程。 详见字节码与即时编译.

语法糖为已有能力提供更便捷的写法,编译早期可将它转换为基础表示。数字字面量中的下划线让人更容易辨读,却不要求运行时增加新的数值表示。与修改类文件格式或虚拟机能力相比,这类改动通常涉及较少层面;但“改动文本少”不代表兼容性影响小,仍需检查规范、编译器、类库、测试和文档之间的一致性。 详见语法糖与修改成本.

语言修改不能只改语法解析器。应同时核对语言规范、编译器原型、类库、测试与文档;如果触及平台,还要检查虚拟机规范、类文件工具、反射、序列化和本地接口。一个单词的规范变化也可能牵动多个层面。Coin采用公开提案、讨论和可运行原型,使参与者能检验兼容性与实现成本,而不只凭愿望接受特性。 详见语言修改影响面。

类型系统规定哪些值与操作可以安全组合。新增规则会与已有规则相遇,产生单独观察某项特性时不易察觉的边界情况。因此语法上的微小变化也可能要求复杂推理和兼容性检查。Coin建议提案避开类型系统,体现的是把修改限制在可控制范围的工程取舍,而不是类型系统本身没有价值。 详见类型系统交互风险。

Java 7允许在switch中以字符串常量写case分支,适合按固定字符串集合选择行为。它减少了连续if判断的样板代码,原有分支和break控制仍需保留。原书将星期名映射到另一种语言的例子,展示的是固定值分派,不意味着switch可替代任意复杂条件。 详见字符串多路分支。

二进制字面量直接表达位模式,例如0b1100110,避免为了写常量而在运行时解析字符串。数字中的下划线用于视觉分组,例如2_147_483_648L;编译时分隔符被移除,不改变数值。两者分别帮助表达位结构和检查长数字,不能把可读性的变化当成数据类型或精度变化。 详见数值字面量可读性。

multi-catch用竖线把多个异常类型列在同一catch中,让真正共享处理策略的异常复用一段代码。例子将缺失、解析失败和配置不一致归为一组,而I/O故障另行处理。合并依据应是处理方式一致;若恢复或诊断动作不同,仍应分开捕获,不能只为缩短代码抹平失败原因。 详见合并同策略异常。

捕获Exception后再抛出同一个、未被重新赋值的异常参数,Java 7编译器可根据try中实际可能抛出的类型推断重抛范围,而非迫使方法声明笼统的Exception。原书以IOException与SQLException说明这一点。final可表达参数不会被改写,但显式final不是此推断成立的唯一写法。 详见精确重抛异常。

TWR将已成功初始化的资源纳入代码块退出时的自动清理。若把FileInputStream直接嵌入ObjectInputStream构造表达式,而外层构造失败,内层流可能没有作为独立资源登记。应先声明底层流fin,再用fin构造包装流in;这样外层初始化失败时,已经初始化的底层资源仍有清理路径。 详见分开登记嵌套资源。

创建泛型实例时,<>让编译器结合上下文推断类型参数,减少声明与构造表达式之间重复的类型信息。例如左侧声明Map>,右侧可写new HashMap<>()。这是类型推断,不是取消泛型检查,也不是把带类型的集合退回原始类型集合。 详见钻石语法类型推断。

变参调用会把尾部参数装进数组,而泛型数组与类型检查之间存在限制,组合后可能产生未经检查的警告。判断实现是否安全应由能控制方法内部行为的API编写者承担;@SafeVarargs表达的是经过核实的安全承诺,不会自动修复危险操作。调用方看不到实现,不能靠忽略警告替代实现方的安全判断。 详见泛型变参安全责任。

本章的资源清理示例需结合勘误理解:TWR只对已登记且成功初始化为非null的资源安排关闭;正文执行失败时,关闭又产生的异常可以作为被抑制异常保留。原书getNullStream示例中,不能由null资源自动关闭推导出另一个被抑制的空指针异常。接口关系应为Closeable继承AutoCloseable。SafeVarargs是实现方作出的安全断言,可抑制相关未经检查的警告,不会自动消除不安全操作。以上更正依据2026-11-06核对的Java 7 Closeable、Java 7 SafeVarargs与JLS 14.20.3。

TWR的资源必须满足AutoCloseable契约,即提供close()供退出代码块时调用。自动管理不等于所有对象都有清理能力;只有纳入资源声明并成功初始化的对象才受到该清理结构管理。原书将继承方向写反:Java 7中应为Closeable继承AutoCloseable,不能据此把只接受Closeable的接口视为接受所有AutoCloseable对象。 详见资源自动关闭契约。

资源使用失败与close()失败可能同时发生。TWR保留先发生的主要异常,把清理失败附为被抑制异常,避免关闭错误覆盖最有诊断价值的失败。排障时应同时查看主异常与其suppressed列表。原书null资源示例不能证明这一点:资源为null时自动关闭逻辑跳过它,调用null对象的方法可抛空指针,但不会因此再产生关闭时的空指针异常。 详见主异常与抑制异常。

原书依据 · 14 处

第2章 新I/O

本章把路径位置表示、目录树遍历、文件操作、异步读写和网络通道串在一起。Path先描述要操作的对象位置,Files和目录访问器再进行实际访问;异步API让发起与完成分开,网络接口则把套接字配置收进通道抽象。这些机制承接第1章的TWR资源管理,不能把API存在理解为所有I/O场景自动安全或一定更快。

2.1 Java I/O简史

NIO为I/O引入缓冲区、通道和非阻塞能力,但旧File接口仍难以一致表达文件属性、目录树和平台能力。NIO.2进一步补齐文件系统抽象与异步I/O,说明网络非阻塞能力和完整文件系统支持是不同问题。选API时应看要解决的对象与调度需求,不能只因名称中都有NIO就把能力视为等价。 详见IO抽象的演进。

原书依据 · 1 处

2.2 文件I/O的基石:Path

Path描述文件系统中的位置,不要求该位置已经存在。构造路径或组合路径是处理位置表示,实际读取、创建、复制等操作才会接触文件系统并可能失败。将“准备目标位置”和“实际操作文件”分开,可表达尚待创建的文件;路径构造成功不能作为文件存在或可读的证据。 详见路径不等于物理文件。

相对路径依赖解析时所采用的目录;工作目录改变,同一../main可能落到不同位置。绝对路径明确根起点,却可能在迁移机器或目录树后失效。选择时应先确定哪些基准稳定:运行目录稳定可用相对关系,部署根变化则应明确提供基准,而不是在代码里固化某台机器的路径。 详见选择路径定位基准。

Path可通过getFileName、getParent、getRoot和subpath检查文件名、父路径、根及名称子序列。例如/usr/bin/zip的根为/,名称元素为usr、bin、zip;subpath(0,2)取usr/bin。根不是名称元素的一部分,子路径也不是从文件系统根重新定位后的物理文件。结果依赖具体文件系统和路径形式。 详见提取路径组成元素。

normalize处理路径表示中的冗余项,不等于查询文件系统。toRealPath定位存在的对象并按默认行为解析符号链接;它不能仅靠文本推断任意不存在文件的真实位置。原书用/usr/logs指向/application/logs的例子说明:去掉./与找到链接目标是不同任务,不能拿前者代替后者。 详见规范化与真实路径。

resolve把给定路径按接收路径进行解析,例如/uat加conf/application.properties;relativize则计算从一个路径走向另一个路径的相对表示。前者组装位置,后者描述位置关系。startsWith、endsWith和equals可检查路径表示关系,不能据此断定两个不同表示最终一定是同一物理文件。 详见路径组合与相对化。

File.toPath可把旧代码持有的File转换为Path;Path.toFile用于向仍要求File的接口传参。这种桥接帮助逐步采用NIO.2,而不必一次重写所有调用。须保留文件系统提供者边界:默认提供者通常能互操作,其他提供者的Path不保证能够转为File。toAbsolutePath返回新路径,调用后若不接收结果,原变量不会因此被改写。 详见新旧文件API互操作。

原书依据 · 6 处

2.3 处理目录和目录树

Files.newDirectoryStream(dir,“*.properties”)按glob模式筛选一个目录的子项,适合枚举当前层匹配文件。glob是有限路径模式,不等于完整正则表达式;也不因写了过滤模式就自动递归子目录。DirectoryStream持有需要释放的资源,示例把它放进TWR,在枚举结束或异常退出时清理。 详见单目录过滤与关闭。

walkFileTree负责遍历,FileVisitor负责各访问阶段的处理。常见用法继承SimpleFileVisitor,只重写visitFile完成筛选,再返回CONTINUE继续。默认不跟随符号链接。原书列出的五个回调及部分签名不符合Java 7最终API:实际是preVisitDirectory、visitFile、visitFileFailed、postVisitDirectory四个;目录访问失败也由visitFileFailed承接。 详见目录树访问回调。

原书依据 · 2 处

2.4 文件系统上的操作、观测与通知

路径确定位置后,文件操作才真正接触存储系统。本节从创建、复制和移动展开,转向属性与权限,再处理文件内容、变化通知和按位置读取。各层解决不同问题:权限说明谁能做什么,打开选项说明以什么方式操作;变化事件告知可能发生的改变,而定位读写决定从哪里处理字节。

Files.createFile创建新文件,Files.delete删除指定文件;路径并不替代操作权限。创建时可传文件属性,例如用POSIX权限表达属主、组和其他人的读写能力,但这些能力由具体文件系统支持。访问权限和打开选项是不同层面:允许程序申请写入,不等于操作系统已授予它写权限。 详见创建删除与访问权限。

Files.copy(source,target)复制文件;REPLACE_EXISTING用于允许覆盖目标,COPY_ATTRIBUTES用于请求复制属性。复制不是跨多个步骤的事务,失败时目标可能仅写入一部分。原书把ATOMIC_MOVE列为复制选项不成立,它用于移动。使用前先按当前操作核对选项,不能因为copy和move都接收CopyOption就互换全部枚举值。 详见复制选项与失败状态。

普通Files.move不保证原子性;显式请求ATOMIC_MOVE后,如果文件系统无法以原子方式完成,应失败而不是假定自动回滚。跨存储位置可能不支持。原书把move默认称为原子操作并传COPY_ATTRIBUTES的示例不应照抄;标准移动选项与复制不同。非原子移动失败后,要重新检查源和目标的实际状态。 详见原子移动的支持边界。

文件大小、修改时间、目录类型和符号链接标记,描述文件对象的不同维度。可用Files.size等单项方法,也可用readAttributes批量获取基本属性;后者便于一次处理一组信息。这些是观测结果,不是对后续操作一定成功的承诺;文件可能在读取属性之后被其他参与者改变。 详见读取基本文件属性。

POSIX权限把读、写、执行能力分别分配给属主、组和其他用户。读取PosixFileAttributes后可得到权限集合,构造目标集合,再通过setPosixFilePermissions写回。修改集合本身不会自动更新磁盘文件。该模式依赖文件系统支持;跨平台代码应处理属性不支持与权限不足,而不是假定所有存储都具有同一权限模型。 详见特定文件权限的读写。

符号链接是指向另一个位置的入口。读取属性时,要明确需要链接本身还是它指向的对象:NOFOLLOW_LINKS用于选择前者。readSymbolicLink读取链接中记录的目标,不保证目标存在,也不保证得到绝对路径;相对目标需按链接位置理解。不能把链接文字直接当作已核实的真实文件位置。 详见符号链接与目标身份。

缓冲读取器适合逐行处理;readAllLines或readAllBytes把整个文件内容作为结果一次返回,写法更短,但要能承受整份数据的内存开销。文本处理须明确字符编码,否则相同字节可能被解释成不同字符。打开流后要安排关闭;新旧流API的桥接并不免除资源生命周期管理。 详见流式读取与整文件读取。

文件写入要区分打开方式、字符编码与访问权限。WRITE表示请求写入,APPEND表示追加,这些选项不会修改文件的POSIX权限。原书newBufferedWrite拼写应为newBufferedWriter;调用默认选项可能创建文件或截断已有内容,不能把示例当作无条件安全的追加写入模板。 详见写入方式不是权限授权。

WatchService让程序注册关心的目录变化,以take或poll取得WatchKey,再消费pollEvents返回的事件,处理完调用reset重新激活该键。它是变化通知,不是完整变更日志:OVERFLOW意味着可能丢失事件,需要重新检查目录状态。阻塞take期间仅修改shutdown标志不保证立即退出,必须另设唤醒或关闭路径。 详见文件变化事件的消费。

SeekableByteChannel允许查询或改变位置和大小,FileChannel提供文件上的定位读写。read(buffer,position)的偏移以字节计算,不能把文件尾1000字节称为1000字符。应先处理文件小于1000字节的边界,检查实际读取数量并管理关闭。指定绝对位置的读操作与改变通道共享当前位置也不相同。 详见定位读取按字节计算。

原书依据 · 10 处

2.5 异步 I/O操作

异步I/O将发起操作与结果完成分离。Future适合由调用者在需要时取结果;CompletionHandler适合结果到来后触发成功或失败处理。两者都必须正确管理字节数量、缓冲区、资源关闭与失败。文件、客户端套接字及服务端接受连接分别有对应异步通道,不要把异步模型误解成回调必在主线程运行。

Future表示已发起但可能尚未完成的操作结果。发起读取后可做独立工作,再用get取得实际结果;尚未完成时get可能等待。isDone只表示操作已结束,结束也可能来自失败或取消,不能等同于读取成功。不要把反复轮询自动视为高效,更不要在业务依赖结果时只检查结束标记而不消费结果或异常。 详见将来式结果的消费。

回调式把结果交给CompletionHandler:completed接收成功结果,failed接收Throwable和附着对象。附着对象携带调用者提供的上下文,不是失败异常本身。原书把失败签名写成failed(V,A)并暗示回到主线程,均不准确:回调线程由通道相关线程池安排,不能把它当作UI或业务主线程。 详见完成回调的成功与失败。

异步文件通道关联线程池,用于处理事件并分发完成处理器;未指定时会使用系统默认池,它可能由多个通道共享。异步不意味着没有线程成本,也不意味着创建通道的open调用本身异步。应区分打开通道、发起读写和消费结果三个动作,避免把后台处理当作无限免费资源。 详见异步通道的线程资源。

分配100000字节缓冲区只给出接收容量,不保证一次异步read返回100000。应使用Future结果或completed中的字节数,判断读到了多少及是否到达文件末尾,再决定后续处理。异步期间不要同时把同一缓冲区用于其他未完成操作;通道能并发,不代表关联的可变缓冲区也可随意共享。 详见读取容量不是完成数量。

原书依据 · 4 处

2.6 Socket和Channel的整合

Socket代表通信端点,Channel提供I/O通道抽象。NetworkChannel统一通道上的绑定与选项,MulticastChannel再扩展组成员接收能力。组播是一对多分发机制;正确地址、网络接口与运行平台是必要条件,加入组与业务收发成功是不同状态。

NetworkChannel把本地绑定、支持选项查询和选项读写统一到通道接口,使应用不必为配置在Socket与Channel两套API间来回转换。使用supportedOptions确认支持范围,再按具体协议使用setOption或getOption。原示例常量所属类型应写StandardSocketOptions;IP_TOS指服务类型字段,不是服务条款。 详见通道上的套接字配置。

IP组播以一个组地址代表一组接收端,由网络完成一对多分发,不是发送端逐个执行普通单播。Java通过MulticastChannel加入组,DatagramChannel提供相应实现,加入时还要明确网络接口。原示例180.90.4.12不是IPv4组播地址,不能直接用于演练;组播能力还受地址族、系统和网络环境约束。 详见组播以组地址分发。

加入组播组需要选择网络接口、准备与地址族一致的DatagramChannel、设置相应选项并绑定本地端口,然后join得到MembershipKey。该键表示接收成员身份,退出可用drop;它不是已经发送或接收到业务数据的证明。原示例只展示成员加入,没有实际收发循环,不能把代码运行到join当作通信已验证。 详见组播成员的生命周期。

原书依据 · 3 处

2.7 小结

本章从位置走到实际I/O,从同步的路径与文件处理扩展到异步结果和网络通信。与第1章资源管理结合后,API能减少样板工作,但仍须处理失败、权限、数量与线程边界。原文把Files写成File以及对性能作概括性保证,不作为本笔记的技术结论;下一部分进一步解释注入、并发、类加载和性能机制。

第二部分 关键技术

第二部分把应用结构、并发执行、运行时装载和性能观测放在同一条学习路线上。依赖注入先减少业务与装配的耦合;并发讨论多核执行的正确性;类文件和加载解释实际运行对象从何而来;性能调优则要求用测量定位成本。它们从不同层次帮助理解程序,不能被编成每个请求必经的一条固定执行链。

第3章 依赖注入

依赖注入让对象接收外部协作者,减少自己构造具体实现的责任。本章由IoC与DI的区分开始,走到JSR330通用注解,再以Guice展示对象图组装。理论回答为什么分工,标准说明共同契约,框架演示如何配置。

3.1 知识注入:理解IoC和DI

控制反转先回答谁安排执行,依赖注入再回答谁取得协作者。示例从业务内部new具体查找器,经过查询工厂,走到接收AgentFinder;接口让不同实现与测试替身可替换。组装职责因此移出业务,而不是凭空消失。框架可集中管理对象图,但手工传参同样能实现注入。

控制反转改变谁安排调用:框架拥有控制流程,在事件发生时调用应用提供的处理逻辑。应用不再必须从中心循环逐项分派,而是专注于被调用时完成自己的职责。GUI事件处理是原文示例。IoC是更广泛的控制关系描述,DI只是针对依赖获取的一种具体形式,不能把两者当作完全相同的术语。 详见反转执行控制权。

依赖注入把对象所需的协作者从外部传入,而不是让对象内部创建具体实现。直接在普通Java代码中构造依赖并传参,也已经是DI;框架只是组织这种装配的一种办法。它改变的是依赖取得与业务使用之间的责任分配,并不自动消除依赖,也不要求所有对象必须由容器管理。 详见依赖注入不依赖框架。

工厂或服务定位器把具体创建集中起来,但业务方法仍主动查询工厂或提交查找凭据;直接注入则把已经选择好的AgentFinder交给业务方法。后者让业务无需知道组装入口。二者都可减少直接new具体类的代码,但“谁寻找依赖”仍然不同,不能只看是否用了接口就认为职责完全分离。 详见定位依赖与接收依赖。

业务只依赖AgentFinder接口时,测试可提供返回固定数据的实现,避开网络服务或电子表格等不稳定外部条件。注入给测试提供替换入口,接口定义可替换的契约;二者协作才使业务逻辑能被单独验证。这不等于替身测试已经覆盖真实服务的集成行为,外部交互仍有独立验证范围。 详见用接口替身隔离测试。

把依赖从业务类中移出去后,选择实现、构造对象和连接依赖的工作并未消失,应由外部装配代码或容器承担。业务类更内聚,是因为它专注于使用依赖完成任务。将任意获取对象的调用隐藏到别处却仍由业务触发,不一定达到同样的职责边界。 详见装配职责仍需归属。

原书依据 · 5 处

3.2 Java中标准化的DI

JSR-330把注入点、候选身份和实例重用分为三组问题:Inject标记在哪里需要依赖,限定符和Named选择同类型候选,Scope及Singleton控制重用,Provider把取得对象的时机交给调用者。标准子集有助于迁移,但容器专有功能仍有边界。本节的注入顺序、单例默认值、不可变性与Provider副本说法已按标准显式勘误。

JSR-330用javax.inject规定常见注入标记与Provider接口,减少代码直接绑定某个框架注解的程度。它统一的是通用子集,不是所有容器的高级配置和生命周期行为。使用专有特性后,迁移仍可能需要改动;“采用标准注解”不能被当作可以无成本更换框架的保证。 详见依赖注入的标准子集。

@Inject可标注构造器、非final字段和符合约束的方法;每类至多一个注入构造器。构造器表达创建对象所需依赖,方法和字段表达后续注入点。原文顺序有误:标准规定先构造器,再字段,再方法;注入方法不能抽象或自行声明类型参数。方法注入并不自动使依赖可选,不能只因采用setter就忽略缺失绑定。 详见注入点与初始化顺序。

当多个候选属于同一类型时,仅凭类型不能表达需要哪一个,限定符与类型共同标识依赖。自定义限定注解用@Qualifier标记并保留到运行时,属性可进一步表达差异;@Named是标准的字符串限定符。名称只是额外身份维度,注入对象仍须满足类型要求,不能用名字绕开类型契约。 详见限定符区分同类型依赖。

作用域说明注入器何时保留和重用对象,而不是描述业务对象本身是否可变。无作用域时,标准默认不为后续注入保留实例;声明作用域后按其规则复用。不支持或冲突的作用域应报错。复用意味着多个使用者可能访问同一对象,因此必须同时考虑对象生命周期与线程安全。 详见作用域控制实例重用。

@Singleton表示注入器对该类型只实例化一次,不等于对象状态不能改变,也不自动提供并发安全。原文将单例说成默认生命周期并把它等同于不会改变的对象,均不能作为通用JSR-330规则。共享可变单例仍需保护状态;“只创建一个”回答身份数量问题,不回答行为是否安全。 详见单例不等于不可变。

Provider的get()把“接收依赖”变为“接收取得依赖的入口”,可延迟或按条件获取对象,也可连接更小作用域。重复get不保证得到新副本,结果仍受配置和作用域约束。延迟获取可能打断循环构造,但若在注入它的构造器内立即get,可能重新触发原来的循环,不能把Provider当作无条件修复。 详见按需获取依赖实例。

JSR-330定义通用的依赖注入接口与注解;书中所述JSR-299的CDI在其基础上面向企业应用提供上下文相关的依赖管理。两者解决的范围不同,不应因为都有注入功能便当作同一套规范。Weld在此作为CDI实现入口出现;使用普通javax.inject注解,不代表已经获得整个企业上下文体系。 详见通用注入与企业上下文。

原书依据 · 7 处

3.3 Java中的DI参考实现:Guice 3

Guice把依赖关系外置到模块:绑定选择实现与候选身份,提供入口处理定制构造,注入器完成对象装配,作用域约束重用。独立程序和Web容器有不同启动入口,业务类仍通过注入点接收依赖。模块/绑定并不替代对状态生命周期的判断,原示例中的作用域拼写按Guice3 API更正。

Guice模块声明依赖类型应对应哪个实现;注入器读取这些绑定,按对象所需依赖建立相互连接的对象图。AgentFinderModule把AgentFinder链接到WebServiceAgentFinder,HollywoodServiceGuice通过构造器接收该接口。业务使用对象,装配规则放在模块,这种分工使替换实现集中到外部配置。 详见模块绑定与对象图。

独立程序可在main创建Injector,再向它请求顶层业务对象,让依赖图随之组装。Servlet应用则把创建注入器放进部署生命周期:配置GuiceFilter,注册GuiceServletContextListener的子类,并在getInjector中创建或取得Injector。它连接的是容器启动与装配时机,不能只加一个过滤器就假定所有业务绑定已配置。 详见应用入口启动注入器。

链接绑定用bind(AgentFinder.class).to(WebServiceAgentFinder.class)选择实现;当同一接口需要多种用途时,可用annotatedWith(Names.named(“primary”))增加身份。注入点的@Named值必须与绑定一致。前者回答选哪个实现,后者进一步区分同类型的哪一组配置,不能只改一端名称而期待自动匹配。 详见链接绑定与命名绑定。

简单构造绑定不能表达全部初始化逻辑时,可用@Provides方法返回定制对象;逻辑增多后可提成Provider实现,再用toProvider绑定。SpreadsheetAgentFinder示例在提供入口中设置表格类型和路径,使业务无需知道这些装配细节。Provider负责如何取得对象,作用域决定能否重用;两者不能混为一个配置。 详见定制对象的提供入口。

Guice可在实现类上声明作用域,也可在绑定链的in(…)中集中配置,或给@Provides方法加作用域。它们都应与希望的复用范围一致。原文的@Request、Session.class及@RequestScope写法不能直接照抄;Guice3 Servlet扩展的注解是RequestScoped、SessionScoped,分别按请求和会话复用对象。 详见作用域声明的三个位置。

有状态对象保留多久,决定哪些调用会看到同一份状态。请求、会话和单例具有不同共享边界;对象生存期拉长,可能把本应隔离的数据留给后续调用,也会增加并发保护要求。Guice默认无作用域,单例是同一注入器中的特定复用策略,不等同于进程全局唯一。不能仅凭“无状态通常便宜”就断言所有对象构造都无需衡量成本。 详见共享状态与生命周期。

原书依据 · 6 处

3.4 小结

本章的主线是把依赖获取从业务职责中分离:工厂展示集中创建,DI进一步让业务只接收所需对象,JSR330定义跨容器子集,Guice负责具体装配。标准注解改善可移植性,却不会抹平容器配置差异;对象被共享后仍需考虑并发,这正是下一章的连接点。

第4章 现代并发

本章先建立并发正确性与进展的判断,再回看传统监视器、线程状态和共享状态的困难,随后引入并发工具包与分支/合并框架。会使用Thread或Runnable只是起点,不足以说明能设计正确的多线程协作。后文其他JVM语言的并发模型也将以这些约束为比较基础。

4.1 并发理论简介

共享对象遇到不可预知的交错执行,会同时产生一致性和进展问题。安全性约束不能发生的坏结果,活跃度约束活动能否结束;性能和重用又为方案增加取舍。隐藏状态和减少通信缩小协调范围,线程池与队列则帮助把业务组织成阶段流水线,二者仍需分别验证正确性与资源成本。

线程可引用同一可变对象,而调度可能在修改中途切换,另一个线程便可能观察到不一致状态。共享带来访问机会,不自动提供修改可见性保证;原文“默认可见”不能理解为无需同步。设计应明确哪些状态共享、谁可修改以及用什么协议协调,而不是仅凭某次运行结果正常判断安全。 详见共享状态遇到抢占调度。

安全性要求并发操作仍维护对象的一致性;活跃度要求尝试的活动最终取得进展或失败。一直持锁不放可能保住局部状态,却让其他任务永久等待。短暂等待和永远无法继续也不同。评估并发方案时必须同时问“会不会出错”和“能否继续”,不能用类型检查或局部互斥代替整个系统的活跃度判断。 详见安全性与活跃度分开判断。

安全、进展、性能和重用存在张力:粗粒度互斥可能限制吞吐,开放内部状态会增加误用空间。减少子系统间通信、隐藏内部状态,并优先用结构强制约束,可缩小需协调的范围。只把要求写在文档里仍依赖调用者遵守,适合无法完全封装的边界,不能把约定本身当成已实施保护。 详见并发设计需要约束边界。

锁和监视器、上下文切换、线程数量、调度、局部性与算法都会影响并发成本。增加线程只改变可调度工作量,不保证单位资源完成更多工作。分析性能时应把这些因素分别考虑,才能区分锁竞争、切换成本和算法本身的额外工作;可重用并发工具也不能替应用选择合适算法。 详见并发开销不只有锁。

时间局部性是短时间反复访问同一位置,空间局部性是访问相邻位置。它们描述访问模式,说明数据组织与执行顺序也会影响成本。并发任务虽然可能同时运行,若破坏了原有局部性,也可能付出额外代价;因此讨论多线程性能不能只计算任务数和CPU核心数。 详见时间与空间局部性。

把业务流程拆成职责集中的阶段,每阶段用线程池处理工作项,再经队列交给下一阶段,可让不同工作项同时推进。原文以信用检查和库存处理说明:一个工作项等待某阶段时,另一个可在别的阶段工作。这是提高重叠程度的组织方式,不是跨阶段原子事务或库存正确性的保证。 详见按业务阶段组织流水线。

原书依据 · 6 处

4.2 块结构并发(Java 5之前)

传统块结构并发先用对象监视器保护临界区,同步还提供跨线程可见性关系。全同步对象让状态边界清楚,却可能因跨对象持锁调用产生死锁。统一锁顺序处理等待环;volatile和不可变设计处理的是不同的共享状态问题。线程暂停与等待并非同一锁行为,final也不等于深不可变,这些原文易错点均已在对应卡中勘误。

synchronized块先取得指定对象的监视器;实例同步方法用当前实例,静态同步方法用对应Class对象。同一把锁上的临界区互斥,不代表锁住一个对象就递归锁住它引用的所有对象。数组本身与元素、外部对象与内部对象都需分别识别;不同实例锁也不能自动保护同一静态共享状态。 详见临界区依赖同一把锁。

持有某监视器的线程可以再次进入同一监视器保护的同步路径,这叫可重入;它不会因为调用本对象另一个同步方法而阻塞自己。非同步方法则不自动检查这把锁,可在其他线程持锁时继续运行。安全性依赖所有相关状态访问遵守共同协议,而不是类里出现过synchronized就全部受保护。 详见可重入与非同步访问。

Java线程状态分为NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。RUNNABLE不保证此刻占有CPU;BLOCKED专指等待监视器锁。原文用就绪/运行及阻塞忙等描述不能直接替代Java状态枚举,等待I/O也不能一概判断为正在核心上忙等。诊断时应区分JVM观测状态与操作系统调度。 详见线程状态不等于CPU状态。

Thread.sleep暂停当前线程,但不会释放它已经持有的监视器。Object.wait要求持有对应监视器,等待时释放该监视器,返回前重新取得它;不代表把其他锁也一并释放。原文把sleep和通知等待都说成会释放锁并不正确。选择暂停方式必须结合条件协议,不能靠睡一段时间保证另一个线程能进入临界区。 详见休眠与等待的锁差异。

完全同步对象策略要求私有状态在构造后和公开操作边界保持一致,相关访问都受同步保护,操作能终止且不在状态不一致时调用外部代码。原例用同一锁协调到达时间Map的读写。其价值是建立清晰的不变量边界;代价是访问串行化和维护纪律,后续漏掉一个访问路径就可能破坏原有推理。 详见同步对象维护一致性。

两个微博节点各自进入同步更新方法,持有本节点锁后再调用对方的同步确认方法:线程一持A等B,线程二持B等A,便都无法完成。局部方法各自互斥并不能防止跨对象循环等待。这个案例的问题是锁依赖成环,不是确认方法计算太慢;仅让某个线程睡眠也不是可靠的解决办法。 详见相互持锁形成循环等待。

如果所有参与线程都按同一全局顺序取得多把锁,就能避免原例A→B与B→A交叉形成的等待环。后来的线程会在第一把锁处等待,而不会持有顺序更后的锁反过来阻塞先行者。约束必须覆盖所有会组合取得这些锁的路径;单独修正一个方法、却保留相反顺序的入口,不能建立这一保证。 详见统一锁顺序打破等待环。

同一监视器上的解锁与后续加锁建立happens-before关系,使保护协议不仅协调进入顺序,也约束跨线程可见性。不能把原文“刷新被锁对象内存”当作精确模型:同步语义不局限于锁对象自身字段,也不意味着任意线程只要读取共享对象就能看到最新写入。关键是双方是否参与正确的同步关系。 详见同步也建立可见性。

volatile为相应读写提供可见性和顺序约束,不把“先读取、计算、再写回”的多步操作合成一个原子动作。例如依赖旧值的更新仍需锁或合适的原子操作。volatile本身不取得监视器,不意味着使用它的整个程序不会死锁;原文把它概括为真正线程安全时,必须限定到它实际提供的保证。 详见可见性不等于复合原子性。

final引用不能重新指向另一个对象,却可指向内部仍能变化的对象。因此字段都声明final不足以证明整个对象不可变;还要约束可达状态和外部别名。原例Update持有Author,只有Author的相关状态也稳定、没有泄漏修改路径时,才可把它作为稳定值使用。不可变设计减少共享修改冲突,但通常以构造新对象表达变化。 详见最终引用不保证深不可变。

构建器保存可逐步修改的参数,通过build调用成品的私有构造器,把配置阶段与最终对象分开。Update.Builder用author和updateText链式设置,最后生成Update,减少长构造参数列表的使用负担。这解决的是装配表达,不自动实现深复制或校验;Builder可变也不代表成品中的引用对象必然不可变。 详见构建器分离配置与成品。

原书依据 · 11 处

4.3 现代并发应用程序的构件

本节用不同构件分担并发协议:原子类封装单个原子更新,显式锁允许限时获取与退让,门闩把准备信号汇总为一次放行,并发容器提供特定操作和迭代语义,队列让生产与消费解耦并暴露速度差。它们解决的是不同层面的协调问题。把一个容器换成线程安全版本,不会顺便解决对象内部状态、整个业务事务或停机协议;本节示例的边界和错误已在对应卡中逐项更正。

AtomicLong.getAndIncrement把读取旧值和递增作为一个原子操作,避免多个线程同时取号时的读改写竞态。这比单独的volatile可见性多了复合更新保证。唯一性只在同一计数器、未重置且未溢出的范围内成立,不是持久化或跨进程ID方案。原子类是专门API对象,不能把AtomicInteger当Integer或AtomicBoolean当Boolean直接替换。 详见原子自增的保证范围。

Lock把获取与释放写成API操作,允许尝试获取、限时等待等控制;这也要求开发者自己保证释放路径。应在成功取得锁后用finally释放,未取得时不能机械unlock。把synchronized换成ReentrantLock,不会自动修复原来的锁顺序或跨对象调用死锁,只是改变了表达和控制手段。 详见显式锁需要显式释放。

读写锁区分读访问与写访问:多个读者可以共享读锁,写者需要独占。它可能适合读取远多于修改的场景,但不是读多就一定更快。ReentrantReadWriteLock实现的是ReadWriteLock,其readLock和writeLock分别提供Lock,不能将它当作一个普通Lock直接替换。仍须遵守所有状态访问的共同保护协议。 详见读写锁的共享与独占。

为第二把锁加超时,却一直持有第一把锁重试,仍会使对方缺少完成所需的锁。原文的修正让确认失败返回false,调用方先释放第一把锁,再暂停和重新尝试。关键是失败后让出已占资源,随机等待只是减少同时竞争的辅助手段;这改善死锁风险,不等于证明每个线程必然公平完成。 详见退避须释放已持有的锁。

CountDownLatch用初始计数表示需要的完成信号数,countDown递减,await在归零前等待;归零后后续等待可通过,计数不能重置。原文quorum=1+MAX_THREADS/2表达严格多数,不只是至少一半。它只统计信号,不知道每个服务真正是否健康,调用者必须只在相应准备完成后发信号。 详见倒计数门闩是一次性门。

ConcurrentMap的putIfAbsent、条件remove和replace把检查与修改合成原子操作,避免先查后改之间被其他线程插入。原例借putIfAbsent保留首次到达时间。原文变量声明为Map却调用putIfAbsent不适用于Java7,应使用ConcurrentMap或具体类型。容器操作安全不代表跨多个键的业务约束自动原子成立。 详见条件更新替代先查再改。

CopyOnWriteArrayList在修改时复制底层数组,已有迭代器继续读创建时的数组,因此后续新增项不会出现在旧迭代中。原文两条时间线展示的是不同快照,并非一个迭代器被另一个线程复制。复制的是元素引用数组,不是所有元素的深副本;读多写少时可能合适,写入频繁或数组很大时须衡量复制与内存成本。 详见快照迭代与写入成本。

BlockingQueue在队列满时让put等待、空时让take等待,将上下游速度差变为可观察的等待。容量边界使生产者不能无限超过消费者,代价是上游也会被拖慢。队列安全性依赖具体并发实现,不是所有Queue都线程安全;默认近似无界的队列也不会自动为应用设置合理内存上限。 详见有界队列形成背压。

带超时的offer允许生产者在规定时间内尝试交付,失败则返回false;消费者可用带超时的poll而不是无限take。超时使代码有机会转做其他事,但不会自动保存未交付工作。原文消息只打印“handoff失败”,业务还需明确重试、拒绝或其他去向,不能把方法返回当作工作已入队。 详见超时交付必须处理失败。

WorkUnit在业务对象外增加包装层,getWork返回被包裹对象;之后可在包装层承载到达时间、处理历史或服务质量等运行信息,避免把调度细节塞进业务类型。兽医预约中的Appointment对应同一思路。包装是职责分离,不是复制对象,也不因此保证T的内部状态线程安全。 详见工作封装携带运行元数据。

兽医消费者在队列为空时阻塞于take,只把shutdown改为true不会唤醒它。示例还在同步方法写普通boolean、在未同步循环读,缺乏一致的可见性协议。退出设计既要让标志可见,也要让阻塞调用有退出路径,并明确处理中断后的行为。不能把吞掉InterruptedException当作完整的停机策略。 详见停机标志不能唤醒阻塞。

TransferQueue.transfer等待消费者实际接收元素,tryTransfer提供立即或限时尝试。它比单纯入队多了接收握手,但消费者拿到任务后可能尚未执行、也可能处理失败。原文“挂号信”比喻应限定为交付,不应扩成业务完成确认;替换队列前要先确认调用者需要的是排队、接收还是处理成功。 详见移交确认不等于处理完成。

Java7的LinkedTransferQueue是无界链式实现,支持空构造或用Collection初始化;原文new LinkedTransferQueue(100)不能作为容量100的构造调用。即使transfer能让生产者等待接收,put或offer也仍可能积累工作,不能把移交握手与有界容量混为一谈,性能优劣也需按真实负载测量。 详见链式移交队列没有容量参数。

原书依据 · 13 处

4.4 控制执行

执行器把任务与实际线程分离:Callable表达计算,Future观察结果,FutureTask让计算可调度并暴露结果状态,定时执行器再添加触发时机。结果获取、超时、取消、异常和资源关闭是不同层面的协议,不能只靠一个接口调用假定它们都已完成。

任务表达要做什么,线程是执行它的资源。让线程池反复执行工作单元,可减少为每项工作创建线程的开销,并把调度责任移交执行器。分离不等于无限提交没有代价;仍须考虑资源数量和积压。业务应按工作单元组织代码,而不是把每个业务对象都直接建模成一个新线程。 详见任务与执行线程分离。

Callable用call()表示可返回结果、可抛异常的一段计算,匿名实现可捕获外部上下文再延迟执行。它是单一抽象方法类型的例子,用于Java7中把行为作为值传递。call本身没有参数,不意味着计算不能使用参数化状态;但它也不能不经适配就代替所有可能的方法签名。 详见单一抽象方法承载计算。

Future.get(timeout,unit)会等待结果,最多等待指定时间;超时不等于后台计算已停止。cancel发起取消,mayInterruptIfRunning允许尝试中断,但不保证强制终止所有运行代码。结果消费、超时策略和计算如何响应取消是不同责任。原文“带超时版本永远不会阻塞”错误,应理解为等待有界。 详见超时与取消的边界。

FutureTask把可执行的Runnable能力与Future的结果、完成和取消能力放在一个对象上。它可包装Callable交给执行器,执行器调用run,使用者通过get消费结果。这样计算定义、执行调度与结果观察可分工。FutureTask本身不是线程,构造它也不意味着任务已经被后台运行。 详见可调度的结果任务。

ScheduledThreadPoolExecutor支持延迟或周期执行,但触发时间不是实时保证。原例poll返回空时立刻getWork会抛空指针,应先判断取出的工作单元是否为null;周期任务异常也可能使后续执行被抑制。取消调度句柄与关闭执行器是不同生命周期动作,不能只保留句柄就认为线程资源已经释放。 详见周期调度须处理空值与失败。

原书依据 · 5 处

4.5 分支/合并框架

分支/合并以可分解的问题为起点,用阈值控制顺序执行与继续分裂,再合并结果。工作窃取帮助平衡不同大小任务,但无法抹去算法和阻塞依赖。排序例展示了任务类型与递归流程,同时暴露有效结果范围和示例错误;MapReduce是相关的分解归并模型,不能与单机线程池等同。

fork/join把大任务递归拆小,达到阈值后顺序计算,再合并子结果。排序示例用RecursiveAction表达无直接返回值的任务,结果保存在字段中。代码用size()而非正文所说<=32;每个结果数组按全输入长度分配,但有效区只占size个元素,不能把数组尾部未用位置当成已排序结果遍历。 详见递归分治与合并边界。

当各工作线程任务量不均时,空闲线程可尝试执行其他线程产生的子任务,减少一边忙、一边闲的情况。这是ForkJoinPool的自动调度策略,不需要应用逐项手工搬任务。它不能证明任何负载都均匀,也不能消除任务本身依赖、同步或I/O阻塞造成的等待。 详见工作窃取平衡任务负载。

适合fork/join的问题通常能自然分解成更小、较独立、显式协作较少的子任务,再将结果组合。粒子模拟、日志分析和计数可作为候选,但应先判断数据依赖与任务粒度。框架不是通用I/O加速器;在未管理的阻塞I/O或同步面前,池并不保证自动补偿,不能靠增加并行度替代问题分解。 详见分治适用性先于并行化。

TimSort结合归并与插入排序思路;Java7对象数组排序文档说明了源自Tim Peters实现的适应性排序。但不能把所有Arrays.sort都统称TimSort,基本类型重载具有不同实现说明,算法说明也不是替代接口契约的永久保证。传null观察堆栈不可靠:原示例构造器会先读取数组length,未必执行到排序算法。 详见排序实现须按重载区分。

MapReduce让map把输入键值对转换为中间键值对,再让reduce合并同一中间键对应的值。它与本节的联系是把数据处理拆成可并行的工作并汇总结果,不代表ForkJoinPool本身提供了分布式容错运行时。原文译注“大于1TB”不是模型成立的必要条件;规模影响选型,不能用一个容量阈值定义模型。 详见映射后按键归并结果。

原书依据 · 5 处

4.6 Java内存模型

JMM描述哪些执行与读值是允许的。线程内顺序和同步动作建立happens-before,再用传递性连接状态传播证据;start与join把启动准备和完成结果连接到其他线程。它不是所有代码块现实时间的全序,正确性应依最低保证推理。

happens-before描述Java内存模型中的可见性与顺序约束,不要求把程序中的所有动作排成一条现实时间线。原文用偏序的自反、反对称和传递性作数学背景,重点是部分元素可以不可比;这个类比本身不创造跨线程同步。它可以由线程内程序顺序、跨线程同步关系以及传递性建立。未被该关系约束的冲突访问可能形成数据竞争,不能因一次观测恰好读到新值就认定代码具有保证。 详见之前发生不是物理先后。

调用Thread.start的动作之前所做的准备,可沿启动关系被新线程的动作承接;线程中的动作发生在其他线程成功join返回之后的动作之前。同步关系有方向,不能把start解释成新线程先完成再调用启动。锁的解锁/后续加锁、volatile写/后续读和程序顺序,可通过传递性组合成更长的可见性证据链。 详见启动与等待完成传递状态。

某个JVM或硬件上反复表现正常,不代表Java内存模型承诺了这种结果。正确性推理应建立在规范允许的行为和同步关系上,而不是把实现偶然更强的观测当作契约。不可变状态减少跨线程传播修改的需求,但仍须满足构造和发布边界,不能用“final字段”代替对可达对象状态的判断。 详见依赖规范最低保证。

原书依据 · 3 处

4.7 小结

本章从正确性和进展要求出发,走过监视器、锁顺序与共享状态,再用原子类、并发容器、队列、执行器和分支/合并分担协调职责。JMM为这些机制提供跨线程行为的推理依据。工具降低手写协议负担,却不会替应用决定事务边界或失败去向;下一章转向类加载和字节码,继续解释平台为何按所见方式运行。

第5章 类文件与字节码

本章从平台而非源码视角解释程序:类型如何进入运行中的VM,如何通过运行时成员描述执行反射,以及如何检查类文件和字节码。DI启动失败与没有源码的编译产物是它提出的两类调试动机。方法句柄和invokedynamic再把这些基础连接到非Java语言的调用机制。

5.1 类加载和类对象

一个类型从二进制表示进入运行态,经过加载与链接,再在需要时初始化。链接中的验证、准备和解析分别处理合法性、静态存储与符号引用,不应把它们混作“找齐所有类”。Class让程序观察类型和成员,类加载器控制取得定义的路径;加载时转换和配置驱动装配展示了框架如何利用这些入口。

类文件不仅含方法字节码,也描述字段、方法、继承和其他元数据。加载取得二进制类型表示,链接把它纳入运行态并检查和准备,初始化才执行类初始化逻辑。三者不是“读到文件就能立即运行”的单一步骤。链接包括验证、准备和解析,而解析可按需要延后,不要求先解析所有引用才允许初始化。 详见加载链接与初始化分工。

验证检查类文件格式、符号与字节码约束,例如类型匹配、局部变量初始化和操作数栈使用,防止不符合虚拟机规则的代码进入执行。通过验证不意味着程序不会抛异常、不会死锁或业务逻辑正确。它提供的是类型与运行环境约束下的保障,不能把“已验证”当成任意运行时故障都已排除。 详见类验证不证明业务正确。

准备为类的静态字段分配存储并设置相应默认状态;解析把常量池中的符号引用映射到可使用的运行时实体。原文前面把准备说成定位全部引用类型不准确,应以它后面的静态字段说明结合规范理解。静态初始化代码属于初始化阶段,不应与准备阶段的默认值设定混淆。 详见准备与解析处理不同对象。

Class对象在运行时代表类型,反射API可据它取得Method和Field等成员描述并间接访问成员。它不是该类型的普通业务实例:描述类型与创建实例是不同动作。原文getSuperClass拼写应为getSuperclass。理解类型描述、成员描述和实际对象的区分,才能追踪框架通过反射发现和连接对象的过程。 详见运行时类型与反射成员。

Java7环境中,引导加载器负责基础运行类,扩展加载器负责扩展,应用加载器处理应用类,框架还可加入定制加载器和资源查找。父加载器委派关系不等于Java类的继承关系;ClassLoader的默认查找会先委派父级。这里是Java7的角色划分,不把rt.jar布局说成所有后续JDK的通用结构,也不把引导加载器概括为永远不验证。 详见加载器职责与委派边界。

EMMA示例在类加载时改写字节码,加入测试辅助信息;测试运行时再记录执行过的方法和分支,从而形成覆盖证据。它说明“加载”可以包含转换,而不只是把磁盘内容原样搬入内存。执行覆盖反映测试触及的范围,不等于每个断言都正确或全部业务场景已被验证。 详见加载时插桩记录覆盖。

配置驱动的DI先启动框架,读取配置后才能知道用户指定的类型,再加载所需类型、创建实例并设置依赖。HollywoodServiceDI的setFinder接收配置指向的AgentFinder,把对象连接到业务服务。原文用定制加载器讲解这种过程,但配置驱动装配不必然要求自定义加载器;类型加载、对象创建和依赖设置应分别追踪。 详见配置发现类型再装配对象。

原书依据 · 7 处

5.2 使用方法句柄

方法句柄把可执行能力封装为有类型的引用:MethodType说明调用形状,Lookup以查找上下文检查权限,invokeExact或invoke再按精确或适配规则执行。私有取消方法的三个入口展示了访问能力如何交给外部,但不构成句柄一定更快或完全没有内存成本的保证。静态lookupClass与运行时对象类型也须区分。

MethodHandle是可以执行的方法、构造器、字段访问等底层操作的类型化引用。它把“取得调用能力”与“使用该能力”分开,使框架能间接调用而不必为每种签名创建专用代理接口。句柄对象不可变,不代表目标对象状态不可变;它也不是自动优于所有反射或直接调用的性能保证。 详见类型化的执行引用。

MethodType用返回类型和一组参数类型表示调用形状,不含方法名称。查找toString时用返回String、无显式方法参数的类型;但findVirtual返回的未绑定句柄,其调用类型还包含接收者参数。原文“没有接收者类型”应限定到查找时的方法描述,不能据此遗漏invokeExact中的对象参数。Comparator的比较方法名是compare,不是compareTo。 详见方法类型与接收者参数。

Lookup记录查找类及可用访问权限,创建句柄时据此检查目标成员。合法上下文可以创建私有方法的句柄,再把有限的调用能力交给使用者;不是对每次调用重新按使用者身份做同样检查。不要把Lookup或敏感句柄随意暴露,也不能把“无关联类只能public”的简化当成完整的包级和继承访问规则。 详见查找上下文也是访问能力。

invokeExact要求调用点的静态参数和返回类型与句柄类型精确匹配;仅对象运行时恰好是某个子类并不足够。invoke允许符合API转换规则的类型适配,如一些装箱、拆箱或引用转换,但不是任意参数都可转换。选择时先检查句柄type及调用点类型;失败应保留实际类型信息,不能靠强制转型猜测签名。 详见精确调用与适配调用。

ThreadPoolManager用反射Method、内部CancelProxy或在本类Lookup中创建的MethodHandle,把私有cancel能力交给外部。代理把类型契约写成普通方法,句柄用运行时方法类型表达,反射则经Method调用。原文meth.invoke(hndl)缺少目标对象,实例方法应按invoke(manager,hndl)理解;三种入口都需明确谁被授权取消哪个任务。 详见对外提供受限调用入口。

MethodHandles.lookup().lookupClass()返回建立查找上下文的类,可用于静态日志初始化,减少到处硬写MyClass.class而遗漏重命名的风险。它不是运行时接收者的getClass;若把整段代码移动到另一个类,查找类也会改变。因此它避免的是固定类名字面量,而不是保证重构后日志归属永远不变。 详见静态上下文识别查找类。

原书依据 · 6 处

5.3 检查类文件

检查类文件先确认产物身份,再用javap查看成员、内部描述符和详细元数据。描述符编码方法与字段形状,常量池以类型化索引连接名称、类型和目标。理解这些关系能解释反汇编输出,而不必把教材中不一致的常量池行原样当成实际构建结果。

javap直接检查类文件,可在源码、构建和部署观测不一致时确认产物究竟包含哪些成员。默认展示包级、protected和public成员,-p再包括private,-s显示内部描述符,-v输出常量池等详细信息。原文“包级protected”不是Java访问级别名称。先确认工具读取的是实际目标文件,不能把旧路径中的输出当成新部署已生效。 详见检查部署产物的真实成员。

JVM描述符以紧凑字符串表达字段或方法类型。方法用(参数描述符)返回描述符,例如()I返回int,(Ljava/lang/String;)V接收String且无返回值;数组在元素描述符前加[。引用类型用L加内部名并以分号结束。J是基本类型long,Long引用须写Ljava/lang/Long;,不能把大小写词名当成同一种类型。

编码 类型或用途
B、C、D、F byte、char、double、float
I、J、S、Z int、long、short、boolean
L内部名; 引用类型
[元素描述符 数组,可重复[表示多维
V 仅方法返回的void

详见类型描述符编码方法形状。

常量池条目按类型解释,并以索引引用其他条目。Fieldref通过Class定位所属类型,通过NameAndType定位字段名和描述符;后者再引用Utf8条目。这是一组相互连接的元数据,不是字段值的平铺清单。原示例的部分run签名与源码不一致,应理解解析关系而不复造其完整输出为已验证产物。 详见常量池用类型化索引连接。

Class和成员引用描述类型、字段或方法目标,NameAndType保存名称与描述符组合;String指向文本条目,Integer、Float、Long、Double保存相应数值常量。MethodHandle、MethodType、InvokeDynamic在Java7加入相关调用元数据。Utf8保存编码文本,不等于字符串对象,其编码是modified UTF-8,不能直接当成任意标准UTF-8字节流解析。 详见常量池条目的不同用途。

原书依据 · 4 处

5.4 字节码

字节码以栈帧中的局部变量与操作数栈执行计算,指令在两者和字段、常量之间搬运值,再通过分支与调用改变控制流。new和构造器调用区分分配与初始化,监视器指令连接并发保护,字符串拼接展示简单源码怎样展开成对象和调用。操作码族名只是阅读组织方式,具体行为必须按真实指令、操作数和返回类型解释。

javap -c -p可查看私有方法中的字节码。行首数字是方法代码中的字节偏移,不是第几条指令;单字节操作码之后可跟不同长度的操作数。一个字节有256种编码,并非255。aload_0等紧凑形式把常见局部变量索引编码进操作码,ldc用8位索引而ldc_w用16位,不能把所有索引一概按两个字节读取。 详见指令偏移与操作数解读。

方法调用建立新的栈帧,其中有局部变量与自己的操作数栈。调用者把接收者和参数准备好,调用发生后被调方法用自己的帧计算,返回值再交回调用者。表达式3+某方法结果中,3可留在调用者的操作数栈等待结果。JVM栈机是抽象执行模型,不意味着JIT生成机器码时不使用硬件寄存器。 详见栈帧隔离每次方法计算。

new负责为对象分配空间,dup保留栈顶引用,invokespecial调用执行实例初始化,三者组成常见构造模式。带参构造时还会在调用前加载参数。Java源码构造器没有返回类型,类文件中的描述符以V结束;构造器也可先委托同类的this(…),不能说每个源码构造器都直接调用父类构造器。 详见分配对象与执行构造分开。

load/store类指令在局部变量与操作数栈间搬运值;ldc取常量,dup复制栈顶值,getfield/putfield访问实例字段,getstatic/putstatic访问静态字段。字段符号引用来自当前执行类的运行时常量池,再针对目标对象取值,不是对象内部藏着一份供getfield索引的常量池。类型前缀如dload、astore区分值种类。 详见值在局部变量栈与字段间流动。

数学运算从操作数栈取值并把结果压回,iadd、isub、imul、idiv等分别表达int计算,其他数值类型有对应变体。i2d等转换指令改变数值表示,不是任意类型之间都存在通用cast指令。读反汇编时要同时核对操作码和入栈值类型,不能只凭变量名猜测执行中的数据表示。 详见数学指令依赖栈值类型。

源码if和循环可编译为条件跳转与goto,switch可用tableswitch或lookupswitch。跳转目标须按指令格式和偏移解释。jsr/ret属于历史子程序机制并受类文件版本约束,不能当现代通用方法调用;goto_w扩大偏移编码,也不会解除Code属性中方法code_length小于65536字节的限制。 详见分支指令表达控制流。

invokestatic用于静态调用,invokevirtual按虚方法规则选择实例实现,invokeinterface用于接口调用,invokespecial处理构造、私有和特定超类调用,invokedynamic经动态调用点链接。调用会消耗相应接收者和参数,但有返回值时还会把结果交回调用者,原表统一写成空栈并不完整。 详见方法调用家族与返回值。

monitorenter和monitorexit以对象引用为监视器目标,分别进入和退出保护。它们关联到前章的互斥与可见性协议,不是给对象递归加锁。分析编译后的同步块时还要看异常退出的释放路径;只看到一次monitorenter,不能判断所有失败分支都已安全释放。同步方法的表示与显式代码块也可能不同。 详见监视器指令对应对象锁。

Java7示例把字符串+展开为构造StringBuilder、append后toString,再调用println。它说明源码表达式可引入额外对象和调用,字符串本身并未原地改变。读字节码可检查这个具体产物的实现方式,但不能把示例推广为所有编译器版本、所有拼接表达式永久使用同一序列,最终成本还受运行时优化影响。 详见字符串拼接的编译展开。

原书依据 · 9 处

5.5 Invokedynamic

invokedynamic延迟的是调用点链接策略:常量池描述名称与类型,BootstrapMethods提供引导入口和静态输入,引导结果CallSite持有实际目标句柄。调用者参数与引导参数不同,目标可变也不意味着签名任意变化。ASM示例说明框架可以直接生成平台调用,不要求Java7源码语法逐项支持。

invokedynamic把调用点链接的选择交给运行时引导逻辑。链接时由引导入口产生CallSite,之后调用交给它当前的目标MethodHandle;这不是每次都重新按普通反射寻找方法。原文关于javac不直接生成该指令的说明仅针对Java7,不能套用到后来的编译器和语言特性。 详见动态调用先链接再执行。

CONSTANT_InvokeDynamic的一部分索引指向BootstrapMethods属性中的表项,另一部分指向常量池NameAndType。引导表项再引用方法句柄及静态参数,名称与描述符则规定调用点身份和类型。它不是直接把第一个索引当成普通Methodref;引导入口也是通过句柄表达,不能忽略这层间接关系。 详见动态索引跨两张元数据表。

CallSite持有目标MethodHandle,链接后的invokedynamic委托给这个目标。一些调用点允许更换目标,但新旧目标必须具有兼容的同一调用点类型;改变目标不等于任意改写调用签名。不同调用点实现的可变性和跨线程可见性规则有区别,不能只凭“可以重连”就忽略并发协议。 详见调用点可换目标但保留类型。

示例调用点的描述符是()Ljava/math/BigDecimal;,说明每次动态调用没有参数并返回BigDecimal;常量池中的数字文本却作为引导的静态参数参与链接。两者属于不同阶段,不能把引导输入误算到运行时调用参数列表中。Lookup、名称和MethodType也属于引导上下文,不等于被调用业务方法的普通参数。 详见引导静态输入不同于调用参数。

ASM可构造包含invokedynamic指令的类,并输出类文件字节供保存或加载,使Java7框架能利用javac当时不直接产生的指令。它提供操作类文件的能力,不替生成者保证类型、栈状态或引导元数据正确。原文展示的是生成与反汇编思路,笔记没有实际运行ASM或把教材输出冒充本机验证结果。 详见字节码库生成平台调用。

原书依据 · 5 处

5.6 小结

本章沿类型进入VM、类型化间接调用、类文件元数据和栈式指令建立平台视角。源码中的创建、调用、循环与拼接,经编译后由具体类文件和指令表达;运行时链接和JIT又会进一步处理。理解这些层次有助于排查部署或框架问题,也为下一章的性能测量与优化建立对象和成本模型。

第6章 理解性能调优

性能分析先用测量回答真正瓶颈在哪里,而不是预设Java代码需要微调。端到端系统还包括数据库、网络与文件系统,指标必须与客户感受和容量问题相连。本章以垃圾收集和JIT作为两个主要运行时子系统,随后讨论测量条件与优化取舍。

端到端性能还可能受数据库、文件系统或网络制约。应先用测量定位瓶颈,再决定是否修改Java代码;不能因自己负责Java就把全部延迟归因于方法实现。 已并入性能优化先测量。

原书依据 · 2 处

6.1 性能术语

性能词汇从不同角度描述系统:延迟是单项耗时,吞吐是单位时间完成量,利用率看资源使用,效率把产出和成本联系,容量附带服务质量约束。增加资源与增加负载是不同实验,扩展曲线和退化曲线可能各自出现非线性的性能肘。

延迟描述给定负载下一个工作单元完成所需时间,吞吐描述给定资源和时间内完成多少工作。二者不可互换:任务完成得多,不代表每个请求等待更短。比较时要明确负载、参考环境及测量区间,并观察负载变化的曲线,而不是用一个脱离条件的平均数字代表系统性能。 详见延迟与吞吐描述不同结果。

利用率是某种资源用于所关注工作的比例,不能只说“服务器利用率”而省略CPU、内存或其他资源及统计口径。不同资源可能同时呈现不同水平,低CPU利用率也不证明系统没有其他瓶颈。原文区分业务工作、清理与空闲,是要求先定义正在统计什么,而不是假定所有监控工具口径相同。 详见利用率需要指定资源。

效率将吞吐与所用资源结合:同等产出用更多服务器或更高成本,效率较低。成本还可按运维人员或其他可比较资源衡量。比较必须保持产出口径和资源单位一致,不能把不同性能目标下的服务器数量直接相除。提高单机速度和降低总体成本可能需要不同决策。 详见效率把产出与成本联系。

容量关心在给定延迟或吞吐要求下,系统能够同时承载多少工作单元。它不是仅由内存大小或进程最大连接数定义的常量。报告容量时需要同时说明负载形态及可接受的服务质量,否则“能容纳更多请求”可能只是让请求排队更久,而不是以相同质量完成处理。 详见容量依赖服务质量约束。

扩展性观察增加资源后性能怎样变化;负载退化观察资源不变而工作量增加时怎样变化。两种实验的自变量不同,不能用其中一条曲线替代另一条。性能可能在某阈值突然非线性变化,形成性能肘;动态运行时也可能触发优化使局部指标改善,因此应测量实际曲线,而不是预设永远线性。 详见扩资源与加负载分开测量。

原书依据 · 5 处

6.2 务实的性能分析法

有效分析先定义可观测项及负载、运行阶段和统计口径,再选择测量办法。手工计时与加载插桩是原文重点介绍的两条路线,不是所有性能观测方法的穷尽清单。JVMTI则是工具与虚拟机交互的接口层,不能把它与一种具体统计方法等同。

性能目标先落到可观测项,例如启动完成后某方法的平均耗时、10个并发客户端下的P90延迟,或并发数从1到1000时的响应退化。方法名、负载、统计口径和运行阶段共同定义问题;只说“更快”无法指导验证。测量结果和结论应始终指向同一口径,避免优化后更换指标来宣称成功。 详见可观测项要带上条件。

JVMTI为监控、分析和调试工具提供对虚拟机状态的查询、事件通知及控制能力,原生agent可在目标进程中与VM交互。原文把它的结果概括为本质上的统计平均值过于狭窄;接口能力与某个分析器采用采样还是精确事件统计是不同层次。它也不是普通业务代码必须自行实现的计时方式。 详见原生工具接口的观测能力。

原书依据 · 2 处

直接测量

直接在代码前后取时间,能快速得到一个耗时观测,但会改变被测路径。时间单位、时钟粒度、记录开销以及冷启动状态都影响解释,不能把打印的毫秒差视为无误差的运行时长。

在方法前后取时间并求差易于实现,却会把计时与记录开销引入被测路径。currentTimeMillis的单位是毫秒,不保证每次变化都精确到1毫秒,也不适合把小于时钟粒度的差值视为精确耗时。冷启动和热执行还可能不同,应先明确测量阶段,再评价这些数字能回答的问题。 详见直接计时存在测量边界。

原书依据 · 1 处

通过类加载自动测量

加载插桩把测量逻辑集中到工具层,得到数据后还需确定可验收目标、停止边界和成本预算。优化以重要路径和总体收益为依据,避免无测量的大改造,同时保持消除无用工作等良好设计。日志守卫展示了一个具体例子,收益仍需放回实际负载验证。

在类加载时给方法进入和退出位置加入测量字节码,可把各处手工计时代码集中到工具层,并把记录交给其他线程或外部服务处理。这样降低源码侵入,却仍有观测扰动和数据处理成本。原文要求去掉解释阶段,只适用于明确研究稳态的目标;若目标是冷启动,排除该阶段反而改变了被测问题。 详见加载插桩集中记录耗时。

目标应说明负载与指标,并给出希望的变化,如10并发用户下端到端P90下降20%。多个指标可能互相牵制,应明确优先级并检查整体效果,而不是只找一个最容易改善的局部数字。初步探索可用来识别重要方法,但探索之后应重新确认目标,再进行有意的优化。 详见把性能目标写成可验收变化。

优化停止点应来自明确目标、收益和机会成本,不能因还可以继续改善就无止境投入。优先处理重要路径,改动后重新测量其对整体指标的影响。原文“达到目标90%通常足够”是经验性取舍,不是可以自行降低硬性服务约束或验收标准的授权。低频路径的收益也须按实际调用量评价。 详见停止优化依据目标价值。

性能改动会消耗开发时间,增加代码复杂度,或引入辅助线程和新的高负载行为。实施前应给这些成本设置可接受边界,才能判断性能收益是否值得。预算不仅是机器资源;维护难度与调优时间也是代价。增加并发资源让主路径更快,仍可能让全系统在压力下出现新的成本。 详见优化也有复杂度预算。

反对过早优化,是反对未经测量就在不重要位置投入大量复杂改造,不是为糟糕设计或明显浪费辩护。良好编码风格仍应避免不需要的对象和无用工作。具体技巧是否有效依赖JVM和负载上下文,不能因过去曾有收益就永远沿用,也不能用一句口号拒绝对关键路径的分析。 详见避免过早优化不等于忽视设计。

调试日志关闭时,先判断isDebugEnabled再构造字符串,可避免为了最终不会输出的消息调用计时方法和拼接文本。它保留了有需要时再记录的能力。若日志没有用途,则应评估移除整个路径;但原文省两个处理器周期只是简化说法,真实收益取决于日志API、JVM与调用频率,应通过测量确定。 详见日志守卫避免无用消息构造。

原书依据 · 6 处

6.3 哪里出错了?我们担心的原因

硬件改进并不等价于单段代码变快。晶体管预算可用于缓存、执行机制或核心,数据所在层次及其访问模式决定了实际等待。JVM再以调度、收集与编译改变运行状态,所以性能分析需要同时认识硬件约束和受控运行时。

摩尔定律讨论的是晶体管数量及经济可行性的历史趋势,不直接承诺时钟频率或某段软件的运行速度按相同比例提高。更多晶体管可用于缓存、复杂执行机制或更多核心,各自对不同负载影响不同。原书预测到2015年前的说法属于出版背景,不能当作对当前硬件趋势的重新验证。 详见晶体管增长不等于软件变快。

寄存器、处理器缓存、主存和外部存储在访问延迟、容量与成本上处于不同层次。缓存用少量较快存储减少等待主存的机会,不能把全部容量都无代价地换成同样快的存储。原书给出的纳秒和毫秒数只作历史示例,不是当前机器的固定常数;处理器等待数据也不必然靠执行NOP实现。 详见内存层次用成本换延迟。

当性能改进更多来自多个核心时,软件需要可并行的工作才能利用它们;仅有更多晶体管或更高标称频率,不保证单个串行任务更快。数据等待与任务之间的重叠也影响总体收益。多核把并发设计和性能更紧密地联系起来,但仍不能跳过共享状态正确性和实际测量。 详见多核收益需要并行工作。

JVM接管调度协作、垃圾收集和即时编译等细节,提高开发便利性,却使相同源码的执行成本随运行阶段变化。这些子系统也会互相影响,单次运行的编译与暂停情况可能不同。分析时要记录环境和阶段,而不是把某次测量当成脱离运行时状态的固定方法成本,也不把受控系统一概断言为无法有效调优。 详见受控运行时让成本随执行变化。

原书依据 · 4 处

6.4 一个来自于硬件的时间问题

机器可使用不同硬件时间源,操作系统和JVM的API不承诺把某一种来源原样暴露出来。日期时间用于对齐日历意义,间隔计时用于经过时长。原书的Linux/Solaris/TSC对比是特定旧环境观测,不改变Java7的nanoTime契约。

原书以RTC、可编程计时芯片、TSC和HPET说明硬件可提供不同时间来源:维持日期时间、产生计时事件或提供计数。操作系统和JVM再把平台能力映射到API。具体频率、计数器同步及节能影响依实现而定,不能仅凭一个API名称推断底层一定是哪块硬件;书中旧平台数字未作为当前配置事实沿用。 详见硬件时间源不止一种。

currentTimeMillis用于毫秒表示的当前时间,nanoTime的起点任意,主要用两次调用之差测经过时长。纳秒单位不保证纳秒分辨率,单机起点也不等于跨机可比时间。原书从旧TSC平台推导nanoTime仅短期可信、长间隔应改用墙钟,不能当Java API通则;应依据API契约与实际平台误差解释结果。 详见日期时间与间隔计时分工。

原书依据 · 2 处

精确度

在给定重复条件下,读数彼此集中说明较好的精密性,但不能单凭这一点判断是否接近参考值,也不能自动生成95%置信区间。条件与统计量是解释测量结果的一部分。

精密性关心在指定重复条件下,测量结果彼此有多接近。多次结果很集中,仍可能整体偏离参考值;报告这种稳定性应说明测量条件和采用的离散程度指标。原文把精密性直接等同于95%置信区间宽度过于简化,不能从“读数看起来稳定”推出准确度或统一覆盖概率。 详见重复稳定不等于没有误差。

原书依据 · 1 处

准确度

准确度关注读数与参考值的关系,偏差和随机变化都会影响结果。单个准确度数字不足以推出特定概率范围,必须先明确它代表的误差模型和评估方式。

准确度关注测量与真实或参考值的接近程度,系统偏差与随机变动应分别考虑。仅说计时器准确到1微秒,并不能直接推出某个读数的95%区间:还需知道误差定义、分布、样本和区间构造。原文以5945纳秒推出3945—7945纳秒的例子缺少这些前提,不应把看似精细的数字当成已经量化的不确定度。 详见准确度与区间需要误差依据。

原书依据 · 1 处

粒度

可辨粒度约束应用能区分的最小时间变化。硬件计数频率、API返回单位和应用实际分辨率不是同一件事,不能把带有很多位数的读数自动当作更精确的观测。

计时器最小可观察的变化决定了能区分多短的时间间隔,打印出更多小数或换成纳秒单位并不会自动改善它。硬件计数经操作系统、JVM和类库暴露后,应用实际能观测到的分辨能力可能不同。不能用最底层计数器频率直接证明应用计时有同样的准确度或粒度。 详见显示单位与可辨粒度不同。

原书依据 · 1 处

分布式网络计时

跨机器计时先面对时钟对齐误差,单机实验则要核对工作量、数据布局和运行阶段。CacheTester通过步长与顺序访问比较显示局部性可能影响耗时,但数组尺寸、缓存行假设和计时观测都须准确描述,不能从一次耗时比值就断定全部硬件原因。

不同机器的时钟即使经过同步,也存在误差与变化,跨机工作流的时间差不能像同一时钟两次读数那样直接解释。NTP改善时间对齐,不是任意精度的保证。诊断应先说明误差是否足以影响事件先后或耗时判断;原书没有展开完整协议,不能据此补造一个无误差的分布式计时方案。 详见跨机器时序须带同步误差。

若以64字节缓存行为例,16个4字节int占同一行附近的连续空间。顺序访问相邻元素可复用已取得的数据,因而做16倍的元素更新,不必付出16倍的内存访问代价。64字节是例子条件,不是所有硬件常数;局部性只提供性能解释线索,不能单凭耗时比例定位到某一级缓存。 详见缓存按行搬运带来摊销。

CacheTester比较每16个元素更新一次与更新每个元素的循环,并先预热再计时。数组长度是1,048,576个int,元素载荷约4MiB,原文称1MB不准确;int宽度也不取决于JVM是32位还是64位。教材耗时仅是原环境观测,既未在此重跑,也不能据其整千纳秒输出证明所有Mac使用同一底层时钟或整个JVM完全没有GC。 详见步长实验先核对实际工作量。

原书依据 · 3 处

6.5 垃圾收集

垃圾收集按可达性判断哪些空间可重用,分代则利用许多对象短命的经验来安排工作。理解这些机制后,才能结合堆摘要、直方图、离线快照和时间曲线定位实际占用,而不是看到大堆或一次暂停就改参数。CMS与G1分别展示并发和区域化的取舍,二者都不是无成本或无限制的暂停承诺。

局部变量可保存基本值或对象引用;引用不是对象本身,对象的基本类型字段仍属于对象的存储。栈帧与堆的区分解释了方法返回和对象仍可存活为何不矛盾。这是运行时的概念模型,不承诺每个源码局部变量都以独立栈槽保留,也不排除优化消除对象分配。 详见局部引用与对象分开看。

标记清除从根引用出发追踪对象之间的引用,标记可达对象,再回收未标记对象。根不只包括局部变量,还涉及静态字段及运行时持有的引用。是否将来还会被业务使用不是收集器的直接判据;仍可达的无用缓存仍会占内存,循环引用本身也不妨碍可达性追踪回收。 详见标记清除按可达性回收。

引用计数记录对象被引用的数量,在数量归零时回收。代价是引用变化时维护计数,单纯计数还无法自行回收彼此引用、却与外部断开的环。它也是自动内存回收技术,不能把原文“不需做垃圾收集”理解成无需回收机制;是否辅以环检测取决于具体语言实现。 详见引用计数的循环难题。

许多对象很快失去用途,另一些对象则长期存活。分代收集利用这个经验,将频繁处理的年轻对象和较少处理的老对象分开,以减少每次收集成本。它是负载相关的经验假设,不是每个对象的寿命保证;Eden、Survivor和老年代的布局及晋升方式也取决于收集器。 详见分代利用对象寿命差异。

经典分代模型的年轻代包括Eden和两个轮换使用的Survivor空间。收集时,将仍存活的年轻对象复制到另一幸存区,或按年龄、空间压力等条件晋升老年代,之后重用腾空空间。Survivor是活对象的中转区,不能把“活着”简单等同于立即晋升。此模型不要求所有收集器有连续的同样布局。 详见幸存区复制与对象晋升。

老对象可能引用年轻对象,因此年轻代收集不能只从年轻对象内部找引用,否则会误回收仍活着的对象。实现可用写屏障与记忆集记录跨代引用,避免每次完整扫描所有老对象。原书强调不能漏标的正确性要求,但由此推出每次年轻代收集必须遍历整个活对象图过强。 详见年轻代收集须看跨代引用。

回收对象可产生分散的空洞;压缩通过移动存活对象整合空闲空间,以便满足连续分配需求。老年代收集是否以及何时压缩由收集器决定,不能把Full GC一概等同于相同的移动算法,也不能把晋升空间不足当作Full GC的唯一触发条件。 详见压缩为连续空间搬移对象。

安全点让JVM能在掌握线程和引用状态的位置协调某些运行时操作。传统HotSpot的部分GC阶段需要这种协调,其他运行时操作也可能引发暂停。因此总停顿时间不等于GC时间;安全点也不是程序员任意指定的源码行,线程到达或处于安全状态所需时间同样值得观察。 详见安全点暂停不限于GC。

在书中JDK7工具语境下,jmap -heap展示收集算法、堆配置和分代使用量,jmap -histo按类型统计实例数与字节数;不带选项则主要列共享对象映射。前者回答空间如何分配,后者帮助找占用最多的类型,二者都不能直接证明对象由谁长期持有。命令可用性须依实际JDK确认。 详见堆摘要与对象直方图区别。

对象直方图给出实例数和总字节数,二者相除可估该类型单个实例的浅占用。书中账号缓存约2520个实例占10.5MB,提示客户增长可能放大内存压力,值得进一步检查字段和缓存策略;这不是已经算清全部可达对象保留大小,也不能仅凭一个大类就宣布内存泄漏。 详见直方图先估每实例成本。

jmap -histo:live只统计活对象,与包含尚未回收垃圾的直方图口径不同。两次结果差异也受采样时刻、应用运行及收集影响,不可仅凭字符数组字节数下降断言相同比例的String实例已死亡。采集可能扰动进程,比较时应记录选项和时刻,而不是把两份输出当同一状态的精确差分。 详见活对象视图会改变观察。

书中命令jmap -dump:live,format=b,file=heap.hprof PID将活对象堆导出成HPROF文件,便于离线分析对象及引用关系。它与线程栈文本、进程core dump并非同一种资料。保存快照不会自动得到泄漏结论,仍需结合持有关系和负载判断;此处只解释工具操作,没有实际对本机进程采集。 详见堆导出支持离线分析。

标准选项之外,-X和-XX参数通常带有实现及版本限制;布尔XX选项以+启用、-禁用,数值选项用等号赋值。不能从书中一个默认值推断所有机器和版本,也不能把CompileThreshold解释成任何配置下第1000次调用必立刻产生机器码。改参数前先确认实际VM及其支持项。 详见JVM参数带有实现边界。

-Xms设置初始堆、-Xmx设置最大堆,旧式分代配置的-Xmn控制年轻代大小。将初始和最大堆设相同可减少运行时扩缩容,但会改变资源占用,不能当作无条件最优设置。书中2MB/64MB默认值只属旧环境;PermGen也不应简单加进-Xmx的Java对象堆容量。传统配置的NewRatio为老年代/年轻代,SurvivorRatio为Eden/单个Survivor;例如8对应理想8:1:1,而不是Eden除以两个Survivor之和。 详见堆容量配置有成本权衡。

在支持该HotSpot参数的版本中,-XX:+DisableExplicitGC启用“忽略显式GC请求”,减号则禁用这项限制。原表用-XX:-DisableExplicitGC表示让System.gc无效,方向写反。该参数并不禁止JVM按需收集,也不把System.gc变成原本保证完成一次收集的调用。 详见禁止显式GC的符号。

旧式GC日志中,PSYoungGen后的前后占用及括号容量描述年轻代,后面的另一组前后占用及容量描述整堆,同一行不意味着发生了两次收集或一次Full GC。末尾秒数是这次事件的时间信息,开头相对时间也不等于日期戳。读日志先认版本、事件和字段,再比较回收量与暂停。 详见GC日志区分区域与全堆。

书中旧HotSpot可用-verbose:gc开启事件信息,PrintGCDetails增加细节,PrintGCDateStamps增加日期戳。PrintGCApplicationConcurrentTime描述应用在线程暂停之间的运行时间,不是并发GC耗时;PrintGCApplicationStoppedTime反映运行时停顿,不能直接全部归因于GC。应把事件日志和总暂停联合解释。 详见GC日志选项须按语义读。

堆占用随分配上升、收集后下降,可形成锯齿。观察回落后的基线比只看瞬时峰值更能发现持续保留;基线上升仍可能是合理缓存或长寿对象积累,须结合工作量及老年代收集后变化判断。稳定的Java堆曲线也不能证明整个进程绝无其他内存问题。 详见内存锯齿看回落后基线。

VisualVM将运行参数、CPU、堆、线程和类等信息放在同一进程视图中,Visual GC等插件可进一步展示空间及收集行为。对照配置与时间曲线能帮助解释锯齿,而不是只盯一张截图。书中是旧JDK附带工具界面,插件和远程能力依版本配置变化,不能把当时的“全部安装”当作现行必要步骤。 详见VisualVM连接观测与配置。

逸出分析判断对象的引用是否超出方法或线程等范围,为分配消除和锁消除提供依据。对可标量替换的对象,编译器可把状态拆开并消去对象分配;这不等于一定在栈上分配完整对象。Oracle的Java7说明明确HotSpot服务器编译器不以栈分配替代这类堆分配,原书图6-9只是过度简化。 详见逸出分析支持消除分配。

CMS在初始标记和重新标记等阶段暂停应用,其余很多工作与应用并发执行,用额外CPU和记账成本换较短暂停。已被处理后又变成垃圾的对象可能留到以后收集,称为浮动垃圾;绝不能因此漏掉仍存活的对象。ParNew是并行而非与应用并发的年轻代收集,书中CMS增量参数也不是普遍必选项。 详见CMS以并发工作换暂停。

G1把堆划为等大小区域,再把这些区域组织为Eden、Survivor和老年代等逻辑集合,角色可随运行变化。通过追踪区域存活量和搬移对象选择收集工作,获得较灵活的回收及压缩安排。区域化不等于取消分代,原书“不区分年轻区和年老区”应纠正;图6-10只能说明区域划分。 详见G1用区域组织分代。

G1的MaxGCPauseMillis表达希望达到的暂停目标,收集器结合工作量选择区域,不能保证每次都在上限内完成。把目标压得很低也可能增加收集开销、影响吞吐;回收能力仍受活对象、分配压力和资源约束。书中固定50ms和200ms组合是旧参数示例,不应原样当作所有服务的承诺或配置方案。 详见暂停目标不是时间保证。

原书依据 · 23 处

6.6 HotSpot的JIT编译

即时编译利用运行时观察把热点转为机器码,内联和单态调用优化将这种观察转为更直接的执行路径。推测必须保留正确性保障;冷启动、分层编译和重新编译也会影响性能测量。编译日志揭示实际发生的事件,不能只从源码猜热点。

HotSpot根据调用、循环等运行信息识别热点,将适合的字节码编译为机器码;解释、编译和重新编译因此可能交错。固定10000次或100倍只是书中的旧配置与示意数字,不是Java契约;编译异步排队也使达到阈值不等于立刻完成。评估时需分清冷启动与稳态。 详见热点编译依赖运行信息。

动态编译可利用运行时类型和分支等信息,围绕真实热点优化;以class文件部署也减少每个平台预制机器码的负担。代价包括运行期间编译成本和预热。不能由此断言AOT永远无法利用剖析或目标硬件信息,更不能推导JIT对每个程序都一定更快。 详见动态编译利用实际负载。

书中C1客户端编译器与C2服务器编译器体现了编译速度、启动表现和优化深度的不同取舍,不是GUI与服务的绝对边界。Java7已有分层编译,可用C1先生成并收集信息,再交C2优化。所需模式及-client/-server可用性取决于实际构建,不能据书中分类保证所有平台都有两者。 详见编译器取舍涉及启动成本。

实时系统关注能否在规定期限内完成,而平均耗时最小并不能保证最坏情形或尾部满足期限。为了更可预测的时间表现,可以接受某些平均性能代价。书中均值与方差的示意图表达这种取舍,但低方差本身不证明硬实时保证,也不说明所有普通服务都愿牺牲尾延迟。 详见实时目标关注可预测性。

内联将被调用方法的实现融入调用者的编译代码,减少调用成本,并暴露进一步优化机会;编译器会权衡热点、代码大小和代码缓存等因素。私有字段的合法访问器也可被内联,保持语言语义不等于必须保留机器级调用。不能为猜测调用开销就先破坏封装,也不能保证所有小方法都内联。 详见内联展开更多优化机会。

若某调用点长期只遇到一种接收者类型,编译器可按这项观察优化虚调用,例如使用直接调用或内联,并通过守卫确保假设仍成立。遇到不同类型时要走合法回退或逆优化,不能执行错误的目标。单态描述调用点的实际接收者分布,不是源代码变量一定声明为具体类。 详见单态调用可带守卫优化。

旧HotSpot用-XX:+PrintCompilation输出编译事件,书中写成Print Compilation的空格不应带入命令。日志可定位被编译方法、字节码大小及标志:s指同步方法,!指含异常处理,%指OSR编译。OSR允许在运行中的长循环等位置切入编译代码;日志格式依版本变化,编译序号也不是业务调用次数。 详见编译日志定位实际热点。

原书依据 · 7 处

小心僵尸

编译代码的失效有生命周期:先禁止新进入,再在无活动执行等条件满足后成为可回收代码。日志中的僵尸是机器码状态,不能解释成Java方法或业务对象死亡。

旧HotSpot日志的made not entrant表示该份编译代码不再接纳新的普通进入,made zombie表示它已无活动执行、可进入回收阶段。它们描述机器码版本的生命周期,不是Java方法被永久删除,也不能仅凭日志词语断定一定由类加载引起;替换编译版本等同样可能改变状态。 详见失效代码分阶段退出。

原书依据 · 1 处

逆优化

逆优化在优化假设失效时恢复正确执行状态,并允许后续采用其他优化。编译产物依赖VM版本、平台及负载,所以不同运行的代码尺寸或编译集合不必相同。

编译器可依据运行观察做带条件的优化;假设失效时,JVM恢复适合继续执行的状态,回到解释或其他有效代码,之后还可重新编译。因此同一方法可能多次优化与撤销。逆优化不是把Java业务结果倒退,也不是JVM已经执行了错误语义;它是维持正确性并适应负载的运行时机制。 详见逆优化保住推测正确性。

原书依据 · 1 处

6.7 小结

性能调优的主线是测量、定位、设目标并解释运行环境;GC和JIT尤其会改变执行阶段与成本。日志与工具帮助把猜测变成可检验的问题。本项重申本章已有方法,不再新增同义卡;下一部分把这些JVM机制与多语言选择联系起来。

第三部分 JVM上的多语言编程

第三部分以同一个JVM上的多种语言展示不同计算范式。学习不只服务于替换Java,也能帮助理解现有集合处理和状态模型;后续依次借Groovy、Scala和Clojure展开。

在同一JVM上学习其他语言,不只是增加语法选项,也能用不同的状态与计算模型重新审视已有Java代码。例如从集合整体变换看循环,会更容易发现映射与过滤这样的通用操作。收益在于扩充思考方法,不等于要立刻改写项目;书中对语言未来地位的预测也不当作现时事实。 详见新范式帮助重看旧问题。

原书依据 · 1 处

第7章 备选JVM语言

本章从Java7表达集合处理的繁琐出发,讨论其他JVM语言及其采用条件。重点不是选一个永久赢家,而是识别任务、团队、工具与运行时之间的关系。

7.1 Java 太笨?纯粹诽谤

交易对账同时涉及两边存在性、身份等价和取消状态口径。书中循环展示了问题,函数值、映射与过滤则把遍历和具体规则拆开;代码简洁不能代替对账正确性,尤其要防止大小写seen检查和去重掩盖异常。

收单系统与派发数据库之间,既可能上游有订单而下游未收到,也可能因误在生产环境创建测试订单而出现下游有、上游无。只验证上游每条都能找到下游,会漏掉后一类异常。集合对账能暴露存在性差异,不能仅凭ID集合相同就断言笔数、状态、金额和账务都一致。关联方案见[[双向集合找缺失记录]]。 详见对账须查两个方向。

先逐个检查上游main_ref是否在数据库ID集合中,命中时加入seen,缺失时记录上游单边;再遍历数据库ID,找不在seen中的下游单边。这样补上[[对账须查两个方向]]中的反向盲点。书中假定引用非空;身份匹配规则必须全程一致,且集合会丢失重复次数,不能据此验收金额或重复交易。 详见双向集合找缺失记录。

当上游把大小写不同的交易引用视为同一身份,下游却按大小写区分时,相同业务记录会被字符串精确匹配判成缺失。异常来自系统之间身份等价规则不一致,而不必然是消息真的丢失。书中编号还存在字符不一致,不能把那组字面编号当可复现实例。方案与缺口见[[匹配回调仍须统一口径]]。 详见身份大小写造成假差异。

书中将contains替换成逐项equalsIgnoreCase比较,或设想把matchFunction传给集合方法,使匹配可遵循不区分大小写的业务规则。这只处理了[[身份大小写造成假差异]]的一个方向:seen若存上游原串、反向仍用HashSet.contains,仍会误报。需要全程采用同一身份等价关系,这是从示例推导的修正要求;不能无条件把任意ID转小写或忽略真实冲突。 详见匹配回调仍须统一口径。

把函数当作值,意味着可以赋给变量、作为参数传入,再由通用操作调用。集合遍历可以保持不变,匹配规则则由调用者提供,不必为每种比较方式复制循环。书中contains(value,matchFunction)是表达设计意图的伪接口,不是Java7标准Set已有重载;面向对象也能用策略对象表达这种变化点。 详见函数值把变化行为传入。

map对输入集合的每个元素应用变换,形成结果集合;输入与输出元素类型可以不同。书中将DBInfo转为primary_key字符串,体现了“取值规则”和“遍历机制”分开。示例没有修改原列表,但不代表任意传入函数都天然纯净:若变换本身有副作用,map这个名字不会消除它。 详见映射逐项产生新值。

filter用返回布尔值的谓词判断每个元素是否保留,true表示满足保留条件,false表示排除。它和map的区别是筛选元素而非把每项转成另一种结果。书中谓词为状态不等于CANCELLED;若实际数据允许状态缺失,原来的msg.get(…).equalsIgnoreCase写法可能空指针,需明确输入契约。 详见谓词筛出满足条件的值。

书中取消订单不进入派发数据库,因此先过滤上游已取消消息,再进行两边存在性检查,避免把正常业务排除误报为缺失。过滤规则表达对账范围,必须来自真实业务契约;不能把这个示例推广为所有取消交易都无需核对,也不能把筛选后集合一致等同于原始全量一致。 详见对账前先明确业务口径。

创建新的List并把旧列表元素引用放进去,只隔离列表的增删结构,不复制元素本身。书中filterCancels因此不会改原列表的成员结构,但两个列表仍可能共享可变Map。把它称为防御性复制时必须说明深度,不能据“返回新List”推导元素也不可变或完全互不影响。 详见新容器未复制内部对象。

将主键列表转为HashSet,会按equals/hashCode去重,并在散列分布良好时让基本成员查询具有常数时间表现。收益不只是“少几个重复元素”,也来自索引结构;代价是丢失顺序和重复次数。因此只关心存在性可用Set,若要识别同一引用多次入库,先去重就会把证据抹去。 详见集合去重改变问题信息。

原书依据 · 10 处

7.2 语言生态学

语言分类包含互相独立的维度:编译与解释说明执行途径,静态与动态说明类型检查方式,命令式与函数式说明组织计算的风格。JVM移植还须维持源语言语义;任何单一标签都不足以判断项目适配性。

解释或编译、静态或动态类型、命令式或函数式,描述不同侧面,不能互相代替。语言和实现也会混合多种特征;看见简短语法不能断言动态类型,看见运行时编译也不能断言没有静态检查。分类适合形成待验证的问题,不宜作为给整门语言永久贴标签的精确边界。 详见语言分类是多个维度。

源码可先编译为字节码,再解释执行或由JIT编为机器码;一种语言也可有多种实现。产生class文件是书中研究JVM语言的一条分类线,不是编译与解释的全部定义。解释器也可以执行预处理后的中间形式,不能把解释一概写成逐行直接执行原始源码。 详见编译与解释可以组合。

静态类型系统在执行前依据表达式、绑定等类型约束检查程序,很多类型可由推断得到,无须逐个手写。动态类型则更多在运行中依据值的类型处理操作。同一绑定先指数字再指字符串是书中动态语言示例,但不是唯一判据;静态类型程序里的对象也仍具有运行时类型。 详见静态类型不同于显式标注。

命令式风格通过指令修改状态表达计算,函数式风格倾向于把输入映射为结果并减少可变状态。面向对象可以组织状态与行为,也能采用函数式操作;一等函数也不自动意味着无副作用。原书把Clojure称为纯函数式且完全无面向对象特性过强,官方说明它允许非纯计算并与JVM对象互操作。 详见状态变化与值变换视角。

JRuby、Jython、Rhino分别把Ruby、Python、JavaScript带到JVM;专为JVM设计的语言则可围绕其类型与运行能力取舍。移植需要维持原语言预期,而不仅是把语法转为class。书中各实现的发布状态及编译模式属当时背景,选择时不能仅凭同名语言就假定原平台全部包都兼容。 详见语言移植要保持原语义。

原书依据 · 5 处

7.3 JVM上的多语言编程

多语言金字塔按职责和变化速度区分稳定、动态与领域层。不同语言提供不同表达成本,复用稳定核心与成熟类库比为追新全面重写更容易保住已有成果。Groovy、Scala与Clojure是本书接下来的三个学习对象,不构成现时市场排名。

多语言金字塔把稳定核心、动态功能和特定领域表达分层:长期运行的核心重视稳定性与测试,较短寿的功能强调交付灵活性,DSL聚焦领域表达。它是关注点分离的思考模型,不是静态类型或某门语言只能待在固定层;层间边界应依据实际职责决定。 详见多语言按变化速度分工。

编译、部署和冗长表达可能拖慢短周期功能的反馈,这为局部尝试其他语言提供理由。评估应观察团队实际编辑到验证的时间,而不是沿用书中90秒到2分钟的历史数值。复用成熟Java类库与稳定核心可保住已有投入;改善局部开发体验本身不构成重写核心的充分理由。 详见换语言先算反馈成本。

Groovy与Java语法和JVM生态接近,书中将它作为脚本、原型和DSL构建的切入点,减少Java团队尝试另一种表达方式的距离。这里说明其在本书中的角色,不把“最有前途”排名或发布时的特性边界当作今天的选型结论;后续章节再展开语言机制。 详见Groovy侧重动态表达。

Scala同时提供面向对象与函数式编程能力,静态类型配合类型推断可减少显式类型书写。它说明语法简洁不等于动态类型,也说明函数式与对象模型可以组合。书中把它列为稳定层候选是用途判断,不是取代Java的既成事实;后续章节提供具体特性的依据。 详见Scala结合对象与函数。

Clojure采用Lisp家族的表达式风格,把函数和不可变数据放在重要位置,并提供JVM运行及并发相关能力。源码发布与编译执行并不矛盾;括号多也不是其计算模型的完整说明。书中动态层定位是示意,并不排除稳定核心用途;“纯函数式”则须按官方允许非纯计算的边界理解。 详见以Lisp形式表达计算。

原书依据 · 5 处

7.4 如何挑选称心的非Java语言

引入语言首先是一个风险与交付问题:从可退出的有限试点开始,验证互操作、工具链、学习和人才供给,再评估长期支持。支付核心与未验证的原生包兼容都说明仅有JVM共同平台远远不够。

面对已运行多年、测试不足且行为尚未完全掌握的支付核心,语言实验会放大回归与排障风险。书中建议先在测试支持或有限外围功能试点,获得学习收益并保留退出能力。所谓低风险应按实际权限、数据和故障影响评估,管理后台并非天然安全;有限试点不代表已授权替换生产核心。 详见新语言从可退出处试点。

共用JVM使既有Java对象与类库可被其他语言复用,但是否顺畅仍须验证双向调用、类型转换与部署依赖。书中用Groovy导入Java包、Java调用Groovy处理JSON并返回Java对象说明这种集成方向。运维人员应参与确认支持条件,不能把“能生成class”直接当作整个技术栈无缝兼容。 详见互操作要验证双向边界。

选语言不能只比较语法:IDE、构建、测试和发布工具决定团队能否稳定交付,跨语言组件还可能各有构建约定。原书对Scala IDE成熟度等评价带有出版时效,需按实际版本验证。一个语言内部好用的构建工具,也不必然适合组织所有其他语言的模块。 详见工具链影响语言实际成本。

团队已有经验决定新语言的学习距离;相近语法可能降低起步成本,而新的类型模型、函数式思维和Lisp表达方式还需要额外训练。不能只看语法长得像Java就推定掌握所有语义,也不宜把原书对某语言难度的评价当所有团队固定排名。试点应显露实际学习成本。 详见范式距离影响学习成本。

语言选择还会影响招募、交接和长期维护。团队成员会变化,不能假设项目始终由最早的专家维护;原语言人才可以成为JVM移植实现的学习来源,但仍需掌握平台差异。书中具体语言的人才多寡属于历史判断,应转成对当前团队可持续支持能力的问题。 详见人才与维护属于选型成本。

某个包在原生Ruby或Python实现通过测试,不代表在JRuby或Jython里连同底层依赖都可用。采用整套栈时,额外的兼容验证应进入成本估算,而不是等上线才发现原生扩展或实现依赖。源码语言相同与执行平台相同是两件事,后者仍影响可部署范围。 详见移植运行时要验包兼容。

原书依据 · 6 处

7.5 JVM对备选语言的支持

备选语言需要编译或解释路径及相应运行时,把高层语义映射到VM能力。内部类、函数对象和混入说明源级特性未必对应独立VM指令;分析class产物才能看到真正的类型和依赖边界。

JVM上的语言可通过生成字节码或解释器执行,并由附加运行时维持自身类型和动态行为。运行时常以JAR等依赖参与部署,所以应用不仅需要业务class文件。包体积只能粗略提示支持规模,还受捆绑类库影响;不能直接把JAR更大解释成同等比例的运行成本。 详见语言运行时补足语义。

编译器可把高层语言特性翻译为JVM已有结构,书中称之为“编译器小说”。理解这种映射有助于解释性能和部署产物,但并非看到一个高层关键字就能推断唯一实现。字符串拼接、检查型异常和内部类各有不同的语言与class文件支持,不应把它们一律理解为VM完全不知其存在。 详见高层特性不等于VM指令。

内部类可编译为单独的class文件,非静态内部类常需保存外部实例关联,编译器还可能合成辅助访问代码。书中MyClass与MyClass$Inner示意的是源码嵌套如何映射到多个产物;$只是命名线索,不证明每个含$的类都是内部类。具体辅助方法也随目标class版本变化。 详见内部类另有编译产物。

Java7可用Callable的匿名实现对象承载一个返回String的call方法,把对象赋给Callable变量后再调用,从而把行为当参数或值操作。匿名的是实现类,不是变量myFn的静态类型。源码匿名类数量与运行时实例数量也不同;不能由创建很多对象直接推断生成同样多的新类。 详见单方法对象承载行为值。

Java7的类不能同时继承多个类实现,但其他JVM语言可用编译器和运行时把trait等源级混入机制映射到VM支持的类与方法。接口在Java7中不提供普通具体实例方法,是本书当时的边界;不能把它推广到后来的Java版本,也不应把VM单类继承误读为所有源语言都不能提供混入。 详见混入实现须由编译器映射。

原书依据 · 5 处

7.6 小结

本章收束为按任务与团队选择语言:分类帮助提问,分层帮助划边界,低风险试点帮助获得证据。本项重述前面已有选型卡,不新增同义卡;下一章开始具体学习Groovy。

第8章 Groovy:Java的动态伴侣

Groovy以接近Java的语法提供动态语言能力、集合与文本处理支持,并复用JVM生态。它编译后仍可能依赖动态调用机制,减少源码样板与运行成本是不同维度。XML构建例子的具体机制放在8.4解释;这里承接上一章关于动态层的用途,而不沿用旧社区地址与流行度排名。

动态Groovy可在运行时选择方法并通过元对象协议支持动态行为,因此源码编译成class后仍可能保留运行时查找成本。原书把GroovyObject说成共同父类不准确,它是接口;也不能断言每个调用都必经invokeMethod或反射。实际路径随编译模式和版本变化,性能须结合负载测量,不能由语言标签直接判定。 详见动态调用有运行时成本。

原书依据 · 1 处

8.1 Groovy入门

本节区分编译器、脚本执行器和图形控制台三个入口。先用小脚本熟悉编辑、执行和输出的位置,再学习语法;工具启动和依赖配置仍属于实际环境的一部分,教材给出的输出不等于本次运行记录。

groovyc把Groovy源文件编译成class,groovy可执行脚本并在需要时编译;GroovyConsole提供编辑区与输出区,方便演练小片段。脚本运行仍需要匹配的Groovy运行时,不能只因已有JVM就省略依赖。书中Hello输出是教材预期,此处没有安装工具或在本机执行,旧菜单和快捷键也不作为跨版本保证。 详见Groovy编译执行入口。

原书依据 · 1 处

8.2 Groovy 101:语法和语义

Groovy的简洁来自脚本组织、默认导入、十进制默认表示与集合字面量等机制。动态变量与显式类型约束仍要放到具体编译模式下理解;脚本的局部变量和Binding又决定方法能看到哪些值。最后用列表、映射和切片把这些规则用于数据。

Groovy允许在显式类定义之外写脚本语句,工具将它们组织成脚本类并在JVM上执行。脚本描述的是源码组织与启动方式,不等于不经编译,也不保证跨平台完全无环境依赖。可以同时使用类和方法结构;书中groovyserv用于减少重复启动开销,是可选工具而非脚本语义的前提。 详见脚本也会编译成类。

Groovy默认导入部分Java与Groovy包以及BigDecimal、BigInteger等类,省去重复import;其他可见类仍可显式导入。import只控制名称解析,不把缺失JAR带到运行时。书中@Grab可声明抓取依赖,或通过classpath提供JAR。java.math包也不同于java.lang.Math这个工具类,不能照抄原文混称。 详见默认导入不等于已有依赖。

Groovy通常把无额外类型约束的小数字面量作为BigDecimal处理,因此3 + 0.2可直接表达十进制3.2。Java的new BigDecimal(0.2)则先接收已近似的double;使用字符串构造可避免这一步。显式double/float及强制转换仍会改变表示,不能据默认BigDecimal断言一切运算都无舍入或精度损失。 详见十进制字面量避免绕远。

Groovy可用def声明未显式指定类型的变量,也可写Date、double等类型约束。后者不自动等于整个方法采用静态类型检查或静态编译:书中把Date赋给double是在运行时报GroovyCastException。读取代码时应区分变量约束、运行时值类型和编译模式,不能把def等同于Java的固定类型推断。 详见类型声明与静态编译不同。

脚本顶层用类型或def声明的变量通常成为脚本run方法中的局部,脚本另行声明的方法不能直接读取它。未声明变量的赋值则可进入Binding,经脚本属性访问;书中hello例子因此表现不同。绑定域属于相应脚本及绑定对象,不是进程全局,也不能把任意漏写声明当成良好的共享状态设计。 详见脚本局部不等于绑定变量。

Groovy的[a,b]可创建列表,[]表示空列表,list[0]按下标访问,size()取元素数;普通列表字面量通常使用ArrayList。可存混合类型不代表后续操作不用检查元素能力。将变量重新赋值为[]只是让该变量指向新列表,不等于清空原列表及所有别名看到的同一实例。 详见列表字面量和元素访问。

Groovy可用[Java:100,Groovy:99]创建映射,[:]为空映射;map[“Java”]访问键值,常见字符串键还可用属性式map.Java访问。简单裸标识符键在这种字面量中表示字符串,不自动取同名变量的值。普通映射字面量通常为LinkedHashMap;重新赋[:]也不等于修改原实例。 详见映射字面量与字符串键。

Groovy列表可用list[0..2]取得从0到2的切片,示例包含右端点;list[-1]访问末项。它们减少手工循环,但区间是否包含边界要看具体操作符,负下标也不是任意负数都有效。切片得到的新容器仍不保证元素被深复制,不能由便捷语法推导更强隔离。 详见区间索引与负下标。

原书依据 · 8 处

8.3 与Java的差异——新手陷阱

与Java相像的语法也隐藏语义差异:省略返回与括号有条件,默认可见性须区分属性和字段,检查型异常不被强制处理但仍会发生,值相等也不同于对象身份。闭包适合承载行为,并不取消内部类支持。

Groovy常可省略行末分号、用最后表达式作为返回值,并在有参数且无歧义的调用中省略括号。这些规则能减少样板,但不是任意位置都可删标点;同一行多语句仍须明确分隔,返回意图不清时可保留return。语法精简服务于可读性,不能从Java外观猜省略后的控制流。 详见省略语法仍须避免歧义。

Groovy类和方法未显式声明可见性时通常为public,而类体中不带可见性修饰的属性声明可生成私有后备字段及访问器。显式private字段与公开属性不是一回事,因此不能把“默认public”机械套到所有变量上。GroovyBean的精简来自属性机制,也不等于取消封装。 详见默认公开须区分属性与字段。

Groovy代码调用可能抛检查型异常的方法时,不强制捕获或在签名声明,但运行时异常仍真实存在。显式throws可作为文档并进入字节码签名,影响Java调用方所见契约;原书“忽略所有throws”过强。不被编译器强制处理,不代表可以忽视文件、网络等失败路径。 详见检查型异常仍可能抛出。

Groovy的==用于逻辑值比较,不能按Java引用==理解;检查是否同一个对象可用is。比较还包含Groovy对数值或Comparable等的语义,不能一概简化为原样调用Java equals。两个不同Integer对象可能值相等而身份不同;与null比较仍可使用==,不用为了身份检查写出不安全的解引用。 详见值相等与对象身份分开。

原书依据 · 4 处

8.4 Java不具备的Groovy特性

属性与空值操作减少常见样板,GString、闭包和集合操作进一步把数据表达与行为组合起来。正则和XML支持则处理文本与树形交换结构。每种便利语法仍有结果类型与边界,例如Elvis依真值而不只看null,XML取出的年龄文本也不自动成为数值。

Groovy属性可省去手写获取与设置方法,使用obj.name时仍可通过访问器实现封装,命名参数也能支持按属性初始化。显式private字段不会因此自动成为标准属性,原书Character把字段全写private却宣称自动Bean行为,不能当通用模板;需要公开属性时应按属性定义或显式提供访问器。 详见属性语法保留访问器边界。

Groovy的@Immutable可通过编译期变换生成不可变对象的相关约束与方法,适合表达在并发之间传递的值。不可变减少共享修改的推理负担,但注解对字段类型和处理方式有版本约束,不能把任意可变对象图都视为已深度冻结。书中只给出用途,没有展开所有生成规则,不能补造完整线程安全保证。 详见不可变注解有支持边界。

person?.name在person为null时返回null,避免这一次属性访问的空指针;接收者非空时正常取属性。它不会自动跳过外层println,所以书中循环仍会输出null那一项,并非完全“什么也不做”。链中后续接收者可能为空时仍需相应保护,方法内部的异常也不会被这个操作符一并吞掉。 详见安全导航返回null。

Elvis操作符x ?: fallback在x按Groovy真值判为真时取x,否则取默认值,减少条件与分支中的重复表达式。false、数值零、空字符串或空集合等也可能进入默认分支,不只null。书中非空检查改写只在相应输入范围下等价;若空字符串有业务含义,就不能无条件替换。 详见默认值依据Groovy真值。

带插值的双引号字符串可生成GString,${…}把值放入文本;单引号不插值,无插值双引号也可为String,三引号支持跨行。GString不是String子类,String本身为final。把插值结果赋给String会发生转换,作映射键时尤其应统一类型,避免GString与String的散列或比较差异造成查找失败。 详见插值字符串有不同类型。

Groovy用{参数 -> 代码}定义可赋值、可传参和可调用的闭包;它还能访问所处词法环境中的变量。单参数闭包常可省略显式参数名而使用it,无参数闭包与隐含单参数并不相同。它适合为集合提供处理行为,但不是单纯用短语法删除所有内部类,仍须考虑捕获和副作用。 详见闭包把代码连同环境保留。

Groovy each把闭包应用到每项,常用于输出等副作用;collect把每次计算结果收集成新集合,对应映射。each中的println返回值不等于collect生成的结果。书中it表示当前元素,减少命名但未改变遍历发生这件事;应按所需输出选择操作,而非认为短语法自动并行或更快。 详见遍历与映射的返回不同。

Groovy inject将累计值和当前元素交给闭包,逐步构造最终结果,对应归约。它与collect逐项生成结果不同:累计值让前一步结果参与后一步。使用前应明确初值、闭包如何更新以及空集合的期望,不能只因都带闭包就认为它们可互换;原书未展开具体并行归约机制。 详见归约携带累计结果。

Groovy findAll保留满足闭包谓词的全部元素,max/min返回按相应比较规则得到的极值。前者输出候选子集,后者输出其中的一个极端值,不能把它们当成相同的遍历简写。具体空集合、null与比较器行为应按API契约处理,原书“集合方法自动处理null”不能推广为任意闭包都不会异常。 详见筛选与极值各有输出。

Groovy的~构造Pattern,=~产生Matcher用于查找,==~给出整串是否匹配的布尔结果。/1010/这种斜杠字面量本身是字符串,不是已经编译的Pattern;书中pattern变量名不能证明其类型。部分匹配应与整串匹配分开,不能看到文本含1010就推定input ==~ /1010/成立。 详见正则查找与整串匹配不同。

Groovy可遍历正则匹配,将完整匹配和捕获组交给闭包。书中对“Hazel 1”用(\w+)和(\d+)分别取名字与年龄文本,再插值输出。捕获到的数字仍是文本,不会因模式用\d就自动具备数值类型;若下游要做年龄计算,需要显式转换并处理范围。 详见正则分组进入闭包参数。

MarkupBuilder把调用形式映射为XML节点,命名参数可写属性,嵌套闭包表达子节点,输出交给Writer。书中person(id:2){ name …; age … }不需要先定义Person类,适合直接描述交换结构。它不同于把任意Java对象自动序列化,也不能由XML语法本身推出关于图灵完备性的简化结论。 详见构建器将树结构写出。

Groovy的XmlParser和XmlSlurper都提供便于按GPath访问的解析结果,但结果模型与更新观察方式不同;DOMCategory则为DOM操作提供Groovy便利语法。书中把Slurper简单称为懒加载不能理解成从不读取输入。选择时先看要读取、导航还是修改,不把三个工具名称当成同一API的别名。 详见XML解析先选结果模型。

XmlParser.parseText先把XML文本解析成节点,再用@id访问属性、name.text()等取子节点文本,最后显式构造Person。这个过程不是自动将XML绑定到Bean,age.text()也仍是字符串。书中Person属性用def,因而示例并未证明年龄已转换成整数;真实领域类型须在映射处明确。 详见节点文本须显式映射到值。

原书依据 · 14 处

8.5 Groovy与Java的合作

Groovy与Java集成先依赖可见类库,再按所需边界选择Shell求值、ClassLoader编译加载或ScriptEngine依赖重载。Binding传入名字与值,Object返回值则需要明确结果契约;原书部分断言和脚本返回示例不能当作已经执行正确的接口。

Groovy调用Java可导入classpath中已有包并使用Java对象,Java调用Groovy则也要提供对应Groovy运行时依赖。书中groovy-all-1.8.6.jar是当时打包方式,不是所有版本的固定清单。JSR223是javax.script标准脚本API,BSF是另一框架,不能照抄原文把二者当同义词。 详见跨语言调用先备齐依赖。

Binding提供名称到值的环境,GroovyShell用它求值脚本,evaluate返回脚本结果;适合嵌入表达式或脚本,不仅限一行。书中Java的2.4会先成为double,且new BigDecimal(10.4)也接收double,因此断言不是十进制精度证明。要表达十进制目标需控制输入类型,此处未声称原断言运行通过。 详见Shell通过绑定交换脚本值。

GroovyClassLoader.parseClass把Groovy文件编译加载成Class,调用方再创建实例并通过GroovyObject.invokeMethod调用方法。书中CalculateMax.getMax接收List并返回最大Integer,展示源文件到对象调用的桥接,而不是仅执行文本表达式。调用链包含编译、文件和实例化失败,示例打印异常不等于已完成可靠的业务错误处理。 详见类加载器编译后再调用。

GroovyScriptEngine从配置根目录或资源入口加载脚本,run接收脚本名和Binding;在类加载能力之上处理脚本依赖与重载,适合多脚本集成。重载不等于所有旧对象与状态被自动迁移,也不表示编辑生产脚本天然安全。书中“运行时修改”说明能力,不能当作无验证发布流程。 详见脚本引擎管理依赖与重载。

书中Hello.groovy只写def helloStatement = …,却在Java端对run结果断言为问候字符串;变量声明不能作为稳定的脚本返回契约。需要返回字符串时,应以该值作为脚本结果,并明确String与GString转换,这是对示例的修正要求而非已执行结果。宿主还须检查返回类型,避免把任意Object直接当业务成功。 详见脚本结果要显式形成契约。

原书依据 · 5 处

8.6 小结

本章用具体语法说明如何以Groovy补充Java:从集合与XML的简练表达,到宿主与脚本的调用边界。小结重述已生成卡片,未新增同义卡;下一章Scala将展示静态类型与函数式结合的另一种取舍,Groovy的Web用途留第13章展开。

第9章 Scala:简约而不简单

Scala结合静态类型、面向对象与函数式风格。本章先看其自身惯用法,再讨论项目适用性、语法、对象模型、集合与actor。导入的金融风险模拟只是用途示例,未给出可运行模拟模型;流行度和未来三四年预测仅是出版时的判断。本项不新增重复的Scala介绍卡。

9.1 走马观花Scala

本节用类定义与入口说明Scala如何用类型推断减少重复,再用match与case类把值的形状带入控制流,最后展示消息驱动的并发组织。简洁的语法仍受静态类型、值与引用的区别和运行时协议约束;旧scala.actors更不能直接等同于所有后来的actor框架。

Scala类名后的参数列表定义主构造器所需输入,方法可引用这些参数。书中CashFlow(amt:Double,curr:String)直接配amount()与currency(),省去重复声明和赋值样板。参数没有因此自动变成所有调用方可读的公开属性;Double也只是语法示例,不构成生产金额表示方案。代码行数减少不能直接证明书中每年节省维护费的估算。 详见主构造参数减少重复。

Scala可从初始化表达式推断局部值的类型,也可从方法体推断适用的返回类型;这减少重复信息,而非转为动态类型。书中def amount() = amt保留等号引入表达式体,调用方仍受静态类型约束。涉及递归或公共接口等场合可能需要或更适合显式类型,不能把所有类型标注当可删样板。 详见静态推断省去类型书写。

Scala val声明不能重新赋值的绑定,var允许改变绑定。val并不保证它指向的对象内部也不可修改,例如绑定到可变集合仍可改变集合内容。优先用val可减少需追踪的状态变化,但不能把它当作整个对象图深度不可变的证据;这一点与Java final引用的边界相通。 详见val固定绑定不冻结对象。

Scala的object声明单例对象,可承载main等方法,减少手写静态工具类样板。书中HelloWorld使用传统Scala2入口,main没有等号和返回类型属于旧过程语法,结果为Unit;不是靠函数体推断出任意结果。迁移Scala3应显式表达Unit,不能把旧语法当跨版本入口的唯一形式。 详见object提供单例入口。

Scala以Array[String]表达元素类型,以args(0)访问数组元素;前者是类型应用,后者是值上的调用语法。与Java的String[]及方括号下标不同。示例的args(0)还假定至少有一个参数,模式匹配默认分支不会替它消除越界风险;省略类型标注也不等于存在Java式泛型生类型。 详见方括号类型与圆括号访问。

Scala match依次按case模式选择分支,匹配后不贯穿到下一分支,并以该分支结果形成整个表达式的值;_可作兜底模式。若可能输入未被覆盖,运行时会有MatchError。穷尽已知有限输入时不必机械添加吞掉错误的默认分支;match是语言构造,也不是书中暗示的普通.match方法调用。 详见match返回首个匹配结果。

case s:String按类型匹配,并把匹配值绑定为分支中的s,随后可调用字符串方法;这将检测和局部命名放在同一处。书中storageSize让String返回length、Int返回4,只是分类语法示例,字符串length不是整个对象实际字节大小,因此不能据方法名当成内存测量工具。 详见类型模式同时绑定值。

Scala catch使用case来区分异常类型,分支可绑定异常对象。书中类加载示例把ClassNotFoundException等转为更贴近调用目的的IllegalArgumentException,并用initCause保留根因,便于诊断。它仍需要明确哪些异常应转换、哪些继续抛出;模式语法不会自动覆盖所有加载或实例化失败。 详见捕获异常按模式分支。

case class TemperatureAlarm(temp:Double)可生成构造、参数访问及值比较等支持,适合表达携带数据的消息。第一参数列表的参数默认可读且为val,也可显式引入可变性,所以不能把case class都当深度不可变。编译器提供apply等能力使构造时常可省new,简洁来自合成机制而不是没有构造过程。 详见case类生成值对象支撑。

case TemperatureAlarm(temp)按模式识别消息并把其中温度绑定到temp,处理逻辑不用先手工转型再取字段。case object Heartbeat则表达不携带参数的单例消息。两者把消息种类和载荷直接带入分支结构;构造器模式看似调用构造器,实际是提取匹配,不是在匹配时创建一个报警。 详见构造器模式拆开消息值。

Scala的==通常执行空值安全的值相等语义,case类可按组成值比较;要比较引用对象身份,应使用AnyRef的eq或其相反操作ne。原书写===并非Scala标准引用比较运算,库可另行定义同名语法,不能直接照搬。值相等也不意味着两个对象共享同一存储或后续修改一起发生。 详见Scala引用身份使用eq。

actor将状态与消息处理绑定在一个并发单元中,其他单元通过消息交互,减少直接共享可变状态。它仍运行在JVM内存模型之上,不自动阻止调用方泄露或直接读取内部字段。书中TemperatureMonitor把警报状态留在处理者内,适合说明组织方式,但不能仅凭extends Actor就证明外部轮询字段安全。 详见actor用消息组织并发。

旧scala.actors的receive从邮箱寻找其偏函数能够处理的消息,没有可匹配消息时会阻塞,未匹配消息可留在邮箱。添加case _能显式消费其他消息,但不等于不加就必抛异常;原书把普通match失败与选择性接收混同。兜底若只打印还可能掩盖协议错误,需按消息契约解释。 详见选择性接收不匹配会等待。

书中TemperatureMonitor实现旧Actor的act循环,Heartbeat分支不改变状态,TemperatureAlarm(temp)则设tripped并记录tripTemp。结构表达“消息决定状态变化”,不是直接让发送者改字段。示例没有启动、关闭、查询回复或告警复位协议,因此本卡只保留原有协作,不把它包装成完整监控系统。 详见温度消息改变监控状态。

原书依据 · 17 处

9.2 Scala能用在我的项目中吗

是否引入Scala要从实际组件和团队判断,而不是从语言特性推出必然收益。边界清晰的小试点、早期互操作验证、明确退出条件和学习预算,把采用决策转成可以观察的结果;它承接第7章的低风险原则并给出更具体的执行条件。

引入Scala的首个组件宜有清晰问题边界、可信需求、已知互操作要求、可估工作量和愿意学习的开发者。这样的边界让结果可评估,也降低语言学习与需求不确定性互相混淆的机会。测试支持区仍有迁移和维护成本,不能把书中“只浪费时间”当无其他代价的保证。 详见语言试点先明确组件边界。

新语言试点可先做短期探索验证,尽早连接既有Java组件,并依据需求约定成功与失败标准;失败时采用预先准备的替代方案。还应为首轮不熟悉语言产生的重构留出预算。书中“扣杀”对应spike式探索,不是先完成整个组件再凭主观喜好决定继续。 详见短试验要有退出条件。

业务与支持团队抵触、技术骨干不支持、开发者缺乏学习动力或截止日期无训练余量,都可能使新语言试点失败;跨地团队还需额外协调培训。它们提示组织承受能力,不是数到三个信号就有统计意义的否决公式。应解释具体影响,再决定时机,不能照搬原书“超过两个没戏”的经验阈值。 详见团队意愿是采用前提。

原书依据 · 3 处

9.3 让代码因Scala重新绽放

本节先建立编译与交互执行的工具入口,再区分静态推断、方法和局部辅助函数。导入管理名称,循环管理遍历与副作用,带yield的推导和函数值则把结果计算提升成可组合表达;闭包工厂展示行为值还能保留环境。

书中scalac HelloWorld.scala产生class,scala HelloWorld带Scala运行时启动入口;无参数scala进入REPL,可输入表达式并复用会话中的绑定。交互执行不取消静态类型检查,也不能把已有会话状态隐含到正式程序依赖中。具体命令和类库打包随版本变化,这里说明旧Scala2工具分工,未在本机运行。 详见编译运行与REPL分工。

Scala2方法体显式使用return时须声明结果类型,递归方法也需要结果类型,普通方法参数类型通常要写明;这不同于有预期类型时对匿名函数参数的推断。例子len(obj:AnyRef)=obj.toString.length根据表达式结果得到Int,而删去等号的旧过程语法会得到Unit。 详见静态推断省去类型书写。

Scala中a + b常可看作a.+(b),符号可以成为方法名,配合中缀调用减少语法负担。语言仍有关键字和特殊构造,不能由此把所有操作符及match都当作普通方法。数值也能从语言层面调用方法,不代表JVM执行时必为每个数值分配一个对象。 详见符号方法支持中缀表达。

Scala可在方法内部定义辅助函数,让实现细节只在外层作用域中可见,而不是提升为整个类都能调用的私有方法。书中factHelper只服务fact2,展示的是可见性收窄;它并未证明递归变为尾递归或无需调用栈。阶乘例对负数返回1是人为处理,Int也存在溢出边界,不能当完整数学实现。 详见局部函数收窄辅助职责。

Scala2用import java.net._导入包成员,用{Map,Seq}选择多个名字,用{Date => UDate}起别名;import也可放在内部作用域以限制名称可见范围。它帮助处理名称冲突,并不自动提供缺失JAR。默认环境还涉及java.lang、scala与Predef,println并非只因为导入scala._;Scala3的导入语法需另看版本。 详见导入可局部化和重命名。

Scala2 while先测条件,do-while先执行再测,适合显式更新循环状态;for(i <- 1 to 10)按生成器遍历,to区间含上界。书中不断修改counter属于命令式风格,语言支持函数值并不排除这种写法。旧do-while不直接作为Scala3通用语法,选择循环时先明确边界和状态变化。 详见循环形式表达不同副作用。

Scala的for可用if守卫限制生成器给出的值,也可串接多个生成器,后一生成器还能依赖前面的绑定。书中先枚举x再枚举1到x的y,是嵌套组合,而非简单把两个列表按位置配对。for按载体支持的方法转换执行,不保证先创建一个新列表再开始循环体。 详见for守卫筛选生成结果。

for(… ) yield expr用每次绑定计算expr并形成载体支持的结果,常见集合上可得到新集合;不带yield的for更适合副作用遍历。书中先算阶乘序列xs,再单独输出,分开了结果构造和消费。结果类型、是否惰性和求值成本取决于载体,不应笼统承诺一律立即新建List。 详见yield收集表达式结果。

Scala的(x:Int) => 2*x创建接受Int并返回Int的函数值,可绑定到doubler再以doubler(3)调用。函数类型Int => Int明确了参数与结果,既能把行为传入,也仍受到静态类型约束。函数值不等于没有名称的方法声明;两者之间的转换和捕获还有各自规则,不因调用外观相同就完全混同。 详见函数值的类型描述输入输出。

adder接收n并返回x => x+n,让生成的函数记住创建时所需的环境;plus2=adder(2)因此之后对不同x都加2。外层调用已经结束,返回函数仍能使用捕获值,这说明闭包不只是代码地址。例子捕获不可变参数,不能据此推断捕获任意可变状态也自动线程安全。 详见闭包工厂保存外层参数。

原书依据 · 11 处

9.4 Scala对象模型:相似但不同

统一类型层级把值和引用放进同一语言模型,但底层表示仍有差异。主辅构造器负责初始化入口,特质复用行为,object与伴生关系组织单例和工厂。case类与模式匹配继续减少重复,而Point的符号方法也提醒:简洁语法仍遵守接收者、方法签名和分支次序。

Scala2的Any位于类型层级顶端,下分AnyVal值类型与AnyRef引用类型;在JVM上AnyRef对应java.lang.Object。Int等在语言层面有方法,实际执行仍可使用JVM基本值,需要时才装箱。原图的ScalaObject等是旧实现细节,不能据“一切皆对象”推断每个数值都在堆上或只靠字面量才能得到数值。 详见统一类型不等于统一表示。

Scala2的Unit表示不携带有意义结果,正常返回值为();Nothing位于类型底部且没有值,可描述不正常返回的表达式;Null用于空引用并属于引用类型体系。三者不是同一个“空”。原书类型图给出了它们的位置,不应把Java void、异常退出和null都混成一种可互换返回值。 详见无结果类型与空引用不同。

Scala2辅助构造器用def this(…)声明,第一步必须调用本类另一个构造器,最终导向主构造器,集中初始化路径。CashFlow示例分别补GBP或金额0,说明为不同输入提供默认值。限制的是构造链,不表示辅助构造器只能填默认参数、之后不能有其他初始化逻辑。 详见辅助构造最终汇入主构造。

def amount = amt声明无参数列表的方法,可用wages.amount访问,外观接近属性;它与def amount() = amt的空参数列表声明不同。书中利用这种区分表达只读查询。是否写括号应跟具体签名和版本规则一致,不能把所有零参数方法都当可任意省括号。 详见无参方法与空参数列表有别。

trait可同时给出待实现成员和已有方法实现,使不同继承支系的类共享行为。Chipped要求chipName并以getName读取,Cat与Dog分别继承Pet再混入Chipped,省去复制getName。类仍需满足抽象成员和父构造要求;这是源级复用机制,不意味着JVM类可多重继承,也不能把Java7接口限制推广到后来的默认方法。 详见特质复用跨类层级的实现。

书中旧Scala编译结果将HelloWorld对象方法放到HelloWorld$模块类,并通过MODULE$保存单例;另一HelloWorld类的静态main转发到模块实例方法。Scala源码没有static关键字,不代表产物没有JVM静态成员。生成文件与转发策略依版本和配置变化,书中javap片段是教材产物,未在本机重新反编译。 详见单例模块与静态转发分工。

同作用域且同源文件的同名class和object可作为伴生关系,并访问彼此私有成员。私有主构造器因此可配合伴生工厂控制实例创建;公开辅助构造器也可提供入口。独立object不是仅因生成一个模块类就自动有用户定义伴生类,Scala自身类内代码也能调用私有构造器,不能把原文两种方式当无例外定理。 详见伴生对象可封装构造入口。

在Point上定义*(Int)使point * 2可调用Point.*,但2 * point首先寻找Int接收者可用的方法,因此不会自动反过来调用Point.*。这是接收者与方法解析的结果,并非语言完全不支持操作符重载。扩展或隐式转换等可另行提供桥接,但本例没有;不能以数学交换律代替实际API签名。 详见符号方法不保证左右对称。

Point例子进一步说明:参数改变时,由编译器合成的比较、散列与展示等支持会随类定义生成,减少手工更新遗漏;这不等于“源码少所以不可能有bug”,自定义实现、可变成员和语义错误仍可能存在。 详见case类生成值对象支撑。

Point(x,0)与Point(0,y)把字段形状用于分支。Point(0,0)同时满足两者,依分支次序首先匹配x轴,说明模式顺序参与结果,而不是自动给出唯一数学分类。 详见构造器模式拆开消息值。

原书依据 · 12 处

9.5 数据结构和集合

集合部分先拆开引用能否重绑、容器能否改动及元素是否可变,再用Nil与cons解释列表的构造。Map的查询、增量结果和原地更新各有返回契约;泛型推断与变型则控制哪些容器可安全代换。原书的Queue和可变Map说明有已知错误,不能把通过某个类型示例当作实现已正确。

Scala集合有可变与不可变版本,默认List等常为不可变;对不可变List追加得到新值,若用var绑定可让变量改指新列表。val绑定的可变容器仍可原地修改,且不可变容器也不保证内部元素不可变。图9-4展示容器与引用的不同维度,不应据一个val就证明整个数据结构可安全跨线程共享。 详见不可变容器仍可共享可变项。

Scala2集合通过细分的特质组合可遍历、顺序、线性访问等能力,使API可按所需性质表达约束,而不只指定具体实现。这样不同集合上的操作形式更一致。书中27个父类型清单依旧版本且有拼写混杂,不能当今天完整继承图;继承层数更多本身也不证明设计必然更优。 详见集合特质描述所需能力。

Nil是空列表,head :: tail在已有列表前放一个元素,得到新列表;2 :: 3 :: Nil按右结合解释为2 :: (3 :: Nil)。Scala符号名末尾冒号决定这种调用结合规则,不是靠猜参数类型决定语法。tail必须能作为列表,且前插可共享旧尾部,不能把cons和拼接多个序列的concat简单等同。 详见Nil与cons构建列表。

Java与Scala集合是不同类型体系,可通过适配或转换互操作。书中JavaConversions让Java列表能调用toList,得到Scala List;这与仅包一层共享底层集合的视图并非同一语义。转换后是否共享元素、后续修改是否反映到另一端,必须按具体方法判断,不能只看“转换”一词就推断深复制。 详见集合转换要看视图与复制。

Scala Map可用key -> value的键值对构造,并在for((key,value) <- map)中解构;映射的get返回Option,命中为Some,缺失为None,区别于Java Map.get直接返回值或null。map(key)则直接取值并可能在缺失时抛异常。不可变和可变HashMap都存在,包名比类名更能说明修改契约。 详见映射查询显式表达缺失。

Scala2中Map的+产生包含新绑定的映射;在可变Map上也不能把它当原地修改,官方API注明从2.8起这一点已改变。要更新可变映射可用+=等明确变更操作,原书“可变映射的+修改自身”不正确。表达式返回一个新结果与对象状态真的改变,是不同的业务结果。 详见加新映射不等于原地更新。

对可变Map,+=可直接调用变更方法,所以val引用也能使用;对不可变Map,若按m = m + pair重写,则需要可重新赋值的var。val不能重绑不等于禁止一切方法引发的修改。读代码时要区分成员方法调用与编译器赋值重写,不能只从+=外观决定是否创建新对象。 详见复合赋值取决于对象方法。

Scala2不接受Java式List生类型,函数参数不能只写List而省掉其类型参数。val xs=List(1,2,3)看似没写Int,是编译器推断出List[Int],并非类型参数不存在。若意图接受未知元素类型,应明确适当抽象,而不是用省略类型参数绕过约束。 详见泛型推断仍须确定类型参数。

把List[Int]与List[String]拼接时,Scala2会在编译期寻找可接受两边元素的类型,示例得到List[Any]。这不是运行时临时修改类型系统,也不保证所有混合集合都推断为同一种公共“类”。拓宽后使用方失去部分静态能力,需重新区分元素,不能把成功编译等同于模型意图仍精确。 详见合并列表可拓宽元素类型。

Queue[T]默认对T不变,因此BengalKitten是Cat子类,不代表Queue[BengalKitten]可传给Queue[Cat]参数。直接构造表达式可受预期类型影响而推成Queue[Cat],先赋变量则可能已推成更窄类型。书中kitties并没显式写类型,失败不是“声明过变量便不能推断”,而是两次推断的上下文不同。 详见容器不变阻止错误代换。

书中Queue.enqueue写成elems ::: List(elem),只返回追加后的List,没有赋回elems,因此调用它并不会更新该队列字段。dequeue却会把elems改成tail,暴露两者状态语义不一致。这个例子可演示泛型语法,但不应作为已正确实现的可变队列;是否改为写回或返回新Queue要先明确职责。 详见返回新队列数据未必已入队。

Java的MyList<? extends Pet>表示某个未知Pet子类型的容器视图,可接收MyList等值,读出元素可当Pet,但不能随意写入另一个Pet子类。它并没有使MyList成为MyList子类型。原示例变量名还不一致,保留的是使用处通配符约束,而非可直接编译的整段赋值。 详见通配符表达受限的未知类型。

Scala类型参数前的+在定义处声明协变:若BengalKitten <: Cat,则List[BengalKitten] <: List[Cat]。这种关系需要类的操作满足类型安全,不可把可写入任意Cat的容器也当成只装小猫的容器。普通不变Queue不能只为通过一次调用就随意加+;编译器会检查类型参数出现的位置。 详见声明协变须约束使用位置。

原书依据 · 13 处

9.6 actor介绍

actor将并发组织为启动、消息入邮箱、按处理域接收和持续消费,减少直接共享状态。这个组织方式仍依赖消息设计、执行资源和生命周期;不可变载荷、阻塞工作隔离与关闭条件都是需要明确的协议边界,而不是继承一个类就自动获得的保证。

旧scala.actors可通过实现Actor.act创建对象,再调用start启动;Actor.actor{…}工厂则创建并启动actor,代码块成为执行主体。声明对象与开始运行不是同一步,不能把构造完成当已进入接收循环。这里是已退出后续标准库的旧API语境,不套用其他框架的创建与启动规则。 详见启动actor有两种入口。

actor ! message把消息交给目标邮箱,接收者再通过receive及处理循环消费;发送不等于业务已处理成功。接收方若不消费,消息会积累。书中将它比作Java处理线程加LinkedBlockingQueue,说明传递工作项的组织方式,并未给出吞吐、容量或可靠投递保证。 详见邮箱把发送与处理解耦。

一组case可定义PartialFunction,其isDefinedAt表示某输入是否在可处理域内;直接对域外值求值可能失败。旧actor的receive用该域筛选消息,因此不能把偏函数域外调用失败推广成每条未知邮箱消息都会触发异常。消息类型不受强约束时,处理域本身就是协议的一部分。 详见偏函数只覆盖部分输入。

actor间传递不可变消息可避免发送后继续修改同一对象、接收端又同时读取的竞态;case类能便利地表达消息种类与数据。case类并不必然深度不可变,若载荷包含可变集合,仍可能泄露共享状态。actor隔离是设计约束,Scala不会替调用方禁止所有直接共享。 详见不可变消息减少共享修改。

actor处理消息时执行长时间阻塞操作,会占住执行资源并推迟后续消息,因而应考虑隔离或异步协作。书中“一个也别做”是实践建议,并非所有receive自身不能等待,也不是语言语法禁令。需要阻塞的工作仍要设计资源与响应边界,不能靠换成actor就消除等待成本。 详见阻塞处理会拖住邮箱消费。

actor通常用循环持续接收消息,停止时需要改变循环继续条件等明确安排。书中提到Boolean条件控制关闭,说明退出不是无限while(true)自动具备的能力。若由外部直接改共享标志,仍会面对可见性和同步问题;原文未给完整关闭协议,不能补造成已经能安全关闭的示例。 详见停止循环需要消息协议。

原书依据 · 6 处

9.7 小结

本章收束在三条线索:类型推断减少重复而保留静态约束,函数与集合表达计算,类型模型与actor表达组织边界。小结没有新机制,已并入本章已有卡;下一章Clojure将进一步把不可变值、身份与状态分开。

第10章 Clojure:更安全地编程

Clojure是Lisp家族的JVM语言,本章以不可变数据和并发抽象为入口,依次讲绑定、基本形式、函数、序列、Java互操作和并发协调。导入没有新算法或并发机制细节,沿用第7章已有Clojure介绍卡;不沿用“Lisp是最古老语言”或“只是重实现Lisp”的简化说法。

10.1 Clojure介绍

理解Clojure先分清稳定的值与随时间变化的关联。def通过Var组织命名空间,fn与defn组织函数,而REPL显示定义、输出与返回结果。前缀形式让代码可被读取成数据结构,宏进一步转换形式;这些机制都不表示语言没有状态或任意数据都可直接执行。

Clojure强调值不被原地改变,以稳定数据帮助推理;同一身份或引用仍可在不同时刻关联不同的值,所以程序依然有状态。它也能接触可变Java对象,并不禁止一切修改。图10-1到10-3用关联变化作入门对照,不能据图断言换一个箭头就自动解决了所有并发协调。 详见不可变值不同于没有状态。

def在命名空间中创建或找到符号对应的Var,并在给出初始化值时设置根绑定;def返回Var本身,普通求值通常取得其关联值。再次def可改变根绑定,不是改变原来那个不可变值,也不等于let局部绑定或线程绑定。理解这层间接关系,才能解释为何重定义hello后同一符号得到不同函数。 详见def建立Var的根绑定。

(fn [] “Hello world”)产生无参数函数值,[]是参数向量;配合def可把函数放入Var,而defn是便于定义命名函数的宏。定义与调用不同,(hello)才是调用当前绑定的函数。省略参数向量不是把名字绑定到任意未知东西的可靠示例,实际会遇到语法或宏展开错误,具体提示依版本。 详见fn造函数而defn命名。

REPL读入表达式、求值并显示结果,会话中的定义还能用于后续探索。println既向输出流写文本,又返回nil,所以教材中一段问候后还会出现nil;它不是第二次业务输出的字符串。探索结果需要整理成可重复代码,已有会话绑定不会自动成为正式程序的一部分;此处没有启动本机Clojure。 详见REPL区分输出与返回值。

Clojure用(f x y)把被调用者放在前面,括号表达式可由读取器形成列表等数据结构,再交给编译求值。代码与可读取数据结构的接近使宏能转换形式,但数据不是不加区分就自动可执行,读取形式也不等于全部语义分析后的AST。原书的波兰表示法历史旁注不作为已核验年代事实保留。 详见前缀形式让代码可被读取。

宏接收代码形式并生成后续处理的形式,让库能提供接近内置结构的写法;defn就是书中用来简化函数定义的例子。特殊形式则有编译器直接理解的求值规则,二者不能完全混同。能扩展表达方式不意味着任意宏都无需理解其展开结果,原章也没有展开宏实现教程。 详见宏在求值前转换形式。

原书依据 · 8 处

10.2 寻找Clojure:语法和语义

特殊形式控制求值方式,if选择分支、let建立局部名字、do按顺序合成动作,quote则抑制当前求值。列表、向量、映射和set提供不同数据语义;统一可调用外观不应掩盖map转换函数、关键字查值、数值运算及相等比较之间的差异。

Clojure条件中只有false和nil为假,其余值都为真,因此0、空字符串和空集合也不能按其他语言习惯当假。if只计算所选分支,并以其结果作为表达式结果;未提供else且条件为假时得到nil。原表“结果为true才走then”应按真值规则理解,而不是只接受布尔true对象。 详见条件真值不只看true。

let的绑定向量为其作用域中的计算提供局部名称,后续表达式可使用这些名字,并返回最后表达式结果。它不向命名空间建立可反复def的全局Var,也不是给一个共享可变盒子赋值。把中间值起局部名能避免重复计算与命名空间污染,具体重绑定仍须区分其词法作用域。 详见let提供词法局部名字。

do按顺序求值多个表达式,并把最后一个结果交给外层,适合在要求单一表达式的位置组合多个动作。前面表达式的结果不自动组成集合,但其副作用仍然发生。它只是明确顺序,不提供事务原子性或回滚,不能因多个动作写在同一括号里就认为失败时自动撤销。 详见do把顺序动作合成表达式。

普通列表形式(1 2 3)会尝试把首项作为可调用者,1不能这样调用;用quote或其简写’可返回列表数据本身而不求值。这不表示该列表在读取层面无效,只是直接求值用途不成立。quote要求一个形式,额外参数不是原表所说“都会被忽略”,不应把错误参数当可依赖语法。 详见引用形式阻止当前求值。

Clojure列表倾向顺序遍历与前端操作,向量支持高效按索引访问,二者均可作为不可变集合使用。把它们分别类比LinkedList与ArrayList有助入门,但实现和更新契约不同,不能当同一个Java类。向量用[]字面量,vector接收逐个元素,vec则把一个输入集合转换为向量。 详见列表与向量有不同访问成本。

Clojure nth接收集合与索引,示例(nth ‘(1 2 3) 1)得到第二项2;可用于多类顺序数据,包括字符串。统一语法不保证同样访问成本:链表可能需要遍历,而向量适合索引访问。边界与默认值形式仍要按API处理,不能从一个成功例子推断任意索引都有效。 详见nth以零起点读取元素。

Clojure映射用交替的键和值构成字面量,映射本身可按键调用;关键字如:name是无须先def的自求值值,也可调用它来查询映射,所以(m :name)和(:name m)都可读值。关键字并非只能接受一个参数的普通函数,还支持缺失默认值等形式;键值匹配不等于字符串与关键字可混用。 详见映射与关键字都可查值。

Clojure map把函数应用到输入集合的元素上,返回结果序列,不是与list同模式的映射字面量构造器。书中map对authors中的每个映射取:name,得到名字序列。输出的惰性求值和序列操作后文继续展开;不能因名称相同就把函数map与键值映射Map混为同一个数据结构。 详见map函数转换而非造映射。

Clojure以#{…}表示集合型的set,用来表达不重复元素的成员关系,区别于保留位置与重复次数的列表或向量。它可类比Java HashSet的用途,但默认不可变并非原地修改型HashSet。若任务关心事件重复次数或输入顺序,就不能不加说明地转成set并认为信息保持完整。 详见集表达无重复的成员关系。

Clojure用(+ 3 4)把加法写成函数调用,+还可接受更多参数,零参数时返回0。符号看起来像操作符,但在这种形式中位于函数位置;=也用于相等比较而不是赋值。理解调用与参数列表比机械搬用Java中缀优先级更可靠,具体数值类型及溢出仍由相应函数契约决定。 详见运算以可变参数函数表达。

Clojure的=可把含等值元素且顺序相同的列表与向量判为相等,identical?则看是否同一个对象。因此内容一致不要求容器类型或元素引用全相同。这个示例针对顺序集合;set与map有各自忽略顺序的值比较规则,不能把“相同顺序”当作所有集合相等的统一条件。 详见顺序值相等不同于身份。

需要取得Var本身而不是当前关联值时,可用(var symbol),对应常见的Var引用写法;它与给符号普通求值的结果不同。 详见def建立Var的根绑定。

原书依据 · 14 处

10.3 使用函数和循环

函数作为值可以进入数据处理流水线:先保存排序键再排序、用apply展开参数、用闭包保存不同环境。loop/recur在明确尾位置组织重复计算,读取器简写减少字符但不替代求值和类型语义;REPL发生错误也不自动说明静态类型检查已完成。

常量函数忽略输入返回固定值,恒等函数返回输入本身;把它们传给list-maker-fun,可分别形成“原值与固定结果”或“原值与自身”的序列。第二参数需要可调用能力,而不只是任意字符串。示例ClassCastException属于执行到不合法调用时的失败,不能据此宣称编译器已静态证明全部参数类型。 详见高阶函数接收可调用行为。

Schwartzian转换先为每项附上排序键,按保存的键排序,再去掉键保留原项。这样可把较昂贵的键计算从比较过程拆出来,通常每个输入只计算一次键。书中以长度或恒等函数示例,图和代码的键/值摆放顺序不同,应按实际取值索引读;内存和构造成本也须纳入权衡。 详见装饰排序避免反复求键。

apply把最后一个序列中的元素展开为函数的实参;书中(apply schwartz [[2 3 1 5 4] ident-fun])把向量和键函数分别传入schwartz。它不同于把整个外层向量作为唯一参数,也不只支持恰好两个传入参数的形式。调用方仍须满足目标函数的参数个数和可调用要求。 详见apply展开最后的参数序列。

loop为一组局部绑定建立重入点,recur以新值回到该点,避免普通自调用不断增加栈帧。recur必须位于允许的尾位置,实参数量也须匹配绑定;它不是任意函数间尾调用优化。like-for先打印再判断是否小于10,因此起始值大于10时仍会打印一次,不能按名字当作先测条件的for。 详见loop与recur控制栈增长。

读取器处理字符层面的简写:引号表示quote,@展开为deref,#‘取得Var,#_丢弃下一个完整形式,#“…“产生正则Pattern。分号只注释到行尾;#_是按形式丢弃,不能等同任意字符块注释。元数据^和语法引用也在这一层工作,不是运行时普通函数调用的替代拼写。 详见读取简写在求值前展开。

Clojure的#(…)是匿名函数简写,%或%1指第一参数,%2等指后续参数;读取器据占位符构造参数列表。它适合短表达式,不意味着外围括号可随意增减,也不能直接嵌套同样的匿名函数简写。较复杂参数或嵌套函数仍可显式写fn以保留作用域清晰度。 详见匿名函数占位符确定参数。

adder接收常量并返回把它加到输入上的函数,plus2与plus3分别保留各自创建时的constToAdd值。再创建plus3不会改变plus2的环境,因此函数返回后仍可使用外层参数。这里捕获的是不可变数值;若闭包持有可变Java对象或引用对象,仍要分析其状态共享,不能仅因叫闭包就证明线程安全。 详见闭包保留各自捕获的值。

原书依据 · 7 处

10.4 Clojure序列

seq把遍历组织为可保留的逻辑位置,而非推进同一个共享游标。first、rest、cons与conj围绕这个抽象工作,惰性实现把生成延后到消费时。空序列和nil、返回seq与保持原容器类型、固定参数与变参都要分别理解,不能被相似语法掩盖。

Clojure seq以first和后续序列描述当前位置,取得后续值不要求原seq变成另一个位置,便于多路算法保留各自进度。Java Iterator.next则会推进该迭代器。这个区别不表示Java绝不可能实现健壮多路算法,也不保证由可变数组或Iterable得到的seq是底层数据的冻结快照。 详见序列不推进共享游标。

seq把可顺序访问的数据转成序列视图,空输入通常得到nil;first nil返回nil。rest在无后续元素时返回逻辑空序列,而不是原表宣称的rest nil也返回nil;next则在没有后续时返回nil。保留这个区别能避免把“集合本身为假”当作检测空集合的条件,因为空集合在Clojure里仍为真。 详见空序列与nil须区分。

cons把元素放到给定序列之前,返回新seq;conj按目标集合的自然插入位置构造新集合,列表通常在前端、向量在尾端。相同输入值和相同新增元素不保证两种操作的顺序结果相同。它们不会原地改不可变集合,但元素本身的可变性仍需另行考虑。 详见cons与conj的方向不同。

every?对集合逐项应用谓词,只要有一次不为逻辑真即可判假;全部满足则为真,空集合也满足这种全称判断。它返回布尔结论,不返回筛选后的集合。书中is-prime只是示例谓词名,没有给出实现,因此不能把教材例子当已在本机验证的素数算法。 详见全称判断依谓词真值。

惰性序列在消费时按需实现值,可用有限前缀处理概念上无限的数据。lazy-seq推迟生成体,take限制所需前缀;不是concat本身使任意立即递归都安全。惰性并不自动等于开新线程,也不保证一次只求一个元素,保留已实现头部还可能使数据长期被引用。 详见惰性序列延后而非免算。

Clojure函数可定义多个固定元数版本,并以& more接收剩余参数序列,但并非每个函数默认接受任意参数。const-fun1只有一个参数,多传会失败;const-fun-arity1显式列出不同形式后才支持示例调用。元数是参数数量,与静态证明每个参数的类型不同,不应把运行时错误都归为编译时类型检查。 详见变参仍有明确的参数约束。

原书依据 · 6 处

10.5 Clojure与Java的互操作

Java互操作把Clojure语法映射到实例、静态成员和构造入口,函数与序列又有相应JVM接口。proxy提供Java回调实现,REPL帮助观察接口后的具体对象,Java也能反过来消费Clojure序列;生成类名和教材运行结果都不成为稳定契约。

Clojure用(.method receiver args)调用实例成员,(Class/staticMethod args)调用静态方法,Class/staticField访问静态字段;new或Class.构造对象,import缩短类名。点语法最终由编译器理解的互操作形式支持,不是把Java包简单视为Clojure命名空间,也不是每个值都先手工从Var取出才能调用方法。 详见Java互操作语法分入口。

Clojure函数在JVM上以实现IFn契约的对象参与调用,Var也可提供可调用入口;序列则由ISeq表达,并非同一个接口。getClass可观察具体运行类,但匿名生成类名不是稳定API。IFn与Callable只是用途上可类比,其参数形式与调用签名并不相同,不能直接替换。 详见可调用值遵循IFn契约。

proxy指定一个可选父类及接口列表、父构造参数和方法体,生成可供Java使用的实现对象。书中用Runnable代理交给调度器,并在run里poll队列。poll可能返回null,直接toString会失败,周期任务也可能因此不再执行;简短代理语法不能替代空结果和失败处理。 详见代理对象实现Java回调。

在REPL里构造Java对象、调用iterator并观察getClass,可以快速理解接口与实际实现的区别。书中ArrayList$Itr和LinkedList$ListItr是所示JDK环境的结果,使用方仍应依赖Iterator契约,不能把观察到的内部类名写成跨版本业务前提。探索是获得线索,不是证明所有集合或运行时都相同。 详见REPL探索实现不承诺实现。

Clojure的持久集合提供相关Java接口的只读部分,Java代码也能使用ISeq。书中StringSeq.create把字符串变成字符序列,循环读first,再把变量改指next,直到null。改变的是Java局部引用,不是让原seq游标前进;依赖JAR与具体类仍需匹配版本,修改集合的可选接口也不因此变得可用。 详见Java读取序列。

原书依据 · 5 处

10.6 Clojure并发

Clojure用不同抽象表达不同共享需求:future和pcalls计算结果,Ref协调事务性状态转换,agent串行执行单个状态的异步动作。不可变值让计算更易重做,但事务外的陈旧余额、重复副作用以及把读取误当等待仍会破坏意图。ATM例子因此同时用于说明机制和暴露边界,而不是正确性已得到验证的成品。

Var的根绑定可由多个线程共享;只有按机制建立的线程局部动态绑定才在线程内隔离。原书“var本质上不可共享”的说法不能推广到def建立的根,不能把重新def误当成安全的每线程局部更新。 详见def建立Var的根绑定。

future提交后台计算,future-done?查询是否完成,而解引用@future在尚未完成时可阻塞,之后得到同一计算的结果。书中最后表达式println返回nil,所以完整计算完成后结果也为nil,并不是打印的文本列表。提交不承诺立即获得CPU,失败和取消也不能当作正常业务结果忽略。 详见future先计算后按需等待。

pcalls接收零参数函数并让它们并行计算,返回按函数次序组织的惰性结果序列;取尚未完成位置的结果可等待,不按谁先完成就自动重排。惰性结果与线程池执行交互,不能把书中一次输出顺序当调度保证,也不应无条件假定无限多个工作都在调用瞬间启动。 详见并行调用返回惰性结果。

Ref提供共享状态的受控引用,dosync为其更新建立事务范围,事务内的Ref变更要么一起提交,要么不提交。读者能看到一致的事务快照及自身变更,冲突可能触发重试。STM保护的是参与事务的引用操作,不自动把Java对象副作用、外部付款或事务外提前读出的值都纳入原子保证。 详见Ref把共享更新纳入事务。

alter把Ref的事务内当前值和附加参数交给更新函数,以返回值作为该Ref的新值;更新函数应返回业务状态值而非Ref本身。这样可用纯函数描述状态转换,由事务控制发布。若函数忽略传入的当前值、只写回事务外计算的陈旧值,使用alter也不能自动恢复正确的读改写语义。 详见alter函数返回新的状态值。

STM遇到冲突可重新运行事务体,文件输出、网络调用或其他不可回滚副作用可能执行多次。把状态计算保持纯粹,可使重试重做计算而不重复外部动作。事务提交原子性并不延伸成外部系统的一次性保证;原章只提出避免副作用,没有给跨系统一致性完整方案。 详见事务重试可能重复副作用。

多个提款线程若先读余额、稍后再决定扣款,其他线程可能已在间隙改变余额,原读取就不能支撑当前判断。即使getBalance和debit各自synchronized,也只保证各次方法执行,不能自动把跨方法的检查与扣款组成一个原子动作。原书用锁内重新读取强调这个根因。方案见[[持同一锁重读再扣款]]。 详见余额检查与扣款必须协调。

原书在同一账户锁的临界区内重新取余额、判断后扣款,让竞争线程按同一协议串行处理,避开[[余额检查与扣款必须协调]]的陈旧判断。保证依赖所有相关写入者遵守这把锁;示例另外的synchronized监视器不等于该ReentrantLock,锁释放也应保证异常路径可靠。它是教学模型,double余额和忽略中断都不是生产实现保证。 详见持同一锁重读再扣款。

Clojure ATM在dosync外读balance并计算dec balance,再让alter-acc把这个预先给定值写入Ref。两线程可读取同一余额后都提交同一新余额,甚至较晚的陈旧写入把余额向旧值拉回;STM重试仍可能沿用事务外参数。此处根因是检查与计算未包含在事务内的当前状态转换,原书未给出完整正确方案;不据最终余额为0就证明扣款没有丢失。 详见事务外算余额仍会丢更新。

agent为单个状态接受异步动作,动作函数得到旧状态及参数,其返回值成为新状态;同一agent一次最多执行一个动作,动作可在线程池不同线程间调度。它不是固定属于某一专用线程,也不是完全不共享状态:其他线程能读取已发布值。不同agent之间不自动形成Ref那样的协调事务。 详见agent串行发布状态结果。

send派发动作后立即返回,@agent读取当前已发布状态,不等待全部排队动作完成。书中两次conj构造的中间值不在动作完成前发布,但紧接send就读取,可能仍看到旧的空向量,不能保证立刻得到两个foo。需要等待完成时须采用明确的同步协议,不能把不可见中间状态误解成自动等待最终状态。 详见agent读取不等待动作完成。

Clojure agent的send适合CPU计算动作,可能阻塞的I/O类动作通常应考虑send-off等相应执行策略。书中wait-and-log故意sleep可展示发布边界,但不宜据此把长阻塞都堆在send执行资源上。运行时管理线程池减少手工线程代码,仍需评估资源、错误及关闭流程,不能推导开发者完全无法控制。 详见阻塞动作须配执行策略。

原书依据 · 14 处

10.7 小结

本章收束在值、引用、序列和并发协调之间的关系:不可变数据简化共享,统一序列简化处理,JVM互操作保留现有类库,而协调机制仍要求正确使用。小结没有新增机制,已并入各卡;下一部分将这些语言能力用于测试、构建与Web开发。

第四部分 多语种项目开发

第四部分把平台与多语言能力应用到交付工艺:测试提供反馈,构建与持续集成提供重复执行的流程,Web框架则提供应用结构。这里是后续章节导航,没有新增独立机制;相应工具的旧流行度描述不当成当前选型结论。

第11章 测试驱动开发

TDD先把预期写成可检查行为,再用小步实现和重构形成反馈,帮助降低修改的不确定性。JUnit、测试替身及ScalaTest分别支撑执行、依赖隔离与另一种测试表达;使用工具本身仍不等于采用测试驱动的节奏。

TDD先写能表达所需行为的测试,再实现足以满足它的代码,并在已有检查下重构。它让“是否达到目标”更早得到反馈,也迫使调用方式和期望结果具体化。写完实现后补测试仍有价值,但不等于同一种设计反馈过程;TDD也不自动保证设计优秀或所有需求都已覆盖。 详见测试先行把需求变成反馈。

开发者不敢改代码,常因为不知道应当保持哪些行为。可重复测试把一部分预期显式化,使小步修改后能快速检查,减少仅凭猜测推进的负担。这是TDD可能带来的工程收益,不是对每个人情绪或项目结果的保证;断言错误、缺漏测试和外部行为仍可能留下不确定性。 详见小反馈降低修改的不确定性。

原书依据 · 2 处

11.1 TDD概览

售票收入例子展示红、绿、重构如何逐步前进,也展示一个绿条的证据边界:只测某个输入时,错误的窄实现仍可通过。明确测试层级、接口、边界和值比较之后,JUnit4才有清楚的对象可执行;重构实现与测试都须保留这种可观察契约。

单元测试关注较小代码单元,集成测试关注协作,系统测试覆盖运行系统,系统集成测试还包含外部系统等边界。不同层级回答不同问题,不能用一组孤立单元测试证明端到端集成正确;边界越大通常也越需要准备环境与观察失败。书中四层是组织示例,不是所有团队必须沿用同名分类。 详见测试层级改变验证边界。

先让新增行为的测试失败,确认缺少什么;再以小实现让它通过,最后在保持行为的前提下改善结构,然后进入下一行为。红可从编译失败起步,也可先建最小接口让断言失败,关键是失败确实针对预期缺口。重构不等于趁机加入未经测试的新行为,绿也不是停止补齐需求的理由。 详见红绿重构形成小步循环。

先从测试调用方法,可迫使开发者明确传入什么、得到什么、异常如何表达。这个首个客户能暴露难以构造对象或难以观察结果的设计问题,但测试不应只迎合实现内部结构。接口契约还要服务实际调用者,不能把方便写断言当作混合业务职责的理由。 详见测试是接口的首个客户。

票数规则为0到100,收入为票数乘30,可把输入分为负数、0、1、正常多值和超上限,再在临界点附近补代表值。只测101不能证明102等都被拒绝,书中中间实现恰好只判断101,体现了窄测试可能放过错误。100与超过100的代表值应进入需求核对,而不是从一个绿条推断整个区间。 详见边界分组比单点更有用。

先对一张票返回30,能使对应测试通过,帮助把实现从空白推进到可反馈状态。它是循环中的暂时实现,不是已完成0到100全部规则的函数。后续用例应驱动一般公式和非法输入处理;不能把“尽量少写代码”解释为故意留下已知需求缺口并交付完成。 详见最小实现只是当前一步。

绿条表示已运行的检查满足断言,不自动证明所有业务规则。书中售票类从只处理1和只拒绝101逐步改进,正说明相同几个测试可能容纳错误实现;最终错误文案写1..100也与允许0不一致。交付前要把真实规则、代表输入和错误契约对应起来,不能靠测试数量代替覆盖判断。 详见测试通过只证明已检查项。

重构在已有行为检查下改善实现,例如把硬编码价格提成常量、合并重复分支或拆分过大的方法。它降低理解与后续修改成本,但已有测试仅保护其实际覆盖范围,不能由此保证所有业务逻辑绝不会漏掉。若改变输入规则或返回结果,应把它作为行为变更重新明确预期。 详见重构应保持可观察行为。

临时设计或代码会把一部分工作推到未来,例如重复分支在规则变化时需要多处同步修改。把这类后续成本称为技术债,有助于解释为何测试变绿后还需整理结构;并非所有短代码或快速实现都必然是债,也不能仅凭“重构过”就声称债务清零。 详见技术债是未来修改成本。

SOLID可作为重构时的一组问题:SRP看是否混入不同变更责任;OCP看稳定接口能否承接预期扩展;LSP看子类型能否遵守父类型行为契约;ISP看客户是否被迫依赖不用的接口;DIP看高层策略是否依赖合适抽象。它们不等于类只能有一个方法、现有代码永不修改或接口越小越好;本章只给出提纲,不补造各原则的完整论证。 详见SOLID审视设计的变化边界。

测试中的重复准备和清理可提取,名称应说明行为意图,结构应让失败原因容易辨认。这样既保留反馈,也降低维护测试的成本;但不能为了消除重复把每个测试真正关心的条件藏进难懂的共享夹具。测试自身仍是代码,不能以“只用于测试”为由放任混乱。 详见测试代码也需重构。

缺少测试的遗留代码很难一次补齐全部检查,可先围绕要改的行为建立可观察保护,再小步推进。原书建议只为新增功能加测试,是控制范围的经验,不应当成禁止为既有行为补回归测试的规则;修复老问题或重构危险区域同样需要先认识其行为,避免新测试只验证新增分支。 详见遗留代码从改动附近建保护。

书中JUnit4以@Test标记测试方法,Assert提供检查,运行器负责发现、执行和汇总结果。框架不是TDD本身,先后顺序和行为选择仍由开发者决定;IDE有测试入口也不代表项目自动有相应依赖。旧4.8.2语境与后续JUnit版本的注解、生命周期不能不加区分地混用。 详见JUnit把断言交给运行器。

JUnit4的@Before在每个测试前准备共同数据,@After在每个测试后清理资源;默认运行模型会为每个测试方法创建新的测试类实例。共享外部资源和静态状态仍可能泄露,不能据新实例就宣布完全隔离。给普通字段设null不是让对象可以回收的必需仪式,清理应针对真正持有的资源。 详见夹具为每个测试准备状态。

JUnit4 assertEquals比较对象时遵循相应相等契约。BigDecimal的equals同时看数值和scale,3.0与3.00不相等,因此期望值的构造也是测试语义的一部分。若业务只关心数值,应明确采用数值比较,而不是随手改预期让断言变绿;书中1.5加1.5的例子并不证明所有十进制表示可互换。 详见数值断言须明确相等语义。

JUnit4的@Test(expected=…)要求测试方法抛出相应异常,否则失败;它并不精确指定是哪一条语句抛出,也不自动检查消息或属性。因此准备代码意外抛同类异常也可能满足过宽预期,应让触发动作清楚且只覆盖要验证的失败。教材异常例子未在本机执行,也不作为当前版本API推荐清单。 详见预期异常须锁定触发动作。

原书依据 · 16 处

11.2 测试替身

测试替身把所需验证与环境变化拆开:虚设满足无关参数,存根控制输入,伪装提供可运行替代环境,模拟再核验契约相关交互。Price注入例展示计算隔离,DAO例展示数据库测试的价值,也暴露会话、构造和清理缺口。替身不能代替真实契约验证,简短教材例子也不等于已可运行的成品。

测试替身在测试中替代真实协作者,以控制输入、隔离环境并缩短反馈。虚设只填位置,存根提供已安排响应,伪装以简化实现完成有用工作,模拟还能检查约定交互;这些是用途区别,不是必须逐级升级的复杂度阶梯。替身成功只能支持被测边界内的结论,不能证明真实外部依赖也满足同样契约。 详见测试替身按所需行为选择。

dummy用于满足本次测试不会使用的参数或字段。例如只测票价折扣时,客户名可取固定字符串Riley,因为结果不依赖它。null只有在契约允许且确实不被访问时才合适,不能把“虚设”理解成任意无效参数;一旦新增校验或行为依赖,测试准备也须跟随真实契约变化。 详见虚设值只填不观察的位置。

把Price接口实现StubPrice注入Ticket,可让getInitialPrice稳定返回10,单独验证折扣计算,而不受网站价格与网络影响。原书示例Ticket(price)默认折扣1.0,却断言9,缺少0.9参数,不能据称已通过。测试应明确价格与折扣两项条件;存根也不必永远只返回一个常量,它可按测试所需安排响应。 详见存根固定输入隔离外部变化。

只要想验证折扣或文本计数,就不宜让单元测试依赖随时变化的外部网站。防火墙、资源迁移和内容修改都可能造成与算法无关的失败;可用可控协作者隔离,另设真实集成测试检查外部契约。手写存根也能提供固定文本,原书“几乎不可能用存根”并不成立,模拟框架不是隔离网络的唯一方式。 详见网络波动不应污染算法测试。

Ticket首次取到价格后保存在faceValue中,后续计算可复用。只调用一次并断言折后金额,最多说明该次结果,不能证明缓存按预期减少后续取价。若缓存次数属于契约,应在多个调用条件下观察来源交互,这是从书中代码推导的测试要求;不把单次verify当完整缓存测试。 详见缓存行为需要独立观察。

fake提供可运行的简化协作者,例如用进程内存数据库支持DAO测试,可更早发现映射和访问代码问题。HSQLDB本身是真实数据库,只是在测试中替代生产数据库承担这类角色。它的方言、事务、类型和并发行为不能自动代表目标数据库,因此快速测试与针对真实环境的验证仍有不同证据范围。 详见伪装用简化实现换速度。

Hibernate用映射描述实体标识及属性到数据库列的对应,配置同时提供方言、驱动和连接入口。这样可通过对象方法表达持久化意图,但底层仍有生成语句与数据库语义,不能据“无需写SQL”推断无须理解事务或数据库差异。书中XML与注解是可选表达途径,偏好不能替代项目维护约束。 详见ORM映射连接对象与存储。

教材用HSQLDB内存连接、Hibernate方言及自动建表配置准备测试环境,目的是降低搭建和清理成本。测试连接、实体映射和数据生命周期仍须明确,不能把自动建表配置带进任意真实库再假定无影响。这里仅保留配置分工,没有创建数据库或交付可执行建表脚本。 详见内存数据库也要隔离配置。

教材Ticket增加ID与访问器,却只给出带ID构造器;这种普通Hibernate POJO装载路径仍需要适当无参构造支持。只在同一Session保存后查询,可能继续拿到已管理对象,不能证明新会话能完整重建实体与其非持久字段。持久化测试应说明跨什么边界验证,不把缓存内成功当可靠存储往返。 详见实体测试须能真实重建对象。

SessionFactory适合共享,Session则不是线程安全对象,通常按工作单元管理。书中DAO把Session存成static并只同步openSession的创建,不能使后续并发访问安全。flush将待处理变化同步到数据库,不等于提交事务;关闭工厂也不能代替清楚的会话及事务结束。教材例子因此不是可直接推广的DAO生命周期模板。 详见会话与事务分开管理。

书中findTicketById先查询列表,再直接取第一个元素;没有记录时会失败,正常命中测试不会覆盖这个分支。按ID查找方法应先明确缺失是返回空结果还是错误,再用测试检查其业务契约。不能只因结果列表在某次有一项,就把get(0)当作所有输入下安全的获取方式。 详见查询成功路径不涵盖缺失。

Mockito用mock(Price.class)创建替代对象,when(…).thenReturn(…)安排取价结果,再注入Ticket测试金额;verify检查指定方法确实被调用。响应安排与交互检查是两种不同观察,前者不是自动验证调用次数,后者也不证明外部网站真的提供该价格。教材通过接口注入,不要求为此额外引入DI容器。 详见模拟安排响应并核验交互。

Mockito默认verify(mock).method()核验一次调用,适合确认被测行为是否通过所需协作者完成。若次数或顺序只是内部实现细节,过度核验会使等价重构破坏测试;若它们影响收费或缓存契约,则需要明确检查。模拟并非总优于其他替身,固定返回也不是存根无法模拟简单状态的定理。 详见交互断言应服务业务契约。

需要套件级昂贵资源时,JUnit4可用静态@BeforeClass与@AfterClass;每测试的@Before/@After则应为实例方法。教材DAO测试把@After写成static且访问实例ticket字段,不能作为可编译的正确清理模板。 详见夹具为每个测试准备状态。

原书依据 · 15 处

11.3 ScalaTest

ScalaTest在旧版本中可复用JUnit边界,同时用Scala匹配器表达结果与异常。它展示从测试引入另一门语言的路径,执行仍依赖套件、运行器和相容类路径。教材的四测通过输出只说明所示环境,不作本次验证证据。

旧ScalaTest可让测试类扩展JUnitSuite并混入ShouldMatchersForJUnit,同时使用JUnit的@Before与@Test,测试Java业务类。它把Scala的表达方式接到既有测试生态,不把Scala变成动态类型语言。类名、特质和模块随版本演进,书中1.6.1写法应按当时依赖组合理解,不能原样当成当前唯一API。 详见复用现有测试边界。

书中evaluating{…} should produce[IllegalArgumentException]把预期异常与一个表达式块放在一起,比在整个测试方法声明expected更容易辨认触发点。同一测试中的多个检查仍应保证意图清楚,避免前一失败掩盖后续。这个语法属于旧ScalaTest匹配器,保留其表达思想,不推成所有版本都支持的写法。 详见异常匹配器聚焦表达式。

运行ScalaTest或JUnitCore时,类路径须包含被测业务类、测试类及相容的ScalaTest/JUnit与Scala运行环境。书中Runner的-s选择套件、-o选择标准输出报告,另一条命令展示同一套测试由JUnitCore运行。教材四测通过及耗时是原环境结果;不能用其本机路径或绿报告证明本次运行成功。 详见测试运行依赖完整类路径。

原书依据 · 3 处

11.4 小结

本章把测试驱动节奏、JUnit执行、替身隔离与Scala表达联系起来,目标是让开发反馈更明确、可重复。小结重述已有机制,不新增同义卡;下一章的构建和持续集成将这些检查放入自动流程,但自动化也不能超出检查本身的证据范围。

第12章 构建和持续集成

构建把团队交付从个人机器经验变成明确的输入到工件的流程,持续集成再让共享改动尽早接受自动检查。发布故事中的拖延来自构建知识隐含和集成延后,改进方向是统一入口、频繁反馈与版本可追溯,而不是简单换一种IDE或装一台服务器。

支付功能发布故事中的问题不是IDE品牌,而是构建步骤依赖个人经验、旧机器状态且分支久未集成。把共同构建入口、配置和所需版本明确下来,团队才能重复产生工件。IDE若调用同一个可重复的项目构建流程也可参与工作,原书“不允许任何IDE构建”应理解为反对隐含个人设置控制交付。 详见构建入口不应只存在于个人。

构建把源码及资源经过编译、测试和打包,形成可部署或可复用的二进制工件。图12-1用清理到打包表达一种常见流程,具体工具的生命周期不必把清理并为同一个阶段序列。流程自动化使重复执行更容易,不能因此跳过对每一步输入、输出和失败含义的理解。 详见流水线把源码变为工件。

持续集成鼓励频繁合并团队工作,并由自动构建尽早暴露组合后的错误,减少长分支到发布前才碰撞的风险。按天提交是书中的经验节奏,定时或提交触发只是实现方式;有CI服务器也不代表团队真的频繁集成。反馈的价值还取决于检查范围和失败后是否及时处理。 详见持续集成缩短集成反馈。

构建的一致性包括知道部署的工件对应哪个版本的源码、配置与依赖,而不只是得到一个同名JAR。重复入口减少个人差异,但还要控制输入版本才能解释两次结果为何不同。书中“随时随地可构建”的目标是工程方向,不等于所有网络、时区和工具差异已经自动消除。 详见工件身份应能追溯源码。

原书依据 · 4 处

12.1 与Maven 3相遇

Maven把项目模型、默认约定和生命周期结合起来,减少各项目重复定义构建。阶段组织先后顺序,插件目标实现实际工作;它仍可配置,并不把所有命令都变成同一种任务。与Ant、Gradle的比较用于理解约束方式,不延续旧流行度判断。

Maven以POM描述项目和构建,并为常见布局与任务提供默认约定,减少各项目重复定义相同结构。需要时可覆盖默认值,但会增加理解与维护配置的成本。掌握惯例有助于阅读其他项目,不等于不看其插件、配置和外部环境就能保证任何项目构建成功。 详见惯例减少重复构建配置。

Maven生命周期由阶段组成,插件目标执行具体任务并可绑定到阶段,也能被直接调用。mvn test会依序经过default生命周期到test为止,实际执行哪些任务由绑定决定。clean和site另有生命周期,不能把compile、test和archetype:generate都当作同一类默认目标。 详见阶段顺序不同于插件目标。

Ant让项目自行组织任务依赖,Maven强调标准生命周期和惯例,Gradle则提供另一种可编程的构建表达及依赖管理。它们在本书中用于比较约束方式,不能把年代、流行度或“新秀”称呼当作当前结论。更灵活不自动更适合项目,标准化也不表示完全不能定制。 详见构建工具取舍看约束方式。

原书依据 · 3 处

12.2 Maven 3入门项目

标准布局分离主代码、测试与资源,target收集生成产物;原型工具可快速建立骨架。真正执行还需要相容插件和依赖来源,下载或代理错误也必须按实际信息诊断。多语言目录展示组织约定,不证明编译器已经自动接通。

Maven典型布局把主源码与测试放在src/main和src/test下,各有java与resources,输出集中到target。资源通常进入相应运行或测试类路径,而target是可再生成产物所在。目录约定帮助理解职责,放入resources不等于自动启用内容过滤;也不能把某个生成目录当源码真源。 详见标准布局分开源码与产物。

Scala和Groovy可采用src/main/scala、src/main/groovy等对应布局,与Java放在同一项目中,但目录存在并不会让Maven核心自动调用所有编译器。相关插件、生命周期绑定及跨语言依赖顺序仍须配置。后续示例的生成存根与编译日志正是这些接线的结果,不是目录名字的魔法。 详见多语言构建还需编译接线。

archetype:generate用所选模板和groupId、artifactId等参数生成初始结构,interactiveMode=false适合已明确参数的非交互调用。模板和插件版本也影响生成内容,书中省略版本的命令不证明以后会得到完全相同项目。生成成功只是骨架可创建,后续依赖、构建和需求仍需验证。 详见原型按参数生成项目骨架。

Maven运行需要构建插件,也可能解析直接依赖及其声明的传递依赖,因此首次执行会有较多下载。本地缓存能减少后续下载,但仓库策略与版本仍影响结果。不能把所有下载简单归咎于类库作者管理差或JAR粒度,更不能由一次BUILD SUCCESS输出证明构建不再需要任何远程内容。 详见构建下载包括插件与传递项。

仓库不可达时先按失败信息区分网络、代理、凭据或坐标问题,而不是直接改全局配置。Maven3通常合并安装目录的全局settings与用户.m2下的settings,用户项优先;代理配置只是其中一部分。团队统一配置也应明确分发与生效范围,不能因多人报错就认定修改某个人安装目录必然解决所有机器。 详见代理配置先核对影响范围。

原书依据 · 5 处

12.3 用Maven 3构建Java7developer项目

POM以坐标和版本识别工件,用插件、依赖作用域和profile安排构建变体。命令再经过清理、编译、测试、打包与本地安装形成不同证据和输出。运行结果必须连同选择范围、版本、配置及工件去向解释,不能把教材日志或一次成功等同于所有检查和部署完成。

groupId、artifactId、version是常用工件坐标,packaging表达打包类型。默认本地仓库中groupId按点分目录,再接artifactId和version;示例应包含com/java7developer/java7developer/1.0.0,原文有漏artifactId或点路径的错误。类型与classifier还可区分附加工件,不能只凭文件显示名确定身份。 详见工件坐标决定仓库位置。

-SNAPSHOT标识开发中的版本,仓库中的实际内容可随构建演进;发布版本则应有明确的稳定身份。Maven不会仅因写了普通version就自行在每次构建追加SNAPSHOT,发布插件按其流程处理版本变更。语义化的版本习惯也不是所有Maven工件都受强制的三段数字格式。 详见快照版本表示演进中的输入。

设置项目源码编码为UTF-8可减少不同机器默认字符集导致的差异,但不能单独保证跨平台构建一致或字节完全相同。JDK、插件、依赖、资源处理和配置同样参与结果。属性要由相应插件实际使用,不能只因POM出现某个值就认定所有工具都遵守它。 详见编码一致只是环境控制一项。

POM的build/plugins声明插件及其版本和配置,具体参数由插件定义,任务是否在某阶段执行还取决于目标绑定与打包默认行为。showWarnings或外部javac路径属于编译器插件配置,不是Maven通用参数。把build.properties放进目录也不代表自动加载,仍需相应读取配置或插件。 详见插件配置须有真实执行绑定。

source和target可约束所用语法及生成字节码级别,但仅设置它们并不能阻止引用较新JDK才有的API。构建Java7目标还需正确选择编译器及平台类库。原书“Maven3默认编译1.5”实际取决于当时编译插件与项目配置,不能作为跨版本Maven固有规则。 详见源码级别不等于平台兼容。

Maven compile依赖通常参与主编译与后续运行,test依赖服务测试编译和执行,不属于正常发布运行依赖范围。作用域不只这两种,也不只是手工往一个固定CLASSPATH塞JAR。把JUnit、Mockito列为test表达了构建职责;最终工件是否捆绑依赖还由打包方式决定。 详见依赖作用域控制可见阶段。

依赖工件自己的POM还可声明依赖,Maven据此解析传递依赖,减少手工补JAR。项目仍须理解实际选中的版本及冲突,不能把“能下载”当作相容性证明。原文的依赖列表描述dependencies声明,不应与单独的dependencyManagement配置块完全混称;后者管理规则并不自动引入全部依赖。 详见传递依赖让版本选择可见。

install:install-file可把给定JAR及坐标加入本地仓库,供本机解析;它既可处理普通类库,也不自动向团队或远程仓库发布。书中ASM例子说明操作对象与坐标的关系,不能由自己的构建成功推断其他机器也有这份文件。团队复用还需明确可访问来源和版本身份。 详见手工安装只解决本机可见。

团队可用二进制仓库管理器托管私有工件,并代理缓存外部仓库,让成员通过共同入口解析依赖。它缓解每个人手工安装的差异,但不会天然保证外界不可访问,访问权限与仓库策略仍须配置。缓存也不等于所有依赖已被验证或版本永远不变。 详见工件管理器提供共同来源。

Maven profile为特定环境或目的覆盖一部分构建配置,可用-P加其ID显式启用。书中ID为ignore-compiler-warnings,命令却漏了compiler中的r,应以实际ID一致为准。关闭警告只改变可见反馈,不修复警告原因;不同profile还会改变产物,排障应记录到底启用了哪些变体。 详见profile明确构建变体。

mvn clean通常清理上次生成目录,mvn compile或test不会自动先运行clean。显式clean可减少旧产物干扰,却会丢弃增量工作带来的速度收益。需要从干净状态验证时应说明这一条件,而不是将一次未清理的成功与从零构建混作同一证据。 详见clean不随普通构建自动来。

普通compile处理主源码与主资源,典型输出在target/classes;测试源码通常到test-compile阶段才编译。多语言项目还须相应插件参与,不能只看到主编译成功就宣布测试代码也编译通过。构建日志展示了实际目标执行,可用来核对配置是否真的生效,教材数量与耗时不作本机结果。 详见编译与测试类编译分阶段。

mvn test依生命周期执行已绑定测试任务,Surefire通常把结果写入target/surefire-reports。POM可排除测试,教材特意排除了部分失败的TDD示例,所以零失败仅针对实际执行集合。报告要与排除、跳过和发现规则一起解释,不能由BUILD SUCCESS推断全库所有测试都运行并通过。 详见测试报告必须连同选择范围读。

package按打包方式形成产物,install阶段再把工件及相关描述安装到本地仓库供其他项目引用;它不表示部署到运行环境或团队远程仓库。调用install会调度此前生命周期阶段,是否重编译由具体任务判断,不是Maven记忆“上次已做过便整段不执行”。默认本地仓库也可被配置改动。 详见打包与本地安装分开。

若Scala和Groovy部分需要各自的主要工件与独立依赖边界,多模块项目可让每个模块表达自己的构建并统一组织。并非一个Maven项目只能产生一份JAR:附加工件及classifier等也可表达其他输出。原文“每个独立JAR必须独立项目”应限于主要工件组织建议,不能当无例外限制。 详见模块边界服务独立构建单元。

原书依据 · 15 处

12.4 Jenkins:满足CI需求

Jenkins把源码、触发与构建入口连成自动任务,并用日志、测试结果与趋势帮助团队得到反馈。工具、环境和权限属于执行条件,任务也须区分检测变更、固定时刻运行与手工检查。教材旧界面说明职责分层,不是当前产品设置的逐项操作指南。

CI任务至少要明确源码来自哪个分支或标签、何时触发、执行什么构建入口;服务器还需要可用的工具和相应访问权限。书中旧Maven任务界面把这三项分开,便于查漏。配置了服务器不会替团队自动频繁提交,也不能由一个仓库URL推断最终构建的是哪个具体版本。 详见任务配置连接源码与构建。

Poll SCM按周期检查源码是否变化,发现符合条件的改动后才触发构建;它与不管代码是否变化都按时执行任务不同。书中*/15式周期用于轮询SVN,不能据“每15分钟”就推断每15分钟必产生一个新工件。手工触发则可用于检查新配置,不用等下个检测周期。 详见轮询检查不等于定时构建。

频繁构建适合快速编译和单元检查,较慢的完整集成检查可安排在另一任务或阶段,以免所有改动都等待最重流程。拆分的目的是更早得到有意义反馈,不代表可以不做慢检查。构建快慢还由脚本与测试设计决定,把工作分到其他执行节点不是自动加速所有瓶颈的保证。 详见快慢检查可拆成不同反馈。

手工启动一次CI构建可暴露源码路径、工具与环境文件是否齐备,再从控制台和测试报告定位失败。书中缺build.properties导致首次失败,说明CI工作区必须具有所需配置,不能依赖开发者机器里的隐含文件。原文$USER/.jenkins路径不作通用路径;修复要按实际工作区和配置来源判断。 详见新任务先用日志验证配置。

CI可同时展示本次构建状态、测试结果和历史健康趋势,它们回答不同问题。测试失败可能由构建进程使任务失败,也可能由报告发布器标为不稳定,取决于策略;不能把任何失败都等同同一种颜色。天气等健康图标更是配置指标,不代表业务正确性已经证明。 详见结果状态取决于报告策略。

工具安装、执行节点、认证授权等属于CI环境,源码位置与构建命令则属于具体任务。书中Jenkins主页和Maven/SVN设置体现这种分层,但旧UI、端口和内置插件清单不作为跨版本保证。团队使用要按实际权限及请求保护机制配置,不能把“界面容易使用”理解为无需运维知识。 详见服务与任务的配置分层。

原书依据 · 6 处

12.5 Maven和Jenkins代码指标

代码指标将部分检查自动化,Checkstyle强调一致性,FindBugs用字节码寻找可疑模式,发布器再形成报告或门禁。静态警告、覆盖观察和业务正确性是不同证据;规则与阈值必须解释,不能用一个数字取代代码和需求判断。

CI插件扩展工具集成和报告能力,安装或更新可能涉及依赖、重启以及正在运行的任务。书中准备关闭再安装是旧环境流程,不能推导所有插件都必需同一种重启步骤;进入准备关闭也不等于强杀当前构建。维护时应明确插件版本和任务处理安排,这里没有实际更改Jenkins。 详见插件变更也有运行生命周期。

静态分析可发现潜在空指针、未用赋值或不恰当比较等模式,帮助建立基本质量反馈,但无法证明业务实现正确。覆盖率来自执行观察,也不应笼统当成静态分析;高覆盖仍可能缺少有效断言。工具零警告与某个指标达标都只是特定检查范围的结果,不是完整质量证书。 详见静态警告只是质量线索。

Checkstyle将团队约定的布局、命名或文档等规则转成重复检查,减少成员阅读与差异比较时的格式噪声。它也有更多检查能力,但并非所有报告都等同真实缺陷。规则应表达团队意图,原书Sun规则与Java7语法支持限制属于当时版本,不能原样当作当前默认与兼容性事实。 详见一致风格减少阅读噪声。

FindBugs基于字节码寻找可疑模式,因此运行前需先有相应编译产物。但规则主要围绕Java惯用法设计,同样的字节码来源于Scala或Groovy时,漏报和误报可能不同。能读取产物不等于同样理解每门源语言,也不应把旧工具名称与示例规则当作所有版本的支持清单。 详见字节码分析仍有语言边界。

分析工具的告警需要回到相关代码、规则与前提判断;确认为误报时可有据排除,而不能为了数字好看直接压掉整类检查。真实问题修复与规则调整也应区别记录。把警告当学习反馈有价值,但告警数量受规则、代码规模和工具版本影响,不能直接给人员或项目质量排名。 详见误报处置需要具体依据。

Maven分析目标可生成报告,Jenkins发布器再读取并按阈值展示健康或设置构建状态。仅运行checkstyle:checkstyle或findbugs:findbugs,不自动意味着发现问题就阻断交付;门禁需要实际配置。书中截图的阈值是该任务例子,不能拿来当所有团队的质量标准。 详见生成报告不等于执行门禁。

原书依据 · 6 处

12.6 Leiningen

Leiningen为Clojure项目提供依赖、REPL、测试与打包的统一入口。交互探索需要保存为源码和可重跑断言,干净启动可暴露遗漏的会话状态。普通包、聚合包、源码与提前编译又决定分发边界,生成工件不等于完成实际部署。

Leiningen把依赖解析、编译、测试和打包统一成Clojure项目常用命令,降低直接操作底层工具的成本。图12-16用Maven、Ant、javac说明书中旧版本如何分工,不是今天内部组件与版本的永久清单。简化入口仍要理解输出与失败边界,不能因工具封装就认为依赖和环境问题已消失。 详见构建门面复用底层能力。

lein脚本提供启动入口,首次运行可能下载工具自身或项目所需依赖,因此与缓存齐备后的执行成本不同。PATH决定能否找到命令,不代表依赖都已安装。书中Windows缺curl等叙述是当时环境,不能据此诊断现有机器;本次仅解释流程,没有安装Leiningen或执行下载脚本。 详见首次启动可能准备工具依赖。

lein new生成项目描述及源码、测试目录,project.clj用defproject表达名称、版本、依赖等构建信息。Clojure命名空间中的连字符通常映射为路径中的下划线,例如hello-lein.core对应hello_lein/core.clj;目录结构仍依模板与版本。项目文件不是把任意字符串放进去就能构建的普通备注。 详见项目描述与命名空间有映射。

Leiningen依赖向量指定工件与版本,缺失项可从配置仓库解析,并包含依赖的依赖。Clojars是Clojure社区的Maven格式仓库,Maven Central也参与默认仓库选择,不能把原文“默认从Clojars”读成唯一来源。只修改本机已下载JAR不等于更新项目声明的共同输入。 详见依赖声明连接社区仓库。

lein repl按项目描述启动带相关依赖的交互环境,便于直接使用业务命名空间和类库,而不必手工拼完整类路径。书中:repl-init属于旧版本配置示例,应按实际工具支持核对。REPL能调用某函数说明当前会话有它,不证明源码与干净启动也已包含同样定义。 详见项目REPL带入依赖环境。

教材函数按连字符拆年、月、日,再调用日期库转成纪元毫秒,适合展示依赖与REPL结合。它不是完整ISO日期时间解析器;时区、合法日期和缺失片段都会影响结果。1970-01-02对应86400000的教材预期依其构造器时间语义,不能推广到任意本地日期或含时间的输入。 详见日期转换先明确输入契约。

REPL适合快速试函数,但稳定成果应回到源码与测试文件,再用lein test等在明确环境下重跑。探索时同时写代码与观察,不自动等于严格先失败测试再实现的TDD;关键是预期是否被明确保存。不能把会话中看过一次正确输出当作持续回归检查。 详见交互探索要沉淀为可重跑测试。

开发时可能在REPL临时改过辅助函数或环境,却没有保存到源码。重新启动并加载项目,可尽早发现这类遗漏,确认结果不只依赖旧会话。重启是验证干净环境的一种办法,不意味着每次定义都必须靠重启才可正确编译;它也不代替保存完整依赖与配置。 详见干净重启暴露隐含会话状态。

clojure.test的is接收待验证形式和可选消息;书中(is true (= 86400000 …))验证的是字面true,比较式只在消息位置,因此即便比较为假也不会按该条件失败。应把等式放在断言条件位置,这是对教材的修正要求而非已执行结果。零失败报告不能证明断言真的在检查所需行为。 详见断言条件不能放成消息。

lein jar一般形成项目工件,uberjar再把依赖内容合入,便于最终应用分发;类库通常保留依赖声明,交由使用方解析。包含依赖会增大包,但不保证所有外部资源、原生库与配置都已齐备,也不替项目生成正确入口。书中大小对比只是该环境示例,不是通用增长倍数。 详见普通包与聚合包包含物不同。

教材JAR含.clj源码,运行时可以读取并编译;这体现了Clojure常见分发方式,不等于语言不能AOT编译或宏一定阻止.class分发。具体包中包含哪些源码与类由构建配置决定。查看实际工件比根据语言类别猜内容可靠,生成JAR本身也不等于已安装、远程发布或部署成功。 详见源码分发与提前编译可共存。

原书依据 · 11 处

12.7 小结

本章收束为重复输入、明确流程和及时反馈:Maven组织构建,Jenkins让团队共同执行,静态报告与测试提供有限但有用的观察,Leiningen把相同目标带入Clojure。小结未新增机制,不另生同义卡;下一章Web开发将继续考察语言与框架的边界。

第13章 快速Web开发

本章把Web开发速度落实为从需求到可观察功能的反馈。Grails和Compojure是原书时代的两条JVM路线,语言、框架和部署能力需要分开判断。开篇只预告后文,不额外生成排名或同义卡。

13.1 Java Web框架的问题

手工反复构建与部署可能拖长反馈,但是否需要整套重启取决于实际工具链。原书对静态类型的批评也需收窄到具体模型和表达成本,不能据此否定所有Java Web框架。多语言金字塔图13-1已查看,模型概念复用第7章。

快速开发受修改、构建、部署、观察的反馈周期影响。频繁的小修改若每次都需手工重启整套服务,就会积累等待成本。应观察实际工具链耗时;书中Java7时代的完整重启流程不是每个Java Web项目的必然限制,自动重载也可能在后台重新编译。 详见缩短修改到观察的时间。

热部署可替换整个应用或局部资源,减少停机等待,但类加载限制、资源状态和容器实现会限制可替换内容。一次JSP更新成功不证明任意类型结构变化都能原位生效。原书JRebel和LiveRebel分别承担开发变化反映与生产部署角色,其“行业标准”评价属于当时背景,不作为当前工具排名。 详见热部署有替换范围边界。

展示清单由图书变成图书与玩具时,应先判断共同展示契约和领域关系,再选择类型与映射方式。不能据类名含Or或And就断言违反SOLID,也不能把退回Object当通用解法。书中Scala反例说明类型推断、类型系统和框架反馈能力需要分别评估,静态类型本身不决定开发速度。 详见类型变化需要模型判断。

原书依据 · 3 处

13.2 选择Web框架的标准

框架评估应覆盖开发、生态、交付与风险,再按项目目标赋权。表13-1全部20项已保留,图13-2的历史分数仅是2011年背景,最终用相同关键功能原型检验候选。

原书2011年评估表的20项是:开发效率、开发者体验、学习曲线、项目健康、人才可得性、就业趋势、模板DRY、组件、Ajax、插件、扩展性、测试、国际化与本地化、校验、多语言、文档教程、图书、REST、移动支持、风险。它兼顾技术、学习和生态,但各项需落实成项目可观察的问题;示例500并发不是统一合格线。 详见框架选型覆盖二十项。

相同框架得分会随权重变化。原书面向快速Web开发提高开发效率、测试支持与文档的权重,得到的是该时点与该目标下的比较。风险、团队经验或长期维护成为主要约束时,应重设标准与权重;历史总分不能当成今天的客观排名,也不能据“满足20项”认定所有能力同样成熟。 详见选型权重表达项目目标。

先选两三个候选,再按自己的标准做相同关键功能原型,观察从开发到测试的实际体验。原型应覆盖项目的重要约束,避免只比较首页或默认CRUD速度。它能验证团队的具体假设,但小规模原型不证明长期运维、性能上限和所有业务需求已经满足。 详见用同一功能比较候选框架。

原书介绍AppFuse把常见Java Web框架与登录、用户管理、按用户展示菜单等能力组合,减少重复搭建。复用平台的价值是提供共性起点,仍要核对业务契约和框架版本。脚注40%至60%代码生成比例只是当时叙述,不是当前项目可承诺的节省幅度;本次未运行AppFuse。 详见基础平台复用共性功能。

原书依据 · 4 处

13.3 Grails入门

Grails以惯例连接Groovy与成熟JVM组件,Spring Roo展示保留Java的相近思路。此处框架定位用于理解后续项目,不把原书成熟度与全项满足说法当成当前能力保证。

Grails借助约定的目录、名称和域对象角色,串联Groovy、Spring、Hibernate、测试与容器,减少逐项配置。开发者必须理解约定才能预测行为和定制差异。Spring Roo在原书中作为保留Java、更多暴露Spring DI的同类思路备选;旧成熟度判断不作为当前选型结论。 详见惯例把框架协作固定下来。

原书依据 · 1 处

13.4 Grails快速启动项目

快速启动以PlayerCharacter贯穿项目生成、约束测试、映射、种子数据、控制器、GSP与脚手架,体现惯例如何缩短反馈。框架增强、启动幂等、模型传递和版本边界仍需显式理解,不能把生成CRUD当作完整业务系统。

旧Grails的create-app生成约定布局并解析依赖,create-domain-class生成域类和单元测试模板。生成文件不等于已有业务实现或测试证明。图13-3的controllers、views、domain、conf各有职责;正文少写复数的controller/view应按真实目录修正。依赖下载还取决于仓库与网络。 详见生成项目只是准备起点。

PlayerCharacter以三个Integer属性表示角色能力,并用constraints为每项声明3到18的范围,validate据约束检查实例。构造完成不等于通过校验,范围校验也不代表所有业务规则或数据库约束已经覆盖。原书有效与越界两个例子只演示基本正反路径,不能替代缺失值等需求的明确判断。 详见约束表达对象有效条件。

教材旧Grails测试通过GrailsUnitTestCase与mockForConstraintsTests引入域对象校验能力,使约束可在单元环境验证。框架运行时自动具备的行为,在普通对象测试中未必已经就绪。正文把方法名误写成单数,示例testConstructorSucceedsWithValidAttributes漏括号,不能把原样代码视为已通过测试;本次未执行。 详见隔离测试要准备框架增强。

GORM按映射惯例把域属性接到数据库,开发、测试与生产可配置不同数据源。惯例可以定制,也有不持久化属性,不能推广成所有带类型变量必存同名表。书中称默认HSQLDB,而截图是Grails2.0.0,2.0.4官方文档已默认H2,故应明确版本差异;生产示例root空口令与自动update不作可直接使用的配置。 详见持久化惯例仍有配置边界。

BootStrap.init在应用启动时准备数据,count为零时才插入的例子可避免通常的重复填充,但检查再插入不是并发原子操作。failOnError使校验失败抛错,不保证前一条成功保存也随之回滚。启动任务需明确已有数据、失败重试与事务边界,不能把示例当成完整并发幂等方案。 详见启动数据需要重复执行语义。

示例PlayerCharacterController的list闭包取得域对象列表,再由list.gsp渲染。路由、数据取得与页面输出是不同职责,模型传递契约必须明确,不能仅假定某个控制器属性必然成为视图变量。图中闭包和列表属性按原书类型表示,不把闭包画成普通方法;实际模型暴露及控制器作用域应按Grails版本核对。 详见控制器协调域对象与视图。

示例URL按上下文、控制器、操作名映射到list闭包,展示约定如何减少路由配置。使用这样的路径并不足以保证符合REST,还需考虑HTTP方法、状态码与资源语义等契约。页面缺失与操作路由缺失也是不同故障;有控制器不代表已经具备可渲染视图。 详见路径映射不证明完整REST。

GSP通过Groovy each闭包遍历角色列表,再输出三项能力。安全解引用pc?.strength避免pc为空时直接解引用失败,并不自动过滤整行,更不等于输出已做HTML转义。原书输出整数仅展示模板机制;改为名字等文本时还需遵循实际模板版本的编码规则。正确约定目录为grails-app/views。 详见视图循环与空安全各司其职。

把域类型绑定到scaffold可迅速得到基础CRUD页面,适合观察模型和默认交互。自定义list.gsp可能覆盖或干扰默认视图,原书先改名便于观察脚手架效果。生成页面不证明授权、输入契约和业务操作已经完整;定制界面与默认实现的优先顺序需按版本确认。 详见脚手架用于验证默认流程。

run-app把开发源码与运行服务连接,部分修改会自动反映到应用,缩短观察时间;框架仍可能在后台编译,也不是任何变化都能免重启。原书生产使用grails war生成工件,再走部署流程。不能把开发时能直接改源码当作生产部署已完成,本次未启动容器或打包。 详见开发重载与生产交付分开。

原书依据 · 10 处

13.5 深入Grails

进一步探索集中在可见性、持久化生命周期与生态集成。日志门槛决定能观察什么,GORM操作仍有标识与事务边界,插件则把独立API接入映射与脚手架等框架惯例。原书列举的关联能力未展开,不补造具体映射教程。

原书旧log4j配置让包记录WARN及以上、特定域类提高到ERROR,以区别需要关注的信号。日志阈值决定哪些级别可见,不改变程序本身是否发生错误;过高门槛可能隐藏排障信息。Config.groovy语法和logger名称属于旧Grails版本,不能作为当前框架默认配置。 详见按组件设置日志门槛。

Grails console带入应用环境后可save、按id读取、修改再保存、最后删除,演示GORM的生命周期接口。原书假定id为1依赖当时数据状态,实际应跟随成功保存实例的标识并处理读取为空。调用save不证明事务已经提交,控制台成功也不证明生产环境与映射同样正确;本次没有操作数据库。 详见持久化演练要跟随真实标识。

普通JAR提供API,框架插件还可提供配置与集成。原书Joda-Time插件让LocalDate参加持久化映射与脚手架展示,价值不只在import后能创建对象。整合范围和兼容性取决于插件版本;书中list-plugins、plugin-info、install-plugin是历史命令,不据此承诺现有Grails仍支持相同入口。 详见插件把库接入框架惯例。

原书依据 · 3 处

13.6 Compojure入门

Compojure以请求路由和普通函数连接业务,Ring提供HTTP抽象与中间件,Hiccup用嵌套数据表达页面结构。这套组合减少模板与配置负担,但开发重载、加载时机、边界参数与依赖版本仍需显式理解。图13-6已查看;示例为2011年工具组合,不作为当前可直接运行教程。

仪表板和操作监控不一定需要按超大网站设计,但简单也不等于忽略非功能要求。先明确规模、可靠性、安全和团队条件,再判断Compojure等精简组件是否适合。原书把它定位于简单任务是当时取舍示例,不是证明该框架存在固定规模上限,也不是允许将教程略去的要求带入生产。 详见先按应用上下文定复杂度。

Compojure表达请求路由与处理组合,Ring提供请求/响应和中间件抽象,适配器把这些函数接到Jetty等HTTP服务器。Ring并非只能连接Jetty,路由DSL也不能全归为Ring本身。图13-6显示的是教材组合;普通页面字符串是响应体,不会因此自动成为完整HTML文档中的body标签。 详见路由层与HTTP适配分工。

project.clj声明依赖与旧lein-ring开发插件,:ring的:handler指向hello-compojure.core/app,后者组合站点中间件与主路由。入口符号必须能加载,依赖声明本身不会生成业务函数。书中Clojure1.2.1、Compojure0.6.2及:dev-dependencies属于旧工具链,不作为当前可直接安装的版本组合。 详见项目配置要连接真实入口。

教材core.clj通过load载入hello文件,再定义路由,借文件划分提高可读性。该load位于顶层,通常随命名空间加载执行,不是每收到匹配请求才首次加载文件。页面函数调用与文件载入是不同时间点。Clojure注释应按其语法书写,教材混入的//标注不能直接复制当可执行Clojure。 详见加载文件不等于请求时加载。

旧lein ring server提供开发HTTP服务并重载修改文件,便于快速观察。文件重载可能重新执行顶层定义,把内存状态全部或部分重置,使会话结果与干净启动不同。怀疑状态不一致时可干净重启再验证;这不是持久化、迁移或生产部署机制,原书端口3000也是示例默认值。 详见自动重载可能重置部分状态。

路由把HTTP方法、路径模式、参数绑定和处理表达式放在一起,依顺序尝试组合中的处理器。具体路由放在静态资源与最终未找到响应之前,避免兜底先终结请求。/hello/:fname的正则只允许ASCII字母,捕获名称作为字符串交给页面函数;它不是所有语言姓名的校验规范。 详见路由同时匹配方法与路径。

Hiccup把标签、属性和嵌套内容写成Clojure向量,再生成HTML,减少拼字符串时结构混乱。引入依赖后仍需让相应命名空间中的html可用,不能仅修改project.clj就假定符号已导入。模板表达简洁与不可信内容的编码是不同问题,旧Hiccup0.3.4示例不证明当前版本或所有用法都会安全转义。 详见HTML结构可用数据表达。

原书依据 · 7 处

13.7 我是不是一只水獭

水獭例串联页面、路由、文件扫描、内存投票与上传,图13-7已查看。它同时揭示原型范围:无访问控制、无上传检查、无投票持久化;还须辨别GET改状态、字符串标识与数值键、next-map-id求最大值错误、全局Var并发覆盖等实现缺口。没有本地运行证明,不能据教材称完整应用就忽略已知缺陷。

水獭例完成比较、投票、上传与结果页,但明确没有访问控制、上传内容安全检查和投票持久化。功能页面齐备只能说明教程范围被展示,不能当作可上线系统。图片扫描能恢复图片目录信息,却不能恢复只存内存的历史投票,不能因重启后仍有图片就认定状态完整恢复。 详见原型范围要写出缺失能力。

结果页用for遍历票数映射的键,生成图片及计票节点;:div#votes.otter-votes是标签id与class的快捷表达,静态文件则由资源路由提供。遍历投票映射意味着没有票数条目的图片可能不出现在结果中,并非自动展示所有图片。多次解引用也不等于取得同一个页面快照。 详见遍历数据生成页面元素。

原书投票路由用GET直接增加票数,客户端重试、抓取或预取可能再次触发动作;作者指出这类错误用于电子商务会产生严重后果。根因是把业务状态改变暴露为应当安全的读取操作,不是单纯URL命名不佳。原则方案见[[读取请求不承载业务修改]];教材未展示支付交易或完整防重实现。 详见用GET改状态会重复执行。

针对[[用GET改状态会重复执行]],原书明确有意义的服务端业务状态不应由GET修改,应使接口方法语义与动作一致。这里的安全性是客户端不请求业务状态改变,日志等附带效果不是同一概念。更换为POST仍不自动解决网络重试、双击或重复支付,教材没有给出完整幂等方案,不把原则改进宣称为支付防重已完成。 详见读取请求不承载业务修改。

扫描器用Files.walkFileTree遍历目录,SimpleFileVisitor代理在visitFile匹配jpg文件名,在visitFileFailed记录失败后继续。匹配扩展名不验证文件内容是有效图片,继续遍历也不代表所有文件均成功登记。此处复用第2章NIO遍历机制,将发现文件和更新业务映射分开理解。 详见文件遍历与业务登记分层。

教材next-map-id把键序列整体作为max的一个参数,再取第0项,因此不是对各个键求最大值。非空集合的首项加1不保证新ID未占用,可能覆盖既有映射;空映射分支恰好能给出1不能证明一般情况正确。需明确聚合调用与空值边界,此处只识别原文缺陷,没有声称已运行修正版。 详见单个集合不会自动展开求值。

投票路由捕获的id是路径字符串,而扫描器创建的映射键是数值。原书直接把该字符串交给otter-exists与contains?,没有展示转换,可能一直找不到对象。数字正则只约束字符形式,不执行数值转换;要在边界明确标识类型与失败处理,不能把格式匹配当作领域对象已存在的证据。 详见边界参数先统一标识类型。

投票数存在Ref中,alter-otter-upvote接收事务中的当前映射,读取已有票数再返回增加后的映射,dosync协调提交。这与先在事务外算好值再覆盖不同。它只协调该Ref,不连带使图片映射、文件写入与HTTP请求成为同一事务;对象存在性与输入类型仍要另行保证。 详见状态转换要使用当前事务值。

multipart表单经中间件解析后,请求映射包含文件信息和:tempfile,应用再把临时文件复制到目标路径。随机UUID文件名有助于避免直接使用用户文件名,却不验证类型、大小或内容,强行追加.jpg也不能把任意文件变成图片。教程明确不做安全检查,本次没有接收或复制上传。 详见上传解析不等于内容校验。

upload-otter先读otter-pics计算新ID,再用def将assoc后的映射重绑到全局Var。两个请求可能基于同一旧映射互相覆盖;目录扫描阶段曾用Ref不代表最终这个已解引用的全局映射仍受STM保护。文件复制与索引更新还可能部分成功,不能把此上传流程称作原子事务或完整持久化。 详见重绑全局映射会丢并发更新。

原书依据 · 10 处

13.8 小结

本章从选型目标走到两个框架的UI与状态管理。真正可迁移的是用项目约束评估工具、缩短反馈并保持请求及状态契约清晰;原书对语言与框架的胜负评价保留历史边界。小结只收束前文,不再生成同义卡。

第14章 保持优秀

结尾章主动声明预测的不确定性,后续代码与模块图应作为历史设计讨论。它把持续学习落实为理解新机制要解决什么问题,而不是把写作时的计划误记成发布事实。

14.1 对Java 8的期待

Java8展望围绕lambda、接口演化和Jigsaw,但正式语法与发布节奏存在差异。保留行为作为数据、接口扩展与明确组件边界的动机,并按正式Java8规范和JDK9迁移资料标出变化。图14-1已查看。

作者明确最后一章只记录写作时的开发方向,语法、设计和发布时间都可能改变。阅读技术展望时,应保存问题背景和设计动机,同时把提案与已发布规范分开。原书期待Java8带来模块化,不等于实际Java8已包含该系统;示意代码也不能因出现在技术书中就当成可编译API。 详见区分提案预测与发布事实。

Java8正式lambda可用参数、箭头和表达式或块体表示行为,并按目标函数式接口匹配参数与结果。SAM不是“单例对象”,也不是任何只有一个方法名的类;判断须遵循函数式接口规则。把lambda当简写有助入门,但并不等同匿名类的全部语义,更不能说它一定无状态或没有参数。 详见函数行为按目标接口定型。

lambda可使用外部环境,捕获的局部变量须为final或effectively final,但引用所指对象仍可能可变。原书“没有状态”说法过强。求值产生目标接口实例的引用,规范不要求每次都分配新对象,所以不能依赖lambda对象身份或用分配次数猜业务执行次数。 详见捕获环境不等于复制对象。

Java8默认方法在接口内提供方法体,可让既有实现复用新行为,但仍要处理继承冲突等规则。原书把AbstractList等类说成接口默认实现的存放位置,以及类加载器插桥再用invokedynamic调用的描述,属于早期构想,不能当作最终规范保证。默认方法支持演化,不承诺所有接口改动都无兼容风险。 详见默认方法给接口提供实现。

原书Schwartzian变换仍是先计算排序键、排序、再去装饰的算法,但List.map、sorted与into链是早期草案,正式Java8的List没有这套API。迁移时应分别理解算法与最终集合/Stream接口,而不是仅替换lambda箭头就假定可编译。该算法细节复用第10章已有卡,本卡只保留版本识别原则。 详见算法想法与集合API分开。

扁平classpath难以明确组件依赖和可见性,模块化试图把运行平台与应用分成显式组件,从而支持更精简部署。图14-1区分用户层模块化与平台本身模块化两条路线。原书这是Jigsaw早期架构展望,正式平台模块化是JDK9的重要变化,不能据本节称Java8已交付模块系统。 详见模块化从依赖边界入手。

Maven和Ivy负责解析及构建依赖,OSGi与平台模块方案涉及运行时组件边界。它们需要集成但不因都谈“依赖”就承担相同职责;模块描述也不自动解决仓库下载和任意版本并存。原书按需安装、独立升级Collections和启动速度等是目标设想,不能把这些全部作为最终JDK的承诺。 详见模块系统不等同依赖仓库。

原书依据 · 7 处

14.2 多语言编程

同一JVM为多语言协作提供基础,但对象可变性、类型表示和调用语义仍需契约。MOP、navigator及图14-2展示统一操作入口与模块集成的构想,不应误认成可直接调用的标准API。

多门语言生成JVM可执行产物,并不消除类型、可变性与调用约定差异。Ruby可变字符串和Java不可变字符串的对照说明,跨语言互操作需要明确转换与行为契约。源语言把值视为对象也不意味着底层永远不用原始表示;共同运行平台不是所有对象可无成本直接交换的保证。 详见共享虚拟机仍有语义鸿沟。

把外部对象包装成目标语言可理解的影子对象,可以简化调用,但会增加分配和适配约束。原书讨论共同接口或超类的路线及其局限,不是证明所有互操作机制都必须共享同一对象基类。选择桥接方式时,需要连同对象身份、类型转换与生命周期理解成本,不能只看能否调用成功。 详见跨语言适配有分配成本。

原书MOP与navigator构想通过统一服务暴露创建对象、读写属性、调用方法、转换类型等能力,避免调用方为每门语言重写一套接口。这里的navigator及图14-2是设计示意,并非已存在的标准Java8 API或现成模块。invokedynamic能作为连接机制,也不会自动统一各语言的对象语义。 详见元对象协议描述对象操作。

原书依据 · 3 处

14.3 未来的并发趋势

硬件并行度推动运行时并发抽象的发展。actor、agent与STM可以改变开发者组织程序的方式,但仍需遵守底层可见性、共享边界与业务一致性约束;本节复用第4、9、10章细节,不重建完整教程。

晶体管增长不等于单线程等比例加速,内存访问和指令级优化都可能成为限制。更多核心提供执行资源,但程序仍需可并行任务与合理数据访问才能受益。原书具体核心数量是时代背景,不能据此评价现有硬件;也不能以“actor天然扩展”跳过串行依赖、消息成本与共享资源分析。 详见更多核心需要可并行工作。

actor、agent与STM把部分调度或一致性机制交给语言运行时,帮助减少开发者手动组合线程和锁的负担。这些机制仍以JMM等底层模型为基础,并没有消除业务不变量、阻塞或外部副作用问题。原书说JVM缺高层结构是当时比较语境,不应否认Java已有并发库或后来演进。 详见高层并发抽象仍受底层约束。

原书依据 · 2 处

14.4 JVM的新方向

本节区分规范与具体VM实现,再讨论元数据内存、协作式执行与值聚合布局的动机。图14-3/4均已查看;PermGen移除已有正式后续事实,协同与tuple示例则保持历史提案身份,不保证API、布局或性能。

JVMS规定合规虚拟机应表现的行为,HotSpot内部优化或工具整合则可能只改变某实现。原书讨论HotSpot与JRockit融合,意在区分平台可移植能力和具体产品改进。HotRockit是社区昵称猜测,任务控制收费与否也是当时可能性,不能写成现在的产品名称或定价事实。 详见规范能力与实现优化分开。

原书展望将类元数据移出PermGen,正式JDK8已改为原生内存中的Metaspace。移除旧内存区并不消除类加载器泄漏或内存耗尽,只是改变分配与限制机制。原文“PermGen区不回收”也过强,不能当作通用GC规则;要结合类卸载条件、收集器与配置分析。 详见移走永久代不消除元数据耗尽。

原书协同程序模型中,执行单元运行到让出点后挂起,再次获调度时从该点之后继续,区别于普通函数从头调用。若同一执行线程中的任务不合作,其他任务可能长期得不到机会。底层承载线程仍可被系统抢占;图14-3只是拟议模型,不是Java8正式交付的协程API。 详见协作调度依赖让出执行点。

在同一协作执行域内,可围绕让出点维持状态一致性,减少任意切换的推理空间。但其他线程或执行池仍可能同时访问共享数据,不能因此删去所有同步。原书“其他时候不会被抢占”的结论只适用于相应模型内部,不是整个JVM都单线程,也不是所有后来协程实现的统一保证。 详见协作执行仍要保护共享边界。

书中tuple拟议把偏移、长度与数组引用封成Slice,希望保留结构表达力同时减少独立对象分配。它是历史值类型设想,tuple关键字不是该书能证明已发布的Java语法,也不等同任意语言中的Tuple或普通不可变类。整体复制包含数组引用不等于深拷贝数组,示例get也未给完整切片边界检查。 详见值聚合旨在减少间接访问。

Entry引用数组先定位引用再访问对象字段,拟议展开布局希望让键值更接近,减少间接访问与缓存读取。性能收益来自具体布局和访问模式,不能断言所有程序都由一级缓存命中率决定,也不能仅凭图14-4证明速度提升。数值计算或金融场景只是动机提名,原书没有给可复制的金融压测结果。 详见连续布局可能改善局部性。

原书依据 · 6 处

14.5 小结

本章以继续关注语言、并发和运行时演进收束全书。持续学习不是把新工具视为自动正确,而是用稳定机制理解变化、核对正式版本并在实际约束下验证。小结没有新增实现机制,不额外生成同义卡。

附录A java7developer:源码安装

附录A介绍原书混合语言示例项目及构建入口。动手实践可补充阅读,但本次交付是笔记与计划,没有下载示例源码或执行构建,因此原书控制台日志不作为实测结果。

A.1 java7developer的源码结构

目录布局把主源码、测试、资源与产物分开。两幅连续目录图00053/00054均已查看;Clojure仅供REPL练习,与另外三门语言进入Maven编译的范围不同。

教材把Java、Groovy、Scala放在各自主源码和测试目录,resources存配置等资源,target保存构建输出。但Clojure目录在这个项目中用于REPL练习,并未因此加入同一Maven编译流程。目录存在与插件实际编译是两种证据;检查构建覆盖需要看目标、配置和产物,不能根据项目含四门语言就声称都已构建测试。 详见多语言目录不代表都被构建。

原书依据 · 1 处

A.2 下载并安装Maven

Maven安装部分覆盖解压、环境选择、版本诊断与用户配置。版本、下载域名和最低JDK都是历史背景;可复用的是核对实际入口、配置与本地缓存各自的责任。Sonatype的Maven: The Complete Reference已登记参考。

mvn -version可观察实际启动的Maven、Java版本及路径,帮助识别PATH与JAVA_HOME指向的环境。它不能证明项目依赖、插件和业务测试均可用。原书Maven3.0.3、旧JDK最低要求与M2_HOME习惯属于历史环境,不能用“大于1.5都行”判断当前版本兼容性;本次未安装工具或修改环境。 详见版本输出只能证明当前入口。

教材.m2/settings.xml保存代理、私有仓库等用户设置,.m2/repository保存下载或install进入本机的工件。缓存减少重复下载,但不代表永不更新或无须联网,运行Help插件也不会保证生成完整settings.xml。可移植构建要区别项目共同输入与本机设置,不能把某人的缓存齐备当作所有开发环境都可重现。 详见用户配置与本地仓库分工。

原书依据 · 2 处

A.3 构建java7developer

构建前通过项目属性文件指定分叉javac,再依需要执行clean、compile、test。阶段、目标、插件执行和成功覆盖范围应分开,网络仅是可能失败原因之一。教材测试日志不是本机证据,未生成同义的完整命令教程。

教材先复制相应操作系统的sample属性文件,再令jdk.javac.fullpath指向具体编译器;附录E通过fork与executable使用该值。这是项目自定义配置链,不是所有Maven项目都认识的内置属性。Maven运行JDK与分叉javac可能不同,环境诊断应分别核对,不能只看JAVA_HOME就断言最终编译器版本。 详见外部分叉编译器需显式路径。

clean清理旧输出,compile编译主源码,test再包含必要的测试编译与执行;它们的成功覆盖范围不同。clean属于独立生命周期,默认test不会自动clean;也并非每次增量构建必须清理。原书网络代理只是一类失败原因,不能见clean失败就改代理;教材20个测试通过的日志不是本机执行证据。 详见成功清理不证明构建成功。

原书依据 · 2 处

A.4 小结

附录A小结鼓励运行和修改例子以加深理解,细节回到第12章。此处无新增机制,实践计划另列,不声称已执行。

附录B glob模式语法及示例

附录B承接第2章,用glob完成目录与路径的模式选择;开篇仅说明用途,语法与边界在接下两项展开。

B.1 glob模式语法

glob的单层与跨层通配、字符集合、备选和转义共同表达路径筛选,参数究竟是文件名还是完整路径决定匹配范围。官方Java7 FileSystem文档已核对,不把glob与正则等同。

Java NIO glob中*匹配零或多个非目录分隔字符,**可跨目录,?匹配一个字符,[]表达字符集合或范围,{}表达备选子模式,反斜杠用于转义。匹配整个路径还是只匹配文件名由传入Path决定。它是路径模式语义,不是正则表达式的另一种拼写,大小写与分隔符行为还要结合文件系统。 详见glob通配有路径层次边界。

原书依据 · 1 处

B.2 glob模式示例

示例补充后缀、长度、字符与前缀匹配。对排版损坏、备选空格、字符串转义和点号规则逐一保留边界;原书rm与tar只作shell类比,不代表调用PathMatcher就会删除或归档。

*.java匹配相应后缀,??要求两个字符,[0-9]匹配一个数字,{groovy,scala}.*表示两个名称前缀备选。原书字母范围例排版损坏,应核对为[a-zA-Z]等合法形式;备选内多余空格可能成为字面内容。模式本身的反斜杠与Java字符串中再转义的反斜杠数量也要区分,不能直接照表猜运行效果。 详见模式示例须按解析层核对。

Java的glob对起始点号没有Unix shell常见的默认隐藏文件排除规则,故同样的星号可能选中不同集合。这里讲的是PathMatcher的选择行为,Java本身不存在本节所写的rm命令,也不会仅因匹配就删除文件。对删除或归档应先确认实际选中集合,不能把一种shell习惯带到另一个API。 详见路径匹配区别于外壳展开。

原书依据 · 2 处

附录C 安装备选JVM语言

附录C给出三门语言与Grails的历史安装路径;此处仅作范围导航,具体可迁移经验在后续项说明。

C.1 Groovy

Groovy1.8.6安装以工具位置、JDK和PATH配合为主,Windows与POSIX有不同环境传播方式。shell配置文件依实际会话而定,旧JDK最低版本及空格路径警告不推广成现行通用规则。

工具根目录变量、JAVA_HOME和PATH分别表达安装位置、Java选择与命令查找。修改shell配置文件通常影响后续相应会话,已运行进程不会自动得到新环境;POSIX子进程还需变量被导出。原书把Mac OS X当作固定shell的表格及若干路径有排版问题,应按实际shell和启动方式判断,避免照抄成通用安装脚本。 详见环境变量生效取决于进程。

原书依据 · 1 处

C.2 Scala

Scala2.9.1的示例提醒复现需记录版本。SCALA_HOME和PATH是启动器定位环节,不能将任何启动失败都归结到这两项;实际兼容性还包含JDK和依赖。

附录明确Scala示例基于2.9.1,语法与工具支持会随版本变化。运行失败时先记录语言、JDK和依赖的组合,再判断是示例错误还是版本差异,不能只反复改PATH。旧发行版的下载格式、目录习惯及Scala启动方式不作为现行推荐,也不主张为了这本书无条件降级整机环境。 详见复现旧例先记录语言版本。

原书依据 · 1 处

C.3 Clojure

Clojure1.2的单JAR入口适合基础REPL,真实项目还要用构建工具组织依赖与测试。Counterclockwise在此是原书IDE集成提名,机制与项目REPL复用第12章,不再生成同义工具卡。

java -cp clojure.jar clojure.main展示旧Clojure1.2的最小交互入口,前提仍是可用Java与正确类路径。它适合试小片段,但没有自动带入项目全部依赖、测试和部署设置;工具化项目要管理这些共同输入。单JAR就能启动是该版本例子,不能推广成以后所有发行组合永远只需一个JAR。 详见REPL入口与项目环境不同。

原书依据 · 1 处

C.4 Grails

Grails2.0.1安装重复工具位置、JDK与PATH流程,复用环境传播卡;新增价值是把框架版本纳入复现输入,并与第13章截图及默认值差异对照,不替用户修改机器配置。

附录指定Grails2.0.1,而正文截图为2.0.0,说明书内也有具体环境差异。GRAILS_HOME和PATH帮助定位启动器,版本输出用于观察选中了什么,不能保证插件、数据库默认值和源码示例均匹配。旧JDK门槛及安装位置建议按历史记录保留;排障还需核对第13章使用的API与实际发行文档。 详见框架版本是复现输入之一。

原书依据 · 1 处

附录D Jenkins的下载和安装

附录D仅引入Jenkins下载与安装,并指向原书帮助站点。没有额外机制,不为入口单独生成卡片。

D.1 下载Jenkins

历史Jenkins1.424可按WAR或系统安装包进入,LTS回应更新节奏的维护需要。安装形式、版本兼容与维护策略分开判断,不沿用旧JDK门槛。

原书Jenkins以长期支持版本回应团队对频繁发布的顾虑,体现选版本还需考虑维护节奏与兼容性。LTS不是永久不升级或零缺陷承诺。下载WAR与系统安装包是交付形式选择,仍须核对具体版本支持的Java、系统与容器,不能沿用Jenkins1.424时代的最低JDK描述。 详见发布节奏是维护策略输入。

原书依据 · 1 处

D.2 安装Jenkins

WAR启动、容器部署与系统安装的差异还影响数据位置和运行用户。图D-1已查看,截图页脚1.420与正文1.424有环境差异;仅见仪表板不能证明CI任务或访问保护已完成。

Jenkins配置、任务和工件应围绕真实JENKINS_HOME定位,其位置会随WAR、系统服务、安装包及覆盖设置变化。原书$USER被当成主目录符号不准确,不能当作可执行路径;~/.jenkins也不是所有安装默认值。看到仪表板仅说明服务响应,不代表认证、插件与构建任务已配置完成;本次没有启动服务。 详见服务数据目录由安装方式决定。

原书依据 · 1 处

附录E java7developer:Maven POM

附录E在第12章POM讲解上继续解释构建插件与依赖。开篇没有新增机制,后续配置按旧项目版本解释。

E.1 构建配置

编译器、Scala、Groovy和属性读取插件共同组织多语言构建,Surefire选择测试范围,Checkstyle与FindBugs提供报告。版本与生命周期绑定要实际核对;已说明清单中的插件层级、XML排版问题。故意排除失败教材测试复用第12章已有卡,不能据绿灯称所有测试都跑过。

教材用Scala与Groovy插件编译源码和测试,并用generateStubs等目标协调跨语言引用;properties插件在initialize读取本机属性。仅声明插件不代表所有目标都会在所需阶段执行,要检查execution与目标的生命周期绑定。此处是旧插件组合,不保证现行插件名称和行为相同,也不把编译stub当成隔离测试的替身对象。 详见插件目标需进入正确构建阶段。

代码清单E-1中plugins结束后又出现plugin,按标准Maven POM层级应核对并放回build/plugins等允许位置;混入的//和排版标记也不能原样当XML。更重要的是检查有效POM是否真的包含预期插件。仅能阅读教材片段不证明Maven接受它,本次没有修建或执行这个示例项目。 详见展示代码要还原合法配置层级。

原书依据 · 2 处

E.2 依赖项管理

依赖坐标、作用域与传递依赖连接本项目所需类库。Guice、javax.inject、Groovy、Hibernate、ASM、JUnit、Mockito、ScalaTest、HSQLDB和Javassist均在前文有用途;本节补充旧ScalaTest作用域例外,未因重复名称重造延伸卡。

compile和test控制依赖在哪些构建及运行路径可用,传递依赖来自依赖自己的描述,最终集合还受冲突选择等规则影响。原书将ScalaTest放compile是旧项目兼容安排,不是所有Scala测试库都应成为生产依赖;工件ID也需结合groupId和版本定位,不能单凭artifactId宣称全局唯一。 详见作用域是实际用途的声明。

原书依据 · 1 处

跨章综合

资源管理、依赖注入和构建生命周期都在明确责任边界。资源声明决定哪些对象由退出逻辑负责关闭,依赖注入决定谁负责提供协作者,构建配置决定哪些输入与目标参与交付。共同经验是把隐含条件显式化,而不是看到“自动”就省去边界核对。

并发与函数式编程在状态上相遇。不可变数据减少被同时改写的对象,却仍需要某种机制指向新的值;锁与STM分别协调相应范围内的转换。只同步单个访问方法,或者把计算留在事务外,都可能让跨步骤的不变量失去保护。Web原型中的内存映射和请求重试又说明:线程内原子性、进程持久化与业务重复执行是不同问题。

性能与交付反馈也要按证据范围理解。一次微基准只观察特定环境,一份测试报告只覆盖实际被执行且有有效断言的路径,一次成功构建只证明当前目标完成。测量、测试和原型互相补充,却不能把任何一个绿灯推广为系统整体正确。旧ScalaTest作用域与Grails默认数据库差异则提醒,版本本身就是可复现输入。

多语言的价值在于对任务采用合适表达,而不是追求语言数量。语言能共享JVM类文件与库,不代表类型语义和状态模型自然一致;用框架快速生成CRUD,也不代表已有授权、持久化和业务契约。选型需要回到项目约束、团队能力以及能否持续验证,不能照搬书中的历史排名。

发散与实践

以下为读者延伸和计划交付,并非作者已执行的结论或本次实测结果。

  1. 沿阻塞队列追踪条件等待:已核验OpenJDK jdk8u402-b06相关源码入口并整理首轮映射,后续用90分钟追踪有界队列与条件等待的协作。
  2. 核对技术预测的发布落点:已用正式规范与迁移文档填写lambda、模块化和元数据内存的对照,后续把剩余预测按证据分成发布、改变和未确认,不靠印象给出结论。

优先从队列的一个成功入队与一个等待恢复路径开始,再阅读版本证据对照。未安排重新实现完整队列、部署旧框架或执行真实资金操作;这些并非理解本书所需的最小实践。

生成进度与管理记录

Java程序员修炼之道

Skill版本:v24

执行模式:light

建档进度:done

信息浓度:高(沿用总表评级,并以跨部分正文抽读确认)

稳定性:低(知识主体包含Java 7与当时的框架、语言和工具版本,原则与历史API须区分)

四象限:工程实践

评级依据:第1部分语言/平台及I/O解释了语法修改成本、资源与路径边界;第2部分抽读3.1(全文)用对象构造→工厂→直接注入比较控制权、耦合和测试;第3部分抽读7.1(全文)用交易对账、map/filter及谓词说明表达能力;第4部分抽读11.1(全文)以门票收入的红—绿—重构过程解释反馈与边界用例。14.5结语强调跨语言互操作与并发演进。主体不止罗列API,故维持高浓度;Java7、Guice3、JUnit4.8.2等版本背景及“未来Java8”的展望使实际使用依赖版本,维持低稳定性。评级仅基于明确范围的抽读,不代表全书已读或截至今日所有示例都可运行。

全文生成完成:153项spine中排除5项非正文,其余148项均已完整读取并逐项讲解,形成515张知识卡。建档done与生成完成分开记录;当前成果已导入并完成文件/数据库对账,归档进度和最终验收见_workflow.md。

整书笔记(全文生成版);覆盖记录。原书完整spine计划见 ../../.local/p3-four-20261105⁄157-reading-plan.json。

章节进度追踪表

章节号 章节标题 状态(pending/done) 卡片数
005 序 done 1
006 前言 done 1
007 致谢 done 0
008 伦敦Java社区 done 0
009 www.coderanch.com done 0
010 Manning出版社 done 0
011 特别致谢 done 0
012 Ben Evans的致谢 done 0
013 Martijn Verburg的致谢 done 1
014 关于本书 done 1
015 阅读须知 done 0
016 读者对象 done 0
017 路线图 done 0
018 代码约定及下载 done 0
019 软件需求 done 0
020 作者在线 done 0
021 关于作者 done 0
022 关于封面图片 done 1
023 第一部分 用Java 7做开发 done 0
024 第1章 初识Java 7 done 0
025 1.1 语言与平台 done 2
026 1.2 Coin项目:浓缩的都是精华 done 3
027 1.3 Coin项目中的修改 done 9
028 1.4 小结 done 0
029 第2章 新I/O done 0
030 2.1 Java I/O简史 done 1
031 2.2 文件I/O的基石:Path done 6
032 2.3 处理目录和目录树 done 2
033 2.4 NIO.2的文件系统I/O done 10
034 2.5 异步 I/O操作 done 4
035 2.6 Socket和Channel的整合 done 3
036 2.7 小结 done 0
037 第二部分 关键技术 done 0
038 第3章 依赖注入 done 0
039 3.1 知识注入:理解IoC和DI done 5
040 3.2 Java中标准化的DI done 7
041 3.3 Java中的DI参考实现:Guice 3 done 6
042 3.4 小结 done 0
043 第4章 现代并发 done 0
044 4.1 并发理论简介 done 6
045 4.2 块结构并发(Java 5之前) done 11
046 4.3 现代并发应用程序的构件 done 13
047 4.4 控制执行 done 5
048 4.5 分支/合并框架 done 5
049 4.6 Java内存模型 done 3
050 4.7 小结 done 0
051 第5章 类文件与字节码 done 0
052 5.1 类加载和类对象 done 7
053 5.2 使用方法句柄 done 6
054 5.3 检查类文件 done 4
055 5.4 字节码 done 9
056 5.5 Invokedynamic done 5
057 5.6 小结 done 0
058 第6章 理解性能调优 done 0
059 6.1 性能术语 done 5
060 6.2 务实的性能分析法 done 2
061 直接测量 done 1
062 通过类加载自动测量 done 6
063 6.3 哪里出错了?我们担心的原因 done 4
064 6.4 一个来自于硬件的时间问题 done 2
065 精确度 done 1
066 准确度 done 1
067 粒度 done 1
068 分布式网络计时 done 3
069 6.5 垃圾收集 done 23
070 6.6 HotSpot的JIT编译 done 7
071 小心僵尸 done 1
072 逆优化 done 1
073 6.7 小结 done 0
074 第三部分 JVM上的多语言编程 done 1
075 第7章 备选JVM语言 done 0
076 7.1 Java 太笨?纯粹诽谤 done 10
077 7.2 语言生态学 done 5
078 7.3 JVM上的多语言编程 done 5
079 7.4 如何挑选称心的非Java语言 done 6
080 7.5 JVM对备选语言的支持 done 5
081 7.6 小结 done 0
082 第8章 Groovy:Java的动态伴侣 done 1
083 8.1 Groovy入门 done 1
084 8.2 Groovy 101:语法和语义 done 8
085 8.3 与Java的差异——新手陷阱 done 4
086 8.4 Java不具备的Groovy特性 done 14
087 8.5 Groovy与Java的合作 done 5
088 8.6 小结 done 0
089 第9章 Scala:简约而不简单 done 0
090 9.1 走马观花Scala done 14
091 9.2 Scala能用在我的项目中吗 done 3
092 9.3 让代码因Scala重新绽放 done 9
093 9.4 Scala对象模型:相似但不同 done 8
094 9.5 数据结构和集合 done 13
095 9.6 actor介绍 done 6
096 9.7 小结 done 0
097 第10章 Clojure:更安全地编程 done 0
098 10.1 Clojure介绍 done 6
099 10.2 寻找Clojure:语法和语义 done 11
100 10.3 使用函数和循环 done 7
101 10.4 Clojure序列 done 6
102 10.5 Clojure与Java的互操作 done 5
103 10.6 Clojure并发 done 11
104 10.7 小结 done 0
105 第四部分 多语种项目开发 done 0
106 第11章 测试驱动开发 done 2
107 11.1 TDD概览 done 15
108 11.2 测试替身 done 13
109 11.3 ScalaTest done 3
110 11.4 小结 done 0
111 第12章 构建和持续集成 done 4
112 12.1 与Maven 3相遇 done 3
113 12.2 Maven 3入门项目 done 5
114 12.3 用Maven 3构建Java7developer项目 done 15
115 12.4 Jenkins:满足CI需求 done 6
116 12.5 Maven和Jenkins代码指标 done 6
117 12.6 Leiningen done 11
118 12.7 小结 done 0
119 第13章 快速Web开发 done 0
120 13.1 Java Web框架的问题 done 3
121 13.2 选择Web框架的标准 done 4
122 13.3 Grails入门 done 1
123 13.4 Grails快速启动项目 done 10
124 13.5 深入Grails done 3
125 13.6 Compojure入门 done 7
126 13.7 我是不是一只水獭 done 10
127 13.8 小结 done 0
128 第14章 保持优秀 done 0
129 14.1 对Java 8的期待 done 7
130 14.2 多语言编程 done 3
131 14.3 未来的并发趋势 done 2
132 14.4 JVM的新方向 done 6
133 14.5 小结 done 0
134 附录A java7developer:源码安装 done 0
135 A.1 java7developer的源码结构 done 1
136 A.2 下载并安装Maven done 2
137 A.3 构建java7developer done 2
138 A.4 小结 done 0
139 附录B glob模式语法及示例 done 0
140 B.1 glob模式语法 done 1
141 B.2 glob模式示例 done 2
142 附录C 安装备选JVM语言 done 0
143 C.1 Groovy done 1
144 C.2 Scala done 1
145 C.3 Clojure done 1
146 C.4 Grails done 1
147 附录D Jenkins的下载和安装 done 0
148 D.1 下载Jenkins done 1
149 D.2 安装Jenkins done 1
150 附录E java7developer:Maven POM done 0
151 E.1 构建配置 done 2
152 E.2 依赖项管理 done 1

非正文排除

spine项 类型 排除理由
1 封面 封面图片及样式,无可读正文
2 版权信息 出版身份及授权,已读取用于书目信息
3 目录 纯导航目录,不含主题讲解
4 版权声明 版权及授权声明,已读取用于出版信息
153 目录 重复Table of Contents,已全文确认仅目录导航

待关联术语

术语名 出现章节 一句话语境
I18n、l10n、Ajax、REST、DRY 121 选型维度与用户交互背景,各项已保留;不补造完整协议教程
DDD、MVC、GSP、GORM、scaffolding 123–124 领域中心、职责分工、模板、映射与默认CRUD生成,按原文展开范围取材
LDAP、Active Directory、CSRF、SVN、cron 115 认证授权、请求保护及源码轮询背景,未扩写完整配置教程
JAR、WAR、RAR、EAR、SAR、HAR、UAT 111、114 工件类型与环境名,只登记未展开的打包细节
敏捷宣言、软件工艺运动 106 开发实践背景,不以群体归属作为TDD适用前提
Scheme、读取器元数据、语法引用 100 尾递归背景及高级读取器语法,只登记未展开的部分
波兰表示法、s表达式、AST 098 前缀代码的读取结构背景,未沿用未经核验的历史年代
软件事务内存 097、103 章导入提名后已在10.6的Ref、alter与重试卡解释机制
包对象、ScalaObject、Traversable、Parallelizable 093—094 包对象仅提名未展开;后几项为旧类型或能力清单,未沿用成当前完整继承结构
逆变 094 作为变型其他形态提及,原章未实质讲解,不补造教程
最小意外原则、BEDMAS、classpath、GPath 084—086 数字默认行为、运算次序、依赖可见性和XML路径导航背景
图灵完备 086 XML旁注未给出可靠判据,不将条件分支加修改内存当成定义
函数字面值、lambda、DSL、trait 074—080 分别作为行为值语法、领域表达、源级混入入口;具体语法留后章
Kawa、Lisp、JavaScript、BASIC、FORTRAN 077—078 语言历史、族属和分类示例,未扩写语言教程
JNI、HPROF、JConsole、MBeans、偏向锁 069 原生接口、堆导出格式、观测入口及其他安全点操作背景,未展开完整接口或锁实现
实时Java、警戒条件、OSR 070 可预测时间目标、优化假设检查和运行中切入编译代码;解释已在相应卡内
ILP、CMT、SRAM、DRAM 063 硬件成本与演进背景;SRAM/DRAM区别已并入内存层次解释,未补造微架构细节
NTP 064、068 启动对时与跨机计时的同步协议入口,未展开协议
Pont Neuf、NTSC、CGA 064 计时硬件历史和命名类比,不扩写无关背景
平均数、中位数、众数、方差、百分位数、标准差、样本大小、正态分布 060 性能工程所需统计概念的提名,未展开统计教程
G1、GC、JIT 058 本章后续运行时主题预告
PermGen、log4j、JMX 053、054 内存成本、日志和监控的背景提名,未展开完整机制
ClassNotFoundException、NoClassDefFoundError 051 启动故障的引子,当前未实质比较区别
插件架构、Java EE、rt.jar、classpath 052 加载用途及Java7平台背景
Hadoop、NoSQL、Has-A、Is-A、终结器 048、049 应用背景、类比及规范条目提名,未展开独立机制
NFS、信号丢失 044 活跃度故障类型的背景提名,未展开机制
ReentrantLock 045 可重入锁的延伸入口,后续工具包详述
实例绑定、无目标绑定、内置绑定、即时绑定、AOP 041(3.3) Guice扩展能力清单与延伸入口,原文未展开机制
MethodHandle、MethodType、反射、VisualVM 037 第二部分导读的后续主题提名
ORM、Hibernate、JNDI 039、040 依赖/查找背景例子,未展开机制
Spring、PicoContainer 039、040 DI容器并列举例,不逐框架扩写
Zork 039 命令行和GUI控制方式的教学例子
Duke 036(2.7) Java吉祥物,正文转场的文化提名
BitTorrent 035(2.6) 点对点程序的背景提名,不据此断言其部署必定使用IP组播
Groovy、Scala、Clojure、Jython、JRuby 005、006、014—017 备选语言与JVM生态预告,非框架名称
TimSort、MergeSort 005 排序实现改变的短例,未说明算法机制
JCP、JLS、JVM规范 005、014 社区标准和平台规范背景
分支/合并、类加载、invokedynamic 005、006、017 后文章节的技术预告
垃圾收集、单派发 014 Java语言与运行时特征提名
依赖注入、TDD、持续集成 006、014—017 技能路线及读者背景
Windows XP、*nix、Mac OS X 019 出版时运行环境列表
jClarity、伦敦Java社区、coderanch 006、008、009、021 作者及反馈组织的历史背景,不展开组织研究

引用文献

标题 类型(书/论文/框架/源码项目) 出现章节 一句话语境
Maven: The Complete Reference 书 136 Sonatype在线手册,原书用户目录表参考;未另读全书
java7developer示例项目 源码项目 134–152 多语言构建及测试的历史对象,本次未下载或运行
Counterclockwise 框架/源码项目 145 原书Eclipse Clojure集成提名,未核验当前可安装性
Jigsaw、OSGi、Da Vinci Machine/mlvm、MOP、Navigator 框架/源码项目 129–130 模块化及互操作的历史项目/协议构想,未混同为Java8正式API
JRockit、HotSpot、HotRockit 源码项目 132 VM融合背景,HotRockit只是原书社区昵称设想
TARDIS、MMORPG 其他 128、132 修辞及应用举例,无独立工程机制
Compojure、Ring、Jetty、Hiccup、lein-ring 框架/源码项目 125–126 路由、HTTP抽象、服务器、HTML表示与开发入口,各职责已展开
clojure.contrib.duck-streams、log4j、SLF4J 框架/源码项目 126 旧上传复制与日志依赖,纯提名不补造新版操作教程
Spring MVC、GWT、Struts 2、Wicket、Tapestry、JSF、Vaadin、Play、JSP/Servlet 框架 120 原书Java Web候选名称列表,未展开机制
JRebel、LiveRebel 框架/源码项目 120 旧开发热替换和生产部署工具定位,历史排名不外推
Comparing JVM Web Frameworks 论文 121 Matt Raible 2011年3月演讲,20项与加权图的历史来源,未另读完整幻灯片
AppFuse 框架 121 共性Web功能基础平台,见延伸阅读卡
Grails、Spring Roo、Apache Ivy 框架/源码项目 122–123 惯例框架、Java备选与旧依赖解析工具
Grails in Action 书 124 Glen Smith与Peter Ledbrook,2009,进阶参考
Cloud Foundry Integration、Quartz、Mail、Twitter/Facebook插件 框架/源码项目 124 原书分别列部署、调度、邮件与社交集成用途,未展开API
Joda-Time插件 框架 124 日期类型的映射与脚手架整合,见延伸阅读卡
Jenkins: The Definitive Guide 书 116 John Ferguson Smart的进阶阅读参考
Clojure in Action 书 117 Amit Rathore的Clojure测试参考
Leiningen、Clojars、clj-time、CounterClockwise 框架/源码项目 117 项目工具、仓库、日期类库和IDE入口,具体用途在相应卡解释
Hudson 源码项目 115 Jenkins历史旁支,旧活跃度评价不作当前事实
Maven、Ant、Gradle、Maven Release Plugin、Nexus 框架/源码项目 112—114 构建、版本流程及团队工件来源;实质用途已保留相关卡,未作当前产品排名
自私的基因 书 113 meme译注的词源旁支,未形成构建知识结论
xUnit Test Patterns 书 108 Gerard Meszaros的测试替身与测试重构参考
HSQLDB、Hibernate、Mockito、ScalaTest 框架/源码项目 108—109 本章实质用途已在替身、ORM及套件卡解释,版本边界分别保留
Test-Driven Development: by Example 书 106—107 Kent Beck的测试驱动开发参考
Working Effectively with Legacy Code 书 107 Michael Feathers的遗留代码参考,未据此补造整书结论
The Principles of OOD 论文 107 SOLID进一步阅读入口,原链接本轮超时;SRP另按提出者博客核对
Effective Java, Second Edition 书 107 语言实践参考,保留原书提名不混同译注版次
TestNG、Checkstyle、FindBugs 框架/源码项目 107 测试备选与静态分析提名,后章处理工具机制
Hibernate 框架 101 译注用惰性加载作背景类比,未展开ORM机制
爱丽丝梦游仙境 书 103 agent地址的文学类比,未作为并发机制证据
Programming Perl: Unmatched power for text processing and scripting 书 099 译注谈驼峰命名的旁支提名,不据此核验词源
Scala in Action 书 095 Nilanjan Raychaudhuri的actor进阶阅读建议
Scala in Depth 书 090 Joshua Suereth的进一步学习建议
Making Java Groovy 书 083 Kenneth A. Kousen的延伸阅读建议
Groovy in Action, second edition 书 086 集合与闭包更多例子的阅读入口
groovyserv 源码项目 084 常驻JVM减少脚本启动开销的可选工具,未展开部署
JAXB、JAXP、XStream、XMLBeans、Xerces、Xalan 框架/源码项目 082、086 XML处理备选入口,未展开各自机制
PCGen、JsonBuilder、Joda-Time 源码项目 086—087 游戏对象例子、JSON构建和Java类库复用入口
Groovy 1.8 Introduces Groovy to JSON 文章 086 Dustin博客的延伸阅读,未用于当前技术结论
BSF 框架/源码项目 087 嵌入脚本备选框架,与JSR223并非同义
Apache Camel DSL、Drools 框架/源码项目 078 领域层示例,未展开机制
ScalaTest、JUnit、Grails、Struts、JSF 框架/源码项目 079 测试或Web试点候选,旧排名不作当前推荐
Leiningen 框架/源码项目 079 语言专用构建工具可能带来混合项目组织成本
JRuby、Jython、Rhino 源码项目 077、080 JVM语言移植例子,其角色与兼容边界已在语言移植卡解释
带go to语句的结构化编程 论文 062 Knuth关于过早优化的延伸出处
OpTier CoreFirst 框架 062 出版时加载插桩工具的例子,不判断当前市场
Java并发编程(Doug Lea,第2版) 书 043 推荐深入并发的专书
Java并发编程实战 书 043 推荐深入并发的专书
算法导论 书 044 单线程及并发算法学习推荐
算法设计手册 书 044 算法设计延伸阅读
Guice官方文档与代码示例 源码项目 041(3.3) 延伸查询绑定类型与AOP的入口
设计模式:可复用面向对象软件的基础 书 039、040(3.1—3.2) 工厂与单例的延伸出处,未复述整书
J2EE核心模式(第2版) 书 039(3.1) 服务定位器模式的出处
控制反转容器和依赖注入模式 论文 039(3.1) Martin Fowler解释IoC/DI的延伸文章
Announcing @javax.inject.Inject 论文 040(3.2) JSR330历史公告
Weld 框架 040(3.2) CDI参考实现的背景入口
Java NIO 书 034(2.5) Ron Hitchens的NIO参考书,原文推荐但未展开内容
Java Performance Tuning 书 005 推荐序用于说明性能主题的参考作品
Java Specialists Newsletter 论文 005、011 推荐序作者的技术简报;只介绍来源身份
Maven: The Complete Reference 书 011 获准引用的Maven参考资料
A Brief, Incomplete,and Mostly Wrong History of Programming Languages 论文 014 以幽默语言史引入Java设计讨论
Grails、Compojure、Guice、Jenkins/Hudson、Checkstyle、FindBugs 框架 005、017 推荐序及路线图中的技术预告
地域服饰风俗纲要 书 022 封面图像的四卷本来源
Perl 源码项目 030(2.1) 正则表达式语法的来源背景,只有简短评价及访问入口
OpenJDK 源码项目 026(1.2) 开源Java平台开发项目,作为语言演进参与背景提及
Adopt OpenJDK 源码项目 026(1.2) 引导新参与者投入OpenJDK的历史计划,未展开具体操作

资金安全问题案例

问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明
余额读后检查与扣款失去协调 [[余额检查与扣款必须协调]] [[持同一锁重读再扣款]] 103 Java示例强调同锁重读,保留所有写入者同协议的边界
STM中沿用事务外陈旧余额 [[事务外算余额仍会丢更新]] — 103 原示例有读改写范围缺口,未给完整正确方案,不补造配对
GET业务修改可能重复执行 [[用GET改状态会重复执行]] [[读取请求不承载业务修改]] 126 水獭投票作为电商错误类比;原文只给方法语义原则,未给支付防重实现
双向交易存在性遗漏 [[对账须查两个方向]] [[双向集合找缺失记录]] 076 既查上游缺下游,也查生产测试单等下游缺上游;集合不验金额和重复次数
交易身份大小写假差异 [[身份大小写造成假差异]] [[匹配回调仍须统一口径]] 076 书中只修一个方向,seen反向检查仍有缺口,已明确未验证的修正要求

实践卡进度

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
001 沿阻塞队列追踪条件等待 实现深读 done 046 计划与首轮映射
002 核对技术预测的发布落点 证据验证 done 129、132 计划与三项对照

实践候选筛选:done

筛选结论:采用有界队列实现深读与历史预测核验,两者目标不同。未采用重新实现完整队列(已有成熟实现)、无明确疑问的性能微基准(不能泛化测量结果)、旧Grails/Compojure整站部署(当前任务无需且历史依赖成本高);同类并发实验与队列深读合并。两卡done指计划及首轮材料交付,后续深读、实验与完整预测表尚未执行。

轻量模式:未执行笔记复核、独立审查及审查结果优化。

生成交接:book-note schema=1;全文、跨章综合与实践入口已生成;所有现存卡唯一primary且有原书出处。轻量模式未执行后置复核/独立审查/审查优化。

相关主题

从本书的主题进入跨书阅读,对照其他书籍的讲解。下方数量包含主题关联的全部卡片与书籍。

暂无公开主题。