activiti 动态自定义流程（包含会签流程）

后台加入工作流步骤（这个不重要，自己实现）

 package com.blk.integrated.pojo;

 import java.io.Serializable;
 import java.util.Date;

 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.Table;

 import org.codehaus.jackson.map.annotate.JsonSerialize;
 import org.springframework.format.annotation.DateTimeFormat;

 import lib.core.utils3.system.CustomDateSerializerHM;

 @Entity
 @Table(name="sys_workflow")
 public class SysWorkflow implements Serializable {

     private static final long serialVersionUID = 1L;

     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name="id")
     private Long id;

     @JsonSerialize(using = CustomDateSerializerHM.class)
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm")
     @Column(name="create_time")
     private Date createTime;
     //工作流名称
     @Column(name="name")
     private String name;
     //工作流描述
     @Column(name="content")
     private String content;

     @Column(name="skip_level")
     private Integer skipLevel;

     public Long getId() {
         return id;
     }

     public void setId(Long id) {
         this.id = id;
     }

     public Date getCreateTime() {
         return createTime;
     }

     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getContent() {
         return content;
     }

     public void setContent(String content) {
         this.content = content;
     }

     public Integer getSkipLevel() {
         return skipLevel;
     }

     public void setSkipLevel(Integer skipLevel) {
         this.skipLevel = skipLevel;
     }

 }

 package com.blk.integrated.pojo;

 import java.io.Serializable;
 import java.util.Date;

 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.Table;

 import org.codehaus.jackson.map.annotate.JsonSerialize;
 import org.springframework.format.annotation.DateTimeFormat;

 import lib.core.utils3.system.CustomDateSerializerHM;

 @Entity
 @Table(name="sys_workflow_step")
 public class SysWorkflowStep implements Serializable {
     private static final long serialVersionUID = 1L;

     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name="id")
     private Long id;

     @JsonSerialize(using = CustomDateSerializerHM.class)
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm")
     @Column(name="create_time")
     private Date createTime;

     @Column(name="workflow_id")
     private Long workflowId;
     //该步骤审核的角色
     @Column(name="role_pkno")
     private String rolePkno;
     /**
      * type==1  会签
      * type==2  普通流转
      */
     @Column(name="type")
     private Integer type;

     public Long getId() {
         return id;
     }

     public void setId(Long id) {
         this.id = id;
     }

     public Date getCreateTime() {
         return createTime;
     }

     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }

     public Long getWorkflowId() {
         return workflowId;
     }

     public void setWorkflowId(Long workflowId) {
         this.workflowId = workflowId;
     }

     public String getRolePkno() {
         return rolePkno;
     }

     public void setRolePkno(String rolePkno) {
         this.rolePkno = rolePkno;
     }

     public Integer getType() {
         return type;
     }

     public void setType(Integer type) {
         this.type = type;
     }

 }

