##### 启动流程 #####

String formId  = request.getParameter("formId");

String procDefId  = request.getParameter("procDefId"); //流程定义ID

String objId  = new UUID; //业务数据唯一ID

String businessKey = ""; // 业务键，提交时组装

//流程变量

Map<String, String[]> flowData = new HashMap<String, String>();

//HTML表单提交数据 --〉 流程变量

flowData = request.getParameterMap();

//启动

//业务键 = 流程ID.实体实例ID;

businessKey = procDefId + "." + objId

workflowService.startProcess(procDefId,businessKey,formData);

//或启动，不存业务键

//ProcessInstance processInstance = formService.submitStartFormData(procDefId, flowData);

##### 提交任务节点 #####

//使用String[]数组是用于处理select类型的多项输入数据

String formId  = request.getParameter("formId");

String procInstId  = request.getParameter("procInstId"); //流程实例ID

Map<String, String[]> flowData = new HashMap<String, String>();

//将表单提交数据注入表单变量

flowData = request.getParameterMap();

//Task task = taskService.createTaskQuery().taskAssignee("user1").singleResult();

Task task = taskHelper.getTask(procInstId)...;

//formService.submitTaskFormData(task.getId(), formProperties);

formHelper.submitTaskFormData(task.getId(), flowData);

##### 一些帮助方法 #####

//用taskId获取业务对象id

public String getBusinessObjId(String taskId) {

        //1  获取任务对象

        Task task  =  taskService.createTaskQuery().taskId(taskId).singleResult();

        //2  通过任务对象获取流程实例

        ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();

        //3 通过流程实例获取“业务键”

        String businessKey = pi.getBusinessKey();

        //4 拆分业务键，拆分成“业务对象名称”和“业务对象ID”的数组

        // a=b  LeaveBill.1

        String objId = null;

        if(StringUtils.isNotBlank(businessKey)){

            objId = businessKey.split("\\.")[];

        }

        return objId;

    }

//根据业务键获取流程实例

public ProcessInstance getProInstByBusinessKey(String businessKey) {

    return runtimeService.createProcessInstanceQuery().processInstanceBusinessKey(businessKey).singleResult();

}

//根据业务键获取任务

public List<Task> getTasksByBusinessKey(String businessKey) {

    return taskService.createTaskQuery().processInstanceBusinessKey("LeaveBill.1").list();

}

package com.lifiti.utils;

import java.io.InputStream;

import java.util.List;

import java.util.zip.ZipInputStream;

import org.activiti.engine.RepositoryService;

import org.activiti.engine.repository.DeploymentBuilder;

import org.activiti.engine.repository.ProcessDefinition;

import org.activiti.engine.repository.ProcessDefinitionQuery;

/**

 * 仓库帮助类:用于部署\删除\察看流程

 *

 * @author wx 王昕

 *

 */

public class RepositoryHelper {

    public static final RepositoryService repositoryService = ActivitiUtils.getProcessEngine().getRepositoryService();

    public static void deploy(String xmlFile) {

        repositoryService.createDeployment().addClasspathResource(xmlFile).deploy();

    }

    /**

     *

     * @param bpmn ,比如"diagrams/Leave.bpmn"

     * @param png, 比如"diagrams/Leave.png"

     * @throws Exception

     */

    public static void deploy(String flowName,String bpmn,String png) throws Exception {

        // 创建发布配置对象

        DeploymentBuilder builder = repositoryService.createDeployment();

        // 设置发布信息

        builder.name(flowName)// 添加部署规则的显示别名

                .addClasspathResource(bpmn)// 添加规则文件

                .addClasspathResource(png);// 添加规则图片

                // 不添加会自动产生一个图片,较影响效率

        // 完成发布

        builder.deploy();

    }

    /**

     *

     * @param zipFile ,比如"diagrams/diagrams.bar"

     * @param flowName,比如"请假流程"

     * @throws Exception

     */

