来源书籍

企业应用架构模式

Skill 版本:v23 系统架构类 经典原理(高信息浓度 + 高稳定性) 177 张卡片

Martin Fowler · 机械工业出版社 · 2010-04-27 · ISBN 9787111303930

类别清单覆盖

3/6

已覆盖 3 补充生成 0 未覆盖 3

全书导读

企业应用架构没有一套通用的分层配方。先识别领域逻辑复杂度、数据访问、并发会话、远程通信和表现需求,再选择职责与代价相配的模式。全书前八章给出选择地图,后半部以机制、使用时机与代码示例解释模式;示例有意简化事务、错误处理及版本差异,不能直接作为生产框架。

全书主线

全书把变化分配到合适的对象与边界:表现层处理交互,领域层处理规则,数据源层处理持久化。领域逻辑的组织决定持久化模式的复杂度;工作单元、标识映射和延迟加载又共同决定对象如何跨越内存与数据库。远程外观和DTO处理进程边界,离线锁和会话状态处理跨请求边界。最后的入口、映射器、接口与插件把这些机制所需的依赖管理串联起来。

架构是难以改变的决定

“架构”定义众多,公认的只有两点:最高层次的系统分解,以及系统中不易改变的决定。Ralph Johnson 指出架构本质上是主观的,是资深开发者对系统设计的共享理解,包括希望尽早做出、因难以改变而重要的决定。正因如此,一旦发现某个决定其实不难改变,它就不再属于架构。判断一件事是否是架构决策,要问的是日后改起来有多痛,而不是它听起来多高端;同一决定在不同团队里分量可能完全不同。 进一步展开见架构是难以改变的决定。

企业应用(工资单、患者记录、发货跟踪、保险等)没有精确定义,但有六个典型特征共同把它和车辆加油、编译器、电子游戏这类软件区分开。持久化数据:数据要跨越程序的多次运行、甚至跨越硬件和操作系统的生命周期,结构还要能在不破坏已有信息的前提下扩展。大量数据:中等规模系统往往涉及GB级、数百万条记录,数据管理本身成为主要工作。多用户并发访问:即使只有几十上百人,也要处理”两人同时操作同一数据项”的正确性问题,事务管理工具能处理但通常无法对开发者完全透明。大量用户界面屏幕:屏幕数量多、用户技术背景参差不齐,还有大量容易被忽视的批处理过程。需要与其他系统集成:企业很少独立存在,不同时期用不同技术构建的系统(COBOL文件、CORBA、消息系统)风格各异,统一集成技术的愿望几乎从未真正实现。业务逻辑本身”无逻辑”:业务规则里充斥着大量因历史原因、行政妥协形成的”一次性特殊情况”(比如为了配合客户账期临时把到账时间推迟两天),这些逻辑会随时间不断变化,因此必须把它们组织成便于应对变化的结构,而不是指望它天生就是自洽的。六个特征共同说明:企业应用的难点往往不在算法本身复杂,而在于数据的持久性、规模、并发、集成和”不讲道理”的业务规则叠加带来的结构性复杂度。 进一步展开见企业应用的六个特征。

企业应用各不相同,有人说“总是这样做”就该警惕。B2C 零售用户多、逻辑简单,重点是可伸缩性;租约合同系统用户不足百人,逻辑复杂、事务可能持续一两小时,需要富客户端和两百多张表;小型开支系统功能简单,难点在于快速交付又要为扩展留余地,过度设计反而拖慢交付。三者难点完全不同,不可能有通用架构。选型前先看清问题,选定模式后通常还要结合实际修改,模式只提供决策依据,思考不能被替代。 进一步展开见没有通用架构。

“可伸缩性”这类性能词汇有六七种含义混用,需要精确区分。响应时间:完成一次外部请求处理所需的时间。响应性:系统响应请求的速度感知,与响应时间不同——如果处理过程中能先给用户一些”已接到请求”的反馈(如进度条),响应性会更好,但响应时间本身并未缩短。等待时间:获得任何响应的最小时间,即使实际工作量为零,远程调用天然比本地调用等待时间长,这也是要尽量避免远程调用的原因。吞吐率:单位时间处理的请求量,企业应用常用每秒事务数(tps)衡量,但需要固定一组有代表性的事务集合才有可比性。负载:系统当前承受的负荷(如并发用户数),常作为其他指标的背景条件。负载敏感度:响应时间随负载变化的程度,变化越小说明系统”衰减”得越慢。效率:性能除以资源消耗。容量:达到可接受性能阈值前能承受的最大负载或吞吐率。可伸缩性:增加资源(通常是硬件)对系统性能的提升幅度,分垂直可伸缩性(提升单机性能,如加内存)和水平可伸缩性(增加服务器数量)。书中用Swordfish和Camel两个系统的对比说明这些术语不能混为一谈:单机时Camel(40tps)效率高于Swordfish(20tps);加一台服务器后Camel到50tps、Swordfish到35tps,Camel容量仍更大,但Swordfish的可伸缩性表现更好;再加服务器后Swordfish每台提升15tps、Camel只提升10tps,此时才能说Swordfish的水平可伸缩性优于Camel——单看容量或效率的某一个快照,得不出关于可伸缩性的结论,可伸缩性衡量的是”增加资源”这个动作本身带来的边际收益,而不是某个时刻的绝对数值。 进一步展开见性能术语辨析。

模式来自对反复出现的好设计的提炼,最大价值是提供共享词汇:团队都懂远程外观,一句话就能传递大量信息。常见陷阱是盲目套用。模式是“半生不熟品”,只给出核心解法,剩下的火候要结合项目补上,同一模式在不同项目中的实现几乎不会相同,因此只生成骨架的模式工具往往效果不佳。一个自检办法是每选一个模式都反问“什么时候可以不用它”,确认场景真的符合其适用条件,而不是因为听起来高级就套上。 进一步展开见模式是半成品。

需求规模大、又想亲手构建全部基础设施的团队,作者的第一条忠告是先考虑现成工具。他见过不止一个项目把大量时间花在搭框架上,而框架并不是项目真正要解决的问题。对工具使用者,模式的价值是揭开工具内幕,帮助决定采用工具支持的哪种映射方式。书中示例为了好懂刻意简化,直接照搬到生产中往往要大改。发散:立项时先问“这块是我们的差异化吗”,不是就买或用开源。参见买O/R工具仍需懂模式。 进一步展开见先用现成工具别造框架。

企业应用不都是大型系统。很多人觉得小系统失败也不起眼,可以少花心思,这确实省了点成本,却忽视了累积作用:企业里往往有大量小系统,各自的架构缺陷叠加起来后果可怕;反过来,在小项目上验证过的改善一旦用到大项目,收益会很大。作者更进一步主张,最好通过简化架构和过程,把大型项目拆成小型项目来做。发散:小系统正是低风险试验新实践的场地。参见没有通用架构。 进一步展开见别轻视小型系统。

作者处理多数性能问题的办法是先把系统建起来跑通,再做基于测量的严格优化。很多设计因“性能考虑”被接受或否决,一到真实环境测量就证明判断错了。优化之后必须和优化前对比测量,否则可能只是白白破坏了代码可读性。推论是:升级虚拟机、硬件、数据库等重大配置变化会让旧优化失效,甚至变成负优化,必须重新确认。例外是少数后期难以弥补的架构决策。发散:给每项优化留一个基准测试。参见性能术语辨析。 进一步展开见优化前后都要测量。

构建企业应用时,硬件可伸缩性往往比单机容量或效率更值得关注。设计人员费尽力气才挤出一点容量,开销常常还不如多买几台机器。若一个单机效率高的方案贵出的钱足够多买几台服务器,选可伸缩性更好的方案反而更划算,即使眼下的负载单机就够。总的来说,买硬件比改旧软件便宜,加服务器比加程序员便宜,但前提是系统真的能水平扩展。发散:可伸缩性是把人力成本换成硬件成本的期权。参见扩展靠复制整个应用。 进一步展开见可伸缩性优先于效率。

原书依据 · 19 处

分层的收益与代价

把系统按”多层蛋糕”的方式组织——每层依托在下层之上、使用下层服务,上层对下层细节一无所知——能带来五个好处:可以在不了解其他层细节的前提下把某一层当作有机整体来理解(如无需懂以太网细节即可在TCP上构建FTP);可以替换某层的具体实现,只要前后提供的服务不变(FTP不管跑在以太网还是PPP上都无需改变);把层间依赖降到最低(物理传输系统变了,只要IP层不变,FTP就不用变);有利于标准化(TCP/IP各自都是本层如何工作的标准);一旦某层建好,可以同时支撑多个上层服务(TCP/IP同时被FTP、telnet、SSH、HTTP复用,否则每个协议都要各自重写底层)。但分层也有两个代价:层次并不能封装所有变化,给用户界面加一个数据域,往往意味着数据库、以及界面和数据库之间的每一层都要跟着改(级联修改);过多层次会因表现形式的反复转换拖累性能,不过对底层功能的封装换来的效率提升,通常大于这个转换代价(例如可以专门优化事务控制层,让其他层跟着受益)。 进一步展开见分层的收益与代价。

客户/服务器两层时代,VB、Delphi 等工具擅长把控件绑定到数据库,处理简单增删改很顺手;一旦出现业务规则、校验和计算,要么塞进客户端,导致逻辑与界面耦合、跨界面重复,要么塞进存储过程,丧失数据库可移植性。三层架构正是为了把领域逻辑从两端拽出来单独建模。Web 兴起时,分层良好的系统只需新增表现层即可上网,逻辑写死在客户端的系统只能重写。是否单独抽一层,看这块逻辑是否已无处安放。 进一步展开见三层为领域逻辑找位置。

layer 与 tier 常被混用,但 tier 往往特指物理分离,如客户端和服务器分处两台机器的两层系统。这里刻意用 layer 强调分层是逻辑组织方式:领域层可以与数据源层同在数据库服务器上,三层甚至可以全部运行在一台笔记本上,逻辑上依然是三层。讨论要不要分层时,先分清说的是逻辑边界还是部署边界,否则容易得出“反正只有一台服务器,不必分层”的误判。 进一步展开见layer不等于tier。

全书围绕表现层、领域层、数据源层三个基本层次展开(命名取自文献[Brown et al.])。表现层负责用户或外部系统(人类、命令行脚本、Web Service调用方)与软件的交互,把外部输入解释成对领域层或数据源层的动作,并把结果显示回去。领域层承担应用必须完成的核心业务工作:依据输入或已有数据做计算、对表现层传入的数据做验证、决定该调度哪些数据源逻辑,是三层中真正装业务规则的地方。数据源层负责与数据库、事务监控器、消息系统等外部系统的交互,对多数企业应用而言主要职责是持久化数据存取。三层之间有一条不能违反的依赖方向铁律:领域层和数据源层绝对不能反过来依赖表现层——这两层的代码里不允许出现调用表现层代码的情况,这样替换表现层(例如给已有Web应用新增命令行界面)时,下面两层不需要跟着连锁修改。领域层与数据源层之间的耦合程度则取决于数据源层采用的具体架构模式。实践中表现层常常绕过领域层直接读取数据源层数据,这样做并不”纯粹”但往往可行。三层划分不要求对应不同的类或物理进程:简单系统可以只是同一过程里的三个子程序,复杂度上升后才逐步演化为不同的类、再到不同的包。 进一步展开见三层职责与依赖方向。

判断某段逻辑是否属于领域逻辑、是否被错放进表现层,最实用的是思想实验:假设为系统新增一个完全不同的表现层,如给 Web 应用加命令行界面,或把数据库换成 XML 文件;若某些功能必须在新层中重写一遍,它就本应放在领域层。例如“销量比上月涨 10% 则标红”,比较逻辑应在领域层提供一个是否显著上涨的方法,表现层只决定怎么显示。这把职责归属的争论变成了可操作的检验。 进一步展开见新增一层看是否重复。

六边形架构把系统看成被外部接口包围的核心,无论调用方是人还是程序都一视同仁,是对称视图。分层视图则刻意不对称:表现层是系统对外提供服务的接口,数据源层是系统使用外部服务(数据库、消息系统)的接口。提供服务与消费服务的方向不同,稳定性要求和演化责任也不同,不应因为都是边界就混为一谈。设计边界时,除了问是不是外部接口,还要问是谁在为谁提供服务。 进一步展开见分层视图的不对称。

选择每层跑在客户端还是服务器端,核心权衡是”响应性/断连可用性”与”维护简易性”的对抗:全部塞进服务器端(配Web浏览器前端)最容易维护,因为改动只发生在一个受控环境里,不用操心分发到各客户端、也不用管客户端上其他软件的兼容性;代价是每次交互都要走一次网络来回,断网时完全无法工作。往客户端搬(胖客户端)能换来更好的响应性和断网可用性,代价是版本升级和客户端一致性维护成本陡增。三层各有偏向:数据源层原则上留在服务器端(除非要支持断连操作,需要把服务器功能复制到功能强大的客户端上,并解决离线修改回传同步的问题);表现层的位置基本被UI形式锁死——胖客户端就跑在客户端,Web界面就跑在服务器端(B2C系统尤其别无选择,只能靠服务器端HTML方案兼容任意来访者);领域逻辑最自由,可以全在服务器、全在客户端,或者拆开——但拆开是最差选择,因为无法明确判断任意一块逻辑到底该去哪查,只有当确实只有一小部分领域逻辑必须在客户端完成、且能被剥离成不依赖其余系统的自包含模块时,才值得这么拆。Jens Coldewey提出的”复杂性增压器”点出了哪些因素会让这类决策的代价急剧抬升:分布式部署、显式多线程、范型差异(如对象/关系不匹配)、多平台开发、极限性能要求(如每秒百笔事务以上)——出现任意一个,开发和运维成本都会明显上升,能避免就该避免。 进一步展开见各层运行位置的决策。

原书依据 · 9 处

三种领域逻辑模式对比

领域逻辑的组织方式主要有三种。事务脚本:每个用户动作对应一个过程,该过程负责接收表现层输入、校验计算、存取数据库、调用其他系统,再把结果返回表现层;脚本内部可拆成共享子例程,但每个动作始终由单一过程驱动。领域模型:围绕领域中的名词(如租约、资产)建立类,校验和计算逻辑分散到各个对象自身承担,不再由一个过程统揽全局,行为分布在对象网络里。表模块:介于二者之间,围绕数据库表(而非过程或对象实例)组织逻辑,每张表只对应一个公共类实例,与记录集配合工作——客户先查询生成记录集,再用记录集构造表模块对象,调用时需附带记录ID区分具体是哪一条记录。三者优缺点各有侧重:事务脚本简单、事务边界清晰、易与简单数据源层配合,但逻辑复杂后容易产生重复代码、结构杂乱;领域模型能用继承/策略等技术从容应对复杂逻辑的持续演化,但上手门槛高、数据源层映射代价大;表模块提供了比事务脚本更多的结构、更容易发现冗余,且天然契合基于记录集的GUI/ORM工具(如.NET环境),但拿不到领域模型的细粒度面向对象组织能力。三者并不互斥,同一系统里用事务脚本处理简单部分、领域模型或表模块处理复杂部分是常见做法。 进一步展开见三种领域逻辑模式对比。

从事务脚本转向领域模型是一次范式转换:事务脚本由一个过程掌控某个动作的全部逻辑,在一处就能看完流程;领域模型把行为分散在对象网络中,初学者常要在对象间来回跳转才能找到某个行为,这种挫折是真实代价。收入确认的例子中,事务脚本的一个方法包揽全部工作;领域模型则层层转发到策略对象,新增一种算法只需新增一个策略类,事务脚本却要不断堆条件分支。评估新范式时,也要诚实计入团队数月的学习成本。 进一步展开见领域模型的范式转换。

表模块看似与领域模型相近,关键区别是:领域模型中每条合同记录对应一个合同对象,表模块只有一个围绕整张表组织的合同对象,先查询得到记录集再构造它,每次调用都要传入具体合同的 ID。它的优势在于契合以记录集为中心的环境,如 COM 与 .NET 的 GUI 工具天然处理 SQL 返回的记录集,可以查询、计算校验、交给界面显示,再把界面数据原样传回。选择表模块,本质上是押注技术栈的生态围绕记录集打转。 进一步展开见表模块面向记录集。

三种领域逻辑模式的选择主要取决于逻辑复杂度:逻辑简单时,领域模型的学习成本和数据源层复杂性得不偿失;复杂度上升后,其他模式新增功能的难度会急剧增加。“复杂度大于 7.42 就该用领域模型”是故意荒诞的说法,意在点明没人知道如何量化领域复杂度,决策曲线只是帮助建立直觉的示意图。实际只能请有经验的人尽早判断;团队越熟悉领域模型,曲线越向它倾斜,但数据源层的复杂性始终存在。 进一步展开见选型没有量化阈值。

领域逻辑模式一旦选定,中途更换代价不小,值得一开始多想。发现选错时,补救方向并不对称:先选事务脚本、后发现逻辑比预想复杂,应毫不犹豫改用领域模型,继续硬撑只会让重复和混乱越滚越大;先选领域模型、想退回事务脚本通常不值得,除非能借此简化数据源层,因为已付出的理解与映射成本不会收回。从简单方案升级往往畅通,从复杂方案降级却要额外拆解,选型时要想清楚回头路好不好走。 进一步展开见换模式的代价不对称。

服务层架在领域模型或表模块之上,只有领域层已相当复杂时才值得切出;只用事务脚本时领域层本身不复杂,再加一层是浪费。有了服务层,表现层与领域层的交互都经过它,它就像应用对外的 API:调用方看到一组清晰统一的方法,不必直接接触内部复杂的对象网络;它也是放置事务控制、安全校验等横切关注点的天然位置,可在这里统一声明每个方法的事务边界与安全特征。 进一步展开见服务层是应用的API。

服务层里该放多少行为,是一个需要认真权衡的决定,它可以看成一个连续谱。最小化的一极:服务层只是一个纯外观,真正的行为全在下层对象里,服务层只负责把上层调用原样转发下去,好处是方法通常按用例组织、更易用,同时是加事务封装和安全检查的天然切入点。最大化的另一极:把大部分业务逻辑都以事务脚本的形式直接塞进服务层,下层领域对象因此变得极简——如果下层是领域模型,这些对象甚至可以退化成与数据库一一对应,从而用上活动记录这类更简单的数据源层。二者的折中是”控制器-实体”风格(术语受[Jacobson et al.]影响):把单个事务/用例特有的逻辑放进事务脚本形式的”用例控制器”里,而可被多个用例复用的行为则放进被称为”实体”的领域对象里。对控制器-实体风格应保持谨慎:和纯事务脚本一样,用例控制器容易产生代码副本;更稳妥的立场是——如果真的决定用领域模型,就该彻底贯彻,让它在应用中占主导地位,不要搞半吊子的折中;只有一种例外情况值得从行数据入口的事务脚本挪一部分冗余行为进去,把它逐步改造成基于活动记录的简单领域模型,但这只用来改进已有缺陷设计,不作为起手方案。默认建议是:先假定不需要服务层,等应用确实需要时再加,且倾向于让服务层尽量最小化;但也承认不少优秀设计者习惯让服务层承载更多逻辑,这是合理的另一种取舍。 进一步展开见服务层瘦身的两极。

领域模型的第二笔开销在数据源层:模型用得越充分,映射到关系数据库就越复杂,通常要靠数据映射器。作者把复杂的数据源层比作固定资产投资:要么花大钱买,要么花大量时间自建,前期回报很低;可一旦建好,后续许多功能都能在它上面低成本完成。所以小项目、一次性系统难以摊薄这笔投入,长期演进的复杂系统才划算。发散:评估是否引入 ORM 时,按资产折旧思路算摊销周期。参见领域模型的范式转换、选型没有量化阈值。 进一步展开见数据源层像固定资产。

原书依据 · 12 处

行入口与表入口的选择

把SQL从领域逻辑中剥离出来、放进独立的”入口”类,是清晰分离数据库访问代码的明智之举——这样应用其余部分完全不用了解任何SQL细节,专攻数据库的开发者也能一眼找全所有数据库访问点。入口主要有两种组织方式:行数据入口对查询返回的每一行产生一个对应实例,是”用面向对象方式看待数据”的直观做法;表数据入口对每个数据库表只用一个对象来管理,提供查询方法并返回记录集这种通用的表格式数据结构。表数据入口与记录集天然匹配,因此是使用表模块时的当然选择,也是组织存储过程访问的合适模式——可以把一整套存储过程集合看作是某张表的表数据入口,必要时再用一个内存中的表数据入口包装存储过程调用,把调用机制封装起来。即使在简单应用中,也值得用某种入口模式把SQL和领域逻辑分离开来,这个收益不取决于应用规模。 进一步展开见行入口与表入口的选择。

如果领域逻辑简单、领域类和数据库表基本一一对应,直接让每个领域对象自己负责与数据库交互,即活动记录,是最省事的选择——可以把它理解成”从行数据入口出发,把领域逻辑逐步加进这个类里”,尤其当从多个事务脚本中发现重复代码时自然演化出来。但随着领域逻辑变得复杂,活动记录会逐渐力不从心:领域类与表的一对一关系会因为把逻辑拆到更小的类中而失效,关系数据库天生不支持继承,导致策略模式等轻量OO技巧很难用上,而且你会希望脱离数据库也能随时测试领域逻辑。这时给领域模型套一层”入口”(行数据/表数据入口)虽然能缓解一些问题,却仍把数据库方案和领域模型耦合在一起,还平添了入口域到领域对象域之间的转换复杂度——因此不推荐把入口用作领域模型的首选持久化机制。真正的解法是让领域模型和数据库彻底独立,用一个专门的间接层(数据映射器)负责两者之间所有的存取映射,让双方能各自独立演化——这是最复杂的一种数据库映射架构,但换来了两层的完全解耦。这些持久化机制并不互斥,但首选机制只应该选一个,不要混用导致凌乱;即便以数据映射器为首选,仍可以用数据入口去封装被视为外部接口的表或服务。 进一步展开见持久化机制的渐进选型。

