activiti的成功部署之路

activiti 部署（idea）

github地址:https://github.com/houli111/test.git

---

前言

activiti简介：
Activiti项目是一项新的基于Apache许可的开源BPM平台，从基础开始构建，旨在提供支持新的BPMN 2.0标准，包括支持对象管理组（OMG），可以定义流程、执行流程并以不同方式对其实现运行。

---

注意：此项目为演示项目，前后端不分离，使用模板跳转，前端页面有部分交互缺陷

一、activiti是什么？为什么要用它？

其实就是一个工作审批流，在我们日常生活中，审批是非常常见的，比如一个简单的请假流程，首先是请假人填写请假单(activiti中的bpmn流程图)，填写完成过后提交到主管手中（部署+启动流程）然后主管开始审批（处理流程），主管审批通过后有总经理审批（处理流程），最后审批完成（流程结束）。

二、使用步骤

-演示项目页面展示

-流程部署（上传即部署）

-启动流程

-登录用户

-查看登录用户的任务，处理流程
至最后一个节点处理结束，流程完成

演示结束

---

1.idea加入actiBPM插件

2.导入activiti需要的pom依赖

代码如下（示例）：

		<dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.1.0.M6</version>
 		</dependency>
		<dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.1.0.M6</version>
        </dependency>
		<dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>6.0.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.activiti</groupId>
                    <artifactId>activiti-bpmn-model</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

3.使用actiBPM画流程图

4.设置activiti表资源

注： 建表过后需要手动创建用户表(user)添加用户

建表方法一(使用java代码不使用配置文件)：
运行代码即可建表

 @Test
    public void test01(){
    //创建一个流程成引擎对像
    ProcessEngineConfiguration conf = ProcessEngineConfiguration.
    　　　　　　　　createStandaloneInMemProcessEngineConfiguration();
    //设置数据源
    conf.setJdbcDriver("com.mysql.jdbc.Driver");
    conf.setJdbcUrl("jdbc:mysql://远程服务器ip:3306/activiti");
    conf.setJdbcUsername("root");
    conf.setJdbcPassword("数据库密码);
    
    //设置自动创建表
    conf.setDatabaseSchemaUpdate("true");
    //在创建引擎对象的时候自动创建表
    ProcessEngine processEngine = conf.buildProcessEngine();
    }

建表方法二(使用activiti.cfg.xml配置文件)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/contex http://www.springframework.org/schema/context/spring-context.xsd
						http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--数据源配置dbcp-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/activiti" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    <!--activiti单独运行的ProcessEngine配置对象(processEngineConfiguration),使用单独启动方式
        默认情况下：bean的id=processEngineConfiguration
    -->

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    <!--代表数据源-->
    <property name="dataSource" ref="dataSource"></property>


   <!-- <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti" />
    <property name="jdbcUsername" value="root" />
    <property name="jdbcPassword" value="root" />-->
    <!--代表是否生成表结构-->
    <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

5.后台处理

部署流程代码：

  @PostMapping("/deployment")
    public String deployment(@RequestParam("bpmn") MultipartFile file) throws IOException{
        //1.得到上传文件的文件名
        String fileName = file.getOriginalFilename();
        String substring = fileName.substring(0, fileName.indexOf("."));
        //2.实现流程部署
        Deployment deployment = repositoryService.createDeployment()
                .addBytes(fileName, file.getBytes()).name(substring).key(substring).deploy();
        //3.输出部署的ID
        String deploymentID = deployment.getId();
        System.out.println("======================================="+deploymentID);

        return "ablank";
    }

登录方法：controller

    @RequestMapping("/login")
    @ResponseBody
    public R login(@RequestParam String user , @RequestParam String pwd){
         login = activitiCommonProcessService.login(user, pwd);
        if(login == null ){
            return R.error("用户为空");
        }
        System.out.println("登录成功");
        return R.ok().put("data",login);
    }

启动流程代码：controller

  /**
     * 启动流程实例
     * 根据流程定义 启动一个流程实例
     * 根据流程定义的一次具体执行过程，就是一个流程实例
     * businessId  业务id  比如：请假流程的业务id就是具体人的请假的单号
     * permissionUserIds 下一步执行人  可以提前注入，也可以每一步的时候在判断，(提前注入的话下一步只能注入的人才可以操作)
     */
    @GetMapping("/startProcessInstance")
    @ResponseBody
   public WebResult startProcessInstance(@RequestParam String processDefinitionKey,
                                          @RequestParam String businessId,@RequestParam String permissionUserIds) {
        ActHiProcinst actHiProcinst = activitiProcessService.startProcessInstance(processDefinitionKey, businessId, permissionUserIds);
        return WebResult.success().withData(actHiProcinst);
    }

启动流程代码：activitiProcessService

  /**
     * 启动一个实例
     */
    @Override
    public ActHiProcinst startProcessInstance(String processDefinitionKey, String businessId, String permissionUserIds) {
        Map<String,Object> map = new HashMap<>();// map 提前注入下一步处理人流程信息
        map.put("businessId",businessId);
        map.put("user",permissionUserIds);
        return commonProcessService.startProcessInstance(processDefinitionKey,map);
    }

启动流程代码：commonProcessService

  @Override
    public ActHiProcinst startProcessInstance(String processDefinitionKey, Map<String, Object> variables) {
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);
        ActHiProcinst procinst = new ActHiProcinst();
        procinst.setProcDefId(processInstance.getProcessDefinitionId());
        procinst.setProcInstId(processInstance.getProcessInstanceId());
        procinst.setTenantId(processInstance.getTenantId());
        return procinst;
    }