    public static void deployZIP(String zipFile,String flowName) throws Exception {

        // 创建发布配置对象

        DeploymentBuilder builder = repositoryService.createDeployment();

        // 获得上传文件的输入流程

        InputStream in = RepositoryHelper.class.getClassLoader().getResourceAsStream(zipFile);

        ZipInputStream zipInputStream = new ZipInputStream(in);

        // 设置发布信息

        builder.name(flowName)// 添加部署规则的显示别名

                .addZipInputStream(zipInputStream);

        // 完成发布

        builder.deploy();

    }

    public static void delDeployment(String deploymentId) throws Exception {

        // 普通删除，如果当前规则下有正在执行的流程，则抛异常

        // repositoryService.deleteDeployment(deploymentId);

        // 级联删除,会删除和当前规则相关的所有信息，包括历史

        repositoryService.deleteDeployment(deploymentId, true);

    }

    /**

     * 查看流程定义 流程定义 ProcessDefinition id : {key}:{version}:{随机值} name ：

     * 对应流程文件process节点的name属性 key ： 对应流程文件process节点的id属性 version ：

     * 发布时自动生成的。如果是第一发布的流程，veresion默认从1开始；如果当前流程引擎中已存在相同key的流程，则找到当前key对应的最高版本号，在最高版本号上加1

     */

    public static void queryProcessDefinition() throws Exception {

        // 获取流程定义查询对象

        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();

        // 配置查询对象

        processDefinitionQuery

                // 添加过滤条件

                // .processDefinitionName(processDefinitionName)

                // .processDefinitionId(processDefinitionId)

                // .processDefinitionKey(processDefinitionKey)

                // 分页条件

                // .listPage(firstResult, maxResults)

                // 排序条件

                .orderByProcessDefinitionId().desc()

                .orderByProcessDefinitionVersion().desc();

        /**

         * 执行查询 list : 执行后返回一个集合 singelResult

         * 执行后，首先检测结果长度是否为1，如果为一则返回第一条数据；如果不唯一，抛出异常 count： 统计符合条件的结果数量

         */

        List<ProcessDefinition> pds = processDefinitionQuery.list();

        // 遍历集合，查看内容

        for (ProcessDefinition pd : pds) {

            System.out.print("deploymentId:" + pd.getDeploymentId() + ",");

            System.out.print("id:" + pd.getId() + ",");

            System.out.print("name:" + pd.getName() + ",");

            System.out.print("key:" + pd.getKey() + ",");

            System.out.println("version:" + pd.getVersion());

        }

    }

    public static void delAllProcess() throws Exception {

        // 获取流程定义查询对象

        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();

        List<ProcessDefinition> pds = processDefinitionQuery.list();

        // 遍历集合，查看内容

        for (ProcessDefinition pd : pds) {

            repositoryService.deleteDeployment(pd.getDeploymentId(),true);

        }

    }

}

package com.lifiti.utils;

import java.util.List;

import javax.servlet.http.HttpSession;

import org.activiti.engine.IdentityService;

import org.activiti.engine.identity.Group;

import org.activiti.engine.identity.User;

/**

 * 认证帮助类:用户\组\角色管理

 * @author wx 王昕

 *

 */

public class IdentifyHelper {

    public static final IdentityService identityService

                        = ActivitiUtils.getProcessEngine().getIdentityService();

    private static final String USER = "ACTUSER";

    public static void saveUser(User user){

        identityService.saveUser(user);

    }    

    public static void saveUser(String userId,String name,String email){

        User user = identityService.newUser(userId);

        user.setFirstName(name);

        user.setLastName("");

        user.setEmail(email);

        user.setPassword(userId);

        identityService.saveUser(user);

    }

    public static User getUser(String userId){

        return identityService.createUserQuery().userId(userId).singleResult();

    }    

    public static String getUserInfo(String userId,String key){

        return identityService.getUserInfo(userId, key);

    }    

    public static void delUser(String userId){

        identityService.deleteUser(userId);

    }        

    public static User getUserByMail(String email){

        return identityService.createUserQuery().userEmail(email).singleResult();

    }    

    public static List<User> findUserByName(String firstNameLike){

        // 貌似有问题,慎用

        return identityService.createUserQuery().userFullNameLike(firstNameLike).list();

    }

    public static List<User> getAllUser(){

        return identityService.createUserQuery().list();

    }    

