1. 项目缘起与核心定位
第一次看到"t3code"这个名字,我下意识地把它拆成了两半:t3和code。在技术圈里,这种命名方式通常意味着某个东西的第三个版本,或者某种三层结构的编码方案。我翻了一圈社区讨论,发现大家对这个词的理解也基本集中在这两个方向上——要么是某个工具链的第三代迭代,要么是一套围绕"三层编码"展开的方法论。
我个人的判断更倾向于后者。原因很简单:如果只是一个工具的版本号,它不会单独成为一个被反复讨论的词条。真正能沉淀下来、被人拿来当项目名用的,往往是某种可复用的编码思路或架构模式。t3code 给我的感觉就是这样——它更像是一套"怎么把复杂问题拆成三层来处理"的编码实践,而不是某个具体的软件产品。
那它到底解决什么问题?说白了,就是当业务逻辑开始膨胀、代码开始互相纠缠的时候,怎么用一套固定的分层思路把混乱摁住。这个问题几乎每个写过两年代码的人都会遇到:一开始一个文件能搞定的事,半年后变成了十几个文件互相调用,改一个地方崩三个地方。t3code 这套思路的核心价值,就是给这种膨胀提供一个"刹车机制"。
适合谁来参考?我觉得三类人最应该看:一是刚过新手期、开始独立负责模块的开发者;二是团队里负责代码规范、天天被 review 折磨的技术负责人;三是那些项目已经跑起来了、但每次加需求都像在拆炸弹的维护者。如果你还在写单文件脚本,这套东西可能有点重;但只要你开始面对"这个功能该放哪一层"的问题,它就值得花时间琢磨。
2. 三层编码思路的整体设计拆解
2.1 为什么是"三层"而不是"两层"或"四层"
分层这件事,业界吵了十几年。两层太薄,业务逻辑和数据处理搅在一起,改数据库字段能影响到界面展示;四层又太厚,为了一个简单的查询要穿过四个文件,写起来累、读起来更累。三层刚好卡在一个认知负担和职责隔离的平衡点上。
我自己的理解是,三层对应的是人类处理问题的三个基本动作:接收输入、处理逻辑、输出结果。任何一段代码,不管多复杂,拆到最后都能归到这三类里。t3code 把这个直觉固化成结构,好处是你在写代码之前就知道每一块该放什么,不用每次重新做决策。
具体来说,这三层通常是:
- 接入层:负责和外部打交道,接收请求、解析参数、做初步校验。它不关心业务怎么算,只关心"进来的东西格式对不对"。
- 逻辑层:真正干活的地方,所有的计算、判断、规则都在这里。它不关心数据从哪来、到哪去,只关心"给我输入,我还你输出"。
- 数据层:负责和存储打交道,读写数据库、调用外部接口、缓存管理。它不关心业务规则,只关心"怎么把数据拿回来、存进去"。
这个划分的妙处在于,每一层只依赖它下面那一层。接入层调逻辑层,逻辑层调数据层,反过来不行。这样当你需要换数据库的时候,只动数据层;需要改业务规则的时候,只动逻辑层;需要加一个新接口的时候,只动接入层。改动被限制在一个层里,不会像涟漪一样扩散出去。
2.2 这套思路和常见架构的区别在哪
有人可能会说,这不就是 MVC 吗?不完全是。MVC 里的 Controller 经常被写成"万能胶水",什么逻辑都往里塞,最后 Controller 变成了事实上的逻辑层。t3code 的思路更强调逻辑层的独立性——它应该是一个纯粹的、可以被单独测试的模块,不依赖任何框架、不依赖任何外部状态。
也有人会把它和 Clean Architecture 对比。Clean Architecture 更强调依赖倒置和领域驱动,概念更多、门槛更高。t3code 更像是它的"轻量版":保留分层思想,但不强制你搞一堆接口和抽象类。对于中小型项目来说,这种轻量做法反而更容易落地。
我试过在一个中等规模的后端项目里用这套思路重构,最直观的感受是代码 review 变快了。以前 review 一个功能要翻五六个文件,现在只要看逻辑层那个文件就够了,接入层和数据层基本是模板化的东西,扫一眼就知道有没有问题。
2.3 落地前需要想清楚的三个问题
在动手之前,有三个问题必须先回答,否则分着分着就乱了。
第一个问题:你的"逻辑层"边界在哪?很多人分层的失败,就败在逻辑层定义不清。我的经验是,逻辑层应该只包含与具体技术无关的业务规则。比如"订单满100减20"是逻辑,"从MySQL查订单"是数据层的事。如果你在逻辑层里看到了 SQL 语句或者 HTTP 请求,那说明边界破了。
第二个问题:跨层调用怎么处理?严格分层下,接入层不能直接调数据层。但现实中经常有"我就查个配置,不想写逻辑层"的情况。我的做法是允许只读的旁路调用,但写操作必须走逻辑层。这样既保证了核心流程的清晰,又不至于为了一个简单查询写一堆样板代码。
第三个问题:层与层之间怎么传递数据?用字典、用对象、还是用专门的 DTO?我倾向于用轻量的数据结构,比如 Python 里的 dataclass 或者 Go 里的 struct。好处是字段明确、类型清晰,比裸字典安全得多,又不像完整的 ORM 对象那么重。
3. 核心细节解析与实操要点
3.1 接入层的写法与常见陷阱
接入层看起来简单,其实坑不少。我见过太多项目,接入层写着写着就变成了"半个逻辑层"——参数校验里夹着业务判断,异常处理里藏着业务规则。
接入层应该只做四件事:解析输入、校验格式、调用逻辑层、包装输出。注意是"校验格式"不是"校验业务"。比如"age 必须是整数"是格式校验,"age 必须大于18"是业务校验,后者应该放在逻辑层。这个区分很重要,因为格式校验是通用的、可以复用的,业务校验是跟着需求变的。
一个典型的接入层函数长这样:
def create_order(request): # 解析 user_id = request.get("user_id") items = request.get("items") # 格式校验 if not isinstance(user_id, int): return error_response("user_id must be integer") if not isinstance(items, list) or len(items) == 0: return error_response("items must be non-empty list") # 调用逻辑层 try: order = order_service.create(user_id, items) return success_response(order.to_dict()) except BusinessError as e: return error_response(str(e))注意这里没有任何业务判断,所有"能不能下单""库存够不够"的问题都扔给了order_service。接入层的职责就是把外部请求翻译成逻辑层能理解的输入,再把逻辑层的输出翻译成外部能理解的响应。
实操心得:接入层的异常处理要克制。只捕获你明确知道怎么处理的异常,其他的一律往上抛,让统一的错误处理机制去兜底。我见过有人在接入层写了个
except Exception然后返回"系统错误",结果把真正的 bug 全吞了,排查的时候一脸懵。
3.2 逻辑层的组织方式与测试策略
逻辑层是整个项目的核心,也是最值得花时间设计的地方。我的经验是,逻辑层应该按业务能力来组织,而不是按技术类型。比如电商项目里,应该是order_service、payment_service、inventory_service,而不是validator、calculator、checker。
每个 service 应该是一个无状态的类或模块,所有需要的外部依赖通过构造函数或参数传入。这样做的好处是测试极其方便——你可以传入 mock 的数据层,单独测试逻辑,不需要启动数据库、不需要发网络请求。
class OrderService: def __init__(self, order_repo, inventory_repo): self.order_repo = order_repo self.inventory_repo = inventory_repo def create(self, user_id, items): # 业务校验 for item in items: stock = self.inventory_repo.get_stock(item["sku"]) if stock < item["quantity"]: raise BusinessError(f"insufficient stock for {item['sku']}") # 业务计算 total = sum(item["price"] * item["quantity"] for item in items) discount = self._calculate_discount(total) # 持久化 order = Order(user_id=user_id, items=items, total=total - discount) return self.order_repo.save(order) def _calculate_discount(self, total): if total >= 100: return 20 return 0这个结构里,_calculate_discount是纯函数,测试起来就是几行断言的事。create方法依赖两个 repo,测试的时候传入内存版的假实现就行,跑起来毫秒级。
注意事项:逻辑层里千万不要直接
import数据库驱动或者 HTTP 客户端。一旦这么做了,你的逻辑层就和具体技术绑死了,想换存储、想加缓存都得改逻辑代码。依赖注入不是花架子,它是保证逻辑层可测试、可替换的关键。
3.3 数据层的封装与边界控制
数据层最容易犯的错是"泄漏"——把数据库的细节暴露给上层。比如逻辑层里出现了SELECT * FROM orders WHERE status = 1,这就是典型的数据层泄漏。逻辑层不应该知道status = 1代表什么,它应该调用order_repo.find_pending_orders()这样的方法。
数据层的接口设计应该以业务语义命名,而不是以技术操作命名。find_pending_orders比query_by_status好,save_order比insert_row好。这样逻辑层读起来就像在读业务规则,而不是在读 SQL。
class OrderRepository: def save(self, order): # 具体的数据库操作 ... def find_pending_orders(self): # 返回待处理的订单 ... def find_by_user(self, user_id): # 返回某用户的订单 ...数据层内部怎么实现是它自己的事——可以用 ORM,可以写原生 SQL,可以调外部 API。只要接口不变,上层就不受影响。我试过把一个项目的存储从 MySQL 换成 MongoDB,只改了数据层的实现,逻辑层和接入层一行没动,半天就搞定了。
常见坑:数据层不要做业务判断。我见过有人在 repo 里写"如果订单金额大于100就标记为VIP订单",这是业务逻辑,应该放在逻辑层。数据层的职责就是存取,任何"如果...就..."的判断都应该往上走。
4. 实操过程与核心环节实现
4.1 从零搭建一个 t3code 结构的项目
假设我们要做一个简单的任务管理后端,支持创建任务、查询任务列表、标记完成。我用 Python 来演示,其他语言思路一样。
第一步:定义数据模型。先想清楚数据长什么样,这是三层之间传递的"货币"。
from dataclasses import dataclass, field from datetime import datetime from typing import Optional @dataclass class Task: id: Optional[int] title: str description: str completed: bool = False created_at: datetime = field(default_factory=datetime.now) def to_dict(self): return { "id": self.id, "title": self.title, "description": self.description, "completed": self.completed, "created_at": self.created_at.isoformat() }用 dataclass 的好处是字段明确、有类型提示、自带构造函数。比字典安全,比完整 ORM 对象轻。
第二步:写数据层。先定义接口,再写实现。接口用抽象类或者 Protocol 都行,我习惯用简单的基类。
class TaskRepository: def save(self, task: Task) -> Task: raise NotImplementedError def find_by_id(self, task_id: int) -> Optional[Task]: raise NotImplementedError def find_all(self) -> list[Task]: raise NotImplementedError def update(self, task: Task) -> Task: raise NotImplementedError class InMemoryTaskRepository(TaskRepository): def __init__(self): self._tasks = {} self._next_id = 1 def save(self, task): task.id = self._next_id self._next_id += 1 self._tasks[task.id] = task return task def find_by_id(self, task_id): return self._tasks.get(task_id) def find_all(self): return list(self._tasks.values()) def update(self, task): self._tasks[task.id] = task return task先写内存实现有个好处:测试跑得快,开发不用等数据库。等逻辑稳定了,再写一个 MySQL 或 PostgreSQL 的实现替换掉就行。
第三步:写逻辑层。这是核心,所有业务规则都在这里。
class TaskService: def __init__(self, repo: TaskRepository): self.repo = repo def create_task(self, title: str, description: str) -> Task: if not title or len(title.strip()) == 0: raise BusinessError("title cannot be empty") if len(title) > 100: raise BusinessError("title too long, max 100 chars") task = Task(id=None, title=title.strip(), description=description) return self.repo.save(task) def list_tasks(self) -> list[Task]: return self.repo.find_all() def complete_task(self, task_id: int) -> Task: task = self.repo.find_by_id(task_id) if task is None: raise BusinessError(f"task {task_id} not found") if task.completed: raise BusinessError("task already completed") task.completed = True return self.repo.update(task)注意create_task里的校验:标题不能为空、不能超过100字符,这些是业务规则,放在逻辑层。complete_task里检查任务是否存在、是否已完成,也是业务规则。
第四步:写接入层。这里用 Flask 演示,换成 FastAPI、Django 思路一样。
from flask import Flask, request, jsonify app = Flask(__name__) repo = InMemoryTaskRepository() service = TaskService(repo) @app.route("/tasks", methods=["POST"]) def create_task(): data = request.get_json() if not data or "title" not in data: return jsonify({"error": "title is required"}), 400 try: task = service.create_task(data["title"], data.get("description", "")) return jsonify(task.to_dict()), 201 except BusinessError as e: return jsonify({"error": str(e)}), 400 @app.route("/tasks", methods=["GET"]) def list_tasks(): tasks = service.list_tasks() return jsonify([t.to_dict() for t in tasks]) @app.route("/tasks/<int:task_id>/complete", methods=["POST"]) def complete_task(task_id): try: task = service.complete_task(task_id) return jsonify(task.to_dict()) except BusinessError as e: return jsonify({"error": str(e)}), 400接入层只做三件事:解析请求、调 service、包装响应。没有任何业务判断,所有规则都在 service 里。
4.2 参数选择与配置的关键决策
搭好结构之后,有几个配置层面的决策会影响后续的维护成本。
关于 ID 生成策略。内存实现里我用了自增整数,简单直观。但换成分布式数据库之后,自增 ID 会有冲突问题。这时候可以考虑 UUID 或者雪花算法。我的建议是:如果项目早期,用自增 ID 就行,别过度设计。等真的遇到分布式场景再换,换的时候只动数据层,上层无感。
关于时间处理。我见过太多项目在时间上翻车——有的存本地时间,有的存 UTC,有的存时间戳,最后对不上。我的做法是统一存 UTC,展示的时候再转本地时区。数据层存 UTC,逻辑层处理 UTC,接入层根据用户时区转换。这样跨时区不会乱。
关于错误码设计。接入层返回给前端的错误码,我建议用业务语义码而不是 HTTP 状态码硬编码。比如TASK_NOT_FOUND、TITLE_TOO_LONG,前端可以根据这些码做不同的提示。HTTP 状态码只用来表达"请求成功还是失败"这个层面。
| 决策点 | 早期方案 | 后期演进 | 影响范围 |
|---|---|---|---|
| ID 生成 | 自增整数 | UUID/雪花算法 | 仅数据层 |
| 时间存储 | UTC 时间戳 | 不变 | 数据层+接入层 |
| 错误码 | 字符串语义码 | 不变 | 接入层 |
| 存储引擎 | 内存 | MySQL/PostgreSQL | 仅数据层 |
| 缓存 | 无 | Redis | 数据层 |
这张表的意思是:好的分层让变化被限制在最小的范围内。你看,除了错误码涉及接入层,其他变化都只影响数据层。这就是 t3code 结构的价值。
4.3 测试怎么写才不痛苦
分层结构最大的红利就是测试好写。我按层来说。
数据层测试:用真实的数据库(比如 SQLite 内存模式),测增删改查是否正确。这部分测试跑得慢一点没关系,数量少。
逻辑层测试:用假的数据层实现,测业务规则。这部分测试应该占大头,跑得飞快。
def test_create_task_with_empty_title(): repo = InMemoryTaskRepository() service = TaskService(repo) with pytest.raises(BusinessError, match="title cannot be empty"): service.create_task("", "some description") def test_complete_already_completed_task(): repo = InMemoryTaskRepository() service = TaskService(repo) task = service.create_task("test", "desc") service.complete_task(task.id) with pytest.raises(BusinessError, match="already completed"): service.complete_task(task.id)这些测试不依赖任何外部服务,跑起来就是毫秒级。我一般会把逻辑层测试写成参数化的,一个规则写一组用例,覆盖边界情况。
接入层测试:用 Flask 的 test client,测请求解析和响应格式。这部分测试也不多,主要验证"参数缺失返回400""正常请求返回201"这类。
实操心得:逻辑层测试的覆盖率应该往90%以上冲,因为它是业务的核心。接入层和数据层到70%左右就够了,它们更多是模板代码,测太多性价比低。
5. 常见问题与排查技巧实录
5.1 分层落地时的典型翻车场景
场景一:逻辑层里出现了框架代码。有人在 service 里from flask import request,直接读请求上下文。这会导致逻辑层无法脱离 Web 框架运行,测试的时候必须启动整个应用。解决办法是把需要的数据作为参数传进来,而不是在逻辑层里主动去取。
场景二:数据层返回了 ORM 对象。逻辑层拿到 ORM 对象后,不小心触发了一个懒加载查询,结果在事务外面执行了 SQL,报错。我的做法是数据层返回纯数据对象(dataclass),不返回 ORM 实体。多一层转换,但省心。
场景三:接入层做了业务判断。比如在路由函数里写if user.is_vip and order.total > 100,这就是业务逻辑泄漏。应该改成调用order_service.can_apply_discount(user, order),把判断收进逻辑层。
场景四:层与层之间循环依赖。A 层的模块 import 了 B 层,B 层又 import 了 A 层。这在 Python 里会直接报 ImportError。解决办法是严格单向依赖,如果发现需要反向调用,说明分层边界画错了,应该把共用的部分抽出来放到更底层。
5.2 问题排查速查表
| 现象 | 可能原因 | 排查方向 | 解决办法 |
|---|---|---|---|
| 改一个功能要动多个层 | 分层边界模糊 | 检查逻辑层是否混入了数据访问代码 | 把数据访问抽到数据层 |
| 逻辑层测试要启动数据库 | 逻辑层直接依赖了具体存储 | 检查 service 的构造函数 | 改为依赖注入接口 |
| 接入层代码越来越长 | 业务逻辑泄漏到了接入层 | 搜索接入层里的 if/else 业务判断 | 把判断移到逻辑层 |
| 换数据库要改很多文件 | 数据层接口泄漏了 SQL 细节 | 检查逻辑层是否有 SQL 语句 | 数据层接口用业务语义命名 |
| 测试跑得慢 | 逻辑层测试用了真实数据库 | 检查测试的依赖 | 逻辑层测试用内存假实现 |
这张表是我自己踩坑总结的,基本上覆盖了80%的分层问题。遇到问题先对照这张表,能省不少排查时间。
5.3 几个容易被忽略的细节
关于日志。日志应该在哪一层打?我的做法是:接入层打请求日志,逻辑层打业务日志,数据层打慢查询日志。接入层记录"谁在什么时候调了什么接口",逻辑层记录"做了什么业务决策",数据层记录"哪条 SQL 慢了"。这样排查问题的时候,顺着日志就能还原整个调用链。
关于事务。事务边界应该放在逻辑层。因为一个业务操作可能涉及多个数据层的调用,比如"创建订单"要同时写订单表和扣库存,这两个操作必须在一个事务里。如果事务放在数据层,每个 repo 方法各自开事务,就没法保证原子性了。
class OrderService: def __init__(self, order_repo, inventory_repo, transaction_manager): self.order_repo = order_repo self.inventory_repo = inventory_repo self.tx = transaction_manager def create(self, user_id, items): with self.tx.begin(): # 多个数据层操作在同一个事务里 order = self.order_repo.save(...) self.inventory_repo.deduct(...) return order关于缓存。缓存应该放在数据层,因为它是存储的一部分。逻辑层不应该关心"这个数据是从缓存来的还是从数据库来的",它只管调repo.find_by_id(),数据层内部决定要不要走缓存。这样逻辑层保持纯粹,缓存策略可以独立调整。
避坑技巧:不要在逻辑层里手动清缓存。我见过有人在 service 里写
cache.delete(f"order:{id}"),结果缓存 key 的格式散落在各处,改一个地方要全局搜索。正确的做法是数据层的save和update方法内部自动处理缓存失效,上层无感。
6. 从 t3code 延伸出的工程习惯
6.1 分层思维如何影响日常编码
用久了 t3code 这套结构,你会发现它改变的不只是代码组织方式,还有思考问题的顺序。以前拿到需求就想着"怎么写",现在会先想"这个需求属于哪一层"。这个思维转变带来的好处是,你在写代码之前就已经把职责划分清楚了,不会写着写着发现"这块逻辑放哪都不对"。
我自己的习惯是,接到一个新功能,先在纸上画三个框:接入、逻辑、数据。然后把需求拆成动作,每个动作归到对应的框里。这个过程通常只要五分钟,但能省下后面几个小时的返工。
还有一个隐性收益是沟通效率。和产品经理讨论需求的时候,我会问"这个规则是业务规则还是展示规则"。业务规则进逻辑层,展示规则进接入层。这样讨论的时候就把边界定清楚了,不会出现"这个判断到底该谁做"的扯皮。
6.2 团队协作中的分层约定
如果是团队项目,分层需要一些明确的约定,否则每个人理解不一样,最后还是乱。
约定一:目录结构反映分层。比如api/放接入层,services/放逻辑层,repositories/放数据层。新人进来一看目录就知道代码该放哪。
约定二:import 规则。接入层可以 import 逻辑层,逻辑层可以 import 数据层,反过来禁止。可以用 lint 工具强制检查,比如 Python 的import-linter,配置好规则后 CI 自动拦截违规 import。
约定三:命名规范。接入层的函数用动词开头(create_order、list_tasks),逻辑层的类用XxxService,数据层的类用XxxRepository。命名一致了,看名字就知道在哪一层。
约定四:代码 review 检查点。review 的时候重点看三件事:逻辑层有没有技术细节泄漏、接入层有没有业务判断、数据层有没有业务规则。这三个检查点过了,分层基本就没问题。
6.3 什么时候该打破分层
分层是手段不是目的。有些场景下,死守分层反而会让代码更复杂。
场景一:简单的 CRUD。如果一个功能就是"查出来返回",没有任何业务逻辑,那接入层直接调数据层也没什么问题。为了分层而分层,写一堆空的 service 方法,纯属浪费。
场景二:性能敏感的路径。有些高频接口,每多一层调用就多一次开销。这种情况下可以允许接入层直接调数据层,但要加注释说明原因,并且把业务逻辑仍然留在逻辑层。
场景三:原型验证阶段。项目刚开始、需求还不明确的时候,先跑通再说。等需求稳定了再重构分层。我见过有人在原型阶段就严格分层,结果需求一变,三层都要改,反而更慢。
我的经验是:分层是为了控制变化的影响范围,如果某个地方根本不会变,那分不分层无所谓。判断标准很简单——问自己"这块代码未来半年会不会改",会改就分层,不会改就怎么简单怎么来。
7. 一个完整的重构案例复盘
7.1 重构前的混乱状态
我之前接手过一个项目,一个order.py文件有800多行,里面什么都有:Flask 路由、业务计算、SQL 查询、邮件发送。每次加需求都是在这个文件里改,改完测试全靠手动点。
最典型的一个函数是这样的:
@app.route("/order", methods=["POST"]) def create_order(): data = request.get_json() user_id = data["user_id"] items = data["items"] # 查用户 conn = get_db() cursor = conn.cursor() cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,)) user = cursor.fetchone() if not user: return jsonify({"error": "user not found"}), 404 # 算价格 total = 0 for item in items: cursor.execute("SELECT price, stock FROM products WHERE sku = %s", (item["sku"],)) product = cursor.fetchone() if product["stock"] < item["quantity"]: return jsonify({"error": "no stock"}), 400 total += product["price"] * item["quantity"] # 折扣 if user["is_vip"]: total = total * 0.9 if total > 500: total = total - 50 # 写订单 cursor.execute("INSERT INTO orders ...") conn.commit() # 发邮件 send_email(user["email"], "Order created", f"Total: {total}") return jsonify({"order_id": cursor.lastrowid, "total": total})这个函数的问题一目了然:数据库操作、业务计算、邮件发送全搅在一起。想改折扣规则,得在 SQL 语句中间找;想换邮件服务,得小心别碰坏业务逻辑。
7.2 重构过程与关键决策
重构分了三步走。
第一步:抽数据层。把所有的 SQL 操作抽到OrderRepository和UserRepository里,接口用业务语义命名。
class UserRepository: def find_by_id(self, user_id): # SQL 查询 ... def is_vip(self, user_id): # 判断是否 VIP ... class ProductRepository: def get_price_and_stock(self, sku): # 查询价格和库存 ... class OrderRepository: def save(self, order): # 插入订单 ...第二步:抽逻辑层。把价格计算、折扣规则、库存检查抽到OrderService里。
class OrderService: def __init__(self, user_repo, product_repo, order_repo, notifier): self.user_repo = user_repo self.product_repo = product_repo self.order_repo = order_repo self.notifier = notifier def create_order(self, user_id, items): user = self.user_repo.find_by_id(user_id) if not user: raise BusinessError("user not found") total = self._calculate_total(items) total = self._apply_discount(total, user) order = self.order_repo.save(...) self.notifier.send_order_created(user, order) return order def _calculate_total(self, items): total = 0 for item in items: price, stock = self.product_repo.get_price_and_stock(item["sku"]) if stock < item["quantity"]: raise BusinessError(f"no stock for {item['sku']}") total += price * item["quantity"] return total def _apply_discount(self, total, user): if user["is_vip"]: total = total * 0.9 if total > 500: total = total - 50 return total第三步:瘦身接入层。路由函数变成薄薄一层。
@app.route("/order", methods=["POST"]) def create_order(): data = request.get_json() try: order = order_service.create_order(data["user_id"], data["items"]) return jsonify(order.to_dict()), 201 except BusinessError as e: return jsonify({"error": str(e)}), 4007.3 重构后的收益与遗留问题
重构完之后,最直观的变化是加需求变快了。以前加一个"满300减30"的规则,要在800行的文件里找半天;现在直接改_apply_discount方法,五分钟搞定,测试也就几行代码。
第二个变化是测试覆盖率上来了。以前这个文件根本没法测,因为一测就要连数据库、发邮件。现在逻辑层的测试用假 repo,跑一遍不到一秒,覆盖率轻松上80%。
当然也有遗留问题。比如邮件发送我抽成了一个notifier接口,但实际实现还是同步的,下单接口的响应时间没降下来。后来加了个消息队列,把邮件发送改成异步,这才彻底解决。这个改动只动了notifier的实现,逻辑层和接入层没动,这就是分层的好处。
复盘心得:重构不要一次到位。我见过有人想一口气把整个项目重构成完美分层,结果改到一半需求来了,新旧代码混在一起更乱。正确的做法是按功能模块逐个重构,重构完一个上线一个,稳扎稳打。
8. 关于 t3code 的一些个人体会
写了这么多,最后说点掏心窝的话。t3code 这套三层结构,本质上不是什么高深的技术,它就是把"想清楚再写"这个朴素的道理结构化了。我见过太多项目,代码乱不是因为技术难,而是因为写的时候没想清楚职责边界,写着写着就搅在一起了。
这套思路最大的价值,是给你一个默认的决策框架。当你不知道一段代码该放哪的时候,问自己三个问题:它是和外部打交道吗?它是业务规则吗?它是数据存取吗?答案自然就出来了。这个框架不完美,但比没有框架强得多。
我也要提醒一句,别把分层搞成教条。我见过有人为了"严格遵守分层",写了一个只有一行代码的 service 方法,纯粹是转发调用。这种为了形式而牺牲实用的做法,反而增加了维护成本。分层的目的是让代码更好改,如果分层本身成了负担,那就本末倒置了。
最后一个实用建议:从下一个新功能开始用这套结构,别急着重构老代码。新功能用新结构写,老代码等有需求改动的时候顺手重构。这样风险最小,收益也最实在。我自己就是这么干的,半年下来,项目里新代码全部是分层的,老代码也重构了七七八八,整个过程没有一次因为重构引发的线上事故。