设计模式与领域驱动
DDD(Domain-Driven Design)领域驱动设计
- 第二章 领域驱动设计基础 - 高宏顺 - 博客园 (opens new window)
- DDD专题案例一《初识领域驱动设计DDD落地》 | 小傅哥 bugstack 虫洞栈 (opens new window)
软件设计的核心目的:高内聚低耦合
# 设计模式详解
“23 种设计模式”是指《设计模式:可复用面向对象软件的基础》(Design Patterns: Elements of Reusable Object-Oriented Software)书中总结的 23 种经典 GoF 设计模式(Gang of Four,四人帮)
- MVC 就像毛坯,而设计模式就是在精装,合理的设计模式使代码复杂,复杂之下蕴含了极强的扩展和解耦能力,如何选择和运用设计模式是一门精深的功夫,搬砖之于室内设计不外乎如此
这些模式分为三大类:创建型、结构型和行为型,可以通过以下方式帮助记忆
- 创建型(5个) → "单工抽建原":工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
- 结构型(7个) → "适装代外桥组享":适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
- 行为型(11个) → "策模观迭责命状备中解访":策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
# 单例模式
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一,属于创建型模式,它提供了一种创建对象的最佳方式
这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建
单例意在保证一个类仅有一个实例,并提供一个访问它的全局访问点,具有以下特点
- 单例类只能有一个实例
- 单例类必须自己创建自己的唯一实例
- 单例类必须给所有其他对象提供这一实例
Spring 中的 Singleton Bean 采用的便是单例模式(创建型),任意一个被 @Mapper / @Service / @Controller / @Repository / @Bean 修饰的接口都是一个单例
单例分类,可分为饿汉式、懒汉式和 DCL 懒汉式,在 Spring 中,维护单例对象的 Map 是一个 ConcurrentHashMap,并且单例的创建只有在 getBean 时才会触发,所以 Spring 中的 Bean 实际上是一个懒汉式单例
# 饿汉式
线程安全,但会造成资源浪费
//饿汉式单例模式
public class Hungry {
private Hungry() {}
private static Hungry HUNGRY = new Hungry();
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
public static Hungry getInstance(){
return HUNGRY;
}
public static void main(String[] args) {
Hungry hungry = Hungry.getInstance();
Hungry hungry1 = Hungry.getInstance();
System.out.println(hungry.hashCode());
System.out.println(hungry1.hashCode());
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 懒汉式
线程不安全,多线程跑时将发生多个线程同时跑一个 LazyMan() 方法,即使返回同一个 LazyMan 对象。对 getInstance() 方法用 synchronized 修饰可以解决此问题,但会大大降低效率
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName() + " ok");
}
private static LazyMan LazyMan;
public static LazyMan getInstance(){
if(LazyMan==null){
LazyMan = new LazyMan();
}
return LazyMan;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# DCL 懒汉式
推荐使用
Double Check Lock,一般情况下线程安全,但不绝对安全
DCLLAZYMAN = new DCLLayzMan();
这行代码并不是一个原子性操作
- 分配内存空间
- 执行构造方法,初始化对象
- 把这个对象指向这块空间
DCL 懒汉
public class DCLLazyMan {
private DCLLazyMan(){
System.out.println(Thread.currentThread().getName() + " ok");
}
private static DCLLazyMan DCLLAZYMAN;
public static DCLLazyMan getInstance(){
if(DCLLAZYMAN == null){
synchronized (DCLLazyMan.class){
if(DCLLAZYMAN == null){
DCLLAZYMAN = new DCLLazyMan();
}
}
}
return DCLLAZYMAN;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
DCLLazyMan.getInstance();
}).start();
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
为了防止有人用反射破解该单例,即 setAccessable(true),可在构造方法中加一把锁,同时抛出异常
private DCLLazyMan(){
synchronzed(DCLLazyMan.class){
if(LAZYMAN != null){
Throw new RuntimeException("不要试图用反射破坏单例");
}
}
System.out.println(Thread.currentThread().getName() + " ok");
}
2
3
4
5
6
7
8
这里需要用 Volatile 令 DCLLAZYMAN 避免指令重排:我们希望的顺序为 123,但经过指令重排可能为132,如此在进行判断时,有可能 A 线程经过 3 把 DACLLAZYMAN 指向了一块空间,B 线程此时判定 DCLLAZYMAN 不为 null 往下执行,直接返回 DCLLAZYMAN,而此时对象未被初始化导致错误(即使这种概率非常非常小)
# 代理模式
常常与字节码增强技术挂钩,例如使用 CGLib 动态生成 Object,就是依据原先的 Class 父类,通过继承的方式生成代理类(这一步操作将在本地生成对应的字节码),而后使用该代理类的字节码进行对象创建
public Object instantiate(BeanDefinition beanDefinition, String beanName, Constructor<?> ctor, Object[] args) throws BeansException {
Enhancer enhancer = new Enhancer();
// 根据原有类创建代理类
enhancer.setSuperclass(beanDefinition.getBeanClass());
enhancer.setCallback(new NoOp() {
@Override
public int hashCode() {
return super.hashCode();
}
});
if(ctor == null){
return enhancer.create();
}
return enhancer.create(ctor.getParameterTypes(), args);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
以上代码中,enhancer 字节码增强器就通过原有类beanDefinition.getBeanClass生成新的代理类,注意这个代理类在编译后是存在相应的字节码文件的,最后在enhancer.create时,是通过这个代理类的字节码文件进行对象生成
在 AOP 中,这样的代理实现更多,字节码增强技术使用更为频繁
# 工厂方法模式
工厂方法模式的定义:定义一个用于创建对象的接口**,**让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类
- 父类提供一个创建对象的方法,但不实现
- 交给子类去决定创建哪个具体类
比方说,我设计了一个 Auth 接口
public interface Auth {
KeyPair keygen();
CryptoMap sign(String message, CryptoMap sk);
CryptoMap sanitize(String message, CryptoMap sk, CryptoMap signature);
Boolean verify(String message, CryptoMap pk, CryptoMap signature);
}
2
3
4
5
6
而后定义了一个抽象类 CipherSystem,去继承 Auth 接口,但仍没有实现具体逻辑,而是实现初始化逻辑
public abstract class CipherSystem implements Auth {
Pairing BP;
Field G1, G2, GT, Zr;
Boolean sanitizable, updatable;
public CipherSystem(Pairing BP, Field G1, Field G2, Field GT, Field Zr, Boolean sanitizable, Boolean updatable){
this.BP = BP;
this.G1 = G1;
this.G2 = G2;
this.GT = GT;
this.Zr = Zr;
this.sanitizable = sanitizable;
this.updatable = updatable;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
最终的实现在 CipherSystem 的子类中,通过每个类的工厂返回实现类,例如
CipherSystem rsa = RSAFactory.creatSystem();
而最终对象的使用通过统一的 CipherSystem 类调用
public static void test(CipherSystem cipherSystem){
KeyPair key = cipherSystem.keygen();
CryptoMap signature = cipherSystem.sign("null", key.sk);
System.out.println(cipherSystem.verify("null1", key.pk, signature));
if(cipherSystem.getSanitizable()){
signature = cipherSystem.sanitize("null", key.sk, signature);
System.out.println(cipherSystem.verify("null", key.pk, signature));
}
}
2
3
4
5
6
7
8
9
10
优点
- 新增产品时不改工厂接口,只需新增子类
- 创建和使用对象分离,提高代码灵活性
- 客户端通过工厂接口使用不同的产品子类
缺点:每新增一个产品类,都需要对应一个新的工厂类,类数量可能较多,结构稍显臃肿
另外,Java 的 BeanFactory 还有线程池都是典型的工厂模式
ExecutorService threadPool = Executors.newCachedThreadPool();
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName() + " ok");
});
2
3
4
每一个 BeanFactory 都是一个生成 Bean 的工厂,每一个 ExecutorService 都是一个生产线程的工厂,每个 C3P0 池都是一个生产数据库连接的工厂
# 策略模式
什么是策略模式?比如 Spring createBean 时的策略选取,通过相同的一个接口,多个策略同时实现该接口,选策略就等于选实现算法,但调用的是同一个 interface 下的接口函数
策略模式与工厂方法模式的区别?
- 工厂方法模式在子类中完成类的实例化,是将初始化方法下放,而策略模式是把业务逻辑方法下放给子类实现
策略模式与代理模式的区别?
- 似乎都是从一个父类(接口)向下寻找对应的实现?(又让我想到“向上委派,向下查找”)
# 观察者模式与事件驱动
在程序设计中,解耦总是和观察者模式挂钩,例如
- Go 的协程通过 Channel 通信,将任务拆解为一对一或一对多的观察者模式
- 消息队列中的发布订阅模式,通过事件通信解耦业务逻辑
事件是解耦的核心,任务的上下游通过事件进行通信并将任务拆解为不同阶段执行,可以说,事件的设计本身就是一种观察者模式的实现,或者说,观察者模式是由事件驱动的
比如你可以定义一个新用户注册的事件,当有用户执行注册完成后,在事件监听中给用户发送一些优惠券和短信提醒,这样的操作就可以把属于基本功能的注册和对应的策略服务分开,降低系统的耦合
以后在扩展注册服务,比如需要添加风控策略、添加实名认证、判断用户属性等都不会影响到依赖注册成功后执行的动作
# 模板方法模式
需求场景:实现流程一样,执行步骤一样,但每个步骤的实现方法不一样
OJ 系统中,判题机有两种模式,一个是远程的本地 Java 命令线程,二个是远程的 Docker 沙箱,两套代码执行流程完全一致
- 保存用户代码
- 编译代码
- 执行代码
- 获取代码输出并返回统计信息
模板方法:定义一套通用的执行流程,让子类负责每个步骤的具体实现,适用于有规范的流程且执行流程可以服用,这意味着能复用的代码可以放在上层实现,能够大量节省代码并且便于项目维护和扩展
定义接口 executeCode,接收 Request,返回 Response
public interface CodeSandbox{
ExecuteCodeResponse executeCode(ExecuteCodeRequest executeCodeRequest);
}
2
3
定义一个模板流程 abstract class
public abstract class JavaCodeSandboxTemplate implements CodeSandbox{
private static final String GLOBAL_CODE_DIR_NAME = "tmpCode";
private static final String GLOBAL_JAVA_CLASS_NAME = "Main.java";
private static final long TIME_OUT = 5000L;
// 继承 CodeSandbox 的执行方法,这是面向用户的公开方法
@Override
public ExecuteCodeResponse executeCode(ExecuteCodeRequest executeCodeRequest){
String code = executeCodeRequest.getCode();
List<String> inputList = executeCodeRequest.getInputList();
// 1.保存文件
File userCodeFile = saveCodeToFile(code);
// 2.编译代码,编译失败直接抛异常
ExecuteMessage compileFileExecuteMessage = compileFile(userCodeFile);
// 3.执行代码,执行失败同样直接抛异常
List<ExecuteMessage> executeMessageList = runFile(userCodeFile, inputList);
// 4.统计是否执行成功,最长时间,最大内存
ExecuteCodeResponse outputResponse = getOutputResponse(executeMessageList);
// 5.清理文件
if(!deleteFile(userCodeFile)){
log.error("Delete file error, user code file path: {}", userCodeFile.getAbsoluteFilePath);
}
// 返回响应
return outputResponse;
}
// 定义流程
protect File saveCodeToFile(String code){
//... 保存的操作各个子类是一致的,所以直接在父类中实现
}
protect ExecuteMessage compileFile(File userCodeFile){
//... 同上
}
protect List<ExecuteMessage> runFile(File userCodeFile, List<String> inputList);
protect ExecuteCodeResponse getOutputResponse(List<ExecuteMessage> executeMessageList){
//... 公共方法在模板类中直接实现
}
protect boolean deleteFile(File userCodeFile){
//...
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
而后在 JavaCodeSandboxTemplate 的子类中实现具体的流程步骤,应用所谓的多态
JavaNativeCodeSandbox extend JavaCodeSandboxTemplateDockerCodeSandbox extend JavaCodeSandboxTemplate
不需要修改的步骤直接 super,需要修改的步骤进行重载 @Override 覆盖就行
模板方法模式和工厂方法模式的区别?
- 同样的在上层抽象,模板方法模式抽象的是业务流程,工厂方法模式抽象的是初始化过程(包括变量的定义、加载和赋值流程等等)
模板方法模式和策略模式的区别?
- 模板方法注重业务逻辑的流程抽象,而策略模式略显简单,像是直接从接口到实现,少了中间的一层 abstract class 的流程抽象
# 装饰者模式
在整个 Spring 的设计中,装饰者模式的运用是隐性的,每个功能的加入,都采用一种低耦合、高扩展度的方式进行接入,在初期显得臃肿,但实际上是始终提供装饰接口和不断装饰完善的展现
# DDD 设计思想
Domain-Driven Design 领域驱动设计
- DIP 依赖倒置原则
- 业务与基础设施解耦
# Service + 贫血模型
贫血模型(Anemic Model),是一种数据与行为分离的对象设计方式,对象仅存储数据,业务逻辑则放在单独的 “服务类” 中
核心特征
- 类内部只有成员变量和对应的 getter/setter 方法,没有业务逻辑。
- 所有业务操作(如计算、校验)都放在专门的服务类(如
OrderService)中。 - 本质上更像 “数据容器”,而非完整的 “业务对象”。
例如:一个订单类Order只存订单号、金额等字段,计算订单折扣、判断是否可取消等逻辑,都放在OrderService里
在我“历来”的开发中,我都是用的这样的模式,这样"大而全"的service + 贫血数据模型架构
# 充血模型
充血模型(Rich Model),是数据与行为绑定的对象设计方式,业务逻辑直接封装在对象内部,让对象既持有数据,又能完成自身相关的业务操作
核心特征
- 类内部不仅有成员变量,还包含与自身数据强相关的业务方法(如校验、计算、状态变更)
- 服务类仅负责协调多个对象的交互(如调用两个对象的方法完成跨对象业务),不承担具体业务逻辑
- 更符合面向对象 “封装” 的核心思想,让对象自己 “对自己负责”
例如:击剑火柴人小游戏中,每个火柴人 MatchMan 把击剑、移动、跳跃等功能都包含了,在主程序中仅需创建 MatchMan 就可以开始游戏
充血模型是更适合领域驱动设计的实现方案,当然,充血模型并非 “银弹”,它对开发者的业务理解能力要求更高(需要准确判断 “哪些行为属于对象本身”),但对于复杂业务系统,这种前期投入能显著降低长期维护成本
# 领域模型
领域模型(Domain Model),领域模型是对业务领域中 “概念、规则、流程” 的抽象表示,是描述业务的 “蓝图”,充血模型和贫血模型都是实现领域模型的具体方式
- 即领域模型是更上层的架构思想,用以分割业务,而充血和贫血模型是代码实现的具体风格
领域模型和微服务的相性一致
# 实体、聚合和值对象
实体 entity 依托于持久层数据 PO 设计,例如用户的一个地址 POJO,它实际上存储在数据库中,通过扩展他的功能,使之成为一个具有完整生命周期的数据
- 用户地址有完整的 CRUD 流程,创建、修改、销毁都在同一数据载体上进行
值对象可以理解为一个数据库记录,例如订单中,用户的收货地址,这个收货地址当然有可能是用户的实体 entity 地址,但是他只是作为一个当前值存放在订单记录中,也就是说,即使用户修改了收获地址,其实体的用户地址并不会改变
这样的 DDD 思想可以作为方法论应用到数据表设计,即实体可以作为一个单独的表存在,而值对象仅作为一个列字段来存储,例如
- 我现在有一个订单表和用户个人信息表,这个订单表该用户用户地址这一字段吗?还是说直接去关联用户个人信息表中的数据项,再去拿地址字段
- 答案是前者,因为在订单表中,用户地址是一个值对象,而非实体,不能这样外键关联,甚至于,对于这样的值对象,我们可以用一个 JSON 字段来进行存储(他只是一个一次性的数据,存着就行,其实不太需要关注他的结构和维护)
聚合对象:聚合对象是值对象的集合,当你对数据库的操作需要使用到多个实体时,可以创建聚合对象(相当于一个 left join?)
- 一个聚合对象来表示一个数据库事务,具有事务一致性,聚合中的实体可以由聚合提供创建操作,实体 PO 也被称为聚合根对象
例如,一个订单的聚合,会涵盖:下单用户实体对象、订单实体、订单明细实体和订单收货四级地址值对象
# DIP 依赖倒置
基于 DIP(Dependency Inverse Principle)依赖倒置原则
传统Service + 贫血模型常见的问题是:Service 层直接依赖 Redis、RPC 客户端、配置中心、MQ 等基础设施,导致业务逻辑与技术实现深度耦合,难以测试、演进和复用
DIP 的核心概念可以概括为以下几点
- 高层模块和低层模块都应该依赖于抽象:高层模块是指那些调用其他模块、类或函数的模块,而低层模块则是被调用的模块、类或函数
- 抽象不应依赖于细节:在软件开发中,抽象通常指的是接口或抽象类,而细节则是具体的实现类
- 依赖倒置的设计理念是相对于细节的多变性,抽象的东西要稳定得多,以抽象为基础搭建的架构比以细节为基础的架构要稳定得多
例如:上层调用依赖于一个底层接口而不关注其实现方式,于是这个底层接口的具体实现和上层调用被分离解耦,同时,这个底层实现也应当依赖于抽象接口实现
具体到实例
- 在一个消息发送的场景中,如果我们有一个
Person类需要发送消息,而消息的发送方式有电子邮件、微信等多种方式,我们可以定义一个抽象的接口IReceiver,然后让Email和WeiXin等具体的消息发送方式实现这个接口 - 这样,
Person类只需要依赖于IReceiver接口,而不是具体的发送方式,当新增一种消息发送方式时,只需要新增一个实现了IReceiver接口的类即可,而无需修改Person类的代码
另外,计算机网络层级的设计就也合这样的依赖倒置,只规范每一层 API 接口,而不关注每一层的具体实现,调用的代码不作修改
在 DDD 架构中,从上往下分别是
- 用户接口层:暴露业务逻辑接口
- 应用层:实现业务逻辑
- 领域层:实现服务功能
- 基础设施层:实现底层仓储和适配器
# 仓储和适配器
仓储即数据库存储,适配器即通信框架,在 DDD 中属于基础设施层
仓储(基础设施层)与领域层的耦合实例
- 在领域层定义 Repository 接口(如
AccountRepository) - 在基础设施层实现该接口,可基于 MyBatis、JPA、RedisTemplate 等技术
- 通过依赖注入将具体实现注入到应用服务中
# 触发器
在 DDD 架构中,领域层的所有外部交互动作,无论是 HTTP、RPC、MQ 消息发布监听,还是定时任务,都被统一视作“触发动作”
- 它们本身不包含业务逻辑,仅作为入口点,负责接收外部请求并调用对应的应用层编排逻辑
如何去调用领域层的服务,就是触发器的工作
触发动作的职责非常明确:解析输入、校验边界、启动流程,然后委托给应用服务进行用例编排
真正的业务规则,始终保留在领域层中,确保核心逻辑不受技术细节污染,实现“业务与基础设施解耦”
# CQRS 和 TDD
# CQRS 读写责任分离
Command Query Responsibility Segregation,读写责任分离
用上 DDD 后,自然就会用上命令与查询分离的设计,这就不得不提到 CQRS
CQRS 源于 CQS 设计模式,CQS(命令查询分离,Command Query Segregation)设计模式建议将对象的方法映射到两类,方法要么改变对象的内部状态,但不返回任何内容,要么只返回元数据
- 只改变状态的方法称为 Command
- 或者一个方法返回信息但不改变内部状态的方法称为 Query
例如,Java 中 Stack 的 pop 方法违反了 CQS 模式,因为它修改了堆栈的内部状态并同时返回信息
在 CQS 模式的基础上,Greg Young 在 2010 年提出了 CQRS(Command Query Responsibility Segregation)架构模式,它也将写入和读取分开,但应用于 API 方面,例如
- Command API 仅使用 POST 路由实现
- 而 Query API 仅使用 GET 路由实现
CQRS 的最大优势之一是可以将技术代码与业务代码分离,特别是在与 DDD 和事件溯源相关的情况下,可以在不更改技术子结构中的任何内容的情况下调整业务逻辑,更重要的是,反之亦然
- CQRS 和 DDD 是天然契合的,CQRS 天然提供一种领域划分逻辑
# TDD 测试驱动开发
Test-Driven Development
简单来说,就是先写测试再写代码,也是 Code Agent 的一种设计思路,主要目的是实现开发效果闭环,在很多的 coding skill 中,用的就是这种设计模式
# DDD 架构设计
# DDD 四层架构
在开始之前,得首先搞清楚几个概念
- 分布式是项目部署的事,不管是单体项目还是微服务项目,都可以采用分布式部署,当然,通常情况下,微服务总是分布式部署
- 微服务是项目模块化的事,与之对应的是单体项目,将单体项目拆分为微服务是常见的操作,Spring Cloud 是最广泛的微服务框架
- DDD 是代码设计的事,与之相对应的是典型的三层模型(Controller-Service-Dao),这是代码组织结构,例如 COLA 架构就是一个典型的 DDD 设计实例
也就是说,我可以用 DDD 的思想开发单体项目,当然也可以开发微服务,这只是一种代码设计风格,至于分布式,那是部署的事
原有的单体架构项目采用三层架构,即 Controller-Service-Dao,典型的贫血模型,DDD 的一个四层架构示例如下
项目结构
| 根目录 | 子包 | 说明 | 备注 |
|---|---|---|---|
| model | dao, data, dto, mservice, service | 领域层 | model.service 中包含一个个具体的业务分块,如 acctivity, agent, aicamera 等等,每个包作为一个个独立模块,实现各自的业务逻辑 |
| bootstrap, library, conf, data, log, swagger | / | 基础设施层 | |
| cmd, cmdtask, script | / | 脚本、消费者 | |
| servers, nsheadserver | router.go, server.go, controller | 用户接口层 | 提供 HTTP 和 NSHead 微服务接口 |
这样的一个完整项目将作为大项目中的一个模块存在,他可能依赖于底层的 base 项目,作为一个业务接口 function 存在,向其他平台或微服务提供业务能力
另外,所有的单测都写在相应模块下,例如 dao 下的activity/table_activity_user_queue.go一定会有一份activity/table_activity_user_queue_test.go
# DDD 微服务分层
度子的微服务项目遵循 DDD 领域驱动进行代码层级设计,大致分为三层,从基础设施(library)到业务逻辑(model)到服务注册(server)
以 CANVAS 为例
CANVAS
|-- bin
|-- bootstrap
|-- cmd
|-- cmdtask
|-- conf
|-- conftest
|-- model
|-- data
|-- document
|-- hestia
|-- httpserver
|-- nshandserver
|-- log
|-- library
|-- noahdes
|-- script
|-- main.go
|-- go.mod
|-- go.sum
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
httpserver 和 nshandserver 分别是 http 和微服务接口,其中 httpserver/controller/* 负责封装 model 层的业务逻辑并导出为出入参数的处理和路由注册
真正的承重层是 model 层,他实现了所有的业务逻辑,从数据库操作到业务逻辑组装到提供封装已经完善的 service 接口
- service 和 mservice 分别对应 http 和微服务业务,在这两个目录下会根据领域把业务划分为一个个小的子包,例如
acctivity / agent / aicamera,每个子包中写好每个子服务的完整业务逻辑,并相互调用 - 在 model/dao 中定义数据结构以及数据库操作,这里更像 Java 风味(在腾子的架构里,SQL 是直接在业务逻辑中调 GORM 拼接的)
model
|-- dao
|-- dto
|-- service
|-- mservice
|-- data
|-- workflow
2
3
4
5
6
7
腾子的项目架构
- services/*.go 接口层:只做规范输入输出和 for 处理
- business/*.go 业务层:业务逻辑处理,每个 go 文件提供一个 Controller 供“外层”调用,这里的外层可以是 business,也可以是上层 service
- models/table/* 模型层:定义数据库 table 数据结构
- config 配置层:配置中心的数据结构和数据初始化
- proto 项目:通过 proto 文件生成 dto 数据结构和接口定义,这是一个公共的区域,通常一个项目对应一个 proto 文件,并在不同微服务的 business 中相互调用
- utils 微服务:一些通用的功能被单独拆成一个微服务项目调用,例如 Redis 锁
但项目架构分层在 dao 层的处理上有明显不同,但在 service 的领域划分有共通之处(一个子包 / 一个文件囊括一个业务,明显的 DDD 思想),这里以 Java 为基准
- 腾子 services 对应 controller(这个基本一致),business 对应 service + dao,这是一个 service 和 dao 的聚合体,他没有明确的 dao 层,models 和 proto 里只定义数据结构和接口,DB、Redis 以及 MQ 的操作嵌合在 business 里的业务语句中
- 度子的 server 对应 controller,业务实现集中在 model/* 中,model 的一个子包表示一种业务,同时在 model 内部会进行 service 和 dao 的分层,例如 model/service/ppt 和 model/dao/ppt 下的所有 go 文件实现了 ppt 这一业务的全部业务逻辑,并通过 model/service/ppt/ppt.go 向 httpserver/controller 提供 api 接口,在 server/controller/* 将其封装为一个 HttpHandler 并在 server/router.go 中注册路由