    public static void saveGroup(Group group){

        // 保存组

        identityService.saveGroup(group);

    }

    /**

     * 新建用户组

     * @param groupId

     * @param name

     * @param type 0:security-role;1:assignment

     */

    public static void saveGroup(String groupId,String name,int type){

        Group group = identityService.newGroup(groupId);

        group.setName(name);

        if (type==0){

            group.setType("security-role");

        }

        else{

            group.setType("assignment");

        }

        identityService.saveGroup(group);

    }

    public static void createMembership(String userId,String groupId){

        try {

            identityService.createMembership(userId, groupId);

        }

        catch (Exception ex ){

        }

    }

    public static void deleteMembership(String userId,String groupId){

        try {

            identityService.deleteMembership(userId, groupId);

        }

        catch (Exception ex ){

        }

    }

    /**

     * 用户所在的所有组

     * @param userId

     * @return

     */

    public static List<Group> findGroupsByuserId(String userId){

        return identityService.createGroupQuery().groupMember(userId).list();

    }

    public static void saveUserToSession(HttpSession session, User user) {

        session.setAttribute(USER, user);

    }

    public static User getUserFromSession(HttpSession session) {

        Object attribute = session.getAttribute(USER);

        return attribute == null ? null : (User) attribute;

    }

}

package com.lifiti.utils;

import java.util.List;

import org.activiti.engine.RuntimeService;

import org.activiti.engine.TaskService;

import org.activiti.engine.task.Task;

/**

 * 运行时帮助类:合并了运行时服务和任务服务的一些操作,比如启动流程\任务签收\完成任务\

 * @author wx 王昕

 *

 */

public class RuntimeHelper {

    public static final RuntimeService runtimeService = ActivitiUtils.getProcessEngine().getRuntimeService();

    public static final TaskService taskService = ActivitiUtils.getProcessEngine().getTaskService();

    public static void startProcessByKey(String processDefinitionKey){

        runtimeService.startProcessInstanceByKey(processDefinitionKey);

    }

    public static void startProcessByKey(String processDefinitionKey,String businessKey){

        runtimeService.startProcessInstanceByKey(processDefinitionKey, businessKey);

    }

    public static List<Task> findUserTasks(String userId){

        return taskService.createTaskQuery().taskCandidateUser(userId).list();

    }

    public static void setAssignee(String taskId,String userId){

        taskService.setAssignee(taskId, userId);

    }

    public static void claimAndComplete(String taskId,String userId){

        taskService.claim(taskId, userId);

        completeTask(taskId);

    }

    public static void claimTask(String taskId,String userId){

        taskService.claim(taskId, userId);

    }

    public static void completeTask(String taskId){

        taskService.complete(taskId);

    }

    public static void addCandidateGroup(String taskId,String groupId){

        taskService.addCandidateGroup(taskId, groupId);

    }

    public static void addCandidateUser(String taskId,String userId){

        taskService.addCandidateUser(taskId, userId);

    }

}

启动时要做的：

identityService.setAuthenticatedUserId(initUserId);

processInstance = runtimeService.startProcessInstanceByKey(流程ID, 业务Key, 变量map);

or

startProcessInstanceById(String processDefinitionId, String businessKey, Map variables) 

变量map定义的方法：

Map<String ,Object > variables = new HashMap<>();

variables.put("initUserId","wangxin");

variables.put("leaveReason","想休假了");

<startevent id="startevent1" name="Start" activiti:initiator="initUserId"></startevent>

<usertask id="reportBack" name="销假" activiti:assignee="${initUserId}"></usertask>

//根据业务键获取流程实例

public ProcessInstance getProInstByBusinessKey(String businessKey) {

return runtimeService.createProcessInstanceQuery().processInstanceBusinessKey("LeaveBill.1").singleResult();

}

//根据业务键获取任务

public List<Task> getTasksByBusinessKey(String businessKey) {

return taskService.createTaskQuery().processInstanceBusinessKey("LeaveBill.1").list();

}

//1、通过任务对象获取流程实例

ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();

//2、通过流程实例获取“业务键”

String businessKey = pi.getBusinessKey();

String processInstanceId="";

// 通过流程实例ID查询流程实例

ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