面向对象数据库把对象直接存到磁盘,程序员无需操心映射,原书作者根据未经受控测试的观察,认为可减少映射投入;“约三分之一”只是他的历史估计,并非普遍测量结论。可多数项目仍选关系数据库,原因是风险而非性能:关系数据库成熟易懂、有大厂长期支持,SQL 为几乎所有工具提供标准接口。一项技术理论上更高效,并不意味着会被选择;当确定性、生态成熟度和供应商可替换性被计入决策时,牺牲部分效率换取低风险完全合理。 进一步展开见关系库胜在生态确定。

有了领域模型,应认真考虑购买商业 O/R 映射工具,而不是自建数据映射器:这件事很复杂,厂商已投入多年,成熟工具比同等规模的手工产物更可靠,代价是价格不菲,需要与自建维护成本比较。但买了工具不能丢开这些映射模式:好工具提供大量配置选项,只有理解单表继承、外键映射、依赖映射等取舍,才知道如何配置。工具解决“怎么实现”,“该怎么取舍”仍是团队自己的责任。 进一步展开见买O/R工具仍需懂模式。

内存中对象一多,又出现新建一行后要拿到其主键才能修改引用它的其他行时,“每个对象自带加载保存方法”就难以管理,必须有人跟踪哪些对象改过、按什么顺序写回。工作单元跟踪所有读入和修改过的对象,按正确顺序提交更新,开发者把工作交给它,而不是显式调用保存。它相当于专职的数据库映射控制器,把本会落到领域层头上的读写协调职责剥离出来。协调职责散落在业务对象各处时,值得单独抽成一个对象。 进一步展开见工作单元协调读写。

把同一行数据加载成内存中两个对象,更新时就会互相覆盖。标识映射在读取前先查是否已加载,已加载就返回原有对象,保证一行只对应一个对象;它顺带像缓存一样省掉部分查询,但根本目的是一致性而非性能。延迟加载解决另一个问题:对象层层关联,读一个就可能带出一大片,于是让引用先指向占位符,真正访问时才读取。两者常一起出现,但一个管“会不会重复加载导致冲突”,一个管“要不要现在就加载”。 进一步展开见标识映射与延迟加载。

查找器用 find(id)、findForCustomer 等方法隐藏 SQL。放在哪里取决于入口类型:基于表的类可以把插入、更新和查找都放在一起;基于行的类若把查找写成静态方法,数据库操作就无法替换,测试时也不能用服务桩代替,所以最好单独建查找器对象,返回一组行对象。另一个陷阱是查找器看到的是数据库状态而非内存状态,只存在于内存、尚未写回的新成员不会出现在结果里,原书建议尽量在内存变更前完成查询;若要让查询包含未提交变化,需显式选择并验证刷新或内存合并策略,不能假定查找器会自动包含。 进一步展开见查找器的归属与陷阱。

读取数据的性能优化有三条经验法则。一,尽量一次读回多行,别为了拿到多行数据在同一张表上反复查询——”数据多了没关系”往往优于”数据不够精确要多次往返”,比如要拿50个人的数据,与其发50次独立查询,不如用一次能覆盖200个候选人的查询、再在内存里用逻辑筛出想要的50个,只是要留意悲观并发控制下一次锁太多行的风险。二,用联接(Join)在一次查询里跨表取数据,代价是记录集看起来会比较古怪,可减少往返,但是否更快须实测;原书“3~4个联接”是历史经验,不能当作数据库通用上限;规划成本、执行计划、索引、行数与实现都会影响结果。三,这些法则终归只是指导,具体该怎么做必须结合自己的数据库和数据实测——数据库系统和应用服务器往往有复杂的缓冲机制,几乎每条经验法则都有让人意外的反例,值得花额外时间做性能剖析和调优,而不是死守通则。 进一步展开见数据库读取三条经验。

对象-关系映射真正棘手的地方在于对象和关系模型处理”连接”的方式根本不同,这体现在两点:其一,表现方式不同——对象通过运行时的引用(内存地址)来表示连接,关系数据库通过指向另一张表的键值来表示连接;其二,多值处理能力不同——对象可以轻松用集合表示”一对多”引用,但关系规范化要求所有关系连接都必须是单值的,这导致对象和表之间的数据结构方向是颠倒的:一个订单对象自然拥有一个订单项集合、订单项无需持有订单引用,但表结构里订单项必须持有指向订单的外键,因为订单表不能有多值列。解决表现问题的通用思路是:给每个对象一个标识域来承载它的关系身份,用标识映射做关系键与对象之间的相互查找。在此基础上,针对不同的连接形态各自有专门的模式来处理:单值域和一对多集合域用外键映射(结合延迟加载避免不必要的查询);多对多关联(两边都是集合)用关联表映射,额外建一张纯关系表来承接;只在拥有者范围内使用、不对外暴露的从属对象用依赖映射简化;日期范围、货币这类没有独立身份的小型值对象用嵌入值直接摊平进宿主对象的表;相对独立、高度互连的一整串小对象(如层次化的组织结构图)则可以用序列化LOB整体存成一个大字段,用一次读取换取避免大量小型数据库调用的开销,代价是SQL无法感知这个大字段内部的结构、难以对其做可移植查询。 进一步展开见对象与关系的连接差异。

SQL没有标准的继承表达方式,因此把一个继承类层次映射到关系表,一般有三种选择,本质是在”数据结构复制”和”访问速度”之间做权衡。单表继承:整个层次的所有类共用一张表——最大的好处是把所有内容放在一起,修改容易、还避免了连接操作;主要弊端是每一行都要为所有可能的子类预留列,造成大量空列浪费空间(多数数据库能较好压缩这种浪费),而且表本身的体积会逐渐成为访问瓶颈。类表继承:层次中每个类各自建一张表——这是类和表之间最简单直观的对应关系,但载入一个对象往往需要多次连接操作,通常会拖累性能。具体表继承:每个具体类各自建一张表——避免了连接操作、可以从一张表直接取出一个完整对象,但可维护性差:修改超类会牵连所有子类对应的表和映射代码,改动层次结构本身代价更大;同时因为没有独立的超类表,主键管理会很棘手、引用完整性也难保证(好处是减少了对超类表的锁争夺)。三种选择并不互斥,同一个层次里可以混合使用(比如整体用单表继承、个别特殊情况单独用类表继承处理),但混用会增加复杂性。没有绝对最优解,可倾向单表继承(易实现、易重构),需要时再用另外两种模式解决不可避免的空列/无用列问题,并建议最终结合具体环境和数据库管理员的建议决定。多继承/接口的情况本质上是这三种模式的变体:单表继承把所有超类和接口塞进一张大表,类表继承为每个接口和超类各建一张独立表,具体表继承在每张具体表里包含所有接口和超类的列。 进一步展开见三种继承映射的权衡。

可以自由设计数据库时,简单逻辑直接围绕数据设计表并用入口隔离 SQL;用领域模型则应先不受数据库牵制地建模,由数据映射器负责持久化,若二者恰好同构也可退用活动记录。但“先建模型后建库”只在短迭代中才安全:花半年建一个不碰数据库的模型、最后再持久化,往往会被性能问题逼着大改设计。每次迭代都应同步建库,迭代不超过 6 周,越短越好。先纯粹设计、后对接现实的做法,只有反馈闭环足够短才可靠。 进一步展开见模型与库要同步迭代。

同一数据有时要从多个来源读取,如方案略有差异的多个数据库,或同时来自 XML 消息、CICS 事务和关系表。给每个源各建一套映射层会产生大量重复。两步映射更好:先把内存对象映射到一个最大化各源共性的逻辑数据存储方案,再从它映射到各个物理存储,把真正的差异隔离在第二步。这层中间表示只在各源共性多、又有几处恼人差异时才划算。对接多个相似但细节不同的外部系统时,这一思路同样适用。 进一步展开见多数据源的两步映射。

手写列到字段的映射代码简单却高度重复,而重复本身就是设计问题的信号。元数据映射把“哪列映射到哪个域”写进元数据,再用代码生成或反射自动产生读写、连接、SQL 拼装乃至按引用完整性排序写入的代码,这也是商业 O/R 工具普遍采用的方式。在其上还能构建查询对象和资源库,让开发者用对象的语言表达查询、不必分辨数据来自内存还是数据库。先手写理解映射,再用元数据简化,才不是绕过理解的捷径。 进一步展开见元数据映射。

数据库连接是珍贵资源,用完要立即释放;连接池如今多由平台提供,自建前先确认确实能提速。要保证需要连接的地方拿得到,层层传参会污染调用链,常用线程范围的注册表存取。要保证用完关闭,不宜依赖垃圾回收:回收时机可能远晚于最后一次引用,只适合作兜底。最好把连接生命周期绑定到事务,开始时打开、提交或回滚时关闭,开发者只关心事务即可,忘记提交也容易发现,工作单元正适合承担这一角色。 进一步展开见连接随事务管理。

映射集合时有两个容易被忽略的细节。一是顺序:对象里常用列表这类有序集合,测试也更方便,但存进关系库后很难维持绝对顺序,要么改用无序集,要么每次查询都显式排序,后者可能代价不小。二是引用完整性:每写一行就检查,就得严格安排更新顺序。若数据库与约束定义支持延迟检查,可把检查放到事务结束,但仍须确认业务错误发现时机和提交失败处理;否则可对更新做拓扑排序,或固定各表的写入顺序,这还能减少死锁和回滚。参见对象与关系的连接差异、死锁成因与预防。 进一步展开见集合顺序与写入顺序。

手写映射代码时有几条朴素纪律。别把 select * 和按位置取列搭配使用,一旦新增或重排列,代码就悄悄错位;按列名取值更易读,若担心慢就实测。用位置索引时,让取值代码紧挨着 SQL 定义。为每个映射结构写最简单的增删改查测试,专门抓 SQL 与代码不同步。尽量用预编译的静态 SQL,避免用字符串拼接查询。发散:拼接 SQL 不只慢,还是注入漏洞的温床。参见行入口与表入口的选择。 进一步展开见SQL编码几条纪律。

书中说的“表”泛指一切表型结构,视图、存储过程封装的查询也算,读取它们和读表没什么两样,麻烦出在更新。视图更新最终影响基础表;原书“不能直接更新”过于绝对,一些数据库对满足条件的简单视图支持直接更新,所以最好用入口等模式把更新逻辑封装起来。另一个隐患是:不清楚视图如何组成的开发者,可能分别更新两个看似无关的视图,而它们底下是同一张表,后一次写入就悄悄覆盖了前一次。更新逻辑做了校验能避免,但仍让人难以理解。参见更新丢失与不一致读。 进一步展开见经视图更新的陷阱。

原书依据 · 21 处

脚本处理请求页面出结果

Web 服务端有两种写法。脚本形式如 CGI、servlet,是检查请求并用输出流写出响应的程序,用它拼 HTML 很别扭,于是出现了 PHP、ASP、JSP 等服务器页面,把代码嵌进 HTML。二者各有所长:脚本适合解释请求中的各种判断,服务器页面适合格式化应答,但处理复杂输入就会变乱。因此应该用脚本解释请求,用服务器页面格式化应答。这种请求处理与应答格式化的分离源自 MVC,是剥离非表现逻辑的具体化。 进一步展开见脚本处理请求页面出结果。

模型-视图-控制器(MVC)是一个被广泛引用却常常被误解的模式,误解的一大根源在于”控制器”这个词被用在太多不同语境里,含义并不统一。为避免混淆,这里用”输入控制器”专指MVC里处理HTTP请求的角色:一条请求消息进入输入控制器,输入控制器从中提取信息后,把业务逻辑转交给合适的模型对象;模型对象与数据源交互、完成处理并收集应答信息后,把控制权交还给输入控制器;输入控制器再决定用哪个视图来渲染应答——这中间通常还要经过把数据放进某个HTTP会话对象、供输入控制器与视图共享这一步,而不是输入控制器直接把数据塞给视图。使用MVC最重要的理由是保证模型与Web表现层彻底分离:这样修改表现层、或者给同一套领域逻辑加一层新的表现层都会很容易,把处理逻辑放进独立的事务脚本或领域模型对象也让测试变得容易——如果视图用的是服务器页面技术,这层分离尤其关键,能避免业务逻辑和页面结构混杂在一起。 进一步展开见Web场景下的MVC。

应用控制器位于表现层与领域对象之间,专门处理应用流程,即各屏幕按什么顺序出现;若独立于具体表现层,还可在多种表现层间复用,但各表现层流程往往不同。并非都需要它:屏幕顺序和导航有丰富逻辑,或网页与领域行为不是简单一一对应时,它才有价值;用户可以任意顺序访问各屏幕时则多余。简单的判断法是:流程由机器主导就需要应用控制器,由用户主导就不需要。 进一步展开见何时需要应用控制器。

选择视图方案实际上要做两个互相独立的决定。第一个决定:转换视图还是模板视图。模板视图允许直接在网页结构里编写表现层、嵌入标签指明动态内容该填到哪里(ASP、JSP、PHP等服务器页面技术都基于此),功能强大灵活,但如果不刻意约束(比如把程序逻辑抽到独立的辅助对象里),很容易让代码和页面结构混成一团、难以维护;转换视图走的是”转换”风格(典型如XSLT),如果领域数据本身是XML格式(或容易转换成XML),输入控制器只需挑选合适的样式表、应用到模型收集的XML数据上即可,效果很好。第二个决定,与第一个决定正交:用单阶视图还是两步视图。单阶视图通常是”一个屏幕对应一个视图组件”,视图直接从领域数据提取内容、生成HTML。两步视图把这个过程拆成两段:先由领域数据生成一个与展现技术无关的”逻辑屏幕”,再把这个逻辑屏幕交给第二阶段渲染成HTML——好处是要改变全局的HTML呈现方式时,只需改动这个共享的第二阶段目标对象,前提是各处屏幕本身共享相似的逻辑设计(如果站点设计得过于精细、各屏幕差异很大,就很难提炼出统一的逻辑屏幕结构);两步视图尤其适合同一套逻辑要服务多种前端外观的场景,比如多家航空公司共用同一套后台订票系统、各自换一套第二阶段呈现,或是要同时支持浏览器和掌上设备这类差异很大的输出终端——当两个界面差异过大(如浏览器与手机屏幕),共享逻辑屏幕就基本不可行了。 进一步展开见视图模式的两个维度。

输入控制器有两种组织方式。页面控制器为每个动作而非严格意义上的每个页面配一个控制器,简单时它就是同时处理输入和视图的服务器页面,多数实现则拆成独立对象,创建处理对象并选择视图。输入控制器都有两项职责:处理 HTTP 请求、决定下一步做什么,二者可以分开。前端控制器分得更彻底:由单一对象接收所有请求,解释 URL 和请求类型后再创建具体处理对象,站点行为结构变化时不必重新配置 Web 服务器。 进一步展开见页面控制器与前端控制器。

原书依据 · 6 处

更新丢失与不一致读

并发控制真正要防范的本质问题主要有两类。更新丢失最容易理解:David和Martin同时编辑同一份文件的不同部分,David后开始却先完成、Martin后完成,Martin提交时读的是David修改前的旧版本,写回时就把David的修改整个覆盖掉,David的更新凭空消失了——这类问题的根源是”读的时候没看到别人已经写进去的东西,写的时候又把这个没看到的更新覆盖了”。不一致读则更容易被忽略:Martin先查了A包有7个类,中途接了个电话,这期间David往A包加了2个类、往B包加了3个类(原本5个类),Martin挂电话后接着查B包看到8个类,两个数字相加得到15——但15永远不是正确答案,正确答案只能是David修改前的12(两次查询都发生在修改前)或修改后的17(两次查询都发生在修改后),因为Martin读到的是两个分别正确但互相矛盾的时间切片拼出来的结果。这两类问题都属于正确性(安全性)层面的失败:只要保证同一时刻只有一人能操作数据,两者都不会发生,但这样做会严重削弱并发的灵活性——因此并发设计从来不是单纯追求正确性,而是要在正确性与灵活性之间根据失败的严重性和实际并发需求做权衡。 进一步展开见更新丢失与不一致读。

更新丢失和不一致读都是正确性问题,只要规定同一时刻只能一人操作数据就能消灭,代价是把并发的灵活性压到最低。所以正确性与灵活性此消彼长,牺牲多少要看失败的严重程度、发生概率以及业务对并发的实际需要。任何并发控制机制本身也会带来新问题,只是通常没原来严重。由此推论:若某场景能容忍偶尔的更新丢失或不一致读,后果轻、概率低,完全可以不加控制,不必对所有数据一视同仁地上锁。 进一步展开见正确性与灵活性的权衡。

谈并发离不开先厘清几个执行语境概念,它们从交互、执行与提交三个角度描述工作,不构成固定大小顺序或严格嵌套关系。请求:外部环境发出的单个调用,处理过程主要在服务器端进行,客户端等待应答;同一用户连续发出的两个请求(如先下单再取消)在服务器看来是否有关联,取决于所用协议是否记录了这层关系。会话:客户端与服务器之间一次较长时间的交互,通常由一连串用户认为逻辑上相关的请求构成,一般始于登录、终于用户退出(或被系统判定为离开);服务器软件往往同时活跃着两种会话——面对客户端的HTTP会话,以及作为其他系统客户端时发起的数据库会话。进程:操作系统级别的重量级执行语境,把内部数据与外界隔离开;线程:进程内部的轻量级活跃执行单元,一个进程可以容纳多个线程,人们爱用线程是因为能在单进程内同时服务多个请求、充分利用资源,但线程通常共享内存,这正是并发问题的源头(也存在不共享内存的”孤立线程”设计)。事务:处理数据库时的另一个重要语境,能把多个请求当作单个请求对待,可能发生在应用程序与数据库之间(系统事务),也可能发生在用户与应用程序之间(业务事务)——这组区分对理解后续的离线并发问题至关重要。理论上每个会话独占一个进程能最大限度减少并发冲突,但现实中很少有服务器工具支持这么做;早期Perl Web系统曾”每请求一进程”,在原书时代因创建进程开销受到质疑,”一个进程一次只处理一个请求”仍是常见的规避并发的简单做法。 进一步展开见五个执行语境辨析。

并发问题源于多个执行单元同时修改同一份数据,最根本的两种解法都直接改变这个前提。隔离:把数据分开,让每份只被一个执行单元访问,如进程独立的内存空间、文件锁下他人只拿到只读副本;好的设计应主动寻找隔离区,让尽量多的工作在区内完成。不变性:只有可修改的共享数据才有并发问题,识别出不变或几乎不变的数据,就能放心共享。面对并发先问能否隔离、是否根本无需修改,真正的锁机制只留给剩下的可变共享数据。 进一步展开见隔离与不变性。

当有些可变数据实在无法隔离时,主要有两种并发控制策略。乐观锁:所有人都能拿到数据的拷贝并自由编辑,谁先完成谁先无阻碍地提交,后完成的人在提交时才会被检测出与已提交修改的冲突,需要自己想办法处理(合并或放弃重做)——可以把乐观锁理解为”关于冲突检测的”策略(尽管它其实不是真正的加锁,但这个叫法太流行以至于无法忽略)。悲观锁:谁先取得数据,别人就不能动它,必须等到锁被释放——可以理解为”关于冲突避免的”策略。两者各有代价:悲观锁的问题是显著削弱并发程度,别人只能干等,对企业数据而言经常连读取都做不到;乐观锁的问题是冲突发生后必须有人去处理合并——源代码这类结构化文本往往能自动合并或至少容易看出差异,但业务数据通常难以自动合并,出现冲突常常只能推倒重来。选择两者的核心标准是”冲突的频率与严重性”:如果冲突很少发生、或者发生了后果也不严重,通常应该选乐观锁(并发性更好、实现也更容易);如果冲突一旦发生会让用户很痛苦(比如已经填了一小时的表单被作废),就应该选悲观锁。但无论选哪一种,都可能引入和原来同样多的新麻烦,不存在无代价的方案。 进一步展开见乐观与悲观并发控制。

不一致读常被忽视:别人改了你依赖的接口,你按旧接口提交,同样会出错。悲观锁用读锁与写锁配合,有人持读锁就拿不到写锁,持写锁则两种锁都拿不到。乐观锁用版本标记检测冲突,提交前把读取过的数据与共享数据的版本比对。但对所有读过的数据都检查容易小题大做,应区分用于决策的数据和顺带读到的数据:产品列表新增一条无关紧要,已汇总的费用清单被改就严重,这需要逐项分析。另一思路是按时间点读取的时序读。 进一步展开见防范不一致读。

本节用悲观锁说明循环等待造成的死锁:Martin锁住了Customer文件、David锁住了Order文件,随后Martin发现自己也需要Order(被David锁着)、David发现自己也需要Customer(被Martin锁着)——双方互相等待,谁都无法继续,除非其中一个放弃。死锁在包含很多参与者的复杂链条里会变得更棘手、更难察觉。处理死锁大致分两类思路:一类是事后处理已经发生的死锁——软件检测死锁后选一个”牺牲者”,放弃其工作和已加的锁(死锁检测本身很难做,对牺牲者也很痛苦);或者给每个锁设超时时间,到期自动失效、工作作废(比死锁检测容易实现,但代价是可能把一个原本没有死锁、只是持锁时间长的人误判为牺牲者)。另一类是从源头上防止死锁发生——死锁的根源是”已经持有一个锁的人还想再申请更多锁”,因此可以强制所有人一开始工作就必须获取全部可能需要的锁,之后不允许再申请新锁;具体实现可以是强制按固定顺序(如字母顺序)获取锁,排序靠后的一方自动成为让步的”牺牲者”;也可以更简单粗暴——谁后申请、谁就自动放弃。原书倾向简单保守地组合这些手段,但需确认策略能一致执行;一种可行做法是(比如”一开始锁光所有需要的资源”加上”超时兜底”),像同时系腰带和背带一样保守,因为死锁太让人头疼、太容易出错——对大多数企业开发者而言,宁可选用简单保守、偶尔产生不必要牺牲者的方案,也不要冒着漏判某个死锁场景的风险。 进一步展开见死锁成因与预防。

