我现在项目开发中碰到一个问题,现在的整个业务流程是,每个客户都会创建多个任务(问卷调研),但是在整体的业务流程上,每个任务都会有一些定制需求,现在是硬编码,当任务 code…
- User
我现在项目开发中碰到一个问题,现在的整个业务流程是,每个客户都会创建多个任务(问卷调研),但是在整体的业务流程上,每个任务都会有一些定制需求,现在是硬编码,当任务 code 等于某个任务的时候,执行相应的流程,如何优雅的解决这个问题,保证每个定制需求尽可能的独立,整体的结构和流程清晰,项目使用的 springboot+MySQL+redis
- Assistant
在项目开发中,当遇到不同的任务需要执行不同的定制化流程时,直接使用硬编码(如
if或switch语句判断任务代码)会导致代码臃肿,难以维护和扩展。为了优雅地解决这个问题,保持代码的清晰性和可扩展性,可以考虑以下几种设计模式和技术方案:1. 策略模式(Strategy Pattern)
概念: 策略模式定义了一系列的算法,将每个算法封装起来,并使它们可以相互替换。策略模式让算法独立于使用它的客户端变化。
应用步骤:
-
定义策略接口:创建一个接口,定义所有任务共同的方法。
public interface TaskStrategy { void execute(); } -
实现具体策略类:针对不同的任务代码,实现不同的策略类。
@Service("TaskCodeA") public class TaskCodeAStrategy implements TaskStrategy { @Override public void execute() { // 任务代码为A的具体实现 } } @Service("TaskCodeB") public class TaskCodeBStrategy implements TaskStrategy { @Override public void execute() { // 任务代码为B的具体实现 } } -
创建策略工厂或使用Spring的依赖注入:
使用Spring的
ApplicationContext或@Autowired注入所有策略,实现按名称获取策略实例。@Service public class TaskStrategyFactory { @Autowired private ApplicationContext applicationContext; public TaskStrategy getStrategy(String taskCode) { return (TaskStrategy) applicationContext.getBean(taskCode); } } -
在业务逻辑中使用策略:
@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)
如果一个任务可能需要按顺序执行多个定制化步骤,可以采用责任链模式。
步骤:
-
定义处理器接口:
public interface TaskHandler { void setNextHandler(TaskHandler handler); void handle(TaskContext context); } -
实现具体处理器:
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); } } } -
构建责任链并执行:
public void processTask(TaskContext context) { TaskHandler handlerA = new ConcreteHandlerA(); TaskHandler handlerB = new ConcreteHandlerB(); handlerA.setNextHandler(handlerB); handlerA.handle(context); }
优点:
- 动态组合处理器,灵活控制处理流程。
- 各处理器职责单一,符合单一职责原则。
4. 使用配置驱动(数据驱动)
将任务的定制化需求抽象为配置,存储在数据库或配置文件中,通过读取配置来控制流程。
步骤:
-
设计配置结构:定义任务配置,包括需要执行的步骤、参数等。
{ "taskCode": "TaskCodeA", "steps": [ {"stepName": "step1", "params": {...}}, {"stepName": "step2", "params": {...}} ] } -
开发通用的任务执行引擎:
public class TaskExecutor { public void execute(TaskConfig config) { for (StepConfig step : config.getSteps()) { // 根据stepName获取对应的处理器 TaskStepHandler handler = getHandlerByName(step.getStepName()); handler.execute(step.getParams()); } } } -
实现各步骤处理器:
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)
允许在运行时加载和执行脚本,定制化需求以脚本形式存在。
步骤:
-
编写脚本:将定制需求写成脚本,存储在数据库或文件系统中。
-
使用脚本引擎执行:
ScriptEngine engine = new ScriptEngineManager().getEngineByName("groovy"); engine.eval(scriptContent);
优点:
- 动态执行代码,灵活性高。
- 无需重新部署应用即可更新定制逻辑。
缺点:
- 调试和维护较为困难。
- 需要处理脚本的安全性。
总结
基于您的需求,推荐使用 策略模式 或 配置驱动 的方式。
- 策略模式 适用于定制化需求明确且数量相对固定的情况,便于维护和扩展新的策略。
- 配置驱动 的方式适用于业务流程变化频繁,需要业务人员或运营人员灵活配置流程的情况。
在实际应用中,可以结合两者。例如,使用策略模式实现各个独立的处理逻辑,再通过配置来组合和控制这些策略的执行。
建议步骤:
-
梳理业务流程:明确哪些部分是固定的,哪些部分是可变的定制化需求。
-
抽象共性,分离变性:将共性的流程固化,抽象可变的部分。
-
设计良好的接口和抽象层次:利用接口和抽象类为定制化需求提供扩展点。
-
使用Spring的特性:通过注解(如
@Component、@Service)和依赖注入,管理策略实例,降低耦合度。 -
完善文档和注释:对每个策略和配置进行详细的说明,方便团队维护。
-
编写单元测试:确保每个策略和流程的正确性,方便后期的重构和扩展。
参考示例代码:
// 定义任务上下文 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 会自动管理。 - 无需修改现有的业务逻辑代码,符合开闭原则。
最后,确保团队成员都理解新的设计模式,并在编码时保持一致的规范,这样才能最大限度地发挥设计的优势,提高代码质量和可维护性。
-