罗罗编程学习记录
本页内容 展开查看

09.8.1 分层架构与依赖倒置

所属:全栈开发面试题库 / 09 高阶架构:高并发与分布式 / 09.8 架构模式与演进

覆盖范围

  • 经典三层与四层架构的职责划分
  • 依赖倒置原则 DIP 与面向接口
  • 六边形架构(端口与适配器)、整洁架构的依赖方向
  • 贫血模型与充血模型的取舍
  • 跨层调用、循环依赖与分层违规识别

高频题速览

编号 题目 难度 频率
09.8.1-001 经典分层架构有哪几层,各层职责是什么 基础 ★★★★★
09.8.1-002 依赖倒置原则 DIP 的核心 基础 ★★★★★
09.8.1-003 六边形架构与传统三层的区别 进阶 ★★★★☆
09.8.1-004 整洁架构的依赖方向 进阶 ★★★★☆
09.8.1-005 领域层为什么不能依赖基础设施层 进阶 ★★★★★
09.8.1-006 贫血模型 vs 充血模型 进阶 ★★★★★
09.8.1-007 跨层调用为什么不能跳层 基础 ★★★☆☆
09.8.1-008 分层架构在微服务下的形态 进阶 ★★★☆☆
09.8.1-009 怎么识别分层违规 进阶 ★★★☆☆
09.8.1-010 分层架构的常见代价与反模式 高级 ★★★☆☆

09.8.1-001 经典分层架构有哪几层,各层职责是什么?

一句话结论

经典三层是表现层(Controller/UI)、业务逻辑层(Service)、数据访问层(DAO/Repository);四层再加领域层或基础设施层;分层的目的是把“做什么”和“怎么做”分开,让业务规则不被框架、数据库、前端绑死。

概念解释

  • 表现层:接收请求、参数校验、序列化、返回视图,不含业务规则。
  • 业务逻辑层:编排用例、事务边界、调用领域对象,是业务用例的入口。
  • 数据访问层:封装持久化细节,向上暴露 Repository/DAO 接口。
  • 领域层(四层中新增):实体、值对象、领域服务,是纯业务规则核心。

原理流程

请求 → Controller → Service → Repository → DB
                              ↓
                          领域对象(实体/值对象)

代码或图示

依赖方向:表现层 → 业务层 → 领域层 → 基础设施层
上层依赖下层,下层不感知上层

常见误区

  • 误区:Service 里写所有 SQL。正解:SQL 应下沉到 Repository,Service 只编排用例。
  • 误区:Controller 可以直接调 DAO 跳层。跳层会让业务规则散落到接口层,后续无法复用与测试。

追问

  • 问:四层比三层多了哪一层?答:多了独立的领域层或基础设施层,把业务核心与技术实现分开,详见 09.8.3。
  • 问:分层越多越好吗?答:过度分层会引入大量样板代码与间接调用,按团队规模与业务复杂度取舍。

09.8.1-002 依赖倒置原则 DIP 的核心是什么?

一句话结论

DIP 是“高层模块不依赖低层模块,二者都依赖抽象;抽象不依赖细节,细节依赖抽象”;在工程上就是业务层定义接口(端口),基础设施层实现接口(适配器),业务代码不 import 具体的 ORM、MQ、HTTP 客户端。

概念解释

  • 高层模块:业务用例、领域规则,不随技术选型变化。
  • 低层模块:数据库、缓存、MQ、外部 HTTP 接口,属于技术细节。
  • 抽象:接口/端口,由业务方定义,承载业务需要的能力。

原理流程

传统:Service → MySQLDriver(业务直接依赖具体库)
DIP:Service → OrderRepository 接口
                ↑ 实现
               MySQLOrderRepository(基础设施层实现)

代码或图示

// 业务层定义端口
public interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
}
// 基础设施层提供适配器
public class JdbcOrderRepository implements OrderRepository { ... }

常见误区

  • 误区:DIP 就是“面向接口编程”。面向接口只是手段,关键是接口的归属——业务层定义接口,而不是框架厂商定义接口。
  • 误区:定义了接口就自动解耦。如果业务层 import 的是具体 ORM 的注解或异常,依然是紧耦合。