事务是一组有明确开始和结束边界的操作。原子性要求受同一事务机制保护的修改整体提交或撤销;一致性要求提交前后满足约束,业务规则仍需应用正确实现;隔离性限制并发事务相互影响,具体可见性由隔离级别决定,并非所有级别都禁止脏读;持久性保证已提交结果在其承诺的故障模型与持久化配置下可恢复。ATM吐钞等外部动作不会因数据库回滚自动撤销,必须另行协调,不能由类比推断数据库事务覆盖所有资源。 进一步展开见事务要素与ACID。

事务资源不只有数据库,还包括消息队列、打印机等。为提高吞吐,事务应尽量短、不跨请求。开启时机有两种:请求事务在请求开始时开启、结束时提交,简单直接;延迟事务把读操作放在事务外,只在要写时才开启,缩短事务时间,代价是开启前没有并发控制,可能不一致读,只在竞争激烈或业务事务跨请求时才值得。还要注意锁粒度:某些数据库/锁策略会在行锁较多时升级,另一些实现并不如此;应核对目标引擎,不从锁数量直接推出必然表锁。通用对象表也须结合访问和竞争评估。 进一步展开见事务时机与锁升级。

可串行化要求并发结果等价于某个串行执行,并不要求实际逐个执行。SQL标准的读未提交可允许脏读;读已提交仍可能不可重复读;可重复读防止既有行值重读变化,但标准仍允许符合查询条件的行集合变化,即幻读。具体产品可提供更强保证,例如PostgreSQL的可重复读不允许幻读,仍可能发生序列化异常。隔离强度与吞吐不存在无条件单调关系;按业务不变量、实现与实际竞争选择,不能把“7+8”混合统计例当作所有可重复读实现的必然表现。 进一步展开见隔离级别与读错误。

系统事务是数据库或事务管理器提供的有界提交单元;业务事务则是用户认为完整的一段工作,如填写账单后确认。用户思考跨越多个请求,不宜默认长期占用数据库事务。拆成短事务后,需要离线并发控制保护中间读取与提交前提。若全部修改先保存在会话中,最后在同一系统事务写出,才可利用它实现最终写集的原子性与持久性;这不等于任意多个已提交事务或外部副作用能自动获得整体ACID。 进一步展开见业务事务与系统事务错位。

应尽可能让事务系统处理并发,自己跨系统事务控制并发是一片危险水域。能把业务事务放进单个系统事务或能承受长事务时,就直接这样做;离线并发模式只是退路。不得不自己处理时,首选乐观离线锁,实现容易、灵活性最好,但要到提交时才发现失败,用户填了一小时的表单才被告知失败代价很大;悲观离线锁能更早发现冲突,但更难实现、灵活性更差。选择会直接影响用户体验,所以并发不是纯技术问题,离不开对业务的理解。 进一步展开见离线并发能免则免。

应用服务器自身的并发(怎样同时处理多个请求)与前面讨论的数据源并发不同:它不涉及事务,因此打交道时用不上相对受控的事务系统这套工具,处理起来风险更直接——显式的多线程编程配合锁和同步阻塞太复杂,容易埋下几乎无法重现、只在极少数情况下发作的诡异错误,因此策略应该是尽量避免让应用开发者直接接触显式的同步和锁机制。最简单的做法是每会话一进程:每个会话独占一个进程,进程间天然完全隔离,可避免进程内共享可变对象造成的一部分线程问题,外部共享资源仍须协调(早期Perl Web系统甚至每请求建一个新进程);代价是进程很贵,大量会话意味着大量资源消耗,可以用进程池缓解——每个进程一次只处理一个请求、但能跨时间处理来自不同会话的多个请求,用更少资源撑住同样多会话,隔离性几乎不受影响(Apache mod_perl等大规模系统采用此法),唯一要小心的是必须保证每个请求结束时都彻底释放所占资源。更进一步是每会话一线程:一个进程内跑多个线程,每次请求由某个线程处理,线程比进程轻得多,能用更少硬件扛更多请求、服务器效率更高;代价是线程之间没有隔离,任何线程理论上都能碰到它能访问的任何数据。较稳妥的立场是:尽管每会话一进程效率不如每会话一线程,原书认为两者均可扩展,实际资源上限与伸缩效果须测量,前者健壮性更好(某个线程崩溃可能拖垮整个进程,而进程级隔离能限制这种破坏),对经验较少的团队而言,用硬件成本换取免于处理线程问题(以及随之而来的调试成本)往往是划算的——但很少见到有人真正做过量化的性能对比测试。 进一步展开见每会话进程或线程。

每会话一线程时,最重要的是给每个线程一个隔离区,让开发者在区内忽略多线程问题。最常用的做法是每次请求都创建新对象,且不放到其他线程能看到的地方,如静态变量。有人怕创建对象昂贵而缓存复用,结果必须自己同步访问,又把线程问题请了回来;而在现代运行环境中,创建对象往往很便宜。例外是静态变量、全局变量、单例仍须同步,需要全局空间时用按线程存放的注册表;数据库连接这类昂贵对象则放进连接池。 进一步展开见每次请求创建新对象。

原书依据 · 16 处

无状态指不跨请求

字面上真正无状态的对象没有任何成员变量,这很罕见,也是糟糕的设计,因为对象本该把状态和行为结合在一起。企业应用中的“无状态服务器”指在请求之间不保留状态的对象:它可以有成员变量,只是每次调用时这些变量之前的值都被视为未定义。根据 ISBN 返回书籍详情的服务,处理一次请求时可以暂存书名、价格来决定页面格式,但请求结束就要丢弃。判断是否无状态,看的是成员变量的值是否需要跨越请求边界存活。 进一步展开见无状态指不跨请求。

对象若要在请求之间保留状态,就必须在用户思考、迟迟不发下一个请求的整段时间里占着资源。设想 100 人查询书籍,每次处理 1 秒,每人每 10 秒发一次请求:有状态设计要为每人配一个对象,共 100 个,其中九成时间闲置;无状态设计只需约 10 个对象就能满负荷服务。请求之间不需要状态时,就不必在意由哪个对象处理,可以用少量对象服务大量用户。决定是否保留跨请求状态前,值得先算这笔专属占用与按需复用的账。 进一步展开见无状态的资源杠杆。

并非所有交互都能无状态,很多交互本身就带有状态。购物车是典型:边浏览边加购的商品必须贯穿整个会话,这是一个尚未提交的业务事务,会话因此是有状态的。状态还可能动态变化:只浏览不购买的会话无状态,一加购就变成有状态;除非没人下单,否则应用无法彻底回避状态问题。不过,有状态的会话仍可以用无状态的服务器对象实现,把状态外置存储,而不是绑在处理请求的对象上,只是这未必总是理想的选择。 进一步展开见购物车让会话有状态。

会话状态活在尚未提交的业务事务中,带有 ACID 的部分性质,也带来反直觉的结果。一致性:用户输入了非法值,系统提示无效,但该值仍是会话状态的一部分,因为校验通常在提交时才严格执行。隔离性:编辑保单十分钟后才去查邮编,期间别人若改了邮编或风险值,就读到了不一致的数据。另外,会话里并非所有数据都是会话状态:为提升性能临时缓存的数据丢了只需重算,而真正的会话状态丢了就会出错。 进一步展开见会话状态与临时缓存。

确认需要保存会话状态之后,存储位置大致分三种。客户会话状态:数据保存在客户端,Web应用里常见做法包括把数据编码进URL、用Cookie、把数据串行化成表单的隐藏域,或者在胖客户端里直接放进对象结构。服务器会话状态:最简单的形式是在各次请求之间直接把数据留在内存里;也可以做得更持久一些,把对象序列化后存到应用服务器的文件系统里,或存进某种共享数据源(比如一张以会话标识号为键、以序列化对象为值的简单数据库表)。数据库会话状态:同样存在服务器端,但做法不同——把会话数据拆解成多张表和多个字段,像存储真正的持久化数据那样存进数据库里。三者并不互斥,理论上可以混合使用来分别存储会话状态的不同部分,只是这样做通常会让”哪部分数据该用哪种方式”变得难以理清;即使主要采用客户会话状态以外的方式,也建议至少在客户端保留一个会话标识号,以便定位对应的服务器端或数据库中的会话数据。 进一步展开见三种会话状态存储。

在客户/服务器/数据库三种会话状态存储方式之间做选择,需要同时权衡多个维度。带宽:客户会话状态要求每次请求都把会话数据整个通过网络传送,数据量小尚可接受,一旦数据量大(书里提到有团队用到过三部莎士比亚戏剧那么大的会话数据)带宽压力会非常可观,即便压缩也未必够用——因此除非会话状态确实很小,否则不建议用客户会话状态。安全与完整性:客户端数据必须防范恶意用户篡改,不加密就可能出现”自己定价”式的漏洞(用户直接改价格)。隔离性:会话数据原则上不该影响会话之外的任何东西(比如没确认的航班预订不该影响其他用户),数据库会话状态在这一点上最棘手,需要额外花力气把会话数据和真正的持久记录数据隔离开。集群与迁移:用户多到需要集群时,要考虑”会话迁移”(一次会话的请求可以被不同服务器接力处理,均衡负载更好,但服务器会话状态难以支持,因为只有处理过该会话的服务器才容易找到其状态)还是”服务器亲和”(同一会话的请求固定绑给同一台服务器,代价是可能因代理IP合并而意外把大量不同用户的流量集中压到一台服务器上)。响应性:服务器会话状态能直接访问、无需转换;客户/数据库会话状态都需要额外的格式转换或查询开销。取消会话的处理:B2C场景里用户经常”人间蒸发”而不是显式退出,客户会话状态天然能应付(忘掉就是了),其余方式则必须主动检测并清理失效会话,或依赖支持会话超时的系统。系统失效恢复:数据库会话状态能扛住客户端崩溃、服务器崩溃、网络中断三种情况;服务器会话状态能否扛住取决于是否落到了持久存储介质;客户会话状态扛不住客户端崩溃,但能应付另外两种。开发代价:服务器会话状态通常最省事(尤其不需要持久化时),客户/数据库会话状态都要花额外精力做数据解析转换。 进一步展开见会话状态的选择框架。

集群处理同一会话的多次请求有两种思路。会话迁移让不同请求由不同服务器处理,负载均衡更精细,尤其适合长会话;但服务器会话状态只有处理过的那台才好找到,要支持迁移往往得模糊服务器与数据库会话状态的界限。服务器亲和让同一会话始终落在同一台服务器,实现简单,但集群常只能按客户端 IP 判断会话,大量用户经同一代理访问时会全部绑到一台上,造成负载倾斜。按客户端标识路由时,要预想多个主体共用同一标识的情况。 进一步展开见会话迁移与服务器亲和。

原书依据 · 7 处

不要分布使用对象

常见的设计是把客户、订单、产品、配送各自做成远程对象部署到不同节点,理由是哪个忙就给它加机器。中间件宣传的透明性让调用看起来不分本地远程,但透明性覆盖不到性能:进程内调用与跨进程、跨机器调用有数量级的差距。按类模型把业务对象拆成分布组件,只会拖慢性能、增加构建和部署难度,这就是分布对象设计第一定律:不要分布使用对象。想利用多台机器,应该用集群复制整个应用,让节点内的调用仍是本地调用。 进一步展开见不要分布使用对象。

按类模型进行跨进程分布之所以行不通,根子在计算机的基本物理特性:进程内的过程调用非常快,两个独立进程间的调用要慢一个数量级,不同机器间的调用又要再慢一两个数量级(具体取决于网络拓扑)。这个数量级差异决定了远程使用的对象接口必须和本地使用的接口长得不一样。本地接口最好是细粒度的——比如地址类给”取城市”“取州”“设城市”“设州”各配一个独立方法,这完全符合面向对象把对象拆细以便灵活组合、覆盖、扩展的一般原则。但同样的细粒度接口搬到远程调用场景就成了灾难:既然每次方法调用都慢,就应该在一次调用里把城市、州、邮编一次性取回或更新完,而不是分三次调用——这催生出一种专门为”减少调用次数”而不是为”灵活可扩展”设计的粗粒度接口,编程上麻烦一些,但为了性能这个代价是值得付的。中间件厂商常说”本地调用照常速度执行、远程调用略慢、只在真正跨进程时才付费”,这个说法本身没错,但掩盖了一个更本质的问题:只要一个对象可能被远程访问,就必须用粗粒度接口,而本地访问的对象适合用细粒度接口——这不是可选项,而是两种物理约束下的必然设计取向,任何两个对象互操作时都该先想清楚它们之间到底是本地关系还是远程关系。 进一步展开见远程接口要粗粒度。

需要利用多处理器提升性能时,多数情况下答案是集群:在每个处理器上部署完整的一套应用对象并复制多份,而不是把客户、订单、产品拆到不同节点。好处有二:每个节点内的调用仍是本地调用,速度不受影响;不必考虑跨进程,可以继续使用细粒度接口,编程更简单、维护更容易。拆分成分布式碎片看似在扩展,实则制造了大量本不需要的远程调用。水平扩展靠复制整体分摊负载,拆分服务边界是为了分离关注点,两者不能混淆。 进一步展开见扩展靠复制整个应用。

“不要分布使用对象”是原则而非绝对禁令——总有一些跨进程的分布是无法消除的,值得像”过街老鼠”一样尽力压缩它们的范围,但不可能压缩到零。典型的五种不可避免场景:一、传统的客户机与服务器之间——用户的个人计算机本来就是共享数据的不同物理节点,天然分属不同进程,这是最典型的跨进程划分。二、基于服务器的应用软件(如应用服务器)与数据库之间——理论上可以把所有应用逻辑写成存储过程塞进数据库进程,但这样做并不实际,因此通常必须有独立进程;好在SQL本身就是为远程数据库访问设计的接口,可以想办法把损耗降到最低。三、Web服务器与应用服务器之间——最好让二者运行在同一进程内,但实际情况不总能如愿。四、因为第三方厂商软件包的限制而不得不做的进程划分——好的软件包至少会提供粗粒度接口来减轻代价。五、其他各种不得不进行的划分——应该想尽办法避免,但总有例外情况逼你就范,这时也只能捏着鼻子把软件划成远程的、粗粒度的组件。 进一步展开见必须分布的五种场景。

既然分布不可避免,好的做法是把”细粒度”和”粗粒度”这两种设计各自限制在自己该待的地方:进程内部照样可以自由使用细粒度对象,关键是只让它们停留在进程内部;而在分布边界上专门放一层粗粒度对象,这层对象自己不做任何实际业务工作,唯一职责是把内部细粒度对象包装成一个远程可访问的外观——这就是远程外观。这样做的好处是让”付出粗粒度接口的代价”这件事变得显式化:只有真正需要被远程调用的对象才套上这层外观,开发者能清楚看到自己在哪里、为什么要付出这个代价,避免”透明”掩盖了远程调用本该被认真对待的事实;同时使用者只要清楚自己是在同一进程内运行,仍然可以直接用底层的细粒度对象,分布策略因此变得非常显性和可控。远程外观通常要搭配数据传输对象一起使用——因为跨越分布边界传输的不只是粗粒度的方法调用,还需要把结果打包成一整块数据一起送过去:领域对象本身通常不能直接通过网络发送,因为它们内部靠一张细粒度的本地对象引用网络互相勾连,不适合被拆解序列化,因此要把客户端真正需要的所有数据单独打包进一个专门用于传输的对象——这就是数据传输对象(不少企业Java开发者习惯称之为”值对象”,容易和本书别处讲的值对象混淆,需要留意区分)。使用数据传输对象有一条重要约束:它只应该引用其他数据传输对象和字符串这类原始类型,绝不能引用网络对端访问不到的东西,否则序列化传输就会失败或产生悬空引用。 进一步展开见远程外观配合DTO。

分布接口传统上用 RPC;基于 XML 的 HTTP 接口,即 SOAP 类 Web Service,一次往返能传大量结构化数据,XML 几乎各平台都能解析,走 HTTP 也易穿越防火墙。代价是转换 XML 开销不小,两端同平台时用平台自带的远程调用效率高得多。所以只有没有更直接的方式时才选 XML 接口,它真正的用武之地是跨平台互操作。也可在面向对象接口上叠加 HTTP 接口兼得两者,但要多维护一套,只在确有需要时才值得。 进一步展开见RPC与XML接口的选择。

原书依据 · 6 处

为纠错能力投资

任何架构建议都是危险的礼物:仅凭一本书无法替具体项目做出合适决策,读者对自己项目的了解胜过作者,建议只能推动思考,不能替代思考。好在架构决策并非不可改变,重构架构很难、代价常被低估,但并非做不到。即便对极限编程整体不感兴趣,也值得采纳持续集成、测试驱动开发和重构三项实践,它们让日后修改架构决策变得更容易。信息不足时,与其追求一次做对,不如保留低成本纠错的能力。 进一步展开见为纠错能力投资。

事务脚本最简单,贴近过程式思维,但难以支撑复杂逻辑、消除重复;领域模型能力最强,是唯一能从容应对复杂业务逻辑的模式,代价是学习门槛高、与关系数据库的映射复杂;表模块居中,处理逻辑的能力强于事务脚本,又能顺畅配合关系数据库。三者中表模块受工具生态影响最大:平台自带强大的记录集支持时,如 .NET,它如虎添翼;缺乏这类工具时则吸引力大减。选型时,工具支撑与理论优劣同样重要。 进一步展开见工具生态影响模式选择。

选定领域层模式后,数据源层的选择直接被它驱动。事务脚本的数据源:即便是最简单的事务脚本,也应该把数据库逻辑单独分离出去(而不是让脚本自带数据库操作),可选行数据入口或表数据入口,主要取决于实现平台是否方便、以及系统未来的走向——如果平台提供丰富的记录集工具(尤其是UI工具和事务性断接记录集),天平会明显倒向表数据入口;一旦选定,通常不需要额外的O/R映射模式,因为内存结构和数据库结构高度一致,工作单元也不是必需的(脚本内部跟踪变化通常很容易),并发问题也简单——脚本基本对应一个系统事务,可以整体封装在单个事务里,唯一需要操心的异常是”一个请求读出数据编辑、下一个请求才保存”这种跨请求场景,用乐观离线锁处理即可,实现容易又能避免挂起会话导致的大面积加锁。表模块的数据源:几乎是天作之合的固定搭配——表数据入口与记录集配合得天衣无缝,数据源层基本不需要再加别的功能,如果记录集本身自带某种并发控制机制,它实质上就顺带扮演了工作单元的角色,进一步压低了开销。领域模型的数据源:最复杂也最有意思——模型简单(十几个与数据库相关的类)时活动记录就够用,想要更松耦合可以上表/行数据入口,做不做这层分离工作量差别不大;复杂度继续上升就要考虑数据映射器,它能让领域模型尽可能独立于其他层,但也是三者中实现最复杂的,除非团队实力很强或者找到了简化映射的办法,否则强烈建议直接买一个映射工具;一旦走上数据映射器这条路,全套O/R映射模式都会派上用场,其中工作单元尤其值得关注,因为它是并发控制的焦点。 进一步展开见领域逻辑配数据源。

表现层的选择在很大程度上独立于下层选择。第一个决定是胖客户界面还是HTML浏览器界面——胖客户体验更好,但代价是要自己负责客户端软件的控制和部署管理;立场很明确:能用HTML浏览器就尽量用,实在不行才上胖客户端(本书也不讨论胖客户端相关的模式,选了这条路就超出本书范围)。走HTML路线后,建议以模型-视图-控制器为设计基础,剩下要做的只有两个决定:选控制器、选视图。控制器的选择很多时候被开发工具直接左右——用Visual Studio最简单的路径是页面控制器配模板视图;用Java可以借助Struts这类流行Web框架,走前端控制器配模板视图的路子。如果不被工具绑定、还有自由选择空间,站点偏文档型(尤其是静态页面和动态页面混杂)时更推荐页面控制器;站点导航和UI逻辑更复杂时则更适合前端控制器。视图的选择主要是模板视图还是转换视图,这很大程度上取决于开发团队更习惯服务器页面技术还是XSLT——虽然转换视图额外带来的可测试性,但整体上仍然略微偏向模板视图;如果站点需要支持多种表现形式,则应该考虑叠加两步视图。与下层的通信方式,取决于”要通信的是哪一层”和”是否同一进程”这两个因素:能放进同一个进程就尽量放,省去低效的进程间通信;实在无法同进程时,才用远程外观包装领域逻辑层、配合数据传输对象与Web服务器通信。 进一步展开见表现层选型框架。

这是 2002 年前后的平台语境,可迁移的是背后的判断。Java 方面,好的 J2EE 应用不需要 EJB,POJO 加 JDBC 足以胜任;事务脚本过度依赖 EJB 会难以摆脱,复杂领域模型宜用 POJO 实现,外面只包一层会话 Bean 作远程外观。无论如何都应避免给实体 Bean 远程接口,它需要细粒度接口,远程接口却该是粗粒度的。.NET 方面,数据集工具丰富,表模块是默认选择。两者共同的经验是看平台工具生态最支持哪种模式。 进一步展开见Java与.NET的默认选择。

存储过程与数据库同进程,省去跨进程开销,常常最快;但多数存储过程环境缺乏良好的结构化机制,还会把应用绑死在特定数据库厂商上。因此实现业务逻辑时宜尽量避开它,除非确有较强的性能诉求。具体做法是默认不依赖存储过程,性能问题真实出现时,再把领域层的某些方法改写成存储过程,把它当作清除瓶颈的优化步骤,而非从一开始就遵循的架构原则。无论用存储过程还是 SQL,都应该用同样的模式隔离数据库访问。 进一步展开见存储过程只作性能优化。

当时业界普遍看好 Web Services,但它是应用集成技术,不是应用构建技术。正确顺序是先按常规方式构建系统,再把确需对外暴露的部分包装成 Web Services,可以把它们看作远程外观;而不是一开始就把单个应用拆成一堆通过 Web Services 通信的碎片。这正是分布对象第一定律的延伸:别因为拆成远程服务很容易,就误以为应该这样拆。异步、面向消息的用法通常比同步 RPC 更合适。 进一步展开见Web服务用于集成。

