Spring MVC+MyBatis+Activiti工作流开发全栈指南

2026年3月4日 互联网

一、技术栈选型与架构设计

在构建企业级Java应用时，选择合适的技术栈至关重要。Spring MVC作为轻量级Web框架，提供清晰的MVC分层架构；MyBatis作为半自动ORM框架，兼具灵活性与性能优势；Activiti作为开源工作流引擎，支持BPMN 2.0标准规范。三者结合可构建出高扩展性的流程管理系统。

典型架构采用三层设计：

  1. 表现层：Spring MVC处理HTTP请求，结合Thymeleaf/FreeMarker实现视图渲染
  2. 业务层：Service组件封装核心逻辑，通过Spring事务管理保证数据一致性
  3. 数据层：MyBatis映射SQL与对象关系，Activiti引擎驱动流程流转

数据库设计需考虑三类表结构：

  • 业务数据表（如订单表）
  • 流程实例表（act_ru_execution）
  • 历史记录表（act_hi_procinst）

二、Spring MVC核心配置实践

2.1 环境搭建与依赖管理

推荐使用Maven进行依赖管理，核心配置示例：

  1. <dependencies>
  2.     <!-- Spring MVC基础 -->
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-webmvc</artifactId>
  6.         <version>5.3.20</version>
  7.     </dependency>
  9.     <!-- Servlet API -->
  10.     <dependency>
  11.         <groupId>javax.servlet</groupId>
  12.         <artifactId>javax.servlet-api</artifactId>
  13.         <version>4.0.1</version>
  14.         <scope>provided</scope>
  15.     </dependency>
  16. </dependencies>

2.2 关键组件配置

  1. DispatcherServlet配置：

    1. @Configuration
    2. public class WebConfig implements WebMvcConfigurer {
    3.  @Bean
    4.  public DispatcherServlet dispatcherServlet() {
    5.      return new DispatcherServlet();
    6.  }
    8.  @Bean
    9.  public ServletRegistrationBean<DispatcherServlet> servletRegistration() {
    10.      return new ServletRegistrationBean<>(dispatcherServlet(), "/");
    11.  }
    12. }

  2. 视图解析器配置：

    1. # application.properties
    2. spring.mvc.view.prefix=/WEB-INF/views/
    3. spring.mvc.view.suffix=.jsp

2.3 控制器开发范式

推荐使用@RestController与@RequestMapping组合：

  1. @RestController
  2. @RequestMapping("/api/orders")
  3. public class OrderController {
  5.     @Autowired
  6.     private OrderService orderService;
  8.     @GetMapping("/{id}")
  9.     public ResponseEntity<OrderDTO> getOrder(@PathVariable Long id) {
  10.         return ResponseEntity.ok(orderService.findById(id));
  11.     }
  13.     @PostMapping
  14.     public ResponseEntity<OrderDTO> createOrder(@Valid @RequestBody OrderDTO dto) {
  15.         return ResponseEntity.created(URI.create("/orders/" + orderService.save(dto).getId()))
  16.                              .body(dto);
  17.     }
  18. }

三、MyBatis持久层开发指南

