一文讲透 GoF 的 23 种设计模式之工厂方法

 1⚡ java片段// 1. 抽象产品
 2public interface AIAgent {
 3    voidexecuteTask();
 4}
 5
 6// 2. 具体产品 A：聊天助理
 7publicclass ChatAgent implements AIAgent {
 8    @Override
 9    publicvoidexecuteTask() {
10        System.out.println("ChatAgent: 正在与用户进行自然语言对话...");
11    }
12}
13
14// 2. 具体产品 B：数据分析助理
15publicclass DataAnalysisAgent implements AIAgent {
16    @Override
17    publicvoidexecuteTask() {
18        System.out.println("DataAnalysisAgent: 正在提取并分析核心数据...");
19    }
20}

 1⚡ java片段// 3. 简单工厂类 (通常使用静态方法)
 2publicclass AIAgentFactory {
 3    
 4    // 根据传入的类型参数，决定实例化哪个具体的 Agent
 5    publicstatic AIAgent createAgent(String agentType) {
 6        if ("chat".equalsIgnoreCase(agentType)) {
 7            return new ChatAgent();
 8        } elseif ("data".equalsIgnoreCase(agentType)) {
 9            return new DataAnalysisAgent();
10        } else {
11            throw new IllegalArgumentException("未知的 Agent 类型: " + agentType);
12        }
13    }
14}

 1⚡ java片段public class Client {
 2    public static void main(String[] args) {
 3        // 客户端不需要知道 ChatAgent 和 DataAnalysisAgent 是怎么被 new 出来的
 4        // 只需要告诉工厂：“给我一个 chat 类型的 Agent”
 5        AIAgent agent1 = AIAgentFactory.createAgent("chat");
 6        agent1.executeTask();
 7
 8        AIAgent agent2 = AIAgentFactory.createAgent("data");
 9        agent2.executeTask();
10    }
11}

 1⚡ java片段// 抽象产品：统一的大模型调用接口
 2public interface LLMClient {
 3    String generate(String prompt);
 4}
 5
 6// 具体产品 A：Claude 客户端
 7publicclass ClaudeClient implements LLMClient {
 8    private String modelVersion;
 9    
10    publicClaudeClient(String modelVersion) { this.modelVersion = modelVersion; }
11
12    @Override
13    public String generate(String prompt) {
14        return"[Claude " + modelVersion + "] 思考并返回结果...";
15    }
16}
17
18// 具体产品 B：OpenAI 客户端
19publicclass OpenAIClient implements LLMClient {
20    private String endpoint;
21    
22    publicOpenAIClient(String endpoint) { this.endpoint = endpoint; }
23
24    @Override
25    public String generate(String prompt) {
26        return"[OpenAI API] 处理输入并返回结果...";
27    }
28}

 1⚡ java片段// 抽象创建者：Agent 工作流骨架
 2public abstract class AgentWorkflow {
 3
 4    // 核心业务逻辑：定义了标准的处理流程（这其实也是个模板方法）
 5    publicvoidprocessTask(String taskContext) {
 6        System.out.println("=== 1. 解析任务上下文，提取关键信息 ===");
 7        
 8        // 【灵魂所在】：这里调用工厂方法，拿到一个产品对象。
 9        // 父类在此刻完全不知道自己拿到的是 Claude 还是 OpenAI。
10        LLMClient client = createLLMClient();
11        
12        System.out.println("=== 2. 请求大模型进行推理 ===");
13        String result = client.generate(taskContext);
14        
15        System.out.println("=== 3. 结果后处理并落库 ===\n" + result + "\n");
16    }
17
18    // 【工厂方法】：将实例化具体产品的职责，推迟到子类去实现
19    protected abstract LLMClient createLLMClient();
20}

 1⚡ java片段// 具体创建者 A：基于 Claude 的工作流
 2publicclass ClaudeAgentWorkflow extends AgentWorkflow {
 3    @Override
 4    protected LLMClient createLLMClient() {
 5        // 这里封装 Claude 特有的复杂初始化逻辑（比如加载凭证、设置代理等）
 6        System.out.println("  -> [工厂方法] 正在初始化 Claude 客户端环境...");
 7        return new ClaudeClient("3.5-Sonnet");
 8    }
 9}
10
11// 具体创建者 B：基于 OpenAI 的工作流
12publicclass OpenAIAgentWorkflow extends AgentWorkflow {
13    @Override
14    protected LLMClient createLLMClient() {
15        System.out.println("  -> [工厂方法] 正在构建 OpenAI 客户端环境...");
16        return new OpenAIClient("https://api.openai.com/v1");
17    }
18}

 1⚡ java片段public class Client {
 2    publicstaticvoidmain(String[] args) {
 3        String task = "编写一段 Python Web 框架对比报告";
 4
 5        // 场景 1：启动基于 Claude 的 Agent 工作流
 6        AgentWorkflow claudeWorkflow = new ClaudeAgentWorkflow();
 7        claudeWorkflow.processTask(task);
 8
 9        // 场景 2：切换为基于 OpenAI 的 Agent 工作流
10        AgentWorkflow openaiWorkflow = new OpenAIAgentWorkflow();
11        openaiWorkflow.processTask(task);
12    }
13}