本书采用的表现层/领域层/数据源层三层模型并不是唯一的分层方式,其他架构教材各有取舍。Brown模型在三层基础上插入两个中介层,共五层:表现层、控制层/中介层(表现层与领域层之间,对应本书的应用控制器)、领域层、数据映射层(领域层与数据源层之间,对应本书的数据映射器)、数据源层。J2EE Core Patterns方案分五层:客户层、表现层、业务层、集成层、资源层——它的独特之处是把”表现层”拆成了客户端部分(客户层)和服务器端部分(表现层),业务层与集成层大致对应、资源层则是集成层要连接的外部服务。Microsoft DNA架构定义表现层、业务层、数据访问层三层,结构上和本书三层能对上号,但关键区别在于数据传递方式:所有层都直接操作数据访问层通过SQL产生的记录集,这个记录集实质上充当了各层之间的数据传输对象,代价是业务层和表现层都被迫要了解数据库结构,好处是表现层可以直接用一些对数据敏感的GUI控件操作被业务层修改过的记录集(这种架构下领域层常组织成表模块、数据源层用表数据入口)。Marinescu方案用五层,把领域层拆成了领域模型加一层服务层——本质是把面向用例的工作流逻辑从纯粹的领域逻辑里剥离出来,是否值得这样拆分存在争议,偶尔有用、大多数情况没必要。Nilsson模型层次更复杂,因为大量依赖存储过程、鼓励把领域逻辑塞进存储过程以求性能,这种做法并不可取(会增加维护开销),但承认这是一种(用得不多的)优化技巧;Nilsson也和Marinescu一样单独设了应用层和领域层,并同样认为小型系统可以不设领域层——这一点上两人的立场一致:领域模型对小型系统意义不大。可取的方法论是:先从三个基本层出发,只有当它们真的变得过于复杂时,才考虑引入应用控制器、数据映射器这类中介层来分担压力——中介层始终是可选的额外方案,不是起手就该有的标配。 进一步展开见五种分层方式比较。

原书依据 · 10 处

事务脚本的组织方式

事务脚本用一个过程处理表现层的一个请求,如“预订房间”包含查空房、算价格、更新数据库,公共子任务可拆成共享子程序。组织成类有两种方式:把相关主题的多个脚本放进一个类;或每个脚本一个类,借助命令模式定义统一的执行方法,便于运行时把脚本当对象操控,但这种需求很少见。无论哪种,都要让脚本与处理表现层和数据源层的类相互独立,且绝不能调用表现层逻辑,这样才容易修改、容易单独测试。 进一步展开见事务脚本的组织方式。

领域模型是融合行为与数据的对象模型,有的对象刻画数据,有的捕捉业务规则。它与数据库模型的根本差异在于混合了数据与过程,拥有多值属性、复杂关联和继承。由此有两种风格:简单领域模型几乎每张表对应一个对象,用活动记录持久化即可;复杂领域模型大量运用继承、策略等模式,形成细粒度对象网络,擅长复杂逻辑,但映射到数据库困难得多,需要数据映射器。选持久化机制不能只看“是否用了领域模型”,还要看它属于哪种风格。 进一步展开见领域模型的两种风格。

单用户桌面应用可以把整个对象图从文件读入内存,一直留在那里。多层信息系统做不到:对象太多,全部放进内存既占空间又耗时。面向对象数据库能管理对象在内存与磁盘间的按需迁移,没有它时就得自己来:一次会话只加载与当前任务相关的部分对象图,如只计算收入确认时不必加载产品对象,这由数据库映射层控制,也就是延迟加载的问题;若要跨多次调用复用对象图,还要把它存在某处,这就是会话状态的问题。 进一步展开见只加载所需的对象图。

领域模型常被担心会臃肿:订单的部分行为只在某个界面用到,全放进订单类会让它越来越大,于是有人想把“特殊”行为挪到事务脚本或表现层。但提前分离也有代价:后来者找不到已有实现,往往另写一段相同功能,造成冗余与不一致。实际上对象臃肿发生得远比想象少,发生了也容易发现和修正,所以宜把行为放在它本该属于的对象里,真的臃肿了再处理。要不要预防某个问题,看它的实际概率和事后修复成本。 进一步展开见不必过早拆出用例行为。

这是 2002 年前后的 J2EE 语境。用实体 Bean 与容器管理持久性实现领域模型有几重障碍:CMP 映射能力有限;实体 Bean 不应重进入,复杂领域模型却常需要;2.0以前实体Bean的远程接口与细粒度调用冲突,2.0可用本地接口缓解;依赖容器和数据库才能运行,创建、测试、调试都慢。为此有人给“普通的 Java 对象”起名 POJO,它组装简单、可脱离容器测试。逻辑简单、贴近表结构时可用实体 Bean;复杂领域模型宜用 POJO 配数据映射器。 进一步展开见实体Bean与POJO。

收入确认的例子中,每个产品关联一个确认策略对象,不同产品类型对应不同策略子类,计算时从合同经产品传给策略。新增算法可通过策略子类扩展既有计算主链路;创建或配置产品时仍须选择新策略。更深的效果是:产品创建时一旦挂上策略,后续计算代码中就不再有条件判断,决策路径在建立对象关系时就已确定,而不是运行时靠 if-else 层层判断。领域模型应对一组相似判断的通用做法,就是把复杂性从算法内部转移到对象之间的关系里。 进一步展开见策略模式消除条件分支。

表模块用一个类对应一张表,只用一个实例处理全部行:一万个订单,领域模型有一万个对象,表模块只有一个。它看似普通对象,却没有标识来表明代表哪个实体,要查某雇员的地址必须写成 getAddress(employeeID),每次操作都要传入主键。它通常配合记录集使用,在 SQL 结果上提供基于方法的接口;一个任务常要多个表模块共同操作同一个记录集。表模块刻意放弃了对象标识,换取与关系数据的顺畅衔接。 进一步展开见表模块靠键访问单行。

表模块要拿到数据,主要有两种组织方式。方式一:让表模块自己包含查询作为工厂方法,直接负责把数据查出来、组装成记录集。方式二:另外配一个独立的表数据入口专门负责查询,表模块只负责在拿到的记录集上跑业务逻辑——代价是设计里多了一个额外的类和相应机制,好处是可以让同一个表模块作用于来自不同数据源的数据(只要为每个数据源各配一个对应的表数据入口即可),实现了”业务逻辑”和”数据从哪来”的解耦。采用表数据入口方式时的典型协作流程是:应用先用表数据入口把数据汇集进一个记录集,再用这个记录集当参数创建表模块(需要多个表模块的行为时,可以用同一份记录集依次创建它们);表模块在记录集上跑完业务逻辑后,把修改过的记录集传给表现层显示,或交给能感知表结构的界面部件直接编辑——这些界面部件根本分不清记录集是直接来自数据库还是已经被表模块加工处理过;GUI里改完的数据要存回数据库前,还会先经表模块校验一遍。这种分离方式还带来一个额外好处:不需要真实数据库就能测试表模块,只要在内存里手工构造一份记录集即可。虽然”表模块”这个名字暗示每张数据库表对应一个表模块,但实际上表模块的结构更多取决于应用程序能识别的”虚拟表”(比如视图和查询),而不真的绑定数据库表本身的结构,对通用视图或其他查询建立表模块同样有效。 进一步展开见表模块配表数据入口。

企业应用常为界面、数据加载、系统集成等多种客户提供接口,它们共享相似的交互逻辑,各自实现就会冗余。服务层把业务逻辑分成两类:领域逻辑只关心问题领域本身,如收入确认的计算策略;应用逻辑关心应用的职责,如通知合同管理者、触发集成,也称工作流逻辑。把应用逻辑塞进领域类有两个坏处:领域类在其他应用中的可复用性下降;日后要把应用逻辑迁到工作流引擎时更困难。服务层正是为保护领域类的可复用性而存在。 进一步展开见区分领域逻辑与应用逻辑。

服务层的具体实现方式主要有两种,区别在于服务层接口之后的职责怎么划分。领域外观方法:服务层实现为领域模型之上的一批”瘦”外观,负责外观的类本身不含任何业务逻辑,所有业务逻辑(包括领域逻辑和应用逻辑)都放在领域模型里完成——瘦外观只负责建立客户层与应用交互的边界和操作集合,这正好体现了服务层”定义应用边界”的核心特征。操作脚本方法:服务层由一批相对复杂的类组成,这些类直接实现应用逻辑(协调响应、处理工作流),但把领域逻辑委托给底层封装好的领域对象类去做;服务层暴露给客户的每个操作都以脚本形式实现,若干脚本组成一个类,一个类围绕一个主题组织相关逻辑(通常命名为”XX服务”),这些应用程序服务类之上还应该抽出一个层超类型来承载公共职责和行为。两种方法的分野本质对应着”领域逻辑与应用逻辑该不该分开放”这个问题的两种回答:领域外观方法几乎把一切都留给领域模型自己扛,操作脚本方法则明确把应用逻辑单独拎出来放进服务层脚本里、只把领域逻辑部分委托出去。 进一步展开见服务层两种实现。

服务层接口是粗粒度的应用操作,天然适合远程调用,但适合不等于应该。为远程调用处理数据传输对象、应对分布的工作量很大,尤其领域模型复杂、编辑界面多时,痛苦程度仅次于对象关系映射,这呼应了分布对象第一定律。建议先设计本地调用的服务层,签名直接使用领域对象;真需要远程能力时,再在其上加远程外观或让服务层对象实现远程接口。Web 界面或 Web Service 与业务逻辑也完全可以在同一进程中运行。 进一步展开见服务层先本地后远程。

服务层该提供哪些操作,由其客户,首先是用户界面的需求决定,所以起点是用例模型和界面设计。企业应用中多数用例是对领域对象的增删改查,与服务层操作几乎一一对应;此外还要协调通知他人、触发集成等响应,并明确哪些事务性资源可共同提交、哪些外部动作需要另行协调;设立服务层本身不自动保证原子性。如何把操作归入不同服务没有硬性规定:应用小时一个以应用命名的服务即可;较大时按子系统划分;也可按领域对象或行为主题命名。 进一步展开见识别服务层操作。

服务层定义各类客户共用的操作集合,并在每个操作中协调应用响应,有时需要跨多个事务性资源原子处理。因此判断是否需要它看两点:业务逻辑是否服务多种客户,如界面加数据加载器;用例响应是否涉及多个事务性资源。满足其一,即便不是分布式系统也值得考虑统一协调的服务层;跨资源原子性仍要求资源与事务管理机制真实支持。反之只有一种客户、只涉及一个资源时,页面控制器自己控制事务即可。但只要能预见将来出现第二种客户或第二个资源,就应从一开始设计服务层。 进一步展开见何时需要服务层。

服务层容易与 J2EE 文献中的会话外观混淆,二者动机不同。会话外观是为了避免对实体 Bean 过多远程调用造成性能损失,把会话 Bean 与实体 Bean 胶合成粗粒度接口,是针对 EJB 缺陷的技巧。服务层则通过区分领域逻辑与应用逻辑来避免冗余、提高领域类的可复用性,是架构层面的模式;其思想源自 Alistair Cockburn 的应用边界模式,早于 EJB。形态相似不代表解决同一个问题,追溯起源更能判断是否适用。 进一步展开见服务层不同于会话外观。

事务脚本胜在简单:逻辑不多的应用用它最自然,理解和运行开销都小。它的典型病是事务之间的重复代码,谨慎提取公共子程序能挡住一部分,业务再复杂就该上领域模型。分界点无法量化,事后把事务脚本重构成领域模型虽可行,却比想象的难,所以早期尽量判断准。作为坚定的面向对象信徒,作者仍提醒:很多问题本来就简单,简单方案开发更快、跑得也更快。参见选型没有量化阈值、换模式的代价不对称。 进一步展开见别盲目排斥事务脚本。

收入确认回答的是“收到的钱何时能记为收入”。卖一杯咖啡,交货收钱当场入账;但客户预付一年顾问费,钱虽今天到账,服务却要一年才完成,中途还可能解约,原书用每月确认1/12作说明。规则来自法律、行业惯例和公司政策,种类多且常变,这正是企业应用业务逻辑“无逻辑”的典型。这些仅为原书教学情境,非现实会计判断;三种产品分期规则更明确为作者虚构。书中用这些规则,统一演示事务脚本、领域模型和表模块。参见企业应用的六个特征、策略模式消除条件分支。 进一步展开见收入确认何时入账。

服务层的收入确认例要求保存合同、排队消息和发送邮件形成协调结果,失败时不应只发通知却未保存业务。但“把方法标成事务性”只有在资源能真实加入同一事务时才可实现原子提交。普通邮件发送不能据此推断随数据库回滚撤销。服务层负责明确协调契约,事务管理器与资源适配器负责执行各自支持的提交机制;示例省略这些细节,不能直接照搬为跨资源一致性的证明。参见识别服务层操作。 进一步展开见通知不自动随事务回滚。

原书依据 · 18 处

表数据入口的返回值

表数据入口的接口很简单:几个查找方法加增删改方法,每个方法映射为一次 SQL 调用,通常无状态。难点在于如何返回多行结果。返回 map 能用,但失去编译期类型检查;返回数据传输对象要多写一个类,换来类型安全和清晰接口,而且常在别处复用;直接返回记录集最省事,在 .NET 中尤其顺手,但让内存对象知道了 SQL,将来换成文件存储也会受阻。跨技术边界的接口,返回值的形状往往决定封装是否干净。 进一步展开见表数据入口的返回值。

J2EE 文献中的数据访问对象 DAO,本质上就是表数据入口的一种,文献演示了用查询方法返回数据传输对象的集合;它是否总以表为单位并不明确,也可能对应行数据入口。本书另起名字而不沿用 DAO,一是因为它只是“入口”这一更普遍概念的特殊用法,希望名字能体现这层关系;二是 DAO 在微软技术体系中另有含义,沿用容易造成跨平台混淆。给概念命名时,要留意这个名字在其他技术生态中是否已有不同含义。 进一步展开见DAO是一种表数据入口。

行数据入口与数据库中的单条记录一一对应,每列对应一个域,负责类型转换,客户可以像访问普通对象一样使用它,数据源细节被挡在接口之后。它与活动记录很相似,区分标准是:对象里是否含有领域逻辑。有领域逻辑就是活动记录,行数据入口只应包含数据库访问逻辑。实践中边界未必泾渭分明,但这个标准很实用:往一个看似行数据入口的对象里添加业务规则时,它实际上已经悄悄变成了活动记录。 进一步展开见行入口与活动记录之别。

事务脚本搭配行数据入口使用时,随着系统演进,常会发现同样的业务逻辑在多个脚本中反复出现,而它们本该放在行数据入口里。不断把重复逻辑移回入口,入口就逐渐演变成活动记录,这是好事,因为它减少了重复。这也给出一条渐进重构路径:先把表包装成纯粹的入口,再把散落在脚本中的行为逐步迁入。它不要求一开始就判断该用事务脚本还是活动记录,而是从最简单的形态出发,跟着代码中暴露的重复走。 进一步展开见从脚本演化到活动记录。

数据映射器的查找方法看似一次请求对应一次 SQL,实际往往更复杂:加载订单时很可能要连同订单行一起加载,客户的一次请求常意味着成批加载一组相关对象。映射器设计者要决定一次返回多少对象,以尽量减少查询次数,这就要求查找方法了解客户实际如何使用这些对象,而不是每个类各自独立查询。例如用一个连接订单与订单行的查询一次加载两种对象,比分别查询快得多。查询粒度应由上层的访问模式决定,而非只看数据模型。 进一步展开见查找方法要懂客户用法。

数据映射器必须读写领域对象的域,而这些域出于封装通常是私有的,这是没有完美答案的两难。几种折中:把映射器与领域对象放在同一个包内,用包可见性访问,但会带来额外依赖;用反射绕过访问控制,虽慢,但与一次写错的 SQL 相比开销可以忽略;提供公开的读写方法,但用状态域保护,只在加载数据时允许调用,并选用不像普通 getter/setter 的名字防止滥用。基础设施需要突破业务层封装时,按场景选择即可。 进一步展开见映射器访问私有域。

映射器创建对象有两种方式。丰富构造函数让对象一创建就完整有效,并能保护不变的域,但两个对象互相引用时,加载一个会触发另一个,循环下去直到调用栈耗尽,绕开它需要凌乱的特例代码。空对象方式先用无参构造函数创建空对象,立即放入标识映射占位,之后遇到循环引用就直接返回这个已登记的对象,从而切断递归;代价是需要仅限加载阶段使用的设置方法,需防止滥用。先登记身份、后回填数据,是打破循环依赖的通用套路。 进一步展开见对象创建与循环引用。

活动记录把数据访问直接放进领域对象,类的每个域对应表的一列,最大优点是简单,容易建也容易懂,适合以增删改查为主的逻辑。它的前提是对象和表同构。一旦业务复杂到需要对象间直接引用、集合和继承,这些结构都难以塞进活动记录,硬加只会越来越乱,这时该换数据映射器。另一个代价是对象设计与表结构紧紧绑在一起,后续重构哪一边都牵动另一边。发散:框架默认用活动记录时,留意模型何时开始偏离表结构。参见从脚本演化到活动记录、持久化机制的渐进选型。 进一步展开见活动记录只适合同构。

原书依据 · 9 处

工作单元记录变化

工作单元要发挥作用,首先得知道自己该记录哪些对象的变化,实现这一点主要有三种技术。调用者注册:谁改了对象,谁就必须显式把这个对象注册到工作单元,没注册的对象提交时不会被写入数据库——好处是允许在内存里改动对象却不写库(比如临时对象、测试场景),坏处是容易因为粗心漏注册而引发难以察觉的漏洞,这点灵活性带来的混乱得不偿失,宁愿用显式拷贝达到同样目的。对象注册:调用者不再负责注册,而是把注册逻辑内嵌进对象自己的方法里——从数据库加载时自动注册为”干净”,调用setter时自动注册为”脏”;代价是工作单元必须以某种方式被对象拿到(传参或放进众所周知的会话对象里),且仍然要求开发者记得在每个该触发注册的地方老老实实调用注册代码,一旦遗漏同样是隐蔽漏洞(也可以借助代码生成或面向方面编程自动织入这些调用,从而把数据库相关代码彻底和常规业务代码分离)。工作单元控制器:工作单元本身接管所有数据库读操作,对象一读出来就注册为”干净”并生成一份拷贝,提交时把当前对象和这份拷贝逐一比较来判断到底变没变——这样可以做到只更新真正改变了的字段、且完全不需要在对象内部埋注册调用,代价是提交阶段的比较工作变重;折中方案是只拷贝真正发生变化的对象,需要注册但仍能有选择地更新,读多写少的场景下能大幅减轻拷贝负担。 进一步展开见工作单元记录变化。

工作单元要解决的根本问题是”记录哪些对象被操作过,以便知道要把哪些数据同步回数据库”,但这不是唯一的解法,几种方案的成熟度依次递进。最原始的方法:每改动一个对象就立即显式保存——简单直接,但代价是数据库调用次数可能远超预期,如果同一个对象在流程里被改了三处,就会触发三次数据库调用而不是一次。改进一步:把更新操作留到最后统一做,为此需要记录下所有被改动过的对象——如果只用普通变量做这件事,变量一多就迅速失控,这种做法和事务脚本配合尚可,但很难用在领域模型这种对象网络更复杂的场景里。再进一步:给每个改动过的对象打上”脏”标记,事务处理完后统一遍历找出所有带脏标记的对象写入数据库——这个方法的价值取决于”找出脏对象”这件事本身有多容易:如果所有脏对象都在一个单一层次结构里,遍历这个结构就够了;但要跨越一个更一般的对象网络(比如领域模型里错综复杂的关联关系)去查找,就变得困难。工作单元则是这条演进路径的终点:把所有相关信息集中放在一个地方管理,一旦启用就不用再为”怎么记录、怎么找到该写的对象”这件事操心,还能顺带充当更复杂场景(比如跨越多个系统事务的业务事务,需要配合乐观/悲观离线锁)的固定处理平台。 进一步展开见是否使用工作单元。

标识映射可以是显式的,为每种对象提供专门方法,如 findPerson(1);也可以是通用的,用一个方法加类型参数,如 find(类型, 1)。通用映射可以做成一个服务所有类型的可复用组件,新增类型无需改动。但更推荐显式映射:在强类型语言中能享受编译期检查,这是用字符串区分类型做不到的;接口也更清楚。每增加一种类型多写一个方法,只是很小的代价。语言支持强类型时,为省代码而放弃编译期检查通常不划算。 进一步展开见优选显式标识映射。

标识映射可以每个会话一个,也可以每个类一个。只有整个数据库使用唯一键时才适合单一映射,好处是入口唯一,也不会踩继承的坑。用多个映射时,最自然的是每个类或每张表一个;数据库与对象模型不一致时,按对象划分更省事。继承是难点:若“小汽车”继承“车辆”,为每个子类各建映射会让多态查找必须逐个查所有映射,所以更宜整棵继承树共用一个映射,代价是键必须在整棵树内唯一,采用具体表继承时这很难保证。 进一步展开见继承树共用标识映射。

标识映射要放在容易找到、且每个会话独立一份的地方。已使用工作单元时,工作单元是最理想的位置,因为它本就记录进出数据库的数据;否则可绑定到会话对应的注册表上。默认一个会话一个映射,否则要给映射加事务保护,这很棘手。有两个例外可以放宽:把对象数据库作为关系数据库之上的事务级缓存;以及永远只读的对象,它们可以跨会话共享、一次性全部加载。单一映射内部也可以按只读与可更新分成两部分,对外提供统一接口。 进一步展开见标识映射放在哪里。