3.1 基础映射配置

  1. XML映射文件示例：

    1. <mapper namespace="com.example.mapper.OrderMapper">
    2.  <select id="findById" resultType="com.example.dto.OrderDTO">
    3.      SELECT id, order_no, amount 
    4.      FROM t_order 
    5.      WHERE id = #{id}
    6.  </select>
    8.  <insert id="insert" useGeneratedKeys="true" keyProperty="id">
    9.      INSERT INTO t_order(order_no, amount)
    10.      VALUES(#{orderNo}, #{amount})
    11.  </insert>
    12. </mapper>

  2. 注解方式配置：

    1. public interface OrderMapper {
    2.  @Select("SELECT * FROM t_order WHERE id = #{id}")
    3.  OrderDTO findById(@Param("id") Long id);
    5.  @Options(useGeneratedKeys = true, keyProperty = "id")
    6.  @Insert("INSERT INTO t_order(order_no, amount) VALUES(#{orderNo}, #{amount})")
    7.  int insert(OrderDTO order);
    8. }

3.2 动态SQL高级应用

  1. 条件查询构建：

    1. <select id="findByCondition" resultType="OrderDTO">
    2.  SELECT * FROM t_order
    3.  <where>
    4.      <if test="orderNo != null">
    5.          AND order_no LIKE CONCAT('%', #{orderNo}, '%')
    6.      </if>
    7.      <if test="minAmount != null">
    8.          AND amount >= #{minAmount}
    9.      </if>
    10.  </where>
    11.  ORDER BY create_time DESC
    12. </select>

  2. 批量操作优化：

    1. @Insert({
    2.  "<script>",
    3.  "INSERT INTO t_order(order_no, amount) VALUES ",
    4.  "<foreach collection='orders' item='order' separator=','>",
    5.  "(#{order.orderNo}, #{order.amount})",
    6.  "</foreach>",
    7.  "</script>"
    8. })
    9. int batchInsert(@Param("orders") List<OrderDTO> orders);

四、Activiti工作流集成方案

4.1 流程引擎初始化

  1. @Configuration
  2. public class ActivitiConfig {
  4.     @Bean
  5.     public ProcessEngineConfiguration processEngineConfiguration() {
  6.         SpringProcessEngineConfiguration config = new SpringProcessEngineConfiguration();
  7.         config.setDataSource(dataSource());
  8.         config.setDatabaseSchemaUpdate("true");
  9.         config.setAsyncExecutorActivate(false);
  10.         return config;
  11.     }
  13.     @Bean
  14.     public ProcessEngine processEngine() {
  15.         return processEngineConfiguration().buildProcessEngine();
  16.     }
  17. }

4.2 核心流程操作

  1. 流程部署与启动：

    1. @Service
    2. public class ProcessService {
    4.  @Autowired
    5.  private RepositoryService repositoryService;
    7.  @Autowired
    8.  private RuntimeService runtimeService;
    10.  public void deployProcess(String bpmnPath) {
    11.      Deployment deployment = repositoryService.createDeployment()
    12.          .addClasspathResource(bpmnPath)
    13.          .name("订单审批流程")
    14.          .deploy();
    15.  }
    17.  public String startProcess(String processKey, Map<String, Object> variables) {
    18.      ProcessInstance instance = runtimeService.startProcessInstanceByKey(processKey, variables);
    19.      return instance.getId();
    20.  }
    21. }

  2. 任务处理逻辑：

    1. @Service
    2. public class TaskService {
    4.  @Autowired
    5.  private TaskService taskService;
    7.  public List<Task> getUserTasks(String userId) {
    8.      return taskService.createTaskQuery()
    9.          .taskAssignee(userId)
    10.          .active()
    11.          .list();
    12.  }
    14.  public void completeTask(String taskId, Map<String, Object> variables) {
    15.      taskService.complete(taskId, variables);
    16.  }
    17. }

4.3 高级流程控制

  1. 会签处理实现：
    ```java
    // 启动多实例任务
    Map variables = new HashMap<>();
    variables.put(“approvers”, Arrays.asList(“user1”, “user2”, “user3”));
    variables.put(“nrOfInstances”, 3);
    variables.put(“nrOfCompletedInstances”, 0);

// 完成时判断
runtimeService.setVariable(executionId, “nrOfCompletedInstances”,
(Integer)runtimeService.getVariable(executionId, “nrOfCompletedInstances”) + 1);

if ((Integer)runtimeService.getVariable(executionId, “nrOfCompletedInstances”) 

  1. >= (Integer)runtimeService.getVariable(executionId, "nrOfInstances")) {
  2. // 所有实例完成后的逻辑

}

  2. 2. **异常流程处理**：
  3. ```java
  4. @RestControllerAdvice
  5. public class ProcessExceptionHandler {
  7.     @ExceptionHandler(ActivitiException.class)
  8.     public ResponseEntity<ErrorResponse> handleActivitiError(ActivitiException ex) {
  9.         if (ex instanceof ActivitiObjectNotFoundException) {
  10.             return ResponseEntity.status(HttpStatus.NOT_FOUND)
  11.                 .body(new ErrorResponse("PROCESS_NOT_FOUND", ex.getMessage()));
  12.         }
  13.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
  14.             .body(new ErrorResponse("PROCESS_ERROR", ex.getMessage()));
  15.     }
  16. }

五、系统集成与最佳实践

5.1 事务管理策略

  1. 分布式事务处理：
    对于跨服务调用，推荐采用Saga模式或TCC模式。本地事务可通过@Transactional注解管理：

    1. @Service
    2. @Transactional
    3. public class OrderProcessService {
    5.  @Autowired
    6.  private OrderMapper orderMapper;
    8.  @Autowired
    9.  private RuntimeService runtimeService;
    11.  public void submitOrderWithProcess(OrderDTO order) {
    12.      // 保存业务数据
    13.      orderMapper.insert(order);
    15.      // 启动流程
    16.      Map<String, Object> variables = new HashMap<>();
    17.      variables.put("orderId", order.getId());
    18.      runtimeService.startProcessInstanceByKey("orderProcess", variables);
    19.  }
    20. }

5.2 性能优化方案

  1. 数据库优化：
  • 为Activiti的ACTRU*表建立合适索引
  • 定期归档历史数据到单独表空间
  • 使用连接池配置（如HikariCP）
  1. 异步处理策略： 
    1. @Async
    2. public CompletableFuture<Void> asyncCompleteTask(String taskId) {
    3.  try {
    4.      taskService.complete(taskId);
    5.      return CompletableFuture.completedFuture(null);
    6.  } catch (Exception e) {
    7.      return CompletableFuture.failedFuture(e);
    8.  }
    9. }

5.3 监控与运维

  1. 流程监控面板：

    1. @RestController
    2. @RequestMapping("/monitor")
    3. public class ProcessMonitorController {
    5.  @Autowired
    6.  private HistoryService historyService;
    8.  @GetMapping("/metrics")
    9.  public Map<String, Object> getProcessMetrics() {
    10.      Map<String, Object> metrics = new HashMap<>();
    11.      metrics.put("runningInstances", historyService.createHistoricProcessInstanceQuery()
    12.          .unfinished()
    13.          .count());
    14.      metrics.put("completedInstances", historyService.createHistoricProcessInstanceQuery()
    15.          .finished()
    16.          .count());
    17.      return metrics;
    18.  }
    19. }

  2. 日志集成方案：
    ```properties

    logback-spring.xml配置示例

logs/activiti.log

logs/activiti.%d{yyyy-MM-dd}.log

%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n

```

六、总结与展望

本方案通过Spring MVC、MyBatis与Activiti的深度集成，构建了可扩展的企业级工作流系统。实际开发中需注意：

  1. 版本兼容性：Spring 5.x与Activiti 6.x/7.x的适配问题
  2. 流程版本控制：采用BPMN XML文件进行版本管理
  3. 异常处理机制：建立完善的流程回滚与补偿机制

未来发展方向包括：

  • 引入规则引擎实现动态审批逻辑
  • 结合低代码平台提升流程设计效率
  • 采用微服务架构实现流程服务的独立部署

通过持续优化与技术创新，该技术栈可支撑从简单审批到复杂业务编排的各类场景需求，为企业数字化转型提供坚实的技术基础。

最新文章