Activity 流程图 应用 SpringBoot 中

1.创建一个 Springboot 项目：https://start.spring.io/

POM 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.3.4.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.activity</groupId>
	<artifactId>activityDemo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>activityDemo</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>11</java.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	    <maven.compiler.source>1.7</maven.compiler.source>
	    <maven.compiler.target>1.7</maven.compiler.target>
	    <activiti.version>6.0.0</activiti.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Srping boot 引用 -->
		<dependency>
			<groupId>org.activiti</groupId>
			<artifactId>activiti-spring-boot-starter-basic</artifactId>
			<version>6.0.0</version>
		</dependency>
<!--  Spring mvc 引用
	<dependency>
       <groupId>org.activiti</groupId>
       <artifactId>activiti-engine</artifactId>
       <version>${activiti.version}</version>
   </dependency>
    
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    
 -->

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
    </dependency>
    
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    
    <!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.8.2</version>
    </dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

导入eclipse

配置数据库连接

server:
  port: 8096
spring:
  datasource:
    jdbc-url: jdbc:mysql://localhost:3306/activity?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
    username: root
    password: root
activiti:
  database-schema-update: true
  process-definition-location-prefix: "classpath*:/processes/*.bpmn"
  history-level: full
  db-history-used: true #配置生成history表,默认false,只会生成17张表

创建 activiti.cfg.xml文件 主要是 <property name="databaseSchemaUpdate" value="true"/>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
 
 
    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activity?useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=UTC&amp;useSSL=false"/>
        <property name="jdbcUsername" value="root"/>
        <property name="jdbcPassword" value="root"/>
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

创建 main 方法 运行：

package com.activity.activityDemo;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;

/**
 * @author LZHH_2008
 * @time   2020年10月29日下午5:19:08
 */
public class GenerateActivityTable {

	 public static void main( String[] args )
	    {
	        ProcessEngine pengine = ProcessEngines.getDefaultProcessEngine();
	        RepositoryService repService = pengine.getRepositoryService();
	        RuntimeService runService = pengine.getRuntimeService();
	        TaskService taskService = pengine.getTaskService();
	        pengine.close();
	        System.out.println("generate success");
	        
	        
	    }
}

数据库中会生成 28张表

2. Eclipse 按照activity 插件，我这边已经安装过。

 在source下面建processes文件夹：新建流程图文件

画流程图

3. Spring boot 启动类

package com.activity.activityDemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.ComponentScan;

import org.activiti.spring.boot.SecurityAutoConfiguration;

@SpringBootApplication(exclude = SecurityAutoConfiguration.class) 
public class ActivityDemoApplication { 
	

	public static void main(String[] args) {
		SpringApplication.run(ActivityDemoApplication.class, args);
	}

}

配置类：

package com.activity.activityDemo;

import java.io.IOException;

import javax.sql.DataSource;

import org.activiti.spring.SpringAsyncExecutor;
import org.activiti.spring.SpringProcessEngineConfiguration;
import org.activiti.spring.boot.AbstractProcessEngineAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.transaction.PlatformTransactionManager;

/**为activiti配置独立的数据源
 * @author LZHH_2008
 * @time   2020年10月30日上午11:29:57
 */
@Configuration
public class ActivitiConfig extends AbstractProcessEngineAutoConfiguration {
 
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource activitiDataSource() {
        return DataSourceBuilder.create().build();
    }
    @Bean
    public SpringProcessEngineConfiguration springProcessEngineConfiguration(
            PlatformTransactionManager transactionManager,
            SpringAsyncExecutor springAsyncExecutor) throws IOException {
 
        return baseSpringProcessEngineConfiguration(
                activitiDataSource(),
                transactionManager,
                springAsyncExecutor);
    	}
}

 

Controller

package com.activity.activityDemo.controller;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.activity.activityDemo.service.ActivitiService;

//import lombok.extern.slf4j.Slf4j;

/**
 * @author LZHH_2008
 * @time   2020年10月29日下午6:13:48
 */
@RestController
@RequestMapping("/activity")
//@Slf4j
public class ActivityController {
	@Autowired
	private ActivitiService activitiService;
	
	/**
	 * 请假申请
	 *
	 *
	 * Object
	 * @param applyDays  请假天数
	 * @return
	 */
    @GetMapping("/apply/{applyDays}")
    public Object getCatalogTree(@PathVariable("applyDays") String applyDays) {
	  //启动流程
      Map<String, String> parameters = new HashMap<>(8);
      if(applyDays != null && Integer.parseInt(applyDays) >3){
    	  parameters.put("result", "2");
      }else{
    	  parameters.put("result", "1");
      }
      
      String wfdName = "apply01";
      String processInstanceId = activitiService.startWorkflow(wfdName, "apply", parameters);
      System.out.println("启动流程成功，流程ID=" + processInstanceId);
      return processInstanceId;
    }
    
    @GetMapping("/approve/{taskId}")
    //public Object complete(String taskId, String userId, String approve, Integer result) {
    public Object complete(@PathVariable("taskId") String taskId) {
        Map<String, Object> params = new HashMap<String, Object>(8);
        params.put("result", "1");
        params.put("userId", "aa");
        params.put("approveRole", "approve");
        activitiService.continueWorkflow(taskId, params);
        return "SUCCESS";
    }

    @RequestMapping(value = "/view-process-img", method = RequestMethod.GET)
    public void viewProcessImg(String processId, HttpServletResponse response) throws IOException {
    	activitiService.getProcessImage(processId, response);
    }
}

 

service

package com.activity.activityDemo.service;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;

import org.activiti.bpmn.model.BpmnModel;
import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.image.ProcessDiagramGenerator;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StreamUtils;


/**
 * @author LZHH_2008
 * @time 2020年10月29日下午6:02:33
 */
@Service
public class ActivitiService {

    @Autowired
    protected RepositoryService repositoryService;

    @Autowired
    protected RuntimeService runtimeService;

    @Autowired
    protected FormService formService;

    @Autowired
    protected TaskService taskService;

    @Autowired
    protected ManagementService managementService;
    @Autowired
    private HistoryService historyService;
    
    

    public String startWorkflow(String wfdName, String businessKey, Map param) {
        ProcessInstance process = null;
        ProcessDefinition processDef = getLatestProcDef(wfdName);
        if (processDef != null) {
            process = runtimeService.startProcessInstanceById(processDef.getId(), businessKey, param);
        }
        return process == null ? "" : process.getId();
    }

    public ProcessDefinition getLatestProcDef(String modelName) {
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().processDefinitionKey(modelName)
                .latestVersion().list();
        ProcessDefinition processDefinition = list.iterator().next();
        return processDefinition;
    }

    public void continueWorkflow(String taskId, Map map) {
        // log.info("工作流处理开始, 任务Id：" + taskId);
        taskService.setVariables(taskId, map);
        String userId = "aa";
        continueWorkflow(taskId, userId);
        System.out.println("工作流处理结束，任务Id：" + taskId);
    }

    @Transactional(rollbackFor = Exception.class)
    public void continueWorkflow(String taskId, String userId) {
        taskService.claim(taskId, userId);
        taskService.setVariable(taskId, "userId", userId);
        taskService.complete(taskId);
    }

}

 

运行启动流程图：

获取流程图：

 

也可以根据自己的逻辑添加 其他流程………………

不足之处，请多指教