为了方便开发者,加载一个对象时顺带自动加载与之相关的对象是很自然的设计,但顺着这个逻辑走到底,会导致加载一个对象牵出一大批相关对象、而真正需要的可能只有寥寥几个,白白拖累性能。延迟加载暂停这个过度加载的过程:在对象结构里设个标记,让真正用到某份数据时才去加载它——俗话说,”如果你懒得做一些事情,当事后证明这些事情根本不需要做的时候你就赚了”。实现延迟加载主要有四种方式。延迟初始化:每次访问某个域前先检查是否为空,为空就现算/现加载再返回,最简单,但会在对象和数据库间强加一层依赖,最适合活动记录、表数据入口、行数据入口这类本来就和数据库耦合的场景。虚代理:放一个”看起来像目标对象、实际什么都没装”的代理对象在域里,只有它的某个方法被调用时才去数据库加载真正的对象——优点是几乎无缝,缺点是代理和真实对象是两个不同的实例,容易在相等性判断上栽跟头,且静态类型语言里可能得为每个被代理的类都造一个代理类。值保持器:专门包一层来持有目标对象,第一次访问值保持器时才真正从数据库读取——代价是宿主类需要知道值保持器的存在,牺牲了强类型的显式性,但能避免虚代理的标识问题。重影:加载对象时先只填充它的ID,各个域第一次被访问时才各自触发加载,可以把重影理解成”整个对象本身就是自己的虚代理”,好处是可以直接把它放进标识映射里,天然避免循环引用问题。 进一步展开见延迟加载四种实现。

延迟加载本为减少数据库访问,用得不当反而会增加访问,这叫波动加载。典型情形是对集合使用延迟加载后逐个访问其中元素,每访问一个就读一次数据库,本该一次读完的数据被拆成大量零散调用,明显拖累性能。办法是调整延迟的粒度:不让集合中的每个元素各自延迟,而是让整个集合作为一个整体延迟加载,一旦触发就把全部内容一次读完。集合巨大时另需专门的值列表处理器。给容器加按需加载时,先想清楚粒度落在容器还是元素上。 进一步展开见警惕波动加载。

是否延迟加载某个域,看加载对象要读多少数据、需要几次数据库调用。与对象主体数据在同一行的域通常不必延迟,反正都要读这一行,即便是序列化 LOB 这样的大字段也只需同一次调用。真正值得延迟的是需要额外数据库访问才能拿到的域或关联对象。从性能看,更常见的优选是一次调用取回所需的全部数据,尤其同属一次界面交互时。延迟加载会增加编程复杂度,如虚代理的相等性、重影的继承处理,所以只在确有需要时使用。

同一行中的大字段是否几乎没有额外成本,取决于存储布局、读取列、网络传输与数据库实现,仍须测量。 进一步展开见只对额外访问延迟加载。

不同用例对同一对象图需要的部分往往不同,为效率应为每个用例加载恰好需要的子图。可以为不同用例准备不同的数据库交互对象,如两个订单映射器,一个连同订单项加载,一个对订单项延迟加载,应用按用例选用;也可以共用加载方法、由不同策略对象决定加载模式。但不宜无限细分:实践中真正用得上的往往只有两级,完全加载和仅供列表识别的轻量加载,再多级别只增复杂度而收益有限。定制粒度应由用例的真实差异决定。 进一步展开见按用例定制加载深度。

领域对象要能找到当前业务事务的工作单元。作为参数层层传递太啰嗦;示例中每个业务事务跑在单个线程上,于是用线程局部变量把工作单元挂到当前线程。若已有会话对象,就放在会话上,因为工作单元逻辑上属于会话。至于何时开启和提交,除了最简单的应用,都应隐式管理:在 servlet 层超类型或前端控制器的命令外层统一开启和提交,业务代码只管改对象,避免到处重复样板代码。参见工作单元记录变化、层超类型。

示例中的工作单元提交循环并不等于完整数据库事务实现;需另外确认事务开启、失败回滚与读取校验。 进一步展开见工作单元宜隐式管理。

标识映射的核心用途是防止两个内存对象对应同一条记录、各改各的;顺带能当读缓存。有几类对象可以不用它:不变对象和值对象不会被修改,没有更新冲突,不过用了仍能缓存,也能防止 Java 里误用 == 比较;依赖映射中的子对象由父对象控制生命周期,不需要独立身份。要记住它的边界:它只管同一会话内的冲突,跨会话的冲突得靠乐观或悲观离线锁。参见标识映射与延迟加载、乐观锁需检查只读依赖。 进一步展开见何时不需要标识映射。

原书依据 · 12 处

优先无意义键

标识域把数据库主键存进对象,用于维护内存对象与数据库行之间的对应,对象系统本身靠内存地址就能保证身份。选键时面临有意义键与无意义键之争。身份证号这类有意义的键听起来理想,实际不可靠:键要唯一且恒定,但人工录入总会出错,这会同时破坏唯一性和恒定性,数据库也只能在错误数据进入后才发现。由数据库生成、不给人使用的无意义键不受人为差错影响。越贴近现实语义的标识符越容易被现实差错污染。 进一步展开见优先无意义键。

创建新对象要分配一个新键,看似简单,实则暗藏不少麻烦,主要有四条路。自动生成域:数据库自身在插入时把某个字段自动递增成新值,最省事,但麻烦在于插入前很难提前知道这个自动生成的键值是多少——如果要插入一份带多条子项的订单,子项需要用到订单的新键作为外键,而这个值往往要等插入真正发生才能拿到,因此需要安排父项插入、取得键、再插入子项的顺序;不能据此断言有关联对象的表不适合自动生成键。现代数据库和驱动可在事务提交前返回已生成的键,例如 PostgreSQL 的 RETURNING。数据库计数器:如Oracle的序列,通过独立的Select语句向数据库要下一个序列值,这个查询在独立事务里自动完成,不会锁住其他正在对同一张表做插入的事务,还能一次多要几个键——效果很好,但不是所有数据库都支持,也没有统一标准。GUID:在本机生成、按特定版本算法生成的大空间标识;有的版本含时间信息,有的使用随机数。唯一性依赖算法、随机源和实现条件,不能当作绝对无冲突保证,缺点是生成的字符串很长,人工输入/阅读不便,还可能拖累索引性能。自造键值:最朴素的办法是用SQL的max函数扫描全表拿最大键再加一,并发时可能读到同一个最大值,实际锁范围取决于数据库、索引与隔离级别,插入少还行,一旦和更新混着跑就很麻烦;更好的自造方案是专门的键表——一张记录”名字/下一个可用值”的表,取键时读出、递增、写回,还可以一次多领几个值减少数据库调用;关键窍门是把对键表的访问放进一个独立的短事务里,这样只锁很短的时间,即便订单插入本身回滚了,从键表领到但没用上的键号也无妨(数字资源本就充裕),还顺带解决了”内存对象一创建就想立刻拿到ID”的需求。 进一步展开见新键生成四策略。

外键映射把对象间的引用关系映射成数据库表间的外键,单值引用(如唱片指向艺术家)很直接,但一旦对象持有的是一个集合(如唱片拥有多条曲目),外键必须反过来存在集合成员那一侧(曲目记录里存唱片的外键),更新时就要面对”怎么知道集合里加了什么、删了什么”这个问题,有三种解法。删除和插入:每次更新前先删掉数据库里和这张唱片相连的全部曲目记录,再把内存里唱片当前持有的全部曲目一次性插入回去——哪怕一条曲目都没真正变过也照删不误,看起来浪费,但逻辑简单、往往反而跑得更快;局限是只有当曲目属于依赖映射(完全归唱片所有、不会被唱片之外的东西引用)时才能这样做。加一个后向指针:让曲目反过来持有一个指向唱片的链接,把关联变成双向——代价是改变了对象模型本身,换来的好处是可以直接套用处理单值域的简单更新技术,不再需要操心集合层面的增删检测。区分对象集:如果前两种都不合适,就只能老老实实做差异对比——要么”通过数据库当前状态区分”(重新从数据库读一份现有集合,和内存里的集合逐一比对,数据库有但内存没有的就删,内存有但数据库没有的就插),要么”通过第一次读取时保存的数据区分”(省一次数据库读取,但如果用了乐观离线锁,可能还是绕不开要通过数据库比对)。此外,向后链接如果是强制的(每条曲目必须归属某张唱片)或链接本身恒定不变(曲目一旦确定就不能换唱片),处理起来都会明显更简单——移除操作就不用单独处理,或者加入永远对应插入、移除永远对应删除。 进一步展开见集合外键更新策略。

对象用集合表示多值域,关系数据库只能用单值域;一对多可以把外键放在单值端,多对多却没有单值端。经典解法是建一张链接表,只存两边的外键,每行对应一对关联,本身没有对应对象和 ID。读取要两步:先查链接表,再查详细对象,可以通过连接查询一次取回,但映射更复杂。关联表比外键映射复杂,除多对多外通常不宜使用;例外是数据库结构不受控制时沿用已有关联表,或关联表本身承载业务含义,这时它其实是一个领域对象。 进一步展开见关联表处理多对多。

有些对象只在另一个对象的语境中出现,如唱片下的曲目;若没有其他表引用它们,可由唱片的映射器一并负责,这就是依赖映射。前提是:每个依赖者恰好属于一个所有者,且除所有者外没有任何对象引用它。依赖者没有标识域、不进标识映射、不能单独查找,更新集合时可以先全删再全部重插。它是简化映射的手段,依赖图不宜过大。使用工作单元时不建议再用依赖映射,因为工作单元不认识依赖者,曾因此在测试后留下孤立行导致失败。 进一步展开见依赖映射的前提。

嵌入值把金钱、日期范围这类小值对象的字段摊平进所有者的记录,读写全由所有者代劳,是依赖映射的特例。简单、固定结构的值对象是典型候选,集合、变化频繁的结构仍需单独权衡,引用对象是否适合则是灰色地带,要看是否需要脱离宿主单独查询。它与序列化 LOB 常面对同类场景,最大区别是能否用 SQL 查询依赖者内部的值:嵌入值可以,序列化 LOB 把整个对象图压进一个字段,是否能查内部取决于存储格式及数据库支持,不能泛化为一律不可查询。依赖结构简单用嵌入值,复杂对象图且不依赖关系化查询时可考虑序列化 LOB,还须处理版本兼容、更新粒度与外部引用。

序列化 LOB 把由小对象组成的复杂对象图,如带层级的组织结构,整体序列化存进一个字段,替代需要大量连接的关系化拆分。要注意它挂在谁的表上:若订单要用顾客详情,应把顾客 LOB 挂在顾客表上,多个订单都链接到同一个顾客;若直接塞进订单表,顾客数据会被复制到每张订单里,顾客信息一变更新就成噩梦。例外是有意保存下单那一刻的顾客快照、不希望随后续变化而变。数据该挂在哪里,先想它将来会不会变、变了是否要联动。 进一步展开见LOB挂在所有者表上。

单表继承把整个继承层次所有类的域放进一张表,加载时靠判别符字段决定实例化哪个类。判别符可以存编码值,但每新增子类都要扩展翻译代码;也可以直接存类名,省去翻译,代价是更占空间,好处是类与表的对应更直观。另一个坑是所有子类的域共享同一命名空间,不同子类用了相同的域名就会冲突,可用类名作前后缀规避。整棵继承树不必只用一种映射:相似子类合并为单表继承,差异大的子类用具体表继承,完全可行。 进一步展开见单表继承的判别符。

类表继承为继承层次中的每个类各建一张表,用共享主键或外键把同一对象在各表中的行关联起来。难点在于高效读取:逐表查询往返太多,一次连接则要承担规划、联接中间结果与数据传输成本;书中“三四张表”的说法是当时的经验,不能当作今天数据库的通用阈值。更麻烦的是不确定要连接哪些表:查具体的足球运动员知道连哪张表,查“一组运动员”却不知道要连哪些子类表,可能需要用外连接保留缺少某些子类行的对象,或先读根表再判断读哪张子类表,发起多次查询。设计时要提前推演这类多态查询怎么写,并用实际数据、索引与执行计划比较。外连接本身不必然更慢,现代数据库也提供标准形式的外连接。

具体表继承为每个具体类各建一张表,超类的域在各表中各复制一份。难点在键:键不仅要在单表内唯一,还必须在整个继承层次涉及的所有表之间唯一,否则同一键值可能查出两行不同的数据,数据库的主键机制保证不了这一点,需要专门的键分配机制;接入既有数据库时更难,只能放弃超类域或改用含表名的组合键。另一个难点是引用完整性:无法给没有对应表的抽象概念“运动员”建外键,只能放弃检查或为每个子类表建链接表。 进一步展开见具体表继承的键难题。

无论采用哪种继承映射,映射器都按继承层次组织:具体子类的映射器声明返回具体类型的查找方法,加载与保存则由每层映射器处理本层特有的数据,再逐级调用超类。难点是支持针对抽象超类的查找,如查一个“运动员”。把它硬塞进超类映射器会让继承与委托纠缠在一起。更清爽的做法是拆开:抽象映射器只为具体映射器提供可复用的基础行为;另建一个独立的运动员映射器作为统一入口,只负责判断该由哪个具体映射器处理并转交。 进一步展开见抽象类查找用委托。

定了用无意义键之后,还要选键的形态。组合键在订单与订单项这类上下文相关的表里很顺手,但简单键处处一致,所有键操作都能共用一套代码,组合键则要在具体类里特殊处理,而且总带有含义,要提防唯一性和恒定性被破坏。类型上,键最常做相等比较和取下一个值,长整型通常最合适。别用日期时间作键,精度和移植都容易出问题。确实需要组合键时,封装成键类,在层超类型统一处理相等和取值。参见优先无意义键、新键生成四策略。 进一步展开见键的形态选择。

按对象逐个加载关联数据很直观,却藏着 N+1 问题:一条查询取回 100 个雇员,再为每人查一次技能,总共 101 次往返。改成一条连接查询能一次取回雇员和技能,但结果集要拆回对象、去重、挂到集合上,代码明显更复杂。作者的建议是只在确实需要处做这种优化,把精力花在真正关键的慢查询上。数据映射器的价值在于把这些复杂度挡在映射层,领域代码无感。参见警惕波动加载、数据库读取三条经验。 进一步展开见N加1查询的取舍。

把对象图序列化存进一个字段,有二进制和文本两种格式。二进制在书中所比较的平台序列化方案里较省事,空间大小仍取决于实际编码与压缩;平台可能自带序列化,但人看不懂;最要命的是版本问题:类一改,几年前存进库的旧数据可能再也读不出来。文本格式人能直接查看,代价是更占空间、若选自定义文本格式可能要自己写解析器,采用已有格式则可以复用工具,可能更慢。XML 免去了自写解析器,却更冗长;空间吃紧时可把 XML 压缩后按二进制存,但也就失去了可读性。发散:存长期数据时,格式的可演进性比编码便利更重要。参见嵌入值与序列化LOB、序列化格式要能容错。 进一步展开见序列化LOB的格式取舍。

原书依据 · 20 处

元数据映射两条途径

把关系-对象映射的细节浓缩进元数据后,让这份元数据真正驱动运行代码主要有两条路。代码生成:写一个程序,输入元数据、输出映射实现类的源代码,这些代码在构建阶段(通常紧邻编译前)生成,看起来和手写的没什么两样,但不应该被手工编辑、也不需要纳入源代码控制——好处是调试时更直观,能在调试器里清楚看到实际运行的代码,这条路更可取,对水平一般的开发者更友好;代价是缺乏动态性,映射一旦要改,至少要重新编译、重新部署相关部分。反射编程:把方法和域当成数据,运行时从元数据文件里读出域/方法名字,动态调用(比如动态找到并调用setName)来完成映射——好处是动态,改一下映射数据文件,现有的类立刻就能用上新元数据,甚至可以在程序运行期间监听某种特殊中断来触发重新读取;反射虽然非常适合数据库映射这个场景,通常仍不建议用它,主要顾虑不是速度(反射调用本身慢,但架在同样慢的远程SQL调用之上,这点损耗未必是大问题,具体影响需要实测),而是反射代码往往很难调试。两种方式都不太好调试,最终选哪个很大程度上取决于开发团队对”生成代码”和”反射代码”各自的熟悉程度。 进一步展开见元数据映射两条途径。

元数据映射有一个隐蔽副作用:改了某个私有域的名字,编译通过、自动重构工具也提示成功,应用却可能在运行时出错,因为旧域名还记在 XML 映射文件里,重构工具看不到。用代码生成时稍好,重新生成能更新引用,但手改过的生成代码会丢失;用反射则连提醒都没有。另一面,它让重构数据库更容易,只需同步修改元数据。凡是把名字对应关系放在代码之外的设计,改名都需要人工核查或专门的一致性测试兜底。 进一步展开见元数据映射躲过重构工具。

直接写 SQL 要熟悉语法和表结构,藏进查找器方法又难以支持灵活的特别查询,改表还得四处改 SQL。查询对象是解释器模式在查询上的应用:一组对象知道如何把自己转换成 SQL,查询用类和域而不是表和列来表达,编写者站在对象模型的视角,表结构变化也被局部化,这需要借助元数据映射。它还有“样例对象”的轻量变体,如只设了姓的 Person 表示按姓查找,但复杂条件就无能为力。宜先做刚好够用的最小版本,再按需扩充。 进一步展开见查询对象用对象语言查询。

资源库协调领域层与数据映射层,对外表现得像内存中的领域对象集合,可以增删对象,映射代码在背后按需读写数据库。客户先构造条件对象描述想要的结果,再调用 matching 取得符合条件的对象。与查询对象的区别在于:用查询对象是在构建并执行查询,用资源库只是描述规约、询问哪些对象符合,根本没有“执行查询”的概念。它把“要什么”和“怎么取”彻底分开,客户从不接触 SQL,转换细节也不会泄露出来。 进一步展开见资源库按规约取对象。

资源库背后的来源不必是关系数据库,只需替换策略对象,客户代码完全不受影响。好处有几点:单元测试时换成纯内存存储,不必真正读写数据库,测试数据只需构造对象放进集合,测试跑得快得多;领域对象来自多种数据源时,可以为 XML 数据流等实现专门的策略,客户不必关心数据来自哪里;对不可变对象可以用长期驻留内存的策略。能否轻松换成纯内存的假实现来跑测试,是检验抽象设计好坏的实用试金石。 进一步展开见资源库可替换数据源。

元数据映射的诱惑是把一切都写成配置,可简单的元数据格式在九成场景里够用,剩下的少数古怪情况若也要用元数据表达,格式会迅速膨胀到难以维护。更好的办法是让通用代码把可变步骤拆成单独方法,例外情况用手写子类覆盖那一个方法。元数据的复杂度应跟着实际需要逐步长,而不是一开始就追求完全通用。发散:任何配置驱动的框架都该留一个写代码的逃生口。参见元数据映射两条途径、层超类型。 进一步展开见元数据特例靠子类覆盖。

原书依据 · 6 处

MVC的两个分离

MVC包含三个角色:模型(不可见的领域信息与行为)、视图(模型在UI上的呈现)、控制器(接收用户输入、操作模型、让视图更新)——可以把”UI”理解成视图和控制器的结合体。理解MVC真正该关注两个分离,且这两个分离的重要程度并不相等。第一个分离——模型与表现(视图+控制器)的分离——是最基本、最重要的软件设计准则之一,原因有三:表现关心的是UI布局这类问题,模型关心的是业务规则和数据交互,两者本就是完全不同性质的关注点;分离之后,同一套模型代码可以配上多种表现(富客户端、Web浏览器、远程API、命令行……甚至同一应用不同页面各有不同UI),而不用重复实现业务逻辑;不可见对象天生比可见对象更容易测试,分离出来的模型逻辑可以脱离笨拙的GUI测试工具直接验证。这个分离的关键在于依赖方向必须是单向的:表现依赖模型,模型绝不能依赖表现——写模型代码时完全不该知道当前是哪种表现在用它,这样表现层才能自由演化、增加新表现也不会牵连模型。第二个分离——视图与控制器的分离——重要程度低得多,态度应是”仅当确实有用时才做”:多数系统里一个视图往往只配一个控制器,几乎每个版本的Smalltalk都没有真正分离过视图和控制器;这个分离在Web前端场景下才重新变得有用(也是Web设计中大量模式的基础),典型理由是想用同一个视图搭配两种不同的控制器策略来实现”可编辑”和”只读”两种模式。要注意一个常见的误引用:很多人把”控制器”理解成”位于模型和视图之间”的中介层(比如应用控制器),但应用控制器和MVC里的控制器其实是完全不同的两个概念,不该混为一谈。 进一步展开见MVC的两个分离。

页面控制器为每个动作配一个输入控制器,职责是解码 URL 提取数据、调用模型处理、选择视图显示结果,可以用脚本或服务器页面实现。有的团队为了一致性,全部用服务器页面或全部用脚本,结果简单 URL 变成大量样板代码,复杂 URL 塞满难维护的 scriptlet。更务实的是按复杂度分别选择;同一站点中页面控制器与前端控制器混用也完全可行,按场景选工具的总代价往往低于强行统一。 进一步展开见控制器方式可以混用。

前端控制器用一个处理程序接收站点的所有请求,从 URL 提取信息后委托给具体的 command 执行。选择 command 有两种方式:静态解析 URL 用条件分发,逻辑清晰且有编译期检查;动态按 URL 或配置文件实例化 command 类,新增 command 不必改处理程序。截取筛选器是装饰器,可链式叠加认证、日志、字符编码等横切处理。每个请求新建 command 对象,也天然避开了多线程问题。 进一步展开见前端控制器与筛选器。

模板视图把动态标记嵌进静态 HTML,页面仍能用所见即所得工具编辑。避免它退化成一堆 scriptlet 的关键是为每个页面配一个辅助对象承载全部逻辑,页面只调用它;大量 scriptlet 让页面失去模块化能力。最棘手的是条件显示:页面里写条件标签,就把模板变成了编程语言。应让辅助对象直接返回该显示的内容或空串。页面出现比读布尔值更复杂的表达式,就是逻辑外泄的信号。 进一步展开见模板视图不写逻辑。