查询全部流程

   // 查询全部流程
    @RequestMapping("/search-Process")
    public String search(Model model){
        //1.查询流程定义信息
        //得到流程定义的查询器
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        List<ProcessDefinition> list = processDefinitionQuery.list();
        //2.将查询结果放入model中
        model.addAttribute("list",list);
        System.out.println("================="+list.size());
        //3.跳转页面
        return "searchProcess";
    }

查询当前登录用户的任务列表 ：controller

    //16.13.   查询任务
    @RequestMapping("/queryTaskByWorkId")
    public String  queryTaskByWorkId(String user, Model model){

        Preconditions.checkNotNull(user,"workId can not be null");
        List<Task> list = commonProcessService.taskQueryByWorkId(user);
        model.addAttribute("list",list);
        System.out.println("========你还有"+list.size()+"个任务需处理");

        return "disposeProcess";
    }

查询当前登录用户的任务列表：commonProcessService

    /**
     * 查询用户的任务列表
     */
    @Override
    public List<Task> taskQueryByWorkId( String workId) {

        TaskQuery taskQuery = taskService.createTaskQuery();
     List<Task> list = taskQuery.taskAssignee(workId).list();
//        }
        //查询当前代理人要执行的任务
        for (int i = 0; i < list.size(); i++) {
            Task task = list.get(i);
            System.out.println("任务id：" + task.getId());
            System.out.println("任务名称：" + task.getName());
            System.out.println("任务执行人：" + task.getAssignee());
        }
        return list;

    }

删除流程

    @RequestMapping("/deleteDeployment")
    public String deleteDeployment(String deploymentId){
        //1.调用repositoryService的方法，实现删除操作
        repositoryService.deleteDeployment(deploymentId,true);

        //2.跳页面
        return "forward:search-Process";
    }

处理任务流程：controller

        //任务处理 组任务 通过nodeCode做验证，防止同一任务 多人重复点击
    @PostMapping("/confirmNodeProcess")
    //http://localhost:9020/activiti/prdocess/confirmNodeProcess
    @ResponseBody
    public void confirmNodeProcess(@RequestBody ParamVO paramVO) throws Exception{

        activitiProcessService.confirmNodeProcess(paramVO.getWorkId(), paramVO.getNodeCode(), paramVO.getProcessInstanceId(), paramVO.getParamMap());
//        return WebResult.success();
    }

处理任务流程：activitiProcessService
注：bpmn中的agree由前端button点击传入

  //16.16.   任务处理 组任务 通过nodeCode做验证，防止同一任务 多人重复点击
    @Override
    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    public boolean confirmNodeProcess(String workId,String nodeCode, String processInstanceId, Map<String, Object> paramMap) throws Exception{
        Preconditions.checkNotNull(workId, "workId can not be null");
        Preconditions.checkNotNull(nodeCode,"nodeCode can not be null");
        Preconditions.checkNotNull(processInstanceId, "processInstanceId can not be null");
        //Preconditions.checkNotNull(paramMap, "paramMap can not be null");
        List<Task> taskList = taskService.createTaskQuery().processInstanceId(processInstanceId).list();
        List<Task> tasks = taskList.stream().filter(task -> nodeCode.equals(task.getName())).collect(Collectors.toList());

//        paramMap.put("agree","true"); //
        if (CollectionUtils.isEmpty(tasks)){
            throw new Exception("任务进度不匹配");
        }
        for (Task task : tasks){
            String taskId = task.getId();
            //taskService.addComment(taskId,processInstanceId ,nodeCode );
            //处理任务
            commonProcessService.doTask(workId,taskId,paramMap);
        }
        return true;
    }

以上为activiti的主要配置，下面是前后端的交互方法

---

# 总结 以上就是今天要讲的内容，本文仅仅简单介绍了activiti的使用，而activiti提供了大量service能使我们快速便捷地处理流程。