公司采购 流程flowable例子

Name: Flowable BPMN 2.0 designer

Location: http://flowable.org/designer/update/



业务描述：
1. 公司采购，因为办公用品价格高低的问题，需要分级审批，各级的审批资金的高低不一样，高于 500 块钱需要总经理审批！
1. 申请流程：
1. 申请人起草填写申请单（申请办公用品【数据库自带价格】、申请理由、使用人），保存后可立即提交申请；
1. 申请人提交审批，发起流程；
1. 部门经理审批；
1. 流程自动处理，采购金额

buyCost

大于 500的，自动转到总经理审批，否则直接转到人事部审批；
1. 如果总经理审批或者人事部审批通过，则自动转到财务部归档，否则被打回到申请人处理；
1. 财务归档处理后，流程转到采购部处理，采购部可以根据办公用品是否需要采购进行控制，选择采购办公用品或者人事部发放办公用品，流程转到此两者之一。
1. 如果申请单被打回到申请人，申请人可以再次修改后重新提交审批，也可以选择放弃、到此流程结束。
1. 如果流程走到采购办公用品，那么，采购部人员可以控制此流程，如果办公用品采购回来了，那么流程转到人事部发放办公用品。
1. 当人事部发放办公用品 人事部处理完过后，流程转到领取办公用品，申请人到人事部去领取办公用品，流程到此结束。

// 使用代码创建工作流需要的23张表
@Before
public void createTable() {
// 工作流引擎的全部配置
ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration
.createStandaloneProcessEngineConfiguration()
.setJdbcUrl("jdbc:jtds:sqlserver://localhost:1433/msgBoard2")
.setJdbcUsername("sa")
.setJdbcPassword("1234")
.setJdbcDriver("net.sourceforge.jtds.jdbc.Driver")
.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

// 工作流的核心对象，ProcessEnginee对象
processEngine = processEngineConfiguration.buildProcessEngine();
System.out.println("-----------工作流引擎开启----------");
}

/**
* 部署流程定义
*/
@Test
public void deploymentProcessDefinition() {
//创建核心引擎对象
Deployment deployment = processEngine.getRepositoryService()
.createDeployment()
.name("flowable入门程序2")
.addClasspathResource("myProcess-test.bpmn20.xml")
.deploy();
System.out.println("##########添加部署##########");
System.out.println("部署ID:" + deployment.getId());
System.out.println("部署名称：" + deployment.getName());
findProcessDefinition();
}

/**
* 启动流程实例
* 使用key值启动
*/
@Test
public void startProcessInstance2() {
// 流程定义的key
String processDefinitionKey = "myProcess-test";
ProcessInstance pi = processEngine.getRuntimeService()// 于正在执行的流程实例和执行对象相关的Service
.startProcessInstanceByKey(processDefinitionKey);// 使用流程定义的key启动流程实例，key对应hellworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动
System.out.println("流程实例ID:" + pi.getId());// 流程实例ID 101
System.out.println("流程定义ID:" + pi.getProcessDefinitionId()); // 流程定义ID HelloWorld:1:4
}

/**
* 启动流程实例
* 使用id值启动
*/
@Test
public void startProcessInstance() {
RuntimeService runtimeService = processEngine.getRuntimeService();//表示正在执行的流程实例和执行对象

ProcurementVO procurementVO = new ProcurementVO();
procurementVO.setEmployee("sky");
procurementVO.setReason("测试用例。。。。。。。。");
List<Articles> articlesList = new ArrayList<Articles>();
Articles articles1 = new Articles("文具", 80, 1);
Articles articles2 = new Articles("电脑", 500, 1);
articlesList.add(articles1);
articlesList.add(articles2);
procurementVO.setArticlesList(articlesList);
double buyCost = 0;
for (Articles articles : articlesList) {
buyCost += (articles.getAmount() * articles.getPrice());
}
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("procurement", procurementVO);
variables.put("buyCost", buyCost);

String processDefinitionId = "myProcess-test:1:105003";
ProcessInstance processInstance =
runtimeService.startProcessInstanceById(processDefinitionId, variables);
System.out.println("##########流程开启##########");
System.out.println("流程实例ID:" + processInstance.getId());
System.out.println("流程定义ID:" + processInstance.getProcessDefinitionId());
findTask();
}

/**
* 查询所有的流程定义
*/
@Test
public void findProcessDefinition() {
List<ProcessDefinition> list = processEngine.getRepositoryService()// 与流程定义和部署对象先相关的service
.createProcessDefinitionQuery()// 创建一个流程定义的查询
/** 指定查询条件，where条件 */
// .deploymentId(deploymentId) //使用部署对象ID查询
// .processDefinitionId(processDefinitionId)//使用流程定义ID查询
// .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询

/* 排序 */
.orderByProcessDefinitionVersion().asc()
// .orderByProcessDefinitionVersion().desc()

/* 返回的结果集 */
.list();// 返回一个集合列表，封装流程定义
// .singleResult();//返回惟一结果集
// .count();//返回结果集数量
// .listPage(firstResult, maxResults);//分页查询

if (list != null && list.size() > 0) {
for (ProcessDefinition pd : list) {
System.out.println("流程定义ID:" + pd.getId());// 流程定义的key+版本+随机生成数
System.out.println("流程定义的名称:" + pd.getName());// 对应helloworld.bpmn文件中的name属性值
System.out.println("流程定义的key:" + pd.getKey());// 对应helloworld.bpmn文件中的id属性值
System.out.println("流程定义的版本:" + pd.getVersion());// 当流程定义的key值相同的相同下，版本升级，默认1
System.out.println("资源名称bpmn文件:" + pd.getResourceName());
System.out.println("资源名称png文件:" + pd.getDiagramResourceName());
System.out.println("部署对象ID：" + pd.getDeploymentId());
System.out.println("是否暂停：" + pd.isSuspended());
System.out.println("#########################################################");
}
} else {
System.out.println("没有流程正在运行。");
}
}