追问

  • 问:依赖注入容器在 DIP 里扮演什么角色?答:把接口与实现的绑定推迟到启动时,业务代码只依赖接口,详见 06.6。
  • 问:DIP 会不会过度设计?答:稳定的业务核心值得做,简单脚本型 CRUD 不必强行套端口。

09.8.1-003 六边形架构(端口与适配器)与传统三层有什么区别?

一句话结论

六边形架构把应用放在中心,外部一切(HTTP、DB、MQ、CLI、测试)都通过“端口”接入,应用定义端口、外部提供适配器;与传统三层的区别是依赖方向反转——应用不感知外部技术,外部技术围绕应用适配。

概念解释

  • 端口:应用对外提供或需要的能力接口,分入站端口(用例)与出站端口(仓储/消息网关)。
  • 适配器:把外部协议翻译成端口调用,例如 Controller 把 HTTP 翻译成用例调用。
  • 六边形:用形状表示应用是中心,外部适配器在四周环绕。

原理流程

外部请求(HTTP) → 入站适配器 → 入站端口(用例)
                                  ↓
                              出站端口(Repository)
                                  ↑
                          出站适配器(Jdbc/Kafka/...)

代码或图示

依赖方向:适配器 → 应用(端口)
应用本身不依赖任何适配器,可独立单元测试

常见误区

  • 误区:六边形只是换个叫法。它的关键是“应用不依赖框架”,脱离 Spring/DB 能独立跑测试。
  • 误区:所有外部调用都要端口。对一次性脚本、外部通知这类简单集成,直接调用也可接受,按稳定性取舍。

追问

  • 问:六边形与整洁架构什么关系?答:整洁架构是六边形思想的进一步细化,把边界画得更细,详见 09.8.1-004。
  • 问:入站端口和出站端口怎么区分?答:入站是外部调应用(用例),出站是应用调外部(仓储/网关)。

09.8.1-004 整洁架构(Clean Architecture)的依赖方向是什么?

一句话结论

整洁架构同心圆从内到外是实体(Entity)、用例(Use Case)、接口适配(Interface Adapters)、框架与驱动;依赖方向只能由外向内,内层不知道外层存在,数据库、Web 框架都是最外圈的细节,可以替换。

概念解释

  • 实体:企业级业务规则,跨用例复用,最稳定。
  • 用例:特定应用的业务编排,依赖实体。
  • 接口适配:把数据转换成用例需要的格式,例如 Controller、Presenter、Repository 实现。
  • 框架层:Spring、DB、MQ 等,最易变。

原理流程

外层 → 内层(箭头向内)
框架层 → 接口适配层 → 用例层 → 实体层
内层永不 import 外层类型

代码或图示

典型违规:实体类 import javax.persistence.Entity
正解:实体是纯 POJO,持久化由外层适配器负责

常见误区

  • 误区:整洁架构等于四层包结构。包结构只是表象,真正约束是依赖方向与内层独立性。
  • 误区:实体必须是充血模型。实体可以是简单对象,但业务规则应留在内层,不要下沉到外层。

追问

  • 问:和 01.3 整洁架构什么关系?答:01.3 从代码组织角度讲,这里从分布式演进视角讲取舍;实现细节参见 01.3。
  • 问:项目小也要套四层吗?答:小项目可以先三层,当业务规则变多、需要替换技术栈时再向内收敛。

09.8.1-005 领域层为什么不能依赖基础设施层?

一句话结论

领域层是最稳定的业务核心,一旦依赖 ORM 注解、MQ 客户端、HTTP 客户端,业务规则就被技术栈绑架,无法独立测试、无法替换技术选型;依赖倒置要求领域层定义端口,基础设施层去实现。

概念解释

  • 领域层:业务规则、实体行为,应该与技术无关。
  • 基础设施层:DB、缓存、MQ、外部 API,易变。
  • 反向依赖:领域层定义 Repository 接口,基础设施层实现它。

原理流程

错误:Order 实体上 @Entity 注解 → 领域层依赖 JPA
正确:Order 是纯对象,OrderRepository 接口在领域层,JdbcOrderRepository 在基础设施层

