activiti 连线、指定处理人、网关、监听、任务类型

2023-12-29 13:25:52

activiti 连线

https://blog.csdn.net/oChangWen/article/details/51910929



import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.activiti.engine.HistoryService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.IdentityLink;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author zcy
 * @version 2019/9/21
 *          Created by zcy on 2019/9/21.
 */
@RestController
@RequestMapping("/study")
@Api("study")
public class StudyController {

    @Autowired
    private RepositoryService repositoryService;
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;

    @Autowired
    private HistoryService historyService;

    private static String processDefindKey= "mySecondProcess";
    @ApiOperation("启动实例")
    @GetMapping("startProcess")
    public void startProcess(){
        System.out.println("启动实例");
        //设置提交人变量
        Map paramMap = new HashMap<>();
        paramMap.put("submituser","王小宝");

        runtimeService.startProcessInstanceByKey(processDefindKey,paramMap);

    }

    @ApiOperation("完成提交任务")
    @GetMapping("submitTaskProcess")
    public void  submitTaskProcess(){
        System.out.println("完成提交任务");
        String taskId = "50028";
        Map paramMap = new HashMap();
        //连线的判断条件
        paramMap.put("leaveDay",4);
        //设置变量
        taskService.setVariable(taskId,"manerUsers","小A,小B,小C,小D");
        taskService.complete(taskId,paramMap);


    }


    @ApiOperation("指派其他人员处理")
    @GetMapping("assignUser")
    public void  assignUser(){
        System.out.println("指派其他人员处理");
        String taskId = "50033";
        //删除指派人
        taskService.deleteCandidateUser(taskId,"小A");
        //指定其他小E处理
        taskService.addCandidateUser(taskId,"小E");
        //chian 就变成单个人，不是组了。以前的组就没有了
        //taskService.claim(taskId,"小K");

    }
    @ApiOperation("经理审批")
    @GetMapping("mangerTaskProcess")
    public void  mangerTaskProcess(){
        System.out.println("经理审批");
        String taskId = "50004";
        taskService.complete(taskId);
    }

}

指定处理人

https://blog.csdn.net/oChangWen/article/details/52504210

3-1.个人任务--分配个人任务方式一（直接指定办理人）

1：流程图中任务节点的配置

3-2.分配个人任务方式二（使用流程变量）

 @ApiOperation("启动实例")
    @GetMapping("startProcess")
    public void startProcess(){
        System.out.println("启动实例");
        Map paramMap = new HashMap<>();
        paramMap.put("submituser","王小宝");

        runtimeService.startProcessInstanceByKey(processDefindKey,paramMap);

    }

3-3.分配个人任务方式三（使用类）

assgin 不要配置，在listener 里面设置

@Service("secondListenr")
public class SecondListner implements TaskListener{
    @Override
    public void notify(DelegateTask delegateTask) {
        System.out.println("-----SecondListner--- "+delegateTask.getId());
        delegateTask.setAssignee("王二宝");
    }
}

查人指派人的任务

    List<Task> taskList2 = taskService.createTaskQuery().taskAssignee("王小宝").list();
        for (Task task : taskList2) {
            System.out.println("taskname:" + task.getName() + " taskId:" + task.getId() + " assgin:" + task.getAssignee());

        }

总结
个人任务及三种分配方式：
    1：在taskProcess.bpmn中直接写 assignee=“张三丰"
    2：在taskProcess.bpmn中写 assignee=“#{userID}”，变量的值要是String的。
         使用流程变量指定办理人
    3，使用TaskListener接口，要使类实现该接口，在类中定义：
         delegateTask.setAssignee(assignee);// 指定个人任务的办理人

3-4、分配组任务方式一（直接指定办理人）

3-5、分配个人任务方式二（使用流程变量）

    @ApiOperation("完成提交任务")
    @GetMapping("submitTaskProcess")
    public void  submitTaskProcess(){
        System.out.println("完成提交任务");
        String taskId = "50028";
        Map paramMap = new HashMap();
        paramMap.put("leaveDay",4);
        // 设置组人员 变量
        taskService.setVariable(taskId,"manerUsers","小A,小B,小C,小D");
        taskService.complete(taskId,paramMap);

    }

3-6.分配个人任务方式三（使用类）

@Service("thirdLister")
public class TaskListenerImpl implements TaskListener {
 
	/**用来指定任务的办理人*/
	@Override
	public void notify(DelegateTask delegateTask) {
		//指定个人任务的办理人，也可以指定组任务的办理人
		//个人任务：通过类去查询数据库，将下一个任务的办理人查询获取，然后通过setAssignee()的方法指定任务的办理人
		//delegateTask.setAssignee("灭绝师太");
		//组任务：
		delegateTask.addCandidateUser("郭靖");
		delegateTask.addCandidateUser("黄蓉");
	}

指定组人员的查询任务：

 @ApiOperation("查询任务:指定人")
    @GetMapping("queryTaskByAssgin")
    public void  queryTaskByAssgin() {
        System.out.println("查询任务:指定人");
//组人员的任务查询
        List<Task> taskList = taskService.createTaskQuery().taskCandidateUser("小D").list();
        System.out.println("-----------------1");
        for (Task task : taskList) {
            System.out.println("taskname:" + task.getName() + " taskId:" + task.getId() + " assgin:" + task.getAssignee());

        }
        System.out.println("-----------------2");
//单个人任务查询
        List<Task> taskList2 = taskService.createTaskQuery().taskAssignee("小D").list();
        for (Task task : taskList2) {
            System.out.println("taskname:" + task.getName() + " taskId:" + task.getId() + " assgin:" + task.getAssignee());

        }
    }

任务获取组人员：

@ApiOperation("查询任务:指定流程实例")
    @GetMapping("queryTask")
    public void  queryTask(){
        List<Task> taskList = taskService.createTaskQuery().processInstanceId("50023").list();
        for(Task task : taskList){
            System.out.println("taskname:"+task.getName()+" taskId:"+task.getId()+" assgin:"+task.getAssignee());
            List<IdentityLink> list = taskService
                    .getIdentityLinksForTask(task.getId());
            if(list!=null && list.size()>0){
                for(IdentityLink identityLink:list){
                    System.out.println(identityLink.getTaskId()+"   "+identityLink.getType()+"   "+identityLink.getProcessInstanceId()+"   "+identityLink.getUserId());
                }
            }

        }
    }

查找历史的任务的组人员

public void findHistoryPersonTask(){
		//流程实例ID
		String processInstanceId = "6201";
		List<HistoricIdentityLink> list = processEngine.getHistoryService()//
						.getHistoricIdentityLinksForProcessInstance(processInstanceId);
		if(list!=null && list.size()>0){
			for(HistoricIdentityLink identityLink:list){
				System.out.println(identityLink.getTaskId()+"   "+identityLink.getType()+"   "+identityLink.getProcessInstanceId()+"   "+identityLink.getUserId());
			}
		}
	}

组人员的任务指派给个人

public void claim(){
		//将组任务分配给个人任务
		//任务ID
		String taskId = "7204";
		//分配的个人任务（可以是组任务中的成员，也可以是非组任务的成员）
		String userId = "小D";
		processEngine.getTaskService()//
					.claim(taskId, userId);
	}


这样查询任务就是：taskService.createTaskQuery().taskAssignee("小D").list()
而之前查询：taskService.createTaskQuery().taskCandidateUser("小D").list()

将个人任务回退到组任务，前提，之前一定是个组任务

public void setAssigee(){
		//任务ID
		String taskId = "6204";
		processEngine.getTaskService()//
					.setAssignee(taskId, null);
	}

向组任务中添加成员

public void addGroupUser(){
		//任务ID
		String taskId = "6204";
		//成员办理人
		String userId = "大H";
		processEngine.getTaskService()//
					.addCandidateUser(taskId, userId);
	}

从组任务中删除成员

public void deleteGroupUser(){
		//任务ID
		String taskId = "6204";
		//成员办理人
		String userId = "小B";
		processEngine.getTaskService()//
					.deleteCandidateUser(taskId, userId);
	}

1：在taskProcess.bpmn中直接写 candidate-users=“小A,小B,小C,小D"
  2：在taskProcess.bpmn中写 candidate-users =“#{userIDs}”，变量的值要是String的。
    使用流程变量指定办理人
      Map<String, Object> variables = new HashMap<String, Object>();
      variables.put("userIDs", "大大,小小,中中");
  3，使用TaskListener接口，使用类实现该接口，在类中定义：
     //添加组任务的用户
    delegateTask.addCandidateUser(userId1);
    delegateTask.addCandidateUser(userId2);
组任务分配给个人任务（认领任务）：
    processEngine.getTaskService().claim(taskId, userId);
个人任务分配给组任务：
    processEngine.getTaskService(). setAssignee(taskId, null);
向组任务添加人员：
    processEngine.getTaskService().addCandidateUser(taskId, userId);
向组任务删除人员：
    processEngine.getTaskService().deleteCandidateUser(taskId, userId);

个人任务和组任务存放办理人对应的表：
act_ru_identitylink表存放任务的办理人，包括个人任务和组任务，表示正在执行的任务
act_hi_identitylink表存放任务的办理人，包括个人任务和组任务，表示历史任务
区别在于：如果是个人任务TYPE的类型表示participant（参与者）
如果是组任务TYPE的类型表示candidate（候选者）和participant（参与者）

网关

https://blog.csdn.net/oChangWen/article/details/52504062

监听、任务类型

任务类型中有几种类型，我选user task 和 service task 介绍

一般流程都选user task 里面需要设置assgin等，也可以设置listener。需要执行complete 才可以完成任务，执行下一个节点。

service task，不需要complete，就会执行。例如：第一个是user task 1执行完complte后，后面跟着service task2 在更正user task3。会执行完service task2后，创建user task3，等待user task3 执行

service task 使用 express 的使用：

新建Service接口和实现类
public interface ResumeService {
    void storeResume();
}

@Service("resumeService")
public class ResumeServiceImpl implements ResumeService {
    @Override
    public void storeResume() {
        System.out.println("任务已经执行.....................................");
    }
}

监听器listener

https://msd.misuland.com/pd/3255817997595449232

监听器分为三种：JavaDelegate TaskListener ExecutionListener

用户任务（UserTask）的监听器为TaskListener

Java服务任务（Service Task）的监听器为JavaDelegate

其他的服务的监听器为ExecutionListener

TaskListener中参数（DelegateTask）是有关于userTask的

JavaDelegate和ExecutionListener参数（DelegateExecution）是有关于流程的

使用监听器的方式有三种：

1.直接是用class的方式，如下标签

activiti:class="org.activiti.examples.bpmn.servicetask.ToUpperCaseFieldInjected"

class ToUpperCaseFieldInjected implment TaskListener



2.用expression的方式（这种方式还没有试验过，之后补充）

<activiti:expression>${genderBean.getGenderString(gender)}</activiti:expression>
@Service("genderBean")
class GenderBean implment TaskListener {
   public void getGenderString(String gender){

   }
}

3.用delegateExpression的方式

activiti:delegateExpression="${someJavaDelegateBean}"
@Service("someJavaDelegateBean")
class SomeJavaDelegateBeanimplment TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        System.out.println("--FiveListner--notify  taskId:"+delegateTask.getId()+"  assin:"+delegateTask.getAssignee());

    }
}

这种方式是利用bean进行查找类的，someJavaDelegateBean是bean，比如现在项目都是由spring管理的，可以在监听器的类上直接加上@Service("someJavaDelegateBean")；

利用这种方式可以和spring进行无缝对接，也解决自定义的service无法注入的问题。第一种方式是服务自定注入自定义service的；@Autowired

以上的implment 都是 TaskListener。那是因为是user task，如果换成 Service Task）的 implment JavaDelegate

其实这个在画图时候，就有提示：

码农公寓

activiti 连线

指定处理人

网关

监听、任务类型

service task 使用 express 的使用：

监听器listener

相关文章