两步视图把”领域数据转HTML”拆成两个阶段:第一阶段把模型数据组装成一个不含任何HTML细节的”逻辑屏幕”结构(字段、标题、表格等面向表现但不涉及具体样式的元素);第二阶段把这个逻辑屏幕结构渲染成真正的HTML。这个拆分带来的核心价值在多外观场景下最为直观:如果用单阶视图(模板视图或转换视图),每个”屏幕×外观”的组合都要各自配一个视图模块——10个屏幕配3种外观就要维护30个单阶视图模块;换成两步视图后,只需要10个第一阶段模块(每屏幕一个)加3个第二阶段模块(每种外观一个),总数从”屏幕数×外观数”降到”屏幕数+外观数”,屏幕和外观越多,这个节省就越可观;即便只有单一外观,两步视图依然让”全局改版”这件事变得轻松——只需要改动共享的第二阶段,不用满世界找每个页面各自的样式代码。但这份收益完全建立在一个前提上:能不能把站点里所有页面的表现需求,收敛进同一个足够简单的”面向表现结构”里——如果站点很复杂、每个页面的外观差异巨大,很难在不同屏幕间找到足够多的共性来提炼出这样一个通用结构,两步视图这时反而成为累赘;换句话说,这个面向表现的结构本身会反过来约束整个站点的设计自由度,对许多站点而言这种限制相当明显。此外,两步视图还需要程序设计人员亲自编写渲染器和控制器对象,不像模板视图那样能让非程序员用可视化工具直接设计页面,任何设计上的调整都绕不开程序员的参与。 进一步展开见两步视图的取舍。

应用控制器决定执行哪段领域逻辑、用哪个视图显示结果,通常维护指向领域命令和视图的两组引用。它宜与 UI 机制完全解耦。一个应用可以按界面区域配多个应用控制器;Web、富客户端等多种界面理论上可以共用,但不同界面往往需要不同的屏幕流,勉强共用会牺牲可用性。它常被组织成状态机,控制流适合用元数据表达。领域逻辑原则上不放进应用控制器,但边界常模糊:偶尔出现可以放进去,反复出现就该在领域模型中分离。 进一步展开见应用控制器与UI解耦。

模板视图以输出页面为骨架,往里填动态内容;转换视图则以输入数据为骨架,为每种领域元素写一条转换规则,如“遇到客户就输出这段 HTML”,规则顺序不影响结果,典型实现是 XSLT。它的好处正对着模板视图的两个弱点:只负责把数据画成 HTML,不容易混进业务逻辑;输入 XML、输出 HTML,脱离 Web 服务器就能测。代价是 XSLT 难学、工具弱,设计师难以上手。选哪种主要看团队熟悉什么。参见模板视图不写逻辑、视图模式的两个维度。 进一步展开见转换视图按输入组织。

原书依据 · 10 处

远程外观宜少而粗

远程外观是建立在细粒度对象之上的粗粒度门面,不含领域逻辑,只把一次粗粒度调用转换成对细粒度对象的多次调用,校验和计算仍留在细粒度对象里。有人偏爱很小的外观,甚至每个用例一个;更好的做法是数量少而粗,中等规模应用一个就够,大型应用也不过六个左右。每个外观因此包含很多方法,但方法都很简单。多个方法在底层调用同一批操作很正常,外观的目的是简化外部客户的使用,而不是简化内部结构。 进一步展开见远程外观宜少而粗。

远程外观和服务层看似相像,定位却不同:服务层不必是远程的,也不必局限于粗粒度,它收敛成粗粒度是为了结构清晰而非节省网络开销,通常也不需要数据传输对象,可以直接返回领域对象。因此领域模型既要支持进程内调用又要支持远程调用时,保留服务层,再在其上加一层远程外观;若应用只走远程,直接把服务层改造成远程外观更省事,前提是服务层中没有额外的应用逻辑,否则让远程外观独立成另一个对象。 进一步展开见远程外观与服务层。

数据传输对象要部署在连接两端,若依赖领域对象,就会把领域模型带到客户端;领域对象也不该依赖 DTO,因为接口格式一变 DTO 就要变,这种变化不应传入领域模型。二者之间的数据搬运由专门的组装器负责:从领域模型组装 DTO,或用 DTO 更新领域模型,这是映射器模式的应用。同一个 DTO 可以配多个组装器,满足不同情境下的更新语义。DTO 往往可以根据数据描述自动生成,组装器涉及两种结构间的转换,通常需要手写。 进一步展开见组装器隔开DTO与领域。

DTO 在网络上传输需要序列化,平台自带的二进制或 XML 序列化通常足够,因为 DTO 结构简单。容易忽视的是 DTO 定义总会变,而服务端与客户端未必能同步升级。纯二进制序列化对结构变化极其脆弱,哪怕只新增一个可选字段也可能导致反序列化失败。XML 序列化适应力强得多;也可以用字典式的二进制格式换取容错,尽管字典作 DTO 本体会丢失强类型。选序列化协议时,对结构演进的容忍度往往比传输效率更重要。 进一步展开见序列化格式要能容错。

DTO 看起来只是一堆字段加访问方法,价值却在于一次远程调用就带回所需的全部信息。远程调用代价高,宁可多带些数据,也别为补漏再跑一趟;一个订单 DTO 往往连同客户、订单项、产品和发货信息一起打包。它的结构要扁平简单,形状由客户端的页面或屏幕决定,而不是照搬领域模型。用一个通用 DTO 还是按请求拆分,没有铁律:数据相近就合用,特殊请求再单独定义。参见远程外观配合DTO、组装器隔开DTO与领域。 进一步展开见DTO按客户需要设计。

原书依据 · 6 处

乐观锁需检查只读依赖

乐观离线锁常见实现是给每条记录一个版本号,更新时在 where 中带上版本号,影响行数为 1 表示成功,为 0 说明已被改动,需回滚。最好同时记录最后修改人和时间,以便友好提示;不要用时间戳代替版本计数,多服务器时钟不可靠。但这只防住了更新丢失:会话 A 开账单时读取顾客地址算税率,会话 B 同时改了地址,A 从未修改地址,检查不到冲突,税率就算错了。解法是把只读但依赖其正确性的记录也纳入版本检查。

版本检查必须保护到本次写入提交;分开查询版本再写入仍有竞态,快照可重复读也可能允许不同记录之间的写偏差。具体不变量可用条件写、共同控制点或合适的可串行化协议保护,并处理冲突重试。PostgreSQL 18隔离说明明确区分快照可重复读和可串行化。 进一步展开见乐观锁需检查只读依赖。

任何锁模式都不能彻底解决企业应用的并发与时序问题,因为“算不算冲突”常常是业务问题。开账单时用了顾客的旧地址算税率,是否必须阻止?也许业务上可以接受,那么该用哪个版本的地址就要由业务规则裁决,版本号检查回答不了。又如两个会话同时向同一集合添加不同元素,标准乐观锁检测不到冲突,却可能违反容量上限或元素互斥等规则。技术锁只能保证检测到的冲突被正确处理,保证不了该检测的场景都被覆盖。 进一步展开见冲突是领域问题。

源代码管理系统是最熟悉的乐观离线锁场景,检测到冲突时通常会自动合并再提交。高效的合并策略让乐观锁异常强大:不仅并发度更高,即便冲突发生,用户也基本不必重做工作。企业应用的难处在于,SCM 只需一种通用的文本合并算法,企业应用却要为形形色色的业务数据各自设计合并规则,有的复杂到不值得实现,有的简单到值得实现。加上合并机制后威力大增,但冲突如何合并又回到了业务规则上。 进一步展开见自动合并放大乐观锁。

悲观离线锁要求业务事务在操作数据前先拿到锁,从源头上避免冲突,代价是限制并发。选锁类型时有三条路。独占写锁:只在业务事务要编辑数据时才需要获取,忽略对数据的读——两个事务不能同时编辑同一份数据,但读操作完全不受限制;如果对”读到最新数据”没有严格要求,可以优先评估这种较少限制读取的方式,但须先满足业务读一致性要求。独占读锁:业务事务哪怕只是想读到最新数据(不一定要修改)也要先拿锁,会严重限制系统并发度,一般不推荐。读/写锁:把前两者的优点结合起来——读锁和写锁互斥(有人持读锁时不能加写锁,反之亦然),但并发的读锁彼此不冲突(一个读锁只是防止别人写,不妨碍别人也来读),这样既能保证读到的数据不会中途被改,又不会像独占读锁那样把所有读操作都串行化;代价是实现起来更复杂,也给业务建模人员增加了理解负担。选锁类型时要同时兼顾并发度、业务实际需求和实现复杂度这三个维度,而且必须让领域建模人员和系统分析师也理解这套加锁策略——加锁从来不只是技术问题,选错锁类型、锁的范围过大或过小,都会导致要么挡不住真正的冲突、要么把多用户系统活生生拖成单用户体验,而这种错误没法靠更高明的技术实现来挽救,只能从加锁策略本身去修正。 进一步展开见悲观离线锁三类型。

跨系统事务实现悲观离线锁有两个坑。一是死锁:像 SELECT FOR UPDATE 那样一直等到锁可用,容易互相永久等待;业务事务动辄几分钟到二十分钟,干等毫无意义,加超时又更复杂。更干脆的做法是不等待,锁不可用就立即抛出异常,让业务事务失败,由调用方决定是否重试。二是会话丢失:客户端中途离开,事务永不结束,锁也不会释放。宜借助容器的会话超时,注册监听器在会话失效时释放其全部锁,或给锁加时间戳定期清理。

释放过期锁只解决占用清理。若旧持有者仍可能继续执行,必须在受保护写入处验证其所有权/代次或使用等价保护,不能把超时清理本身当成写入安全保证。 进一步展开见悲观离线锁的两个坑。

一组对象经常被当作一个整体来修改(比如顾客和他的一组地址),逐个加锁很麻烦——不仅调用方要自己写代码找齐所有对象才能加锁,乐观离线锁下批量读取多个对象来加锁会拖累性能,悲观离线锁下则会让锁表争夺更激烈。粗粒度锁用一把锁覆盖一整组对象来解决这个问题,关键是先为这组对象建一个”控制点”。共享锁:让组内每个对象共享同一个版本号(不是”版本相同”,而是”共用同一个版本号变量”),任何一个成员被修改,这个共享版本号递增一次,就相当于给整组对象上了锁;配合悲观离线锁时,同样可以让组内成员共享某种锁标记(一个共享的版本对象就很适合充当这个标记)。根对象锁:把一簇相关对象看作一个”聚集”(这是Eric Evans与David Siegel提出的概念)——聚集有一个唯一的根对象作为访问入口,以及定义”聚集范围”的边界,锁住这个根对象,按定义就等于锁住了整个聚集里的所有成员;要让这招管用,聚集里的每个成员都得有办法导航到根对象(可以直接持有到根的引用,也可以逐级向上访问父节点直到抵达根,层级深的话后者会拖累性能,因此导航中间对象时应该配合延迟加载——但要小心这种延迟加载如果跨越多个系统事务,可能导致系统状态不一致,这是应当避免的)。两种实现各有代价:共享锁在关系数据库里意味着几乎所有查询都要联接版本表;根对象锁则要在加锁前导航读取一批中间对象,也拖累性能,而且和悲观离线锁搭配时经常需要重新读取这些中间对象以确保它们是最新的。使用粗粒度锁最根本的理由应该是业务需求本身——比如一个带着若干资产的租约对象,允许一个用户改租约的同时另一个用户改其中的资产,在业务上根本说不通,这才是”必须把租约和资产绑成一把锁”的真正原因,而不是单纯出于技术层面的性能考量;同时也要警惕不要为了套用这个模式而生造出不自然的对象关系。 进一步展开见粗粒度锁两种实现。

加锁模式最怕有人漏写加锁代码,而离线并发问题极难测试。隐含锁把不能跳过的加锁动作下沉到框架、层超类型或代码生成中。应自动化的是乐观锁的版本存储、检查与递增,以及悲观锁中为读取获取锁、事务结束释放所有锁;唯独为编辑获取写锁不该自动化:否则写锁失效时用户无从提前知道、无法尽早止损,并发度也被压到最低。框架只需在提交前检查写锁是否已显式获取,没有就抛出并发异常,而不是依赖可能被关闭的断言。 进一步展开见隐含锁只自动化读锁。

乐观离线锁默认只在最后提交时才报告冲突,用户可能白忙了很久。可以提供一个随时调用的检查方法,在长流程的关键节点看看数据是否已被他人改动,发现了就提前停下,少做无用功。但这只是预警,检查通过不代表提交一定成功,最终仍以提交时的版本校验为准。另一个提高灵活性的办法是看清事务到底依赖什么:若只依赖某行是否存在或某个字段,用条件判断代替整行版本检查,能减少不必要的失败。参见乐观锁需检查只读依赖、离线并发能免则免。 进一步展开见乐观锁的提前预警。

悲观离线锁靠一个锁管理对象发放锁,它只记录“谁锁了什么”,业务代码只能通过它申请和释放,不能直接碰锁表;应用服务器集群时,锁表要放进数据库。使用协议要回答四个问题:何时加锁,通常在读数据之前,保证锁住的是最新数据;锁什么,通常只锁主键,不必先把对象加载出来;何时释放,默认在业务事务结束时;拿不到锁怎么办,立即失败并告知用户。原则是在用户刚开始工作时就拿齐所有锁,冲突暴露得越早越好。参见悲观离线锁三类型、悲观离线锁的两个坑。 进一步展开见悲观锁的使用协议。

原书依据 · 11 处

客户会话状态的技术

在HTML场景下把会话状态存进客户端,主要有三种技术,各有明显短板。URL参数:把会话数据编码进请求URL,对少量数据(如会话标识号)很方便,很多平台还能自动重写URL附加会话ID;明显的限制是URL长度、以及改变URL会影响浏览器收藏夹,因此不建议在面向普通顾客的系统里这样用。表单隐藏域:用<INPUT type="hidden">把会话状态序列化进不可见的表单域,每次响应写入、每次请求读回;虽然界面上看不到,但打开页面源代码就能看到这些数据,而且如果站点里混杂着一些过时或固定的静态页面,一旦导航到这些页面就会丢失全部会话数据。Cookie:由浏览器自动在客户端和服务器之间传输,用法上和隐藏域类似,但受制于大小限制、只能在同一域名下生效(多域名站点之间不会自动传递),还有部分用户会主动关闭Cookie导致依赖它的站点直接失效——实际还取决于浏览器、站点与用户策略;有些系统会先探测客户端是否支持Cookie,不支持时自动退化为URL重写方案。这三种技术有一个共同的安全提醒:Cookie并不比其他方式更安全,客户端数据同样可能被窥探或篡改;而几乎所有系统都会用客户端方式承载”会话标识号”这一项数据,此时要格外提防恶意用户篡改标识号来窃取别人的会话——常见对策是让会话ID由系统随机生成,不能靠对可预测的简单ID做散列就获得足够随机性。应使用成熟框架或密码学安全随机生成的会话标识,并配置合适的传输、Cookie作用域和过期策略。 进一步展开见客户会话状态的技术。

业内流传“无状态会话 Bean 性能更好,应避免有状态会话 Bean”。这个说法站不住:作者报告ThoughtWorks在特定应用、几百并发用户的负载测试中未观察到这项影响;这只是案例,不证明所有环境没有差异。因此应在当前应用中比较实现复杂度与实测性能;真正需要谨慎的理由是故障恢复能力,这取决于应用服务器厂商。面对“某方案性能差应避免”这类经验之谈,与其凭直觉接受或否定,不如在自己的场景下做一次有代表性的负载测试。 进一步展开见性能疑虑用负载测试。

会话状态序列化存进数据库后,要清理作废的会话。常规做法是监督进程定期扫描并删除过期会话,频繁的查询和删除本身开销不小。Kai Yu 的做法更巧妙:把会话表分成 12 段,每两小时轮换一次,轮换时直接清空最旧的一段,再把接下来两小时的新会话写进去。代价是存活超过 24 小时的会话会被强制清理,这是作者案例当时可以接受的前提;当前是否可接受须核对会话寿命及续期规则。它把逐条判断删除变成整段清空,这一思路也适用于日志滚动、缓存过期等场景。 进一步展开见会话表分段轮换清理。

数据库会话状态每次请求都要从数据库读出需要的数据、处理后再存回数据库,其核心难题在于——会话过程中产生的中间数据是局部的、不该在整体提交之前就影响系统的其他部分。比如正在编辑一份订单,把它的中间状态存进数据库时,必须让它和其他”已确定”的订单区分开,否则它就会被误算进”可供租借的图书数量”“每日收入统计”这类查询结果里,污染那些本该只反映已提交事实的数据。区分”会话中的临时数据”和”真正的记录数据”主要有两种方案。标记字段:在每一行数据上加一个字段表明它是不是会话数据——最简单是一个isPending布尔值,更好的做法是存一个会话ID(这样能方便地按会话ID一次取出某个会话的全部数据),配套要求所有查询语句都得加上”会话ID为空”的过滤条件才能只看到真实记录(或者建一个视图来屏蔽这层判断,但视图本身也有性能代价);这个方案影响面很大,因为凡是接触这份记录数据库的代码都得理解这个会话ID字段的含义。临时表:给每张真实表各配一张结构完全相同的临时表(字段名保持一致,临时表额外加一个会话标识号字段),会话中的数据先写进临时表,等真正提交时再转移到正式表——好处是不会像标记字段那样影响到所有查询代码,代价是数据库映射代码里要加入”选哪张表”的判断逻辑,而且书中建议可按草稿阶段调整完整性约束和审查规则,是否缺失取决于建表与校验实现(这是双刃剑:可以按需选择性地在临时表上补规则,也可能因为疏忽而漏掉本该有的校验)。无论用哪种方案,都还要处理会话取消或超时后的清理(找到并删除对应会话的所有数据,配合定时巡检未活动会话),以及回滚的复杂性——一种选择是每次请求结束时提交部分修改、限制取消范围,但这必须符合产品承诺,不能直接认定符合用户预期。 进一步展开见数据库会话状态张力。

原书依据 · 4 处

入口与相近模式之别

入口是封装外部系统或资源访问的对象——把某个外部资源天然复杂的API(关系数据库的JDBC/SQL、XML的W3C/JDOM等)包装成一个看起来像常规对象的简单接口,让其他代码不必直接理解这些API的复杂性。入口是否值得单独列为一个新模式,还是把它归为外观或适配器的变体,最终基于三点实质区别把它独立出来。与外观模式的区别:外观通常是服务的作者提供给通用受众使用的,目的是简化一个较复杂的API,且外观呈现的接口形状往往与原始接口不同;入口则是客户方为了自己的特定应用而编写的,接口可以只是原样照搬被包装的资源接口,目的主要是为将来替换资源或做测试提供切入点,而不是为了改变接口形状。与适配器模式的区别:适配器修改一个已经实现好的接口、让它匹配另一个你要用的接口;入口通常面对的场景是压根没有一个已存在的接口需要去适配(虽然实现入口内部时可能会用到适配器,那时适配器只是入口实现的一部分,而不是入口本身)。与调停者模式的区别:调停者用来解耦多个对象,让它们不必互相引用、只需各自和调停者打交道;入口通常只涉及两方(客户端和被包装的资源),而且被包装的资源本身完全不知道入口的存在。可迁移启发:几个”看起来都是包一层”的经典模式(外观/适配器/调停者/入口),真正的分野往往不在”包了一层”这个表面动作本身,而在于”这层包装是谁写的、为了谁而写、面对的是几方关系、原始接口是否已经存在”这几个更细致的问题——判断该用哪个名字/哪种设计定位,要回到这些具体问题上找答案,而不是停留在”都是包装”这个笼统印象。 进一步展开见入口与相近模式之别。

映射器是两个必须隔离的子系统之间的绝缘层,负责双方的通信,而双方都感知不到它的存在;这比调停者更彻底,用调停者时各对象至少知道调停者存在。映射器运行起来后搬运数据很直观,难点在于如何被激活,因为不能由被隔离的任一方直接调用它。解法有二:由第三方子系统触发映射;或让映射器作为某一方的观察者,监听事件后自行工作。入口比映射器简单得多,是更常见的默认选择;只有交互复杂且相对独立于双方时才值得用映射器。 进一步展开见映射器难在激活。

分离接口把接口定义在一个包、实现放在另一个包,客户只依赖接口,不知道实现包的存在。典型场景是框架代码调用应用代码、领域层调用数据映射器、调用其他团队的功能而不想被其 API 变动绑架。但给每个类都套上分离接口是过犹不及:保持分离要额外工作,往往还要配工厂类;一开始放在一起,真需要时再拆也只是一次简单重构。只有确实要打破依赖、会有多个实现,或要在编译期强制包依赖规则时,才值得引入。 进一步展开见不要处处分离接口。

注册表是一个”众所周知”的全局对象,让代码在没有合适的关联路径可循时(比如只知道客户ID、却没有指向客户对象的引用)也能找到需要的公共对象或服务。设计注册表要把接口和实现分开考虑——接口宜用静态方法(这样应用里任何地方都能方便地调用到),但特别提醒:方法是静态的,不代表背后的数据也必须存在静态域里,除了存常量,应尽量少用静态域。决定数据该怎么存之前,先要看清数据的作用域:有的数据贯穿整个进程,有的只在单个线程内全局,有的只在一次会话内全局——不同作用域需要不同的存储实现,但对外暴露的接口应该保持一致,调用方不需要关心某个静态方法背后返回的到底是进程级数据还是线程级数据。进程作用域的数据,常见做法是用单子模式(内部用静态域存唯一实例,但对外只暴露隐藏这个实例的静态方法,而不是直接暴露实例本身);但单子在多线程环境下管理”可修改数据”很容易出乱子(多线程无法预知顺序地读写同一对象),除非数据本身是只读常量(比如美国州名列表这种进程启动时加载、运行期基本不变的数据),否则不建议用单子存可变数据。线程作用域的数据(如数据库连接)通常借助线程局部存储或者”以线程为键的字典”来实现,但对外接口写法(如Registry.getDbConnection())和进程作用域时应完全一致;会话作用域的数据同样可以用字典技术——每个会话开始时把会话ID记进线程作用域的注册表,后续按这个会话ID去查一个以会话为键的映射结构。 进一步展开见注册表接口与数据。