if(pi!=null){

System.out.println("当前流程节点在：" + pi.getActivityId());

}else{

System.out.println("流程已结束!!");

}

// 创建任务查询对象

TaskQuery taskQuery = taskService.createTaskQuery();

// 配置查询对象

String candidateUser="张三";

taskQuery

// 过滤条件

.taskCandidateUser(candidateUser)

// 排序条件

.orderByTaskCreateTime().desc();

// 执行查询

List<Task> tasks = taskQuery.list();

System.out.println("======================【"+candidateUser+"】的候选公共任务列表=================");

for (Task task : tasks) {

System.out.print("id:"+task.getId()+",");

System.out.print("name:"+task.getName()+",");

System.out.print("createTime:"+task.getCreateTime()+",");

System.out.println("assignee:"+task.getAssignee());

}

// 创建任务查询对象

TaskQuery taskQuery = taskService.createTaskQuery();

// 配置查询对象

// String assignee="user";

String assignee="李四";

taskQuery

// 过滤条件

.taskAssignee(assignee)

// 分页条件

// .listPage(firstResult, maxResults)

// 排序条件

.orderByTaskCreateTime().desc();

// 执行查询

List<Task> tasks = taskQuery.list();

System.out.println("======================【"+assignee+"】的代办任务列表=================");

for (Task task : tasks) {

System.out.print("id:"+task.getId()+",");

System.out.print("name:"+task.getName()+",");

System.out.print("createTime:"+task.getCreateTime()+",");

System.out.println("assignee:"+task.getAssignee());

}

// claim 认领

String taskId="";

String userId="李四";

// 让指定userId的用户认领指定taskId的任务

taskService.claim(taskId, userId);

String formId = request.getParameter("formId");

String procInstId = request.getParameter("procInstId"); //流程实例ID

Map<String, String[]> flowData = new HashMap<String, String[]>();

//将表单提交数据注入表单变量

flowData = request.getParameterMap();

formHelper.submitTaskFormData(request.getParameter("taskId"), flowData);

// 完成任务

taskService.complete(taskId );

<userTask id="task1" name="My task" >

<extensionElements>

<activiti:taskListener event="create" class="org.activiti.MyLeaderHandler" />

</extensionElements>

</userTask>

//动态实现任务分配

public class MyLeaderHandler implements TaskListener {

public void notify(DelegateTask delegateTask) {

LeaderService ls =....

String userLeader = ls.findLeaderbyUserId(XXXXXXX);

delegateTask.setAssignee(userLeader);

delegateTask.addCandidateUser(XXX);

delegateTask.addCandidateGroup(XXXX);

...

}

}

public class FakeLdapService {

public String findManagerForEmployee(String employee) {

return "Kermit";

}

public List<String> findAllSales() {

return Arrays.asList("kermit", "gonzo", "fozzie");

}

}

<userTask id="miTasks" name="My Task" activiti:assignee="${assignee}">

  <multiInstanceLoopCharacteristics isSequential="false"

     activiti:collection="assigneeList" activiti:elementVariable="assignee" >

    <completionCondition>${nrOfCompletedInstances/nrOfInstances >= 0.6 }</completionCondition>

  </multiInstanceLoopCharacteristics>

</userTask>

public class AssgineeMultiInstancePer implements JavaDelegate {

    @Override

    public void execute(DelegateExecution execution) throws Exception {

        System.out.println("设置会签环节的人员.");

        execution.setVariable("pers", Arrays.asList("张三", "李四", "王五", "赵六"));

    }

}

public class MulitiInstanceCompleteTask implements Serializable {

    private static final long serialVersionUID = 1L;

    public boolean completeTask(DelegateExecution execution) {

        System.out.println("总的会签任务数量：" + execution.getVariable("nrOfInstances") + "当前获取的会签任务数量：" + execution.getVariable("nrOfActiveInstances") + " - " + "已经完成的会签任务数量：" + execution.getVariable("nrOfCompletedInstances"));

        System.out.println("I am invoked.");

        return false;

    }

}

//完整帐号信息创建

IdentityHelper.java

