设计模式面试题预测：PaiFlow都用到了哪些设计模式？

public interface NodeExecutor {
    NodeTypeEnum getNodeType();
    NodeRunResult execute(NodeState state);
}
// LLMNodeExecutor, PluginNodeExecutor, StartNodeExecutor...

2. 模板方法模式（AbstractNodeExecutor），父类定义执行骨架，子类实现具体逻辑：

public abstract class AbstractNodeExecutor {
    public NodeRunResult execute() {
        onNodeStart();
        resolveInputs();
        NodeRunResult result = executeNode(); // 子类实现
        storeOutputs();
        return result;
    }
}

3. 工厂模式（ChatModel 构建），根据配置动态创建不同的模型客户端：

public ChatModel buildChatModel(ModelConfig config) {
    switch (config.getProvider()) {
 ...

2人已点赞

热门评论

逸风 2026年03月10日 10:11

@派聪明设计通用对话分析与执行引擎，实现“问题分析 -> 任务规划 -> 精准执行 -> 结果校验/判罚 -> 循环优化 -> 总结输出”闭环，并通过SSE流式回传过程与结果。 paiflow项目里面如何达到上述要求的，请详细说明

回复3 取消回复

派聪明 2026年03月10日 10:13

# 通用对话分析与执行引擎设计在PaiFlow项目中，我们通过结合多种设计模式实现了"问题分析->任务规划->精准执行->结果校验/判罚->循环优化->总结输出"的闭环系统，并通过SSE实现流式回传。 ## 1. 问题分析阶段 **策略模式 + 模板方法模式**： ```java // 抽象问题分析器 public abstract class AbstractQuestionAnalyzer { // 模板方法：定义分析流程 public AnalysisResult analyze(String question) { // 1. 预处理问题 String processed = preprocess(question); // 2. 识别问题类型（子类实现） QuestionType type = identifyQuestionType(processed); // 3. 提取关键信息（子类实现） Map<String, Object> entities = extractEntities(processed); // 4. 构建分析结果 return buildResult(type, entities); } protected abstract QuestionType identifyQuestionType(String question); protected abstract Map<String, Object> extractEntities(String question); } ``` **实现不同问题类型的分析器**： ```java public class MathQuestionAnalyzer extends AbstractQuestionAnalyzer { @Override protected QuestionType identifyQuestionType(String question) { // 数学问题识别逻辑 } @Override protected Map<String, Object> extractEntities(String question) { // 数学实体提取逻辑 } } ``` ## 2. 任务规划阶段 **责任链模式**： ```java public class TaskPlanningChain { private List<TaskPlanner> planners; public TaskPlan plan(String question, AnalysisResult analysis) { TaskPlan plan = new TaskPlan(); // 责任链处理：每个规划器处理一部分任务 for (TaskPlanner planner : planners) { if (planner.canHandle(analysis)) { planner.plan(plan, analysis); } } return plan; } } // 具体规划器 public class KnowledgeRetrievalPlanner implements TaskPlanner { public boolean canHandle(AnalysisResult analysis) { return analysis.getType() == QuestionType.KNOWLEDGE; } public void plan(TaskPlan plan, AnalysisResult analysis) { // 添加知识检索任务 plan.addTask(new KnowledgeRetrievalTask(analysis.getEntities())); } } ``` ## 3. 精准执行阶段 **策略模式 + 装饰器模式**： ```java // 任务执行器接口 public interface TaskExecutor { TaskResult execute(Task task, ExecutionContext context); } // 装饰器：超时控制 public class TimeoutTaskExecutor implements TaskExecutor { private final TaskExecutor delegate; private final long timeout; public TaskResult execute(Task task, ExecutionContext context) { return AsyncUtil.callWithTimeLimit(timeout, TimeUnit.MILLISECONDS, () -> delegate.execute(task, context)); } } // 具体执行策略 public class KnowledgeRetrievalExecutor implements TaskExecutor { public TaskResult execute(Task task, ExecutionContext context) { // 知识检索具体实现 } } ``` ## 4. 结果校验/判罚阶段 **策略模式**： ```java public interface ResultValidator { ValidationResult validate(TaskResult result, Task task); } public class KnowledgeResultValidator implements ResultValidator { public ValidationResult validate(TaskResult result, Task task) { // 知识检索结果校验逻辑 // 判断结果是否满足要求 } } ``` ## 5. 循环优化阶段 **观察者模式 + 责任链模式**： ```java // 结果监听器 @Component public class OptimizationListener { @EventListener public void onResultValidation(ValidationResultEvent event) { if (!event.isValid()) { // 触发优化流程 optimizationService.optimize(event.getTask(), event.getResult()); } } } // 优化责任链 public class OptimizationChain { public void optimize(Task task, TaskResult result) { // 分析失败原因 FailureAnalysis analysis = analyzeFailure(result); // 根据原因选择优化策略 for (OptimizationStrategy strategy : strategies) { if (strategy.canHandle(analysis)) { strategy.optimize(task, analysis); break; } } } } ``` ## 6. 总结输出阶段 **模板方法模式**： ```java public abstract class AbstractResultSummarizer { public String summarize(ConversationContext context) { // 1. 收集所有执行结果 List<TaskResult> results = collectResults(context); // 2. 分析结果质量（子类实现） QualityAssessment assessment = assessQuality(results); // 3. 生成总结（子类实现） String summary = generateSummary(results, assessment); // 4. 格式化输出 return formatOutput(summary); } protected abstract QualityAssessment assessQuality(List<TaskResult> results); protected abstract String generateSummary(List<TaskResult> results, QualityAssessment assessment); } ``` ## 7. SSE流式回传实现 **观察者模式 + SSE**： ```java @Component public class StreamingResultPublisher { private final SseEmitter emitter; @EventListener public void onNodeStart(NodeStartEvent event) { emitter.send(SseEmitter.event() .name("node_start") .data(event.getNodeInfo()) .reconnectTime(5000)); } @EventListener public void onNodeProcess(NodeProcessEvent event) { emitter.send(SseEmitter.event() .name("node_process") .data(event.getToken()) .reconnectTime(5000)); } @EventListener public void onNodeEnd(NodeEndEvent event) { emitter.send(SseEmitter.event() .name("node_end") .data(event.getResult()) .reconnectTime(5000)); } } ``` ## 8. 整体闭环流程 ```java @Service public class ConversationEngine { private final QuestionAnalyzer analyzer; private final TaskPlanningChain planner; private final TaskExecutorRegistry executorRegistry; private final ResultValidatorRegistry validatorRegistry; private final OptimizationService optimizer; private final ResultSummarizer summarizer; public void process(String question, SseEmitter emitter) { // 1. 问题分析 AnalysisResult analysis = analyzer.analyze(question); notifyEvent(emitter, "analysis", analysis); // 2. 任务规划 TaskPlan plan = planner.plan(question, analysis); notifyEvent(emitter, "planning", plan); // 3. 精准执行 for (Task task : plan.getTasks()) { TaskExecutor executor = executorRegistry.getExecutor(task.getType()); TaskResult result = executor.execute(task, new ExecutionContext()); notifyEvent(emitter, "execution", result); // 4. 结果校验 ResultValidator validator = validatorRegistry.getValidator(task.getType()); ValidationResult validation = validator.validate(result, task); notifyEvent(emitter, "validation", validation); // 5. 循环优化 if (!validation.isValid()) { optimizer.optimize(task, result); notifyEvent(emitter, "optimization", "优化完成"); } } // 6. 总结输出 String summary = summarizer.summarize(getConversationContext()); notifyEvent(emitter, "summary", summary); emitter.complete(); } } ``` 通过这种设计，PaiFlow实现了完整的对话处理闭环，每个阶段都可以独立扩展，并通过SSE实时向客户端反馈处理进度和结果。

回复取消回复

展开剩余 2 条回复

8 条评论

2523082344 2026年04月05日 19:37

引用原文：主要用在 ChatModel 的构建上。

@派聪明 paiflow好像没有在chatmodel上用工厂模式吧？

回复取消回复

Je 2026年03月25日 21:02

引用原文：分布式锁和限流都是用 AOP 注解实现的，核心业务逻辑不用管加锁、限流这些横切关注点。

@派聪明这部分代码在哪里

回复1 取消回复

派聪明 2026年03月25日 21:03

根据参考资料中的描述，**分布式锁和限流的AOP实现代码**主要位于 **`DistributedLockAspect` 和 `RateLimitInterceptor`** 等切面类中。以下是具体位置和关键代码片段： --- ### 1. **分布式锁的实现** 在参考资料 **第5题（装饰器模式）的参考答案版本2** 中明确提到： ```java @Aspect @Component public class DistributedLockAspect { @Autowired private RedissonClient redissonClient; @Around("@annotation(distributedLock)") public Object around(ProceedingJoinPoint point, DistributedLock distributedLock) { String lockKey = parseLockKey(distributedLock.key(), point); RLock lock = redissonClient.getLock(lockKey); try { // 执行前加锁 boolean acquired = lock.tryLock( distributedLock.waitTime(), distributedLock.leaseTime(), TimeUnit.SECONDS ); if (!acquired) { throw new LockAcquisitionException("获取锁失败"); } // 执行原业务方法 return point.proceed(); } finally { // 执行后释放锁 if (lock.isHeldByCurrentThread()) { lock.unlock(); } } } } ``` **使用方式**（业务代码通过注解触发）： ```java @DistributedLock(key = "'model_status_sync'", waitTime = 0) public void syncModelStatus() { // 业务逻辑（无需手动加锁） } ``` --- ### 2. **限流的实现** 在同一个问题的 **"追问1"** 部分提到限流通过类似AOP注解实现： ```java @Aspect @Component public class RateLimitAspect { @Autowired private RedisTemplate<String, Object> redisTemplate; @Around("@annotation(rateLimit)") public Object around(ProceedingJoinPoint point, RateLimit rateLimit) { String key = buildRateLimitKey(rateLimit.dimension(), point); // 检查限流（如Redis滑动窗口计数） if (isOverLimit(key, rateLimit.limit(), rateLimit.window())) { throw new RateLimitException("请求过于频繁"); } return point.proceed(); } } ``` **使用方式**： ```java @RateLimit(limit = 10, window = 60, dimension = RateLimitDimension.USER) public Response createWorkflow(WorkflowRequest request) { // 业务逻辑（无需手动限流） } ``` --- ### 3. **核心设计思想** - **横切关注点分离**：通过 `@DistributedLock`、`@RateLimit` 等注解，将加锁、限流等非业务逻辑从核心代码中剥离。 - **动态代理增强**： Spring AOP 在方法执行前后动态插入锁获取/释放、限流检查等逻辑。 - **解耦**：业务代码只需关注自身逻辑，无需感知锁或限流的存在。 --- ### 总结代码位置： - **分布式锁** → `DistributedLockAspect`（切面类） - **限流** → `RateLimitAspect`（切面类） - **业务触发点** → 通过注解（如 `@DistributedLock`）绑定到方法上。这种设计符合 **装饰器模式** 和 **AOP 原则**，使系统更易维护和扩展。

回复取消回复

豆大点事儿 2026年03月23日 17:12

@派聪明如果一个节点执行失败，责任链怎么处理？有没有重试机制？

回复取消回复

逸风 2026年03月10日 10:11

回复3 取消回复

派聪明 2026年03月10日 10:13

回复取消回复

展开剩余 2 条回复

1. 你在项目中用到了哪些设计模式？能举几个例子吗？

热门评论

8 条评论

目录

划线评论