注册表本质上是全局数据,能通过对象间引用找到目标时就尽量不用它。两种替代方案:参数传递,但多层转发可能使参数只是“路过”(书中九成为修辞性说明,未给出测量依据),真正使用者在调用链深处,这正是注册表能省下的;构造函数注入,只在创建时传一次引用,适合只有部分类用到的数据。确需注册表时,宜用显式的注册表类而非裸 map:显式类的方法清楚表明能取到什么,裸 map 要翻遍所有读写处才知道有哪些键。全局数据在证明无辜之前,一律有罪推定。 进一步展开见注册表是有罪推定。

引用对象与值对象的区别不在大小,而在判等方式:引用对象靠标识,值对象靠属性值,两个日期只要年月日相同就相等。值语义不等同于语言的参数传递机制;即使以对象引用传递,也可通过不可变性实现按值理解的领域对象。许多语言不原生支持值语义,这时要让值对象不可变,理由是避免别名 bug:Martin 与 Cindy 共享同一个日期对象,Martin 若把入职日期就地改成 5 月,Cindy 的日期也会跟着变。缺乏值语义时,不可变性是防止改一处影响另一处的具体手段。 进一步展开见值对象不可变防别名。

按比例把资金分给多方时,各份独立取整不能保证“各份之和等于总额”。规则为七三分账、总额 5 分钱时,结果是 3.5 分与 1.5 分:四舍五入得 4+2=6 分,多出 1 分;都向下取整得 3+1=4 分,少了 1 分;都向上取整又多出 1 分。这不是实现疏忽,而是逐项独立取整在数学上无法保证总量守恒。照搬“总额乘比例再四舍五入”在这个两方示例中可能产生1分差额,误差范围随参与方和规则改变,长期累积成资金缺口。解决见货币分配器零误差分账。 进一步展开见分账舍入误差无解。

针对分账舍入误差无解,几种方案各有问题:忽略误差会对不上账;把最后一份定义为总额减去已分配部分,误差全堆在最后一份,不公平;让调用方逐次声明取整方式,账户一多代码就凌乱。更好的是给货币类加分配器方法,如 aMoney.allocate([7, 3]),返回一组金额并保证总和恰好等于原额。代价是必须记得调用它。把分配封装成单一操作,才能从设计上守住总量守恒。

这里的“零误差”仅指分配结果总额守恒,尾差归属仍需符合业务规则。原书教学实现没有完整处理负金额、零权重、整数溢出等边界,不能把示例直接当生产分账库。 进一步展开见货币分配器零误差分账。

空值破坏多态,使用引用前必须先判空,判空代码到处重复;它只是“特殊情况需特殊处理”中最常见的一种。特殊情况模式为这类情形建一个子类,如“空顾客”,重载所有方法提供无害的默认行为,原本返回空值的地方都返回它。通常可用享元共享实例,但需要各自累积欠费的居民客户就不能共享。“没有顾客”与“有一个身份不明的顾客”含义不同,宜用不同子类表达;其方法的返回值也应是特殊情况对象。 进一步展开见特殊情况替代空值。

主键生成器这类行为在不同环境需要不同实现,如测试用内存计数器、生产用数据库序列。常见做法是在工厂方法里判断环境,工厂一多就乱:新增一种部署组合要改好几个工厂并重新编译。插件模式先用分离接口定义这些行为,再用插件工厂在运行时按代码之外的配置文件把接口连接到实现,换配置只需改文件。语言支持反射时,工厂可以完全通用;不支持时仍需条件判断,但集中在一处,而不是散落在多个工厂里。 进一步展开见插件集中环境配置。

企业系统常依赖信用评分、税率查询等不受控的第三方服务,它们不可预测又常是远程调用,会拖慢开发与测试。测试时可用运行在内存中的服务桩替代:先用分离接口定义访问点,再用插件在测试与生产实现之间切换。关键是保持极简:销售税服务桩最简版几行代码返回统一税率。供测试追加数据的 setup 方法,在真实实现中被调用时应直接报错。一旦开始给服务桩加复杂特性,就偏离了它的目的。 进一步展开见服务桩越简单越好。

记录集是表格数据在内存中的表示,让领域逻辑可以直接生成或操作与 SQL 结果形状相同的数据。多数实现用隐式接口,如 aReservation[“passenger”],想知道该用哪个键只能翻源码;显式接口如 aReservation.passenger,能保留类型信息。记录集中,列名本就写在生成它的 SQL 里,隐式接口的痛点有所缓解,但仍宜优先显式接口,或借代码生成得到显式记录集。 进一步展开见记录集宜用显式接口。

层超类型为某一层中的所有对象提供一个共同的超类,把它们都需要、又不希望到处复制的行为收进去,例如所有领域对象继承的 DomainObject 统一处理标识域,所有数据映射器也可以共享一个映射器超类;一层中有几类对象时,也可以有多个层超类型。它思想简单,却被许多模式反复借用,如重影的状态管理、隐含锁的自动加锁。使用前先确认这些行为确实是整层共有的,否则共同超类会变成堆放杂项的垃圾场。 进一步展开见层超类型。

外部系统常给出“万能”接口,如 send(类型字符串, 参数数组),灵活却看不出有哪些合法消息、各需什么参数。入口的职责是在客户这一侧把它翻译成显式方法,如 sendConfirmation(订单号, 金额),名字说明用途,参数带类型,编译器能帮忙查错。新增消息类型时要改入口,但用万能接口照样得改调用方。入口还把返回码翻译成本语言惯用的异常,并预留一个可覆盖的发送方法,测试时换成服务桩。参见入口与相近模式之别、服务桩越简单越好。 进一步展开见入口把通用接口显式化。

大量软件在处理钱,书中所讨论的平台缺少合用的内建货币抽象,于是常见两类错误:把美元和日元直接相加,以及舍入时悄悄丢掉零头。货币模式用一个值对象同时保存金额和币种,金额存成整数分或定点小数,绝不用浮点。加减先校验币种,不同币种相加直接报错;按比例算税用乘法,在多方之间分钱用分配器;币种换算交给转换器对象,因为有的换算规则规定了取整方式。实际性能仍须按当前数据量和实现测量。参见货币分配器零误差分账、值对象不可变防别名。 进一步展开见货币类别用浮点。

原书依据 · 17 处

跨章综合

领域模型把复杂规则表达为对象协作,数据映射器则把持久化复杂度隔离;两者不是所有应用的默认答案。事务脚本和活动记录在简单场景中可以更直接。随着规则、数据映射和使用方式变化,需要重新比较成本,而不是把模式排成固定升级路线。

对象身份、版本和锁解决不同问题。标识映射避免一个上下文内出现同一行的不同对象,版本检查发现受保护数据的变化,系统事务控制一组实际数据库操作。三者不能彼此替代,刷新也不自动意味着提交。远程外观减少调用次数,DTO选择可传输的数据,但普通外部通知不会仅因一个方法被声明为事务性就随数据库一起回滚。

参考文献中的对象关系映射、事务处理、分布计算和领域建模可作为后续入口。旧版EJB、JSP、ADO.NET及工具能力评价保留历史语境;当前条件另以固定版本官方材料核验。

发散与实践

读者延伸:实践计划及其准备材料保留在本书ideas目录。已有历史记录与本轮计划区分,尚未执行的观察、测量或验证不作为实际结果;涉及实现深读的项目与版本单独记录核验入口。

生成进度与管理记录

企业应用架构模式

Skill 版本:v7 - 本次实际使用规则:book-notes v10(2026-10-03 按逐 spine 覆盖台账重跑,进行中);历史使用规则:book-notes v8(2026-09-24 按 _card_review.md 完成 S4 修订:正文压缩至 200 字内、标题压缩至 15 字内、补 ch18-013 层超类型,并补做主题索引维护),详见 _workflow.md。

整体评级

四象限结论:经典原理(高信息浓度 + 高稳定性)

评级理由:

本书围绕企业应用长期存在的结构性问题展开:分层边界如何划分、领域逻辑该用什么组织方式、对象模型与关系数据库如何映射、Web表现层的职责如何拆分、并发与事务隔离如何权衡、会话状态放在哪里代价最小、分布式调用的边界该划在何处。全书不是某个框架或版本的操作手册,而是在事务脚本、领域模型、表模块、数据映射器、工作单元、标识映射、远程外观、数据传输对象等几十个模式之间反复说明各自的适用条件、优点和代价,属于典型的”讲清楚为什么这样设计、各方案如何取舍”的高浓度内容。虽然书中大量示例使用Java、C#、J2EE、.NET、Web Services等2002年前后的具体技术栈,但支撑这些模式的核心判断——”远程调用不等于本地调用因此接口要粗粒度”“复杂领域逻辑需要领域模型而非事务脚本”“持久化机制应该与领域模型解耦”“业务事务可能跨越多个系统事务因此需要离线并发控制”——在今天的Web系统、微服务、ORM框架和SaaS后台架构中依然成立,稳定性很高。因此定为经典原理,是可反复查阅的架构决策参考书,而非速查手册。

类别:系统架构类(判定依据:全书围绕分层架构、领域逻辑组织方式、数据访问架构等大型软件系统的整体架构设计展开,不针对单一具体框架,符合category-checklists.md“系统架构类”的判定标准)

章节进度

V10 重跑(2026-10-03):历史表没有逐 spine 覆盖记录,已全部恢复 pending,须按 _coverage.md 逐来源项、逐单元重读后再恢复 done。

章节号 章节标题 精读/略读 状态 卡片数
第0章 引言(架构/企业应用/企业应用的种类/关于性能的考虑/模式) 精读:定义全书讨论范围的核心概念,是后续所有模式的坐标系 pending 5
第1章 分层 精读:三大基本层次的划分是全书核心方法论坐标系 pending 7
第2章 组织领域逻辑 精读:事务脚本/领域模型/表模块/服务层的选型直接影响架构走向 pending 7
第3章 映射到关系数据库 精读:对象模型与关系模型的错配问题及应对策略 pending 14
第4章 Web表现层 精读:请求处理与视图生成的基本拆分方式 pending 5
第5章 并发 精读:执行语境、隔离、锁、事务边界等企业系统一致性风险 pending 14
第6章 会话状态 精读:会话状态放在客户端/服务器/数据库的代价权衡 pending 7
第7章 分布策略 精读:远程接口与本地接口的本质区别及分布边界划分原则 pending 6
第8章 通盘考虑 精读:不同领域逻辑模式搭配不同数据源模式的组合决策 pending 8
第9章 领域逻辑模式 精读:事务脚本/领域模型/表模块/服务层四种模式 pending 14
第10章 数据源架构模式 精读:表数据入口/行数据入口/活动记录/数据映射器四种模式 pending 7
第11章 对象-关系行为模式 精读:工作单元/标识映射/延迟加载三种模式 pending 9
第12章 对象-关系结构模式 精读:标识域/外键映射/关联表映射/依赖映射/嵌入值/序列化LOB/三种继承映射/继承映射器共十种模式 pending 11
第13章 对象-关系元数据映射模式 精读:元数据映射/查询对象/资源库三种模式 pending 5
第14章 Web表现模式 精读:MVC/页面控制器/前端控制器/模板视图/转换视图/两步视图/应用控制器七种模式 pending 6
第15章 分布模式 精读:远程外观/数据传输对象两种模式 pending 4
第16章 离线并发模式 精读:乐观离线锁/悲观离线锁/粗粒度锁/隐含锁四种模式 pending 7
第17章 会话状态模式 精读:客户/服务器/数据库三种会话状态存放模式 pending 4
第18章 基本模式 精读:入口/映射器/层超类型/分离接口/注册表/值对象/货币/特殊情况/插件/服务桩/记录集共十一种模式 pending 13

实践卡进度

以下保留历史版本的实践进度、名称与当时执行陈述;本轮v23筛选和实际交付以文末记录及当前ideas文件为准。历史done不表示本轮已执行。

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
idea-001 Hibernate的Session如何实现三件套 实现深读 done 第10、11章 待完成的对照表框架+已核验的模式关系背景(源码级细节待后续深读)
idea-002 Rails胖模型问题印证活动记录的复杂度边界 证据验证 done 第9、10章 已核验的社区证据清单+对照笔记框架(逐篇精读结论待后续深读)
idea-003 Spring MVC的DispatcherServlet映射前端控制器理论 实现深读 done 第14章 已核验的框架级对应关系+对照表框架(源码级细节待后续深读)

待关联术语

术语名 出现章节 一句话语境
模式的标准描述结构(名字/意图/概要/动机/运行机制/使用时机/延伸阅读/例子) 第0章 0.5.1 说明后续每个模式条目将按此固定八段式呈现,属于全书排版约定而非可迁移架构知识
ISAM/VSAM等批处理文件格式 第1章 1.1 提及早期批处理系统直接操作的具体文件格式,未展开讲解
VB/PowerBuilder/Delphi 第1章 1.1 提及客户/服务器时代的具体胖客户端工具,未展开讲解
TRS-80 第1章 1.3 提及B2C系统必须兼容的极端老旧客户端型号,仅作举例
Unix X servers 第1章 1.3 提及远程操作台式机上Web服务器的特例场景,未展开讲解
微软COM/.NET记录集开发网格 第2章 2.1⁄2.2 提及表模块契合的具体平台生态,未展开讲解
JDO 第3章 3.1 提及Java世界中”面向对象数据库风格逻辑层”的例子,作者表示经验不足未展开评价
select*与列序号/列名索引的取舍、静态SQL预编译、多SQL打包调用 第3章 3.8 具体数据库驱动层面的操作技巧,时效性强,未单独展开生卡
拓扑分类法解决引用完整性写顺序问题 第3章 3.4.1 提及一种具体技术但明确”不是本书讲述的范围”,未展开
COM单线程空间、J2EE EJB隔离机制 第5章 5.7 提及为线程分配隔离数据空间的具体平台方案,未展开讲解
TOPLink等O/R映射工具的代理迁移方案 第7章 7.4 提及用代理在进程间迁移对象的分布方式,作者坦言未见过实际应用,未展开
异步的、基于消息的处理方式 第7章 7.5 作者表示个人偏好正转向此方向但本书未展开讨论,未单独生卡
JDBC2.0 Row Sets、EJB2.0规范、容器管理持久(CMP)、组成实体(Composite Entity)模式 第8章 8.4.1 提及Java/EJB具体技术细节,未展开讲解
Oracle数据库内运行Java程序的方案 第8章 8.4.3 提及缓解存储过程厂商绑定问题的具体技术,未展开讲解
收入确认问题的Java/C#代码示例(表数据入口/策略类/ADO.NET数据集/索引器等具体实现) 第9章 9.1.4⁄9.2.4⁄9.3.3⁄9.4.4 各模式的完整代码走查(含货币模式的浮点精度处理提示),核心思想已提炼入对应卡片,代码本身未逐条生卡
ADO.NET数据阅读器(游标式)与数据集(容器式)的取舍、分离接口解决查找方法依赖、存储过程封装为表数据入口的技巧 第10章 10.1.4⁄10.1.5⁄10.4.1⁄10.1.1 具体实现层面的取舍细节,核心思想已在相关卡片提炼,未单独展开
工作单元的批量更新(batch update)技巧、.NET无连接数据集实现工作单元的版本/状态机制、JDBC批处理机制 第11章 11.1.1 具体平台/技术实现细节,未单独展开
值列表处理器 第11章 11.3.1 提及应对巨型集合延迟加载的专门模式,未展开讲解(该模式在后续模式目录章节中会有专门定义)
第12章大量C#/Java代码示例(键表实现/多表查询/关联表SQL/XML序列化部门层级/继承层次加载等) 第12章 10个模式的完整代码走查,核心思想已提炼入对应卡片,代码本身未逐条生卡
组合模式(备忘录模式引用)、GUID生成算法细节 第12章 12.6.1⁄12.1.1 提及具体实现技术,未展开讲解
第13章代码示例(元数据+反射的Java实现/查询对象与资源库的具体代码) 第13章 13.1.3⁄13.2.4⁄13.3.4⁄13.3.5 完整代码走查,核心思想已提炼入对应卡片,未逐条生卡
第14章大量Java/C#/XSLT代码示例(Servlet+JSP/ASP.NET服务器页面/截取筛截器/两阶XSLT/状态模型应用控制器等) 第14章 14.2-14.7各模式代码走查,核心思想已提炼入对应卡片,未逐条生卡
观察者模式(用于MVC多视图同步)、CGI.pm(Perl脚本式模板视图) 第14章 14.1.1⁄14.4.1 提及具体实现技术,未展开讲解
第15章Java/C#代码示例(会话Bean远程外观/Web Service/DTO传输唱片信息/XML序列化) 第15章 15.1.3⁄15.1.4⁄15.2.4⁄15.2.5 完整代码走查,核心思想已提炼入对应卡片,未逐条生卡
异步接口配合DTO延迟加载表示调用结果 第15章 15.2.2 提及异步场景下DTO的用法,超出本书同步系统讨论范围,未展开
第16章Java代码示例(领域层+数据映射器/锁管理对象/共享锁与根对象锁的具体实现/隐含悲观离线锁) 第16章 16.1.3⁄16.2.3⁄16.3.3-5⁄16.4.3 完整代码走查,核心思想已提炼入对应卡片,未逐条生卡
Where子句全字段检查(无版本字段时的乐观锁替代方案)、序列化隔离级别系统事务处理读写锁不一致读 第16章 16.1.1⁄16.2.1 具体实现层面的取舍细节,核心思想已在相关卡片提炼,未单独展开
Java/.NET服务器会话状态具体实现(HTTP会话/有状态会话Bean/实体Bean存LOB/.NET状态服务) 第17章 17.2.1 平台特定实现细节,核心思想已在相关卡片提炼,未单独展开
Flyweight模式(特殊情况实现细节)、IEEE754浮点运算细节 第18章 18.8.1 提及的具体实现技术,核心思想已在相关卡片提炼或过于简单未生卡(层超类型已于 S4 补为 ch18-013)
第18章代码示例(私有消息服务入口/领域对象层超类型/单子与线程安全注册表/货币类/空对象/ID生成器插件/销售税服务桩) 第18章 18.1.3⁄18.3.3⁄18.5.3-4⁄18.7.3⁄18.8.4⁄18.9.3⁄18.10.3 完整代码走查,核心思想已提炼入对应卡片,未逐条生卡

引用文献

标题 类型 出现章节 一句话语境
[Brown et al.] 论文/书 第1章 1.2 表现层/领域层/数据源层的命名取自该文献,未展开讲解具体出处细节
[Jacobson et al.] 论文/书 第2章 2.2 “控制器-实体风格”术语受该文献强烈影响,未展开讲解具体出处细节
[Gang of Four] 书 第3章 3.1 提及策略模式出处(即《设计模式》GoF),未展开讲解
[Brown and Whitenack]、[Ambler]、[Yoder]、[Keller and Coldewey] 书/论文 第3章 3.9”进一步阅读”推荐的数据库映射主题参考书,未展开讲解具体内容
[Alur et al.]、[Knight and Dai] 书/论文 第4章 4.3”进一步阅读”推荐的Web表现层模式与输入/应用控制器术语参考书,未展开讲解具体内容
[Snodgrass]、[Fowler TP] 书/论文 第5章 5.4.1 提及时序读具体实现方法的参考文献,未展开讲解
[Bernstein and Newcomer]、[Lea]、[Schmidt et al.] 书/论文 第5章 5.8”进一步阅读”推荐的并发主题深入参考书,未展开讲解具体内容
[Waldo et al.] 论文 第7章 7.1 提及分布式对象陷阱的出处,未展开讲解具体内容
[Beck XP]、[Fowler CI]、[Beck TDD]、[Fowler Refactoring] 书 第8章 8.0 提及极限编程/持续集成/测试驱动开发/重构的出处文献,未展开讲解
[Nilsson]、[Marinescu]、[Kirtland] 书 第8章 8.4.3⁄8.5 提及存储过程见解与其他分层方式的具体出处,未展开讲解
[Larman]、[Fowler AP]、[Hay]、[Martin and Odell]、[Evans] 书 第9章 9.2.3”进一步阅读”推荐的面向对象/领域模型主题参考书,未展开讲解具体内容
[Cockburn PloP]、[Cockburn UC]、[Alpert et al.]、[Coleman et al.] 书/论文 第9章 9.4.3”进一步阅读”推荐的服务层/应用边界/用例方法学参考文献,未展开讲解具体内容
[Beck Patterns]、[Nilsson] 书 第11章 11.1.1⁄11.3.1 提及延迟初始化模式出处与批量更新的.NET实现见解,未展开讲解具体内容
[Alpert et al.]、[Evans and Fowler]、[Evans] 书 第13章 13.2.3⁄13.3.3 提及查询对象/规约模式的具体参考文献,未展开讲解具体内容
[POSA] 书 第14章 14.1.1 提及深入了解MVC的参考文献,未展开讲解具体内容
[Riehle et al.] 书 第15章 15.2.3 提及序列化灵活方式的参考文献,未展开讲解具体内容

资金安全问题案例

问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明
5分钱按70%/30%分账无解 分账舍入误差无解 货币分配器零误差分账 第18章 多方分账时逐项独立取整无法保证总额守恒,需用专门的分配器方法统一协调舍入

类别清单核对(系统架构类)