代码或图示

// 错误:领域层 import 基础设施
import javax.persistence.Entity;
@Entity public class Order { ... }

// 正确:领域层纯 POJO
public class Order {
    private OrderId id;
    private List<OrderLine> lines;
    public void addLine(Product p, int qty) { ... }
}

常见误区

  • 误区:用了 JPA 就必须在实体上加注解。正解:可以用 XML 或独立的 ORM 映射类,把注解留在基础设施层。
  • 误区:领域层不依赖任何框架就是“贫血”。领域层可以有行为,只是不 import 框架类型。

追问

  • 问:领域事件这种概念属于哪层?答:领域层定义事件,基础设施层负责发布到 MQ,详见 09.8.3。
  • 问:怎么强制依赖方向?答:ArchUnit 等工具写规则,禁止领域层 import 基础设施包,CI 里执行。

09.8.1-006 贫血模型与充血模型怎么取舍?

一句话结论

贫血模型是只有 getter/setter 的数据对象,业务规则散落在 Service;充血模型是实体自带业务行为,Service 只做编排;领域复杂时充血模型更内聚,但要接受学习成本与跨实体行为的领域服务拆分。

概念解释

  • 贫血模型:实体是数据载体,Service 是事务脚本,简单直接但业务规则分散。
  • 充血模型:实体封装状态与行为,例如 order.pay()、order.cancel(),业务规则内聚。
  • 领域服务:多个实体协作、不便放在单个实体上的逻辑放在领域服务。

原理流程

贫血:Service 读 Order → 改字段 → 存回去
充血:order.pay(payment) → 内部状态机迁移 → 发布领域事件

代码或图示

// 充血
public void pay(Payment payment) {
    if (status != Status.PENDING) throw new IllegalStateException();
    this.status = Status.PAID;
    registerEvent(new OrderPaidEvent(this.id));
}

常见误区

  • 误区:充血模型就是把所有逻辑塞进实体。跨实体协作、需要外部网关的逻辑应放领域服务或应用服务。
  • 误区:贫血模型一定不好。CRUD 型后台系统、规则简单时贫血模型开发更快,强行充血会增加复杂度。

追问

  • 问:Spring 项目里常见哪种?答:大部分是贫血模型,团队接受度高但业务规则分散;DDD 项目倾向充血。
  • 问:怎么识别“应该充血”的信号?答:当一个 Service 同时操作多个实体字段、且这些字段变化是同一个业务规则时,下沉到实体。

09.8.1-007 跨层调用为什么不能跳层?

一句话结论

跳层会让下层规则被上层直接绕过,业务规则散落到多个入口,导致无法统一加事务、日志、权限、缓存;分层的价值在于所有请求都经过约定的路径,跳层等于破坏这一约定。

概念解释

  • 跳层:Controller 直接调 DAO,或领域层直接调 MQ。
  • 后果:事务边界、审计、缓存失效点丢失,后续无法统一治理。
  • 例外:跨层只读查询为性能绕过 Service 时,必须明确标注并接受代价。

原理流程

合法:Controller → Service → Repository
违规:Controller → Repository(事务、日志、权限缺失)

代码或图示

评审时检查:
- Controller 里是否注入了 Mapper/Repository
- 领域对象里是否有 @Transactional

常见误区

  • 误区:为了性能跳层无所谓。性能问题应通过索引、缓存、读写分离解决,而不是绕过分层。
  • 误区:跳层是技术债,但不影响功能。当需要加权限、审计、灰度时,散落在 Controller 里的查询会成为重写灾难。

追问

  • 问:查询接口可以跳过 Service 吗?答:简单查表可以,但带业务规则(过滤、聚合、权限)的查询仍应走应用服务。
  • 问:怎么在代码里禁止跳层?答:ArchUnit 规则禁止 Controller 包 import Repository 包。

09.8.1-008 分层架构在微服务下是什么形态?

一句话结论

微服务内部分层与单体一致(接口层/应用层/领域层/基础设施层),变化在于跨进程的调用替代了进程内调用;每个服务内部仍要保持依赖方向,跨服务通过 API、消息契约通信,不能共享数据库表。