//创建模型并部署工作流

 package com.blk.back.service.impl;

 import java.io.File;
 import java.io.InputStream;
 import java.util.*;

 import javax.transaction.Transactional;

 import com.blk.integrated.pojo.SysUserRoleMappingPo;
 import lib.core.utils3.StringUtils;
 import lib.hibernate.dao.SimpleDao;
 import org.activiti.bpmn.BpmnAutoLayout;
 import org.activiti.bpmn.model.*;
 import org.activiti.bpmn.model.Process;
 import org.activiti.engine.ActivitiException;
 import org.activiti.engine.ProcessEngine;
 import org.activiti.engine.ProcessEngines;
 import org.activiti.engine.repository.Deployment;
 import org.activiti.engine.runtime.ProcessInstance;
 import org.activiti.engine.task.Task;
 import org.apache.commons.io.FileUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.blk.back.service.SysWorkflowService;
 import com.blk.core.util.RetKit;
 /**
  *
  * @project cb-console-service
  * @author suruozhong
  * @description (工作流管理)
  * @date 2017年10月19日
  */
 import com.blk.integrated.dao.SysRoleDao;
 import com.blk.integrated.dao.SysWorkflowDao;
 import com.blk.integrated.dao.SysWorkflowStepDao;
 import com.blk.integrated.pojo.SysRolePo;
 import com.blk.integrated.pojo.SysWorkflow;
 import com.blk.integrated.pojo.SysWorkflowStep;
 @Service
 @Transactional
 public class SysWorkflowServiceImpl implements SysWorkflowService {

     @Autowired
     private SysRoleDao sysRoleDao;
     @Autowired
     private SysWorkflowDao sysWorkflowDao;
     @Autowired
     private SysWorkflowStepDao sysWorkflowStepDao;
     @Autowired
     private SimpleDao simpleDao;
 　　　//获取角色下所有用户
     private List<String> getUserRole(String rolePkno){
         List<String> list = simpleDao.getDelegate().createSQLQuery("select user_pkno from sys_user_role_mapping where role_pkno=:rolePkno").setParameter("rolePkno",rolePkno).list();
         return list;
     }

     @Override
     public RetKit save(SysWorkflow model,String stepArr) {

         model.setCreateTime(new Date());
         sysWorkflowDao.getDelegate().save(model);
         JSONArray arr = JSONObject.parseArray(stepArr);
         List<SysWorkflowStep> stepList = new ArrayList<SysWorkflowStep>();
         for(int i=0; i<arr.size();i++) {
             SysWorkflowStep step = new SysWorkflowStep();
             JSONObject obj = JSONObject.parseObject(arr.get(i).toString());
             step.setId(obj.getLong("id"));
             step.setCreateTime(new Date());
             step.setWorkflowId(model.getId());
             step.setRolePkno(obj.getString("rolePkno"));
             step.setType(obj.getIntValue("type"));
             sysWorkflowStepDao.merge(step);
             stepList.add(step);
         }
         //部署工作流
         addFlowDeployment(model,stepList);
         return RetKit.ok();
     }

       /**
         *@Date：2017/11/24
         *@Description：创建流程并部署
         *
         */
       protected void addFlowDeployment(SysWorkflow workflow,List<SysWorkflowStep> stepList){
         System.out.println(".........start...");
         ProcessEngine processEngine= ProcessEngines.getDefaultProcessEngine();

         // 1. 建立模型
         BpmnModel model = new BpmnModel();
         Process process=new Process();
         model.addProcess(process);
         process.setId("news");
         process.setName(workflow.getName());
         process.setDocumentation(workflow.getContent());
         //添加流程
         //开始节点
         process.addFlowElement(createStartEvent());
         for(int i=0; i<stepList.size(); i++){
             SysWorkflowStep step = stepList.get(i);
             //判断是否会签
             if(step.getType()==1){
                 //会签
                 //加入并行网关-分支
                 process.addFlowElement(createParallelGateway("parallelGateway-fork"+i,"并行网关-分支"+i));
                 //获取角色下所有用户
                 List<String> userList = getUserRole(step.getRolePkno());
                 for(int u=0; u<userList.size();u++){
                     //并行网关分支的审核节点
                     process.addFlowElement(createUserTask("userTask"+i+u,"并行网关分支用户审核节点"+i+u,userList.get(u)));
                 }
                 //并行网关-汇聚
                 process.addFlowElement(createParallelGateway("parallelGateway-join"+i,"并行网关到-汇聚"+i));

             }else{
                 //普通流转
                 //审核节点
                 process.addFlowElement(createGroupTask("task"+i,"组审核节点"+i,step.getRolePkno()));
                 //回退节点
                 process.addFlowElement(createUserTask("repulse"+i,"回退节点"+i,"${startUserId}"));
             }
         }
         //结束节点
         process.addFlowElement(createEndEvent());

         //连线
         for(int y=0; y<stepList.size(); y++){
             SysWorkflowStep step = stepList.get(y);
             //是否会签
             if(step.getType()==1){
                 //会签
                 //判断是否第一个节点
                 if(y==0){
                     //开始节点和并行网关-分支连线
                     process.addFlowElement(createSequenceFlow("startEvent", "parallelGateway-fork"+y, "开始节点到并行网关-分支"+y, ""));
                 }else{
                     //审核节点或者并行网关-汇聚到并行网关-分支
                     //判断上一个节点是否是会签
                     if(stepList.get(y-1).getType()==1){
                         process.addFlowElement(createSequenceFlow("parallelGateway-join"+(y-1),"parallelGateway-fork"+y,"并行网关-汇聚到并行网关-分支"+y,""));
                     }else{
                         process.addFlowElement(createSequenceFlow("task"+(y-1),"parallelGateway-fork"+y,"上一个审核节点到并行网关-分支"+y,""));
                     }
                 }
                 //并行网关-分支和会签用户连线，会签用户和并行网关-汇聚连线
                 List<String> userList = getUserRole(step.getRolePkno());
                 for(int u=0; u<userList.size(); u++){
                     process.addFlowElement(createSequenceFlow("parallelGateway-fork"+y,"userTask"+y+u,"并行网关-分支到会签用户"+y+u,""));
                     process.addFlowElement(createSequenceFlow("userTask"+y+u,"parallelGateway-join"+y,"会签用户到并行网关-汇聚",""));
                 }
                 //最后一个节点  并行网关-汇聚到结束节点
                 if(y==(stepList.size()-1)){
                     process.addFlowElement(createSequenceFlow("parallelGateway-join"+y,"endEvent","并行网关-汇聚到结束节点",""));
                 }
             }else{
                 //普通流转
                 //第一个节点
                 if(y==0){
                     //开始节点和审核节点1
                     process.addFlowElement(createSequenceFlow("startEvent", "task"+y, "开始节点到审核节点"+y, ""));
                 }else{
                     //判断上一个节点是否会签
                     if(stepList.get(y-1).getType()==1){
                         //会签
                         //并行网关-汇聚到审核节点
                         process.addFlowElement(createSequenceFlow("parallelGateway-join"+(y-1),"task"+y,"并行网关-汇聚到审核节点"+y,""));
                     }else{
                         //普通
                         process.addFlowElement(createSequenceFlow("task"+(y-1),"task"+y,"审核节点"+(y-1)+"到审核节点"+y,"${flag=='true'}"));
                     }
                 }
                 //是否最后一个节点
                 if(y==(stepList.size()-1)){
                     //审核节点到结束节点
                     process.addFlowElement(createSequenceFlow("task"+y,"endEvent","审核节点"+y+"到结束节点","${flag=='true'}"));
                 }
                 //审核节点到回退节点
                 process.addFlowElement(createSequenceFlow("task"+y,"repulse"+y,"审核不通过-打回"+y,"${flag=='false'}"));
                 process.addFlowElement(createSequenceFlow("repulse"+y,"task"+y,"回退节点到审核节点"+y,""));
             }
         }

         // 2. 生成的图形信息
         new BpmnAutoLayout(model).execute();

         // 3. 部署流程
         Deployment deployment = processEngine.getRepositoryService().createDeployment().addBpmnModel(process.getId()+".bpmn", model).name(process.getId()+"_deployment").deploy();

         //        // 4. 启动一个流程实例
 //        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey(process.getId());
 //
 //        // 5. 获取流程任务
 //        List<Task> tasks = processEngine.getTaskService().createTaskQuery().processInstanceId(processInstance.getId()).list();
 //        try{
 //            // 6. 将流程图保存到本地文件
 //            InputStream processDiagram = processEngine.getRepositoryService().getProcessDiagram(processInstance.getProcessDefinitionId());
 //            FileUtils.copyInputStreamToFile(processDiagram, new File("/deployments/"+process.getId()+".png"));
 //
 //            // 7. 保存BPMN.xml到本地文件
 //            InputStream processBpmn = processEngine.getRepositoryService().getResourceAsStream(deployment.getId(), process.getId()+".bpmn");
 //            FileUtils.copyInputStreamToFile(processBpmn,new File("/deployments/"+process.getId()+".bpmn"));
 //        }catch (Exception e){
 //            e.printStackTrace();
 //        }

         System.out.println(".........end...");
     }

     //任务节点-组
     protected UserTask createGroupTask(String id, String name, String candidateGroup) {
         List<String> candidateGroups=new ArrayList<String>();
         candidateGroups.add(candidateGroup);
         UserTask userTask = new UserTask();
         userTask.setName(name);
         userTask.setId(id);
         userTask.setCandidateGroups(candidateGroups);
         return userTask;
     }

     //任务节点-用户
     protected UserTask createUserTask(String id, String name, String userPkno) {
         List<String> candidateUsers=new ArrayList<String>();
         candidateUsers.add(userPkno);
         UserTask userTask = new UserTask();
         userTask.setName(name);
         userTask.setId(id);
         userTask.setCandidateUsers(candidateUsers);
         return userTask;
     }

     //任务节点-锁定者
     protected UserTask createAssigneeTask(String id, String name, String assignee) {
         UserTask userTask = new UserTask();
         userTask.setName(name);
         userTask.setId(id);
         userTask.setAssignee(assignee);
         return userTask;
     }

     /*连线*/
     protected SequenceFlow createSequenceFlow(String from, String to,String name,String conditionExpression) {
         SequenceFlow flow = new SequenceFlow();
         flow.setSourceRef(from);
         flow.setTargetRef(to);
         flow.setName(name);
         if(StringUtils.isNotEmpty(conditionExpression)){
             flow.setConditionExpression(conditionExpression);
         }
         return flow;
     }

     //排他网关
     protected ExclusiveGateway createExclusiveGateway(String id,String name) {
         ExclusiveGateway exclusiveGateway = new ExclusiveGateway();
         exclusiveGateway.setId(id);
         exclusiveGateway.setName(name);
         return exclusiveGateway;
     }

     //并行网关
     protected ParallelGateway createParallelGateway(String id,String name){
         ParallelGateway gateway = new ParallelGateway();
         gateway.setId(id);
         gateway.setName(name);
         return gateway;
     }

     //开始节点
     protected StartEvent createStartEvent() {
         StartEvent startEvent = new StartEvent();
         startEvent.setId("startEvent");
         return startEvent;
     }

     /*结束节点*/
     protected EndEvent createEndEvent() {
         EndEvent endEvent = new EndEvent();
         endEvent.setId("endEvent");
         return endEvent;
     }

 }

部署完流程图

（当前选择两个步骤的流程图）