维度 覆盖状态(已覆盖/补充生成/未覆盖) 关联卡片标题或未覆盖理由
服务拆分原则 部分覆盖 本书成书于2002年、聚焦单体/2-3层企业应用而非微服务,但分层边界与服务边界划分的思路一致:ch01-004《三层职责与依赖方向》、ch07-004《必须分布的五种场景》、ch09-012《识别服务层操作》
通信机制 已覆盖 ch07-006《RPC与XML接口的选择》,另ch08-007《Web服务用于集成》
一致性与事务权衡 已覆盖 ch05-011《业务事务与系统事务错位》、第16章全部乐观/悲观离线锁与粗粒度锁卡片(ch16-001至ch16-007)
可观测性设计 未覆盖 全书未讨论日志采集、监控指标、链路追踪体系;成书年代(2002)早于现代可观测性实践成型,属于本书主题范围之外,非漏判
容错设计 未覆盖 未讨论熔断、降级、重试等现代分布式容错机制;书中”死锁快速失败”(ch16-005)解决的是并发锁竞争而非服务间调用容错,性质不同,确认未覆盖而非漏判
扩展性瓶颈与应对 已覆盖 ch07-003《用集群复制整个应用》、ch05-013《每会话进程或线程》
部署与发布策略 未覆盖 未讨论灰度发布、回滚等工程实践;ch08-001提及持续集成/测试驱动开发/重构三项技术实践,但不涉及具体的发布策略机制,确认未覆盖而非漏判

主题索引维护

本书是企业应用模式的原典,按模式族新建 6 个主题(对象-关系映射、领域逻辑组织、Web 表现层、事务与离线并发、会话状态、分布与远程接口),并把分层、扩展、值对象、全局状态、测试替身等跨书议题并入已有主题。结论以 2026-09-24 本次 v8 修订后的标题为准。

卡片标题 结论 主题文件或原因
架构是难以改变的决定 已复用 notes/_topics/architecture-principles-complexity.md
企业应用的六个特征 已复用 notes/_topics/architecture-principles-complexity.md
没有通用架构 已复用 notes/_topics/architecture-principles-complexity.md
性能术语辨析 已复用 notes/_topics/scalability-dimensions.md
模式是半成品 已复用 notes/_topics/architecture-design-process.md
分层的收益与代价 已复用 notes/_topics/layered-architecture-ports.md
三层为领域逻辑找位置 已创建 notes/_topics/domain-logic-organization.md
layer不等于tier 已复用 notes/_topics/layered-architecture-ports.md
三层职责与依赖方向 已复用 notes/_topics/layered-architecture-ports.md
新增一层看是否重复 已复用 notes/_topics/layered-architecture-ports.md
分层视图的不对称 已复用 notes/_topics/layered-architecture-ports.md
各层运行位置的决策 已复用 notes/_topics/layered-architecture-ports.md
三种领域逻辑模式对比 已创建 notes/_topics/domain-logic-organization.md
领域模型的范式转换 已创建 notes/_topics/domain-logic-organization.md
表模块面向记录集 已创建 notes/_topics/domain-logic-organization.md
选型没有量化阈值 已创建 notes/_topics/domain-logic-organization.md
换模式的代价不对称 已创建 notes/_topics/domain-logic-organization.md
服务层是应用的API 已创建 notes/_topics/domain-logic-organization.md
服务层瘦身的两极 已创建 notes/_topics/domain-logic-organization.md
行入口与表入口的选择 已创建 notes/_topics/object-relational-mapping.md
持久化机制的渐进选型 已创建 notes/_topics/object-relational-mapping.md
关系库胜在生态确定 已复用 notes/_topics/storage-model-choices.md
买O/R工具仍需懂模式 已创建 notes/_topics/object-relational-mapping.md
工作单元协调读写 已创建 notes/_topics/object-relational-mapping.md
标识映射与延迟加载 已创建 notes/_topics/object-relational-mapping.md
查找器的归属与陷阱 已创建 notes/_topics/object-relational-mapping.md
数据库读取三条经验 已创建 notes/_topics/object-relational-mapping.md
对象与关系的连接差异 已创建 notes/_topics/object-relational-mapping.md
三种继承映射的权衡 已创建 notes/_topics/object-relational-mapping.md
模型与库要同步迭代 已创建 notes/_topics/object-relational-mapping.md
多数据源的两步映射 已创建 notes/_topics/object-relational-mapping.md
元数据映射 已创建 notes/_topics/object-relational-mapping.md(2026-09-24 旧记录清理后加入)
连接随事务管理 已创建 notes/_topics/transactions-offline-concurrency.md、notes/_topics/resource-ownership-lifetime.md
脚本处理请求页面出结果 已创建 notes/_topics/web-presentation-patterns.md
Web场景下的MVC 已创建 notes/_topics/web-presentation-patterns.md
何时需要应用控制器 已创建 notes/_topics/web-presentation-patterns.md
视图模式的两个维度 已创建 notes/_topics/web-presentation-patterns.md
页面控制器与前端控制器 已创建 notes/_topics/web-presentation-patterns.md
更新丢失与不一致读 已创建 notes/_topics/transactions-offline-concurrency.md
正确性与灵活性的权衡 已创建 notes/_topics/transactions-offline-concurrency.md
五个执行语境辨析 已创建 notes/_topics/transactions-offline-concurrency.md
隔离与不变性 已创建 notes/_topics/transactions-offline-concurrency.md
乐观与悲观并发控制 已创建 notes/_topics/transactions-offline-concurrency.md
防范不一致读 已创建 notes/_topics/transactions-offline-concurrency.md
死锁成因与预防 已创建 notes/_topics/transactions-offline-concurrency.md
事务要素与ACID 已创建 notes/_topics/transactions-offline-concurrency.md
事务时机与锁升级 已创建 notes/_topics/transactions-offline-concurrency.md
隔离级别与读错误 已创建 notes/_topics/transactions-offline-concurrency.md
业务事务与系统事务错位 已创建 notes/_topics/transactions-offline-concurrency.md
离线并发能免则免 已创建 notes/_topics/transactions-offline-concurrency.md
每会话进程或线程 已创建 notes/_topics/transactions-offline-concurrency.md、notes/_topics/server-io-concurrency-models.md
每次请求创建新对象 已创建 notes/_topics/transactions-offline-concurrency.md
无状态指不跨请求 已创建 notes/_topics/session-state-management.md
无状态的资源杠杆 已创建 notes/_topics/session-state-management.md
购物车让会话有状态 已创建 notes/_topics/session-state-management.md
会话状态与临时缓存 已创建 notes/_topics/session-state-management.md
三种会话状态存储 已创建 notes/_topics/session-state-management.md
会话状态的选择框架 已创建 notes/_topics/session-state-management.md
会话迁移与服务器亲和 已创建 notes/_topics/session-state-management.md
不要分布使用对象 已创建 notes/_topics/remote-interface-distribution.md
远程接口要粗粒度 已创建 notes/_topics/remote-interface-distribution.md
扩展靠复制整个应用 已创建 notes/_topics/remote-interface-distribution.md、notes/_topics/scalability-dimensions.md
必须分布的五种场景 已创建 notes/_topics/remote-interface-distribution.md
远程外观配合DTO 已创建 notes/_topics/remote-interface-distribution.md
RPC与XML接口的选择 已创建 notes/_topics/remote-interface-distribution.md
为纠错能力投资 已复用 notes/_topics/architecture-refactoring.md
工具生态影响模式选择 已创建 notes/_topics/domain-logic-organization.md
领域逻辑配数据源 已创建 notes/_topics/domain-logic-organization.md
表现层选型框架 已创建 notes/_topics/web-presentation-patterns.md
Java与.NET的默认选择 已复用 notes/_topics/architecture-design-process.md
存储过程只作性能优化 已创建 notes/_topics/domain-logic-organization.md
Web服务用于集成 已创建 notes/_topics/remote-interface-distribution.md
五种分层方式比较 已复用 notes/_topics/layered-architecture-ports.md
事务脚本的组织方式 已创建 notes/_topics/domain-logic-organization.md
领域模型的两种风格 已创建 notes/_topics/domain-logic-organization.md、notes/_topics/ddd-tactical-modeling.md
只加载所需的对象图 已创建 notes/_topics/object-relational-mapping.md
不必过早拆出用例行为 已创建 notes/_topics/domain-logic-organization.md
实体Bean与POJO 已创建 notes/_topics/domain-logic-organization.md
策略模式消除条件分支 已创建 notes/_topics/domain-logic-organization.md、notes/_topics/interface-design-dispatch.md
表模块靠键访问单行 已创建 notes/_topics/domain-logic-organization.md
表模块配表数据入口 已创建 notes/_topics/domain-logic-organization.md
区分领域逻辑与应用逻辑 已创建 notes/_topics/domain-logic-organization.md
服务层两种实现 已创建 notes/_topics/domain-logic-organization.md
服务层先本地后远程 已创建 notes/_topics/domain-logic-organization.md
识别服务层操作 已创建 notes/_topics/domain-logic-organization.md
何时需要服务层 已创建 notes/_topics/domain-logic-organization.md
服务层不同于会话外观 已创建 notes/_topics/domain-logic-organization.md
表数据入口的返回值 已创建 notes/_topics/object-relational-mapping.md
DAO是一种表数据入口 已创建 notes/_topics/object-relational-mapping.md
行入口与活动记录之别 已创建 notes/_topics/object-relational-mapping.md
从脚本演化到活动记录 已创建 notes/_topics/domain-logic-organization.md
查找方法要懂客户用法 已创建 notes/_topics/object-relational-mapping.md
映射器访问私有域 已创建 notes/_topics/object-relational-mapping.md
对象创建与循环引用 已创建 notes/_topics/object-relational-mapping.md
工作单元记录变化 已创建 notes/_topics/object-relational-mapping.md
是否使用工作单元 已创建 notes/_topics/object-relational-mapping.md
优选显式标识映射 已创建 notes/_topics/object-relational-mapping.md
继承树共用标识映射 已创建 notes/_topics/object-relational-mapping.md
标识映射放在哪里 已创建 notes/_topics/object-relational-mapping.md
延迟加载四种实现 已创建 notes/_topics/object-relational-mapping.md
警惕波动加载 已创建 notes/_topics/object-relational-mapping.md
只对额外访问延迟加载 已创建 notes/_topics/object-relational-mapping.md
按用例定制加载深度 已创建 notes/_topics/object-relational-mapping.md
优先无意义键 已创建 notes/_topics/object-relational-mapping.md
新键生成四策略 已创建 notes/_topics/object-relational-mapping.md
集合外键更新策略 已创建 notes/_topics/object-relational-mapping.md
关联表处理多对多 已创建 notes/_topics/object-relational-mapping.md
依赖映射的前提 已创建 notes/_topics/object-relational-mapping.md
嵌入值与序列化LOB 已创建 notes/_topics/object-relational-mapping.md
LOB挂在所有者表上 已创建 notes/_topics/object-relational-mapping.md
单表继承的判别符 已创建 notes/_topics/object-relational-mapping.md
类表继承的连接难题 已创建 notes/_topics/object-relational-mapping.md
具体表继承的键难题 已创建 notes/_topics/object-relational-mapping.md
抽象类查找用委托 已创建 notes/_topics/object-relational-mapping.md
元数据映射两条途径 已创建 notes/_topics/object-relational-mapping.md、notes/_topics/reflection-runtime-dynamism.md
元数据映射躲过重构工具 已创建 notes/_topics/object-relational-mapping.md
查询对象用对象语言查询 已创建 notes/_topics/object-relational-mapping.md
资源库按规约取对象 已创建 notes/_topics/object-relational-mapping.md
资源库可替换数据源 已创建 notes/_topics/object-relational-mapping.md
MVC的两个分离 已创建 notes/_topics/web-presentation-patterns.md
控制器方式可以混用 已创建 notes/_topics/web-presentation-patterns.md
前端控制器与筛选器 已创建 notes/_topics/web-presentation-patterns.md
模板视图不写逻辑 已创建 notes/_topics/web-presentation-patterns.md
两步视图的取舍 已创建 notes/_topics/web-presentation-patterns.md
应用控制器与UI解耦 已创建 notes/_topics/web-presentation-patterns.md
远程外观宜少而粗 已创建 notes/_topics/remote-interface-distribution.md
远程外观与服务层 已创建 notes/_topics/domain-logic-organization.md
组装器隔开DTO与领域 已创建 notes/_topics/remote-interface-distribution.md
序列化格式要能容错 已创建 notes/_topics/remote-interface-distribution.md、notes/_topics/data-interchange-formats.md
乐观锁需检查只读依赖 已创建 notes/_topics/transactions-offline-concurrency.md
冲突是领域问题 已创建 notes/_topics/transactions-offline-concurrency.md
自动合并放大乐观锁 已创建 notes/_topics/transactions-offline-concurrency.md
悲观离线锁三类型 已创建 notes/_topics/transactions-offline-concurrency.md
悲观离线锁的两个坑 已创建 notes/_topics/transactions-offline-concurrency.md
粗粒度锁两种实现 已创建 notes/_topics/transactions-offline-concurrency.md
隐含锁只自动化读锁 已创建 notes/_topics/transactions-offline-concurrency.md、notes/_topics/correct-by-construction.md
客户会话状态的技术 已创建 notes/_topics/session-state-management.md
性能疑虑用负载测试 已创建 notes/_topics/session-state-management.md、notes/_topics/performance-profiling.md
会话表分段轮换清理 已创建 notes/_topics/session-state-management.md
数据库会话状态张力 已创建 notes/_topics/session-state-management.md
入口与相近模式之别 已复用 notes/_topics/modularity-information-hiding.md
映射器难在激活 已复用 notes/_topics/modularity-information-hiding.md
不要处处分离接口 已复用 notes/_topics/interface-design-dispatch.md、notes/_topics/modularity-information-hiding.md
注册表接口与数据 已复用 notes/_topics/global-state-scope.md
注册表是有罪推定 已复用 notes/_topics/global-state-scope.md
值对象不可变防别名 已复用 notes/_topics/ddd-tactical-modeling.md
分账舍入误差无解 已复用 notes/_topics/numeric-precision.md
货币分配器零误差分账 已复用 notes/_topics/numeric-precision.md
特殊情况替代空值 已复用 notes/_topics/interface-design-dispatch.md
插件集中环境配置 已复用 notes/_topics/reflection-runtime-dynamism.md、notes/_topics/modularity-information-hiding.md
服务桩越简单越好 已复用 notes/_topics/testing-effectiveness.md
记录集宜用显式接口 已创建 notes/_topics/object-relational-mapping.md
层超类型 已复用 notes/_topics/inheritance-composition.md

2026-10-23 v23轻量恢复

执行模式:light

  • 首次生成Skill版本保留;本轮实际使用book-notes v23 / book-workflow v4。
  • 本轮逐项全文读取239正文项、全部627内嵌图片OCR并查看结构图及含混处后,保留并修正177张知识卡;未批量改写历史学习元数据。
  • 整书笔记:_book_note.md,schema 1,SHA-256 580af3f4b77d13a6f141b8c7ecacde255d5db0d5d0c8ea5959025c0735ebd230;177个primary、219处原书来源。
  • 未执行笔记复核、独立审查及审查结果优化。实践筛选与导入归档结果另见本轮交接,不凭历史done宣称本次已经执行。
v23全文取材与实践完成
  • 本轮239正文项、242阅读单元全部done,无pending;3项排除为封面、平台宣传、版权页(版权页另用于元数据)。原书图示/代码图片已读,取材裁决见_coverage.md和_v23_evidence/reading-log.json。
  • 177知识卡(保留176路径并新增通知事务边界卡);219处原书证据、177个primary;生成时对时效性/范围条件作了修正,历史文本备份在_v23_evidence/generation-corrections。
  • 实践候选筛选:done(已筛选完毕)。保留Hibernate和Spring MVC两个固定版本实现深读,首轮映射及100分钟/详细计划已交付;Rails社区讨论不能据此证明复杂度必然因果,候选延期,旧稿备查。
  • 本轮未执行框架测试、部署或真实业务实验;未执行生成后的复核、独立审查和优化。

相关主题

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

主题索引

存储模型选型

比较关系型、键值、列式、文档与全文检索等存储模型的特性取舍与适用场景。

699 张卡片 · 63 本书

主题索引

聚合、实体与值对象

比较实体、值对象、聚合与聚合根、工厂等战术建模要素的判定标准与设计原则。

375 张卡片 · 17 本书

主题索引

测试有效性与验证手段

比较单元测试、变异、模糊测试、静态分析与故障注入各自能证明什么。

366 张卡片 · 63 本书

主题索引

架构方案设计与评估

比较备选方案设计、评估选择、容量预估与详细设计等架构设计流程中的判断方法。

352 张卡片 · 40 本书

主题索引

分布式事务与一致性

比较内部与外部一致性、XA/2PC/3PC、CAP 与 BASE,以及可靠事件队列、TCC、SAGA、AT 等柔性事务方案。

308 张卡片 · 61 本书

主题索引

架构设计原则与复杂度来源

比较架构要解决的复杂度来源(性能、可用性、扩展、成本、安全、规模)以及合适、简单、演化等设计原则。

228 张卡片 · 40 本书

主题索引

单机高性能与I/O模型

比较进程/线程并发模型、I/O 多路复用、Reactor 与 Proactor 等单机高性能设计。

226 张卡片 · 46 本书

主题索引

模块化与信息隐藏

比较以函数、闭包、包或服务划定模块边界并隐藏实现细节的方法。

209 张卡片 · 51 本书

主题索引

分层、洋葱与六边形架构

比较分层、洋葱与六边形架构如何隔离核心业务逻辑与外部技术细节,以及各层职责与调用规则。

196 张卡片 · 43 本书

主题索引

性能剖析与诊断工具

比较采样剖析、火焰图、执行追踪与调用栈诊断的使用方法和解读边界。

168 张卡片 · 34 本书

主题索引

数据交换格式设计

比较数据交换格式的简洁性、互通性与安全解析要求。

146 张卡片 · 38 本书

主题索引

架构重构

比较识别重构目标、沟通推动与分段实施等架构重构方法。

138 张卡片 · 29 本书

主题索引

系统扩展的维度

比较水平复制、按业务拆分与数据分片等不同维度的扩展手段及其适用问题。

134 张卡片 · 52 本书

主题索引

隔离级别与并发控制

ACID 各自的边界,脏读、不可重复读、幻读与写偏斜分别由什么机制挡住:两阶段锁与意向锁、MVCC 快照与可见性判断、可串行化快照隔离的冲突检测,以及死锁成因、锁粒度与长事务的代价。

109 张卡片 · 18 本书

主题索引

企业集成模式

比较管道过滤器、各类消息通道、命令/文档/事件消息结构、路由(内容、动态、分离聚合、分散聚集、处理过程管理器)、转换(封装、丰富、过滤、存放证、标准化、规范模型)与端点模式的适用场景和取舍。

99 张卡片 · 24 本书

主题索引

分布边界与远程接口

何时才需要分布、远程接口为何要粗粒度,以及远程外观、数据传输对象与序列化格式的设计。

93 张卡片 · 29 本书

主题索引

会话状态管理

有状态与无状态会话的取舍,以及会话状态存放在客户端、服务器或数据库的代价与清理。

81 张卡片 · 37 本书

主题索引

业务事务与离线并发

业务事务比系统事务长得多,中间隔着用户思考时间:乐观离线锁与悲观离线锁怎么选、粗粒度锁与隐含锁的代价、版本号与条件更新怎样防止覆盖、预留与冻结怎样替代事后校验,以及离线并发为什么能免则免。

79 张卡片 · 28 本书

主题索引

领域逻辑的组织方式

事务脚本、领域模型、表模块与服务层的选型、演化与边界:业务逻辑放在哪里、以何种结构组织。

78 张卡片 · 17 本书

主题索引

开源项目选型与使用

比较学习、选型、灰度引入与二次开发开源项目的方法与风险控制。

75 张卡片 · 34 本书

主题索引

简单性与复杂度控制

比较区分必要与意外复杂度、删减代码与接口、以简化方案推进工程的做法。

72 张卡片 · 25 本书

主题索引

接口设计与动态分派

比较接口粒度、隐式/显式实现、接口值表示与动态分派的取舍。

66 张卡片 · 18 本书

主题索引

数值表示与精度

比较浮点、定点等数值表示的精度误差与特殊值陷阱。

62 张卡片 · 9 本书

主题索引

资源所有权与生命周期管理

比较不同语言与框架如何表达独占/共享所有权、释放时机和作用域退出清理。

62 张卡片 · 20 本书

主题索引

对象与关系的结构映射

对象与关系在粒度、继承、标识和关联上的阻抗不匹配:单表/类表/具体表三种继承映射的取舍,嵌入值与值集合怎样摊平或拆表,复合主键与关联表怎么写,命名与元数据怎样保持映射透明。

56 张卡片 · 7 本书

主题索引

数据库设计与E-R建模

比较数据库设计各阶段、数据抽象方法、E-R 模型的要素与集成冲突、向关系模型的转换规则,以及存取方法与重组织、重构的取舍。

56 张卡片 · 16 本书

主题索引

Web表现层模式

Web 请求处理与视图生成的拆分:MVC、页面/前端控制器、模板与转换视图、两步视图、应用控制器。

53 张卡片 · 16 本书

主题索引

继承、原型与组合复用

比较类继承、原型继承、函数化构造与组合在代码复用上的取舍。

50 张卡片 · 18 本书

主题索引

数据入口与工作单元

表数据入口、行数据入口、活动记录与数据映射器各自的职责边界,工作单元怎样记录变化并在提交时统一写回,标识映射怎样保证同一行只有一个对象,以及持久化机制该怎样渐进选型。

45 张卡片 · 8 本书

主题索引

资源库与查询

资源库为什么取代 DAO、集合式接口怎样隐藏存取细节,规约与查询对象怎样表达条件而不泄漏表结构,加载深度、N+1 与懒加载的取舍,以及原生 SQL、类型化查询与查询构建器各自的边界。

31 张卡片 · 8 本书

主题索引

反射与运行时动态性

比较反射机制换取的动态能力及其可设置性约束和性能代价。

25 张卡片 · 9 本书

主题索引

全局状态与作用域管理

比较全局变量的危害来源、作用域规则与隔离全局状态的手段。

16 张卡片 · 7 本书

主题索引

金额表示与分摊守恒

归纳金额的精确表示,以及等额分摊时舍入差额和整数余数的处理方式。

9 张卡片 · 6 本书