protected void createUser(String userId, String firstName, String lastName, String password,

        String email, String imageResource, List<String> groups, List<String> userInfo) {

  if (identityService.createUserQuery().userId(userId).count() == ) {

    User user = identityService.newUser(userId);

    user.setFirstName(firstName);

    user.setLastName(lastName);

    user.setPassword(password);

    user.setEmail(email);

    identityService.saveUser(user);

    if (groups != null) {

      for (String group : groups) {

        identityService.createMembership(userId, group);

      }

    }

  }

  if (imageResource != null) {

    byte[] pictureBytes = IoUtil.readInputStream(this.getClass().getClassLoader().getResourceAsStream(imageResource), null);

    Picture picture = new Picture(pictureBytes, "image/jpeg");

    identityService.setUserPicture(userId, picture);

  }

  if (userInfo != null) {

    for(int i=; i<userInfo.size(); i+=) {

      identityService.setUserInfo(userId, userInfo.get(i), userInfo.get(i+));

    }

  }

}

//解锁操作

BpmnService.java

public Set<String> unlockProcess(String processInstanceId, String messageName, Map<String, ? extends Object> variables){

    Set<String> exIds = new HashSet<String>();

    log.debug("Unlocking Process with processInstanceId:'"+processInstanceId+"'");

    List<Execution> executions = runtimeService.createExecutionQuery()

              .messageEventSubscriptionName(messageName).processInstanceId(processInstanceId)

              .list();

    for (Execution execution2 : executions) {

        String curExId = execution2.getId();

        exIds.add(curExId);

        runtimeService.setVariables(curExId, variables);

        runtimeService.messageEventReceived(messageName, curExId);

    }

    return exIds;

}

//监听计数器

TaskCompletionListener.java

org.activiti.engine.delegate.DelegateTask

public void notify(DelegateTask delegateTask) {

  Integer counter = (Integer) delegateTask.getVariable("taskListenerCounter");

  if (counter == null) {

    counter = ;

  }

  delegateTask.setVariable("taskListenerCounter", ++counter);

}

//任务中间变量设置

DelegateTaskTaskListener.java

public void notify(DelegateTask delegateTask) {

  Set<IdentityLink> candidates = delegateTask.getCandidates();

  Set<String> candidateUsers = new HashSet<String>();

  Set<String> candidateGroups = new HashSet<String>();

  for (IdentityLink candidate : candidates) {

    if (candidate.getUserId() != null) {

      candidateUsers.add(candidate.getUserId());

    } else if (candidate.getGroupId() != null) {

      candidateGroups.add(candidate.getGroupId());

    }

  }

  delegateTask.setVariable(VARNAME_CANDIDATE_USERS, candidateUsers);

  delegateTask.setVariable(VARNAME_CANDIDATE_GROUPS, candidateGroups);

}

//*指派流程测试

TaskServiceTest.java

public void testTaskOwner() {

  Task task = taskService.newTask();

  task.setOwner("johndoe");

  taskService.saveTask(task);

  task = taskService.createTaskQuery().taskId(task.getId()).singleResult();

  assertEquals("johndoe", task.getOwner());

  task.setOwner("joesmoe");

  taskService.saveTask(task);

  task = taskService.createTaskQuery().taskId(task.getId()).singleResult();

  assertEquals("joesmoe", task.getOwner());

  taskService.deleteTask(task.getId(), true);

}

//用于实体类型转换

private User getUserInfo(Employee employee) {

  User user = new UserEntity(employee.getUserCd());

  user.setFirstName(employee.getGivenName());

  user.setLastName(employee.getFamilyName());

  user.setEmail(employee.getEmail());

  user.setPassword(employee.getPasswd());

  return user;

}

CommandContext.java

@SuppressWarnings({"unchecked"})

public <T> T getSession(Class<T> sessionClass) {

  Session session = sessions.get(sessionClass);

  if (session == null) {

    SessionFactory sessionFactory = sessionFactories.get(sessionClass);

    if (sessionFactory==null) {

      throw new ActivitiException("no session factory configured for "+sessionClass.getName());

    }

    session = sessionFactory.openSession();

    sessions.put(sessionClass, session);

  }

  return (T) session;

}