Skip to content
The Chat Archive
o1-preview-2024-09-12· OpenAI WildChat-4.8M (AI2)

我现在项目开发中碰到一个问题,现在的整个业务流程是,每个客户都会创建多个任务(问卷调研),但是在整体的业务流程上,每个任务都会有一些定制需求,现在是硬编码,当任务 code…

  1. User

    我现在项目开发中碰到一个问题,现在的整个业务流程是,每个客户都会创建多个任务(问卷调研),但是在整体的业务流程上,每个任务都会有一些定制需求,现在是硬编码,当任务 code 等于某个任务的时候,执行相应的流程,如何优雅的解决这个问题,保证每个定制需求尽可能的独立,整体的结构和流程清晰,项目使用的 springboot+MySQL+redis

  2. Assistant

    在项目开发中,当遇到不同的任务需要执行不同的定制化流程时,直接使用硬编码(如 if 或 switch 语句判断任务代码)会导致代码臃肿,难以维护和扩展。为了优雅地解决这个问题,保持代码的清晰性和可扩展性,可以考虑以下几种设计模式和技术方案:

    1. 策略模式(Strategy Pattern)

    概念: 策略模式定义了一系列的算法,将每个算法封装起来,并使它们可以相互替换。策略模式让算法独立于使用它的客户端变化。

    应用步骤:

    1. 定义策略接口:创建一个接口,定义所有任务共同的方法。

      public interface TaskStrategy {
          void execute();
      }
      
    2. 实现具体策略类:针对不同的任务代码,实现不同的策略类。

      @Service("TaskCodeA")
      public class TaskCodeAStrategy implements TaskStrategy {
          @Override
          public void execute() {
              // 任务代码为A的具体实现
          }
      }
      
      @Service("TaskCodeB")
      public class TaskCodeBStrategy implements TaskStrategy {
          @Override
          public void execute() {
              // 任务代码为B的具体实现
          }
      }
      
    3. 创建策略工厂或使用Spring的依赖注入:

      使用Spring的ApplicationContext或@Autowired注入所有策略,实现按名称获取策略实例。

      @Service
      public class TaskStrategyFactory {
          @Autowired
          private ApplicationContext applicationContext;
      
          public TaskStrategy getStrategy(String taskCode) {
              return (TaskStrategy) applicationContext.getBean(taskCode);
          }
      }
      
    4. 在业务逻辑中使用策略:

      @Service
      public class TaskService {
          @Autowired
          private TaskStrategyFactory strategyFactory;
      
          public void processTask(String taskCode) {
              TaskStrategy strategy = strategyFactory.getStrategy(taskCode);
              strategy.execute();
          }
      }
      

    优点:

    • 遵循开闭原则:添加新策略无需修改现有代码。
    • 策略之间相互独立,便于维护。

    2. 使用策略枚举(Enum + 策略模式)

    如果策略数量有限,也可以使用枚举来管理策略。

    public enum TaskStrategyEnum {
        TASK_A("TaskCodeA") {
            @Override
            public void execute() {
                // 任务A的实现
            }
        },
        TASK_B("TaskCodeB") {
            @Override
            public void execute() {
                // 任务B的实现
            }
        };
    
        private String taskCode;
    
        TaskStrategyEnum(String taskCode) {
            this.taskCode = taskCode;
        }
    
        public abstract void execute();
    
        public static TaskStrategyEnum getByCode(String code) {
            for (TaskStrategyEnum strategy : values()) {
                if (strategy.taskCode.equals(code)) {
                    return strategy;
                }
            }
            throw new IllegalArgumentException("无效的任务代码");
        }
    }
    

    使用:

    public void processTask(String taskCode) {
        TaskStrategyEnum strategy = TaskStrategyEnum.getByCode(taskCode);
        strategy.execute();
    }
    

    优点:

    • 枚举类型天生是单例,线程安全。
    • 策略的定义集中管理,清晰明了。

    3. 责任链模式(Chain of Responsibility Pattern)

    如果一个任务可能需要按顺序执行多个定制化步骤,可以采用责任链模式。

    步骤:

    1. 定义处理器接口:

      public interface TaskHandler {
          void setNextHandler(TaskHandler handler);
          void handle(TaskContext context);
      }
      
    2. 实现具体处理器:

      public class ConcreteHandlerA implements TaskHandler {
          private TaskHandler nextHandler;
      
          @Override
          public void setNextHandler(TaskHandler handler) {
              this.nextHandler = handler;
          }
      
          @Override
          public void handle(TaskContext context) {
              // 处理逻辑
              if (nextHandler != null) {
                  nextHandler.handle(context);
              }
          }
      }
      
    3. 构建责任链并执行:

      public void processTask(TaskContext context) {
          TaskHandler handlerA = new ConcreteHandlerA();
          TaskHandler handlerB = new ConcreteHandlerB();
          handlerA.setNextHandler(handlerB);
          handlerA.handle(context);
      }
      

    优点:

    • 动态组合处理器,灵活控制处理流程。
    • 各处理器职责单一,符合单一职责原则。

    4. 使用配置驱动(数据驱动)

    将任务的定制化需求抽象为配置,存储在数据库或配置文件中,通过读取配置来控制流程。

    步骤:

    1. 设计配置结构:定义任务配置,包括需要执行的步骤、参数等。

      {
          "taskCode": "TaskCodeA",
          "steps": [
              {"stepName": "step1", "params": {...}},
              {"stepName": "step2", "params": {...}}
          ]
      }
      
    2. 开发通用的任务执行引擎:

      public class TaskExecutor {
          public void execute(TaskConfig config) {
              for (StepConfig step : config.getSteps()) {
                  // 根据stepName获取对应的处理器
                  TaskStepHandler handler = getHandlerByName(step.getStepName());
                  handler.execute(step.getParams());
              }
          }
      }
      
    3. 实现各步骤处理器:

      public interface TaskStepHandler {
          void execute(Map<String, Object> params);
      }
      
      @Component("step1")
      public class Step1Handler implements TaskStepHandler {
          @Override
          public void execute(Map<String, Object> params) {
              // 具体处理逻辑
          }
      }
      

    优点:

    • 高度灵活,新增或修改任务流程无需修改代码。
    • 适合流程变化频繁的场景。

    5. 引入规则引擎或工作流引擎

    对于复杂的业务流程,可以考虑使用规则引擎(如 Drools)或工作流引擎(如 Activiti、Flowable、Camunda)。

    优点:

    • 专业的流程和规则管理,支持复杂的业务需求。
    • 可视化流程设计,便于业务人员参与。

    注意:引入第三方引擎会增加项目的复杂度,需要评估引入成本和收益。

    6. 采用脚本引擎(如Groovy、JavaScript)

    允许在运行时加载和执行脚本,定制化需求以脚本形式存在。

    步骤:

    1. 编写脚本:将定制需求写成脚本,存储在数据库或文件系统中。

    2. 使用脚本引擎执行:

      ScriptEngine engine = new ScriptEngineManager().getEngineByName("groovy");
      engine.eval(scriptContent);
      

    优点:

    • 动态执行代码,灵活性高。
    • 无需重新部署应用即可更新定制逻辑。

    缺点:

    • 调试和维护较为困难。
    • 需要处理脚本的安全性。

    总结

    基于您的需求,推荐使用 策略模式 或 配置驱动 的方式。

    • 策略模式 适用于定制化需求明确且数量相对固定的情况,便于维护和扩展新的策略。
    • 配置驱动 的方式适用于业务流程变化频繁,需要业务人员或运营人员灵活配置流程的情况。

    在实际应用中,可以结合两者。例如,使用策略模式实现各个独立的处理逻辑,再通过配置来组合和控制这些策略的执行。

    建议步骤:

    1. 梳理业务流程:明确哪些部分是固定的,哪些部分是可变的定制化需求。

    2. 抽象共性,分离变性:将共性的流程固化,抽象可变的部分。

    3. 设计良好的接口和抽象层次:利用接口和抽象类为定制化需求提供扩展点。

    4. 使用Spring的特性:通过注解(如@Component、@Service)和依赖注入,管理策略实例,降低耦合度。

    5. 完善文档和注释:对每个策略和配置进行详细的说明,方便团队维护。

    6. 编写单元测试:确保每个策略和流程的正确性,方便后期的重构和扩展。

    参考示例代码:

    // 定义任务上下文
    public class TaskContext {
        private String taskCode;
        private Map<String, Object> params;
    
        // getters and setters
    }
    
    // 策略接口
    public interface TaskStrategy {
        void execute(TaskContext context);
    }
    
    // 策略实现
    @Service("TaskCodeExample")
    public class ExampleTaskStrategy implements TaskStrategy {
        @Override
        public void execute(TaskContext context) {
            // 实现具体的任务逻辑
        }
    }
    
    // 策略工厂
    @Service
    public class TaskStrategyFactory {
        @Autowired
        private Map<String, TaskStrategy> strategyMap;
    
        public TaskStrategy getStrategy(String taskCode) {
            TaskStrategy strategy = strategyMap.get(taskCode);
            if (strategy == null) {
                throw new IllegalArgumentException("未找到对应的任务策略");
            }
            return strategy;
        }
    }
    
    // 任务服务
    @Service
    public class TaskService {
        @Autowired
        private TaskStrategyFactory strategyFactory;
    
        public void processTask(TaskContext context) {
            TaskStrategy strategy = strategyFactory.getStrategy(context.getTaskCode());
            strategy.execute(context);
        }
    }
    

    这样,当需要新增或修改定制化需求时,只需:

    • 新增一个实现了 TaskStrategy 接口的类,使用 @Service("TaskCode") 注解,Spring 会自动管理。
    • 无需修改现有的业务逻辑代码,符合开闭原则。

    最后,确保团队成员都理解新的设计模式,并在编码时保持一致的规范,这样才能最大限度地发挥设计的优势,提高代码质量和可维护性。