概念解释

  • 服务内分层:每个微服务仍是一个小单体,内部按端口/适配器组织。
  • 跨服务通信:同步 HTTP/gRPC 或异步消息,契约优先。
  • 共享反模式:两个服务直连对方的库,会重新形成分布式单体。

原理流程

单体内:方法调用
微服务内:Controller → Service → Repository(同进程)
微服务间:HTTP/gRPC/MQ(跨进程,契约管理)

代码或图示

每个微服务 = 一个六边形架构实例
跨服务调用 = 出站适配器(HTTP client)实现的端口

常见误区

  • 误区:拆成微服务就不用分层了。微服务内部不分层会让单个服务变成泥球。
  • 误区:跨服务可以共享一个数据库。共享库会让两个服务在 schema 层面强耦合,失去独立演进能力。

追问

  • 问:跨服务事务怎么处理?答:最终一致,用 TCC/Saga/本地消息表,详见 09.6。
  • 问:服务粒度多大合适?答:一个业务能力闭环、一个团队能独立交付,详见 09.8.2。

09.8.1-009 怎么识别分层违规?

一句话结论

用架构守护工具(ArchUnit、NetArchTest)写依赖规则,CI 里强制执行;同时在评审时检查包依赖方向、import 列表、注解归属、事务边界位置,违规案例纳入代码评审 checklist。

概念解释

  • 架构守护测试:用代码断言“领域层不能 import 框架包”这类规则。
  • 包依赖方向:允许 A→B,禁止 B→A,工具可扫描。
  • 评审 checklist:事务注解是否在应用层、Controller 是否注入了 Repository。

原理流程

CI 流水线:
  单元测试 → 架构守护测试 → 构建
违规时直接 fail,不允许合并

代码或图示

// ArchUnit 示例
classes().that().resideInAPackage("..domain..")
    .should().onlyDependOnClassesThat()
    .resideInAnyPackage("..domain..", "java..");

常见误区

  • 误区:靠人评审就能守住。人评审会漏,工具必须自动化。
  • 误区:规则一次写死。随着业务演进,规则要复盘,避免把合理的演进也挡掉。

追问

  • 问:历史代码怎么补?答:先把新代码规则守住,旧代码用 ArchUnit 的冻结测试(Freeze)记录违规清单,逐步清零。
  • 问:跨团队怎么统一?答:把架构守护测试作为公共库,各服务引用同一份规则。

09.8.1-010 分层架构的常见代价与反模式是什么?

一句话结论

分层引入样板代码、间接调用、调试链路变长;常见反模式是“Service 贫血”“Controller 写业务”“Repository 变成万能 DAO”“为分层而分层”;按业务复杂度选择,不要为了套模式牺牲可读性。

概念解释

  • 样板代价:每个用例都要 Controller/Service/Repository/接口,小功能也要走一遍。
  • 反模式:分层清晰但业务规则散在各层,变成“合理的混乱”。
  • 调试代价:一次请求跨多跳,堆栈变长。

原理流程

业务简单 → 三层足够,不要硬套六边形
业务复杂 → 收敛依赖方向,保护核心领域

代码或图示

反模式信号:
- Service 里只有一行 orderMapper.updateById(...)
- Controller 里有 if/else 业务判断
- Repository 里塞了跨表 join 和业务过滤

常见误区

  • 误区:分层越细越高级。过度分层让新人读代码要跳 5 个包才能看到一行 SQL。
  • 误区:分层架构就是 DDD。DDD 是业务建模方法,分层是代码组织方式,两者相关但不等价。

追问

  • 问:小团队怎么折中?答:保持三层,但包结构上把领域模型单独放,未来需要时再拆分。
  • 问:什么时候该重构分层?答:当一次业务变更要改 5 个类、且每个类都在做同样的事时,说明分层失效了。

待整理清单

  • [ ] ArchUnit 规则清单与示例
  • [ ] 真实项目中分层重构的复盘
  • [ ] 与 01.3 整洁架构章节的交叉引用细化