/**
* 获取任务
*/
@Test
public void getTask() {
// 与任务相关的service,正在执行的service
TaskService taskService = processEngine.getTaskService();
// 任务ID
String taskId = "85005";

Task task = taskService.newTask(taskId);
System.out.println(task.getId() + "    " +
task.getAssignee() + "    " +
task.getName() + "    " +
task.getProcessInstanceId());
System.out.println("################################");
}

/**
* 设置流程变量
*/
@Test
public void setVariables() {
// 与任务相关的service,正在执行的service
TaskService taskService = processEngine.getTaskService();

// 任务ID
String taskId = "107508";

Map<String, Object> variables = new HashMap<String, Object>();
//        variables.put("approve", false);
variables.put("endOut", true);
//        taskService.removeVariable(taskId, "buyCost");
taskService.complete(taskId, variables);

System.out.println("设置流程变量成功！");
findTask();
}

/**
* 删除流程定义(删除key相同的所有不同版本的流程定义)
*/
@Test
public void delteProcessDefinitionByKey() {
// 流程定义的Key
String processDefinitionKey = "myProcess-test";
// 先使用流程定义的key查询流程定义，查询出所有的版本
List<ProcessDefinition> list = processEngine.getRepositoryService()
.createProcessDefinitionQuery()
.processDefinitionKey(processDefinitionKey)// 使用流程定义的key查询
.list();
// 遍历，获取每个流程定义的部署ID
if (list != null && list.size() > 0) {
for (ProcessDefinition pd : list) {
// 获取部署ID
String deploymentId = pd.getDeploymentId();
//      /*
//       * 不带级联的删除， 只能删除没有启动的流程，如果流程启动，就会抛出异常
//       */
//       processEngine.getRepositoryService().deleteDeployment(deploymentId);

/**
* 级联删除 不管流程是否启动，都可以删除
*/
System.out.println("删除部署：" + deploymentId);
processEngine.getRepositoryService().deleteDeployment(
deploymentId, true);

}

}
}

/**
* 查询流程状态（判断流程正在执行，还是结束）
*/
@Test
public void isProcessEnd() {
String processInstanceId = "25001";
ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象
.createProcessInstanceQuery()//创建流程实例查询
.processInstanceId(processInstanceId)//使用流程实例ID查询
.singleResult();

if (pi == null) {
System.out.println("流程已经结束");
} else {
System.out.println("流程没有结束");
}
}

/**
* 查询任务
* --通过流程实例id
*/
@Test
public void findTask() {
//        String processInstanceId = "42501";
List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据（历史表）相关的service
.createHistoricTaskInstanceQuery()//创建历史任务实例查询
//                .processInstanceId(processInstanceId)
.orderByHistoricActivityInstanceId().asc()
.list();

if (list != null && list.size() > 0) {
for (HistoricTaskInstance hti : list) {
System.out.println(hti.getId() + "    " +
hti.getAssignee() + "    " +
hti.getName() + "    " +
hti.getProcessInstanceId() + "   " +
hti.getStartTime() + "   " +
hti.getEndTime() + "   " +
hti.getDurationInMillis());
System.out.println("################################");
}
}
}

/**
* 查询当前人的个人任务
*/
@Test
public void findMyPersonTask() {
String assignee = "sky";
List<Task> list = processEngine.getTaskService()// 与正在执行的认为管理相关的Service
.createTaskQuery()// 创建任务查询对象
.taskAssignee(assignee)// 指定个人认为查询，指定办理人
.list();

if (list != null && list.size() > 0) {
for (Task task : list) {
System.out.println("任务ID:" + task.getId());
System.out.println("任务名称:" + task.getName());
System.out.println("任务的创建时间" + task);
System.out.println("任务的办理人:" + task.getAssignee());
System.out.println("流程实例ID:" + task.getProcessInstanceId());
System.out.println("执行对象ID:" + task.getExecutionId());
System.out.println("流程定义ID:" + task.getProcessDefinitionId());
System.out.println("#################################");
}
}
}

/**
* 得到实际的 组任务列表
*/
@Test
public void findGroupTaskList() {
String groupName1 = "procurementOfManager";
String groupName2 = "procurementOfPersonnel";

TaskService taskService = processEngine.getTaskService();
List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup(groupName1).list();
System.out.println(groupName1 + " have " + tasks.size() + " tasks:");
for (int i = 0; i < tasks.size(); i++) {
System.out.println((i + 1) + ") " + tasks.get(i).getName());
}
System.out.println("#################################################");
TaskService taskService2 = processEngine.getTaskService();
List<Task> tasks2 = taskService.createTaskQuery().taskCandidateGroup(groupName2).list();
System.out.println(groupName2 + " have " + tasks2.size() + " tasks:");
for (int i = 0; i < tasks2.size(); i++) {
System.out.println((i + 1) + ") " + tasks2.get(i).getName());
}
}