activiti--操作例子

package com.example;

import java.io.Reader;
import java.io.StringReader;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;

import org.activiti.bpmn.converter.BpmnXMLConverter;
import org.activiti.bpmn.model.BpmnModel;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.repository.ProcessDefinitionQuery;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.IdentityLink;
import org.activiti.engine.task.Task;
import org.junit.Before;
import org.junit.Test;

/**
 * 测试流程
 * @author 20150205
 *
 */
public class TestActiviti {
    
    /**
     *  RepositoryService 管理流程定义 
        RuntimeService 执行管理，包括启动、推进、删除流程实例等操作 
        TaskService 任务管理 
        HistoryService 历史管理(执行完的数据的管理) 
        IdentityService 组织机构管理 
        FormService 一个可选服务，任务表单管理 
     */
    
    /**
     * 
     */
    
    ProcessEngine processEngine = null;
    RepositoryService repositoryService = null;
    RuntimeService runtimeService = null;
    TaskService taskService = null;

    @Before
    public void init() {
        //加载spring配置文件，创建 ProcessEngine
        processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")
                .buildProcessEngine();
        repositoryService = processEngine.getRepositoryService();
        runtimeService = processEngine.getRuntimeService();
        taskService = processEngine.getTaskService();
    }


    /**
     * 部署流程定义加载test.bpmn文件
     */
    @Test
    public void deploy(){
        Deployment deployment  = repositoryService.createDeployment()
                .addClasspathResource("diagrams/qingjia.bpmn")
                .name("请假流程")
                .category("办公类别")
                //.tenantId("租户1")
                .deploy();
        String id = deployment.getId();
        
        //级联删除，不管流程是否启动
        //repositoryService.deleteDeployment(id, true);
        
        System.out.println("***************部署流程定义完成***************" + id);
    }
    
    public void deployStr() throws Exception {
        XMLInputFactory factory = XMLInputFactory.newFactory();
        Reader reader = new StringReader("bpmnxml字符串");
        XMLStreamReader streamReader = factory.createXMLStreamReader(reader);
        BpmnXMLConverter converter = new BpmnXMLConverter();
        BpmnModel bpmnModel = converter.convertToBpmnModel(streamReader);
        Deployment deployment = repositoryService.createDeployment()//创建Deployment对象
                .name("")
                .category("")
                .tenantId("000000")
                .addBpmnModel("", bpmnModel)
                .deploy();//部署
        
        
      //字符串  
//        String text = "<?xml version="1.0" encoding="UTF-8"?><definitions>...</definitions>";           
//          
//         deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service  
//                        .createDeployment()//创建部署对象  
//                        .addString("helloworld.bpmn",text)                    
//                        .deploy();//完成部署  
    }
    
    @Test
    public void selectP() {
        //获取到流程查询对象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        //查询所有流程定义
        List<ProcessDefinition> list = processDefinitionQuery.list();
        //查询所有流程定义最新的流程，最新的版本
        Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();
        
        List<ProcessDefinition> list1 = repositoryService.createProcessDefinitionQuery().orderByProcessDefinitionVersion().asc().list();
        for (ProcessDefinition processDefinition : list1) {
            //留最新的key
            map.put(processDefinition.getKey(), processDefinition);
        }
        System.out.println("查询流程模板");
        
        
    }
    
    
    //查询正在执行的流程实例，判断流程是否结束
    public void selectProcessInstance() {
        ProcessInstance singleResult = runtimeService.createProcessInstanceQuery()
                .processInstanceId("processInstanceId")
                .singleResult();
        if(singleResult==null) {
            //流程已结束
        }
        
    }
    
    

    /**
     * 启动一个请假流程
     */
    @Test
    public void start() {
        for(int i = 0 ; i < 1; i++){
            //根据KEY默认安装流程版本启动流程
            String processId = runtimeService.startProcessInstanceByKey("qingjiaid").getId();
            System.out.println("***************启动第" + i + "个请假流程完成***************" + processId);
        }
        
        //流程执行对象表act_ru_execution
        //一个流程只有一个流程实例
        //多个流程对象对应一个流程示例，比如流程中有分支和聚合
        
        
    }
    
    /**
     * 设置流程变量和任务变量
     * 
     */
    
    
    @Test
    public void setVariable() {
        //runtimeService.setVariables(executionId, variables);
        //taskService.setVariables(taskId, variables);
        //启动流程时设置流程变量
        //runtimeService.startProcessInstanceByKey(processDefinitionKey, variables)
        //taskService.complete(taskId, variables);
        Map<String, Object> variables = new HashMap<String, Object>();
        //可以覆盖，覆盖修改
        variables.put("请假天数", 4);
        variables.put("请假原因","事假");
        taskService.setVariables("2504", variables);
        //存放对象时，对象必须序列化并且不能修改，否者反序列化时会出错，比如保存变量后，对象添加一个新属性，解决：必须有一个序列化版本ID
        //taskService.setVariableLocal("taskId", "variableName", new Person());
        //Local  是和任务ID关联，当前任务结束后，act_ru_variable表就不存在了，下一个任务获取不到了，历史表里有act_hi_varinst
        //taskService.setVariablesLocal(taskId, variables);
        System.out.println("设置任务变量");
        
        Map<String, Object> variables1 = taskService.getVariables("2504");
        System.out.println("获取任务变量"+variables1.toString());
        
        Map<String, Object> variables2 = runtimeService.getVariables("2501");
        System.out.println("获取流程变量"+variables2.toString());
        
        
        //历史流程变量
//        List<HistoricVariableInstance> list = processEngine.getHistoryService()//
//            .createHistoricVariableInstanceQuery() // 创建一个历史的流程变量查询对象
//            .variableName("请假天数").list();
    }
    
    //查询具体任务
    @Test
    public void selectTask() {
        List<Task> tasks = taskService.createTaskQuery().taskAssignee("张三").list();
        for (Task task : tasks) {
            System.out.println("" + task.getName() + ",id:" + task.getId());//任务的name与id
            System.out.println(task.getAssignee());//任务拥有者
            System.out.println(task.getProcessInstanceId());//流程实例id
            System.out.println(task.getProcessDefinitionId());//流程定义id
            taskService.complete(task.getId());//完成任务
        }
    }
    
    /**
     * 查询组任务
     */
    @Test
    public void selectGroupTask() {
        //act_ru_identitylink
        //TYPE_    participant个人任务，组任务
        //candidate  张三,李四
        List<Task> tasks = taskService.createTaskQuery().taskCandidateUser("张三").list();
        
        //查询正在执行任务办理人
        List<IdentityLink> IdentityLinks = taskService.getIdentityLinksForTask("taskId");
        for (IdentityLink identityLink : IdentityLinks) {
            //identityLink.getUserId()
            //identityLink.getType()
            System.out.println();
        }
        //将组任务分配给某个人(可以是组内的人，也可以不是)
        //拾取任务
        //taskService.claim("taskId", "userId");
        //将个人任务回退到组任务，前提，之前也是一个组任务
        //taskService.setAssignee("taskId", null);
        //向组任务中添加成员
        //taskService.addCandidateUser("taskId", "userId");
        //taskService.deleteCandidateUser("taskId", "userId");
    
    }


    
}