工作流 订阅
工作流(Workflow),指“业务过程的部分或整体在计算机应用环境下的自动化”。是对工作流程及其各操作步骤之间业务规则的抽象、概括描述。在计算机中,工作流属于计算机支持的协同工作(CSCW)的一部分。后者是普遍地研究一个群体如何在计算机的帮助下实现协同工作的。工作流主要解决的主要问题是:为了实现某个业务目标,利用计算机在多个参与者之间按某种预定规则自动传递文档、信息或者任务。工作流概念起源于生产组织和办公自动化领域,是针对日常工作中具有固定程序活动而提出的一个概念,目的是通过将工作分解成定义良好的任务或角色,按照一定的规则和过程来执行这些任务并对其进行监控,达到提高工作效率、更好的控制过程、增强对客户的服务、有效管理业务流程等目的。尽管工作流已经取得了相当的成就,但对工作流的定义还没有能够统一和明确。Georgakopoulos给出的工作流定义是:工作流是将一组任务组织起来以完成某个经营过程:定义了任务的触发顺序和触发条件,每个任务可以由一个或多个软件系统完成,也可以由一个或一组人完成,还可以由一个或多个人与软件系统协作完成。1993年工作流管理联盟(Workflow Management Coalition,WfMC)作为工作流管理的标准化组织而成立,标志着工作流技术逐步走向成熟。WfMC对工作流给出定义为:工作流是指一类能够完全自动执行的经营过程,根据一系列过程规则,将文档、信息或任务在不同的执行者之间进行传递与执行。 展开全文
工作流(Workflow),指“业务过程的部分或整体在计算机应用环境下的自动化”。是对工作流程及其各操作步骤之间业务规则的抽象、概括描述。在计算机中,工作流属于计算机支持的协同工作(CSCW)的一部分。后者是普遍地研究一个群体如何在计算机的帮助下实现协同工作的。工作流主要解决的主要问题是:为了实现某个业务目标,利用计算机在多个参与者之间按某种预定规则自动传递文档、信息或者任务。工作流概念起源于生产组织和办公自动化领域,是针对日常工作中具有固定程序活动而提出的一个概念,目的是通过将工作分解成定义良好的任务或角色,按照一定的规则和过程来执行这些任务并对其进行监控,达到提高工作效率、更好的控制过程、增强对客户的服务、有效管理业务流程等目的。尽管工作流已经取得了相当的成就,但对工作流的定义还没有能够统一和明确。Georgakopoulos给出的工作流定义是:工作流是将一组任务组织起来以完成某个经营过程:定义了任务的触发顺序和触发条件,每个任务可以由一个或多个软件系统完成,也可以由一个或一组人完成,还可以由一个或多个人与软件系统协作完成。1993年工作流管理联盟(Workflow Management Coalition,WfMC)作为工作流管理的标准化组织而成立,标志着工作流技术逐步走向成熟。WfMC对工作流给出定义为:工作流是指一类能够完全自动执行的经营过程,根据一系列过程规则,将文档、信息或任务在不同的执行者之间进行传递与执行。
信息
应用学科
计算机科学、管理学
适用领域
云计算
中文名
工作流
外文名
Workflow
工作流工作流类型
工作流(WorkFlow)就是工作流程的计算模型,即将工作流程中的工作如何前后组织在一起的逻辑和规则在计算机中以恰当的模型进行表示并对其实施计算。工作流要解决的主要问题是:为实现某个业务目标,在多个参与者之间,利用计算机,按某种预定规则自动传递工作流属于计算机支持的协同工作(Computer Supported Cooperative Work,CSCW)的一部分。后者是普遍地研究一个群体如何在计算机的帮助下实现协同工作的。许多公司采用纸张表单,手工传递的方式,一级一级审批签字,工作效率非常低下,对于统计报表功能则不能实现。而采用工作流软件,使用者只需在电脑上填写有关表单,会按照定义好的流程自动往下跑,下一级审批者将会收到相关资料,并可以根据需要修改、跟踪、管理、查询、统计、打印等,大大提高了效率,实现了知识管理,提升了公司的核心竞争力。 工作流2.0的定义是:实现工作过程管理的自动化、智能化和整合化。工作流2.0最主要的特征就是可以灵便的实现数据整合和数据统计,消除信息孤岛,既能实现OA办公系统内部工作流之间的数据整合,如借款与报销、预算与决算等,又能实现OA办公系统工作流与其他业务系统之间的数据整合,如HR、ERP、CRM等。工作流2.0能彻底的弥补工作流1.0的不足,它不但实现OA办公系统内部的数据整合,也实现OA办公系统和第三方应用系统之间的数据整合。如果给工作流1.0打上标签的话,那就是“无纸化、重复工作、流程孤岛、系统孤岛、数据孤岛”;工作流2.0对应的便是“智能化、效率质量提升、外部数据整合、消除信息孤岛、内部数据整合”。毫无疑问,工作流2.0更加智能,更加整合,能够实现数据的同步交换和共享的特征更受用户欢迎,能有效帮助企业简化多余流程,是未来工作流技术发展的方向。
收起全文
精华内容
参与话题
问答
  • 工作流(Workflow)基本介绍

    万次阅读 2018-08-31 01:36:09
    工作流简介 工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行,从而实现某个预期的业务...

    工作流简介

    工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行,从而实现某个预期的业务目标,或者促使此目标的实现”。 通俗的说,流程就是多个人在一起合作完成某件事情的步骤,把步骤变成计算机能理解的形式就是工作流。

    工作流要解决的主要问题是:为实现某个业务目标,在多个参与者之间,利用计算机,按某种预定规则自动传递文档、信息或者任务。

    工作流管理系统(Workflow Management System, WfMS)是一个软件系统,它完成工作流的定义和管理,并按照在系统中预先定义好的工作流规则进行工作流实例的执行。工作流管理系统不是企业的业务系统,而是为企业的业务系统的运行提供了一个软件的支撑环境。工作流管理联盟(WfMC,Workflow Management Coalition)给出的关于工作流管理系统的定义是:工作流管理系统是一个软件系统,它通过执行经过计算的流程定义去支持一批专门设定的业务流程。工作流管理系统被用来定义、管理、和执行工作流程。

    工作流应用广泛,在由任务驱动的各种系统中都有应用,例如OA、CRM、ERP、ECM、BI等。在企业应用中还有很多产品或平台集成工作流引擎,用来处理系统运行过程中发起的业务流程。

    工作流总是以任务(Task)的形式驱动人处理业务或者驱动业务系统自动完成作业。有了工作流引擎之后,我们不必一直等待其他人的工作进度,直白地说,我们只需要关心系统首页的待办任务数即可,由系统提醒当前有多少待办任务需要处理。

     

    采用工作流管理系统的优点:

    1)提高系统的柔性,适应业务流程的变化

    2)实现更好的业务过程控制,提高顾客服务质量

    3)降低系统开发和维护成本

     

    工作流生命周期

    一个完整的工作流生命周期会经过五个步骤,并且迭代循环:

    定义:工作流生命周期总是从流程定义开始。此阶段的任务主要是收集业务需求并转化为流程定义。一般由业务需求人员进行,然后交由开发人员加工转化为计算机可以识别的流程定义。

    发布:由开发人员打包各种资源,然后在系统管理(平台)中发布流程定义。在具体的流程引擎中包括流程定义文件、自定义表单、任务监听类。

    执行:具体的流程引擎(例如,Activiti)按照事先定义的流程处理路线以任务驱动的方式执行业务流程。

    监控:此阶段是依赖执行阶段。业务人员在办理任务的同时收集每个任务(Task)的结果,然后根据结果做出相应处理,例如,在采购办公用品流程中,在通过领导审批之后,采购人员就要根据申请单外出采购。

    优化:在此阶段,一个完整的流程已经结束,或许能满足业务需求,或许需要优化,而糟糕的情况是需要重新设计(流程没结束就异常终止),优化与设计正是此阶段需要处理的。根据整个流程的运行过程结果分析问题的根源,然后在此基础上进一步改进,并再次开始一个新的周期。

     

    工作流引擎

    所谓工作流引擎是指workflow作为应用系统的一部分,并为之提供对各应用系统有决定作用的根据角色、分工和条件的不同决定信息传递路由、内容等级等核心解决方案。

    例如开发一个系统最关键的部分不是系统的界面,也不是和数据库之间的信息交换,而是如何根据业务逻辑开发出符合实际需要的程序逻辑并确保其稳定性、易维护性和弹性。

     

     

    BPM介绍

    Business Process Management(业务流程管理).是一套达成企业各种业务环节整合的全面管理模式,实现跨应用、跨部门、跨合作伙伴与客户的企业运作。

    BPM是为了实现一定的经营目的而执行的一系列逻辑相关的活动的集合。

    BPM最早是由工作流和企业应用集成(Enterprise Application Intergration)逐步融合而发展起来的。随着时间的推移,BPM的定义范围逐步扩展,不仅用来满足无纸化办公需求,现在BPM是一种企业集成技术,作为对面向服务系统架构SOA( Service-Oriented Architecture)、企业应用集成EAI (Enterprise Application Integration)、企业服务总线ESB( Enterprise Service Bus)的补充。

    BPM通常以Internet方式实现信息传递、数据同步、业务监控和企业业务流程的持续升级优化。

     

    BPMN2.0 概述

    业务流程模型注解(Business Process Modeling Notation - BPMN)是 业务流程模型的一种标准图形注解。这个标准是由对象管理组(Object Management Group - OMG)维护的。

    BPMN定义了业务流程图,其基于流程图技术,同时对创建业务流程操作的图形化模型进行了裁减。业务流程的模型就是图形化对象的网图,包括活动(也可以说工作)和定义操作顺序的流控制。

    BPMN2.0 规范定义了业务流程的符号以及模型,并且为流程定义设定了转换格式,目的是为了让流程的定义实现可移植性,那么用户可以在不同的供应商环境中定义流程,并且这些流程可以移植到其他遵守 BPMN2.0 规范的供应商环境中。

     

    BPMN2.0 元素

    BPMN2.0 的目的是建立简单的并且易懂的业务流程模型,但是同时又需要处理高度复杂的业务流程,因此要解决这两个矛盾的要求,需要在规范中定义标准的图形和符号。BPMN中定义了 5 类基础的元素分类:

    流对象(Flow Objects):在一个业务流程中,流对象是用于定义行为的图形元素,主要有事件(Events)、活动(Activities)和网关(Gateways)三种流对象。

    数据(Data):主要有数据对象(Data Objects)、数据输入(Data Inputs)、数据输出(Data Inputs)和数据存储(Data Stores)4 种元素。

    连接对象(Connecting Objects):用于连接流对象,主要有 4 种连接流对象的方式,包括顺序流(Sequence Flows)、消息流(Message Flows)、关联(Associations)和数据关联(Data Associations)。

    泳道(Swimlanes):泳道提供了有 2 种途径组织基础的模型元素,分别是池(Pools)和道(Lanes)。

    制品(Artifacts):制品主要用于为流程提供附加信息,当前制品包括组(Group)和注释(Text Annotation)。

    以上的元素分类以及其下面的元素,均是 BPMN 规范中元素的组成部分,每个对象均有自己对应的图形,以下表格为各个元素的图形及其描述。

    元素 描述
    事件(Events) 用于描述流程中发生的事件,事件会对流程产生影响,事件会被触发或者会产生结果。
    活动(Activities) 活动是工作流中一个通用的术语,活动包括任务(Task)和子流程(Sub-Process)。
    网关(Gateways)  网关主要用于控制流程中的顺序流的走向,使用网关可以控制流程进行分支与合并。
    顺序流(Sequence Flow) 顺序流显示流程将会执行哪个活动。
    消息流(Message Flows) 消息流主要用于显示消息在流程参与者之间的传递情况。
    关联(Association) 主要用于连接流程元素及其制品(流程信息)。
    池(Pool)  存放道的容器。
    道(Lane) 用于区分流程参与人的职能范围。
    数据对象(Data Object)  数据对象主要表示活动需要的或者产生的信息。
    消息(Message)  消息主要用于描述流程参与者之间的沟通内容。
    组(Group)  主要用于存放一些流程信息,包括流程文档、流程分析信息等。
    注释(Text Annotation) 主要为阅读流程图的人提供附加的文字信息。

     

     

     

    展开全文
  • Activity工作流入门

    万次阅读 多人点赞 2018-05-23 22:16:12
    1. 工作流概念工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行,从而实现某个预期的业务...

    1. 工作流概念

    工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行,从而实现某个预期的业务目标,或者促使此目标的实现”。

     

    工作流管理系统(Workflow Management System, WfMS)是一个软件系统,它完成工作量的定义和管理,并按照在系统中预先定义好的工作流逻辑进行工作流实例的执行。工作流管理系统不是企业的业务系统,而是为企业的业务系统的运行提供了一个软件的支撑环境。

     

    2. Activiti简介

    Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理(BPM)框架,它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。Activiti基于Apache许可的开源BPM平台,创始人Tom Baeyens是JBoss jBPM的项目架构师,它特色是提供了eclipse插件,开发人员可以通过插件直接绘画出业务流程图。

    Activiti框架底层有数据库提供支持,根据版本不同,表的数量不一致,activiti5.13有23张表。底层使用mybatis操作数据库,开发人员不需要自己编写sql

    Jbpm4.4底层也有数据库支持,18张表。 底层使用hibernate操作数据库。

     

    Activiti的后台是有数据库的支持,所有的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。

    1) ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 (图片,规则,等等)。

    2) ACT_RU_*: 'RU'表示runtime。 这些运行时的表,包含流程实例,任务,变量,异步任务,等运行中的数据。 Activiti只在流程实例执行过程中保存这些数据, 在流程结束时就会删除这些记录。 这样运行时表可以一直很小速度很快。

    3) ACT_ID_*: 'ID'表示identity。 这些表包含身份信息,比如用户,组等等。

    4) ACT_HI_*: 'HI'表示history。 这些表包含历史数据,比如历史流程实例, 变量,任务等等。

    5) ACT_GE_*: 通用数据, 用于不同场景下。


    3. 安装插件(流程设计器插件)

    第一步:解压zip文件到eclipse中的dropins目录中


    第二步:重启eclipse,勾选save选项


    第三步:使用插件设计流程图


    4.手动创建数据库表

    Activity自带建表脚本,选择手动建表的话,只需要选取对应数据库的脚本即可,里面包含的Create、upgrade和drop相关脚本(upgrade脚本是用于工作流版本升级时候用的),当然Activity也支持自动建表,可以参考下面的DEMO,但是不建议自动建表,本案例用的是mysql,所以我选取的是mysql的脚本




    创建后应该可以看到有23张表,本教程使用的是Activity5.13

    5.自定义流程

    右击工程->NEW->Other->Activity->Activity Diagram,新建一个工作流模板

    然后就可以开始拖拉控件设计流程了,设计好的流程,只要通过发布操作,就可以自动在数据库插入相应数据,可参考下面demo,以下是一个简单的流程:

    6.入门Demo

    [java] view plain copy
    1. package activity.demo.test;  
    2.   
    3. import java.util.List;  
    4.   
    5. import org.activiti.engine.ProcessEngine;  
    6. import org.activiti.engine.ProcessEngineConfiguration;  
    7. import org.activiti.engine.ProcessEngines;  
    8. import org.activiti.engine.impl.juel.ExpressionFactoryImpl.Profile;  
    9. import org.activiti.engine.repository.Deployment;  
    10. import org.activiti.engine.repository.DeploymentBuilder;  
    11. import org.activiti.engine.repository.ProcessDefinition;  
    12. import org.activiti.engine.repository.ProcessDefinitionQuery;  
    13. import org.activiti.engine.runtime.ProcessInstance;  
    14. import org.activiti.engine.task.Task;  
    15. import org.activiti.engine.task.TaskQuery;  
    16. import org.junit.Test;  
    17. import org.junit.validator.PublicClassValidator;  
    18.   
    19.   
    20. public class HelloWorld {  
    21.     // 使用框架的自动建表功能(不提供配置文件)  
    22.     @Test  
    23.     public void testCreateTablesAutomaticallyWithoutConfigFiles() {  
    24.         // 创建流程引擎配置对象  
    25.         ProcessEngineConfiguration config = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();  
    26.         // 设置jdbc连接参数信息  
    27.         config.setJdbcDriver("com.mysql.jdbc.Driver");  
    28.         config.setJdbcUrl("jdbc:mysql:///eam-mirror");  
    29.         config.setJdbcUsername("root");  
    30.         config.setJdbcPassword("root");  
    31.         // 设置自动建表  
    32.         config.setDatabaseSchemaUpdate("true");  
    33.         // 使用配置对象创建流程引擎对象,创建对象过程中会自动建表  
    34.         ProcessEngine processEngine = config.buildProcessEngine();  
    35.     }  
    36.   
    37.     // 使用框架的自动建表功能(提供配置文件)  
    38.     @Test  
    39.     public void testCreateTablesAutomaticallyWithConfigFiles() {  
    40.         ProcessEngineConfiguration config = ProcessEngineConfiguration  
    41.                 .createProcessEngineConfigurationFromResource("activiti-context.xml""processEngineConfiguration");  
    42.         ProcessEngine pe = config.buildProcessEngine();  
    43.     }  
    44.   
    45.     // 使用框架的自动建表功能(提供配置文件---使用默认配置)  
    46.     @Test  
    47.     public void testCreateTablesAutomatically() {  
    48.         ProcessEngine pe = ProcessEngines.getDefaultProcessEngine();  
    49.     }  
    50.   
    51.     ProcessEngine pe = ProcessEngines.getDefaultProcessEngine();  
    52.   
    53.     // 将设计的流程图部署到数据库中  
    54.     @Test  
    55.     public void testDeploy() {  
    56.         // 创建部署构建器对象,用于加载流程定义文件(UserInfoAudit.bpmn,UserInfoAudit.myProcess.png),部署流程定义  
    57.         DeploymentBuilder deploymentBuilder = pe.getRepositoryService().createDeployment();  
    58.         deploymentBuilder.addClasspathResource("UserInfoAudit.bpmn");  
    59.         Deployment deployment = deploymentBuilder.deploy();  
    60.         System.out.println(deployment.getId());  
    61.     }  
    62.   
    63.     // 查询流程定义  
    64.     @Test  
    65.     public void testQueryProcessDefinition() {  
    66.         // 流程定义查询对象,用于查询流程定义表----act_re_procdef  
    67.         ProcessDefinitionQuery query = pe.getRepositoryService().createProcessDefinitionQuery();  
    68.         // 添加过滤条件,取最新版本  
    69.         query.latestVersion();  
    70.         // query.processDefinitionId(processDefinitionId)  
    71.         // query.processDefinitionKey(processDefinitionKey);  
    72.         // 添加排序条件  
    73.         query.orderByProcessDefinitionVersion().desc();  
    74.   
    75.         // 添加分页条件  
    76.         // query.listPage(firstResult, maxResults);  
    77.   
    78.         // 查询所有流程  
    79.         List<ProcessDefinition> processDefinitionList = query.list();  
    80.         for (ProcessDefinition pd : processDefinitionList) {  
    81.             System.out.println(pd.getId());  
    82.         }  
    83.   
    84.     }  
    85.     // 根据流程定义启动流程实例----操作的数据表:act_ru_execution act_ru_task  
    86.     @Test  
    87.     public void testStartProcess(){  
    88.         String processDefinitionId = "UserAuditProcess:2:504";  
    89.         //根据流程实例ID去启动流程  
    90.         ProcessInstance pInstance = pe.getRuntimeService().startProcessInstanceById(processDefinitionId);  
    91.         System.out.println(pInstance.getId());  
    92.     }  
    93.       
    94.     //查询任务列表  
    95.     @Test  
    96.     public void testQueryTaskList(){  
    97.         //创建任务查询对象,查询表act_ru_task  
    98.         TaskQuery query = pe.getTaskService().createTaskQuery();  
    99.         String assignee ="张三";  
    100.         //添加过滤条件  
    101.         query.taskAssignee(assignee);  
    102.         //排序  
    103.         query.orderByTaskCreateTime().desc();  
    104.         List<Task> taskList = query.list();  
    105.         for(Task task : taskList){  
    106.             System.out.println("taskId:"+task.getId()+",taskName:"+task.getName());  
    107.         }  
    108.     }  
    109.     //办理任务  
    110.     //办理个人任务,操作的表是act_ru_execution,act_ru_task  
    111.     @Test  
    112.     public void testExecuteTask(){  
    113.         String taskId= "604";  
    114.         pe.getTaskService().complete(taskId);  
    115.     }  
    116.       
    117. }  


    7.Activity框架学习指南


    展开全文
  • 采用springboot+flowable快速实现工作流

    万次阅读 多人点赞 2018-04-07 23:04:21
    工作流框架大家一定不陌生,各种OA系统里我们常常用到。 对于JAVA领域来说一说起工作流框架第一浮现我在脑海中的便是大名鼎鼎的Activiti了。很久以前学习Activiti框架时我也曾记录过一篇文章。见链接:工作流框架...

    前言    

        工作流框架大家一定不陌生,各种OA系统里我们常常用到。    

        对于JAVA领域来说一说起工作流框架第一浮现我在脑海中的便是大名鼎鼎的Activiti了。很久以前学习Activiti框架时我也曾记录过一篇文章。见链接:工作流框架Activiti常用功能初探  尽管当时只是学习了一下在之后的相关工作和项目中并没有用到,通过学习后了解了下, 仅对于知识广度进行了扩宽。

    最近在一个开源项目里见到有使用另一个工做流框架:flowable 。简单用了下感觉还是挺方便的,于是乎决定还是要来使用下并在此做下记录,便于后面用到时可以“拿来主义”,哈哈!

    什么是flowable?

    对于flowable是什么以及关于此框架的具体信息可以参看此项目的官方文档:https://www.flowable.org/docs/userguide/index.html

    官网对于此项目如何使用有非常详细的描述,只是目前还没有对应的中文文档。

    Flowable is a light-weight business process engine written in Java.这是官网文档对此框架的完美解释:Flowable是一个用java语言写的轻量级工作流引擎。

    在简单了解flowable后与activiti框架相比的第一感觉就是开发方便快速,易与springBoot等各种框架快速整合。如果项目中需要快速实现一些工作流的相关功能那么用此框架是一个不错的选择。

    使用版本

        用测试方便,这里都使用springBoot和flowable最新的稳定版本

        springBoot版本:2.0.1.RELEASE

         flowable版本:6.3.0

    Flowable与springBoot项目整合

    添加依赖

    将flowable的依赖加入到POM中即可,flowable使用需要一个数据库,这里为了方便我选择mysql

    <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!--flowable工作流依赖-->
            <dependency>
                <groupId>org.flowable</groupId>
                <artifactId>flowable-spring-boot-starter</artifactId>
                <version>6.3.0</version>
            </dependency>
            <!--mysql依赖-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.45</version>
            </dependency>
        </dependencies>        <dependency>
                <groupId>org.flowable</groupId>
                <artifactId>flowable-spring-boot-starter</artifactId>
                <version>6.3.0</version>
            </dependency>
            <!--mysql依赖-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.45</version>
            </dependency>
        </dependencies>

    flowable配置

    测试方便flowable配置为默认的即可。为了测试时方便看日志信息,我这里将flowable的定时job功能暂时关闭,其他的都用默认的

    当然记得要添加一个数据源,我这里添加的mysql,并且记得建好对应的mysql库,如果没有建就自己建一个吧

    like this:

    CREATE DATABASE  `flowable-spring-boot` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

     

    spring:
      datasource:
        url: jdbc:mysql://127.0.0.1:3306/flowable-spring-boot?characterEncoding=UTF-8
        username: root
        password: root
    flowable:
    #关闭定时任务JOB
      async-executor-activate: false

    这样操作后,flowable与springBoot的整个就完成了! 个人非常方便!

    然后就可以运行了,初次运行时flowable会将自动执行flowable中的初始化脚本完成工作流所需要的数据表的建立,如果指定的数据库中还未创建过flowable的相关数据表的话。

    定义流程文件

    上面已经完成了flowable与springboot的整合了,接下来就可以使用此框架进行流程需要开发了!

    同样在flowable官方文档中对于流程文件它有这样的建议:

    The Flowable engine expects processes to be defined in the BPMN 2.0 format, which is an XML standard that is widely accepted in the industry. 

    flowable建议采用业界标准BPMN2.0的XML来描述需要定义的工作流。

    那么BPMN这个流程文件应该怎么写呢?

    Typically, such a process definition is modeled with a visual modeling tool, such as the Flowable Designer (Eclipse) or the Flowable Modeler (web application).

    上官方文档中有看到这样的描述后即便我不会写也不怕了。通常都是通过专门的流程建模工具来画出来的,可以用Eclipse里的流程插件来画。同时Flowable也提供了对应的web管理台可以对流程文件进行创建。详见: Flowable UI applications

    为了方便测试,这里采用一个开源项目中的流程文件,其描述如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xmlns:flowable="http://flowable.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
                 xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
                 typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath"
                 targetNamespace="http://www.flowable.org/processdef">
        <process id="Expense" name="ExpenseProcess" isExecutable="true">
            <documentation>报销流程</documentation>
            <startEvent id="start" name="开始"></startEvent>
            <userTask id="fillTask" name="出差报销" flowable:assignee="${taskUser}">
                <extensionElements>
                    <modeler:initiator-can-complete xmlns:modeler="http://flowable.org/modeler">
                        <![CDATA[false]]></modeler:initiator-can-complete>
                </extensionElements>
            </userTask>
            <exclusiveGateway id="judgeTask"></exclusiveGateway>
            <userTask id="directorTak" name="经理审批">
                <extensionElements>
                    <flowable:taskListener event="create"
                                           class="com.haiyang.flowable.listener.ManagerTaskHandler"></flowable:taskListener>
                </extensionElements>
            </userTask>
            <userTask id="bossTask" name="老板审批">
                <extensionElements>
                    <flowable:taskListener event="create"
                                           class="com.haiyang.flowable.listener.BossTaskHandler"></flowable:taskListener>
                </extensionElements>
            </userTask>
            <endEvent id="end" name="结束"></endEvent>
            <sequenceFlow id="directorNotPassFlow" name="驳回" sourceRef="directorTak" targetRef="fillTask">
                <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='驳回'}]]></conditionExpression>
            </sequenceFlow>
            <sequenceFlow id="bossNotPassFlow" name="驳回" sourceRef="bossTask" targetRef="fillTask">
                <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='驳回'}]]></conditionExpression>
            </sequenceFlow>
            <sequenceFlow id="flow1" sourceRef="start" targetRef="fillTask"></sequenceFlow>
            <sequenceFlow id="flow2" sourceRef="fillTask" targetRef="judgeTask"></sequenceFlow>
            <sequenceFlow id="judgeMore" name="大于500元" sourceRef="judgeTask" targetRef="bossTask">
                <conditionExpression xsi:type="tFormalExpression"><![CDATA[${money > 500}]]></conditionExpression>
            </sequenceFlow>
            <sequenceFlow id="bossPassFlow" name="通过" sourceRef="bossTask" targetRef="end">
                <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='通过'}]]></conditionExpression>
            </sequenceFlow>
            <sequenceFlow id="directorPassFlow" name="通过" sourceRef="directorTak" targetRef="end">
                <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='通过'}]]></conditionExpression>
            </sequenceFlow>
            <sequenceFlow id="judgeLess" name="小于500元" sourceRef="judgeTask" targetRef="directorTak">
                <conditionExpression xsi:type="tFormalExpression"><![CDATA[${money <= 500}]]></conditionExpression>
            </sequenceFlow>
        </process>
        <bpmndi:BPMNDiagram id="BPMNDiagram_Expense">
            <bpmndi:BPMNPlane bpmnElement="Expense" id="BPMNPlane_Expense">
                <bpmndi:BPMNShape bpmnElement="start" id="BPMNShape_start">
                    <omgdc:Bounds height="30.0" width="30.0" x="285.0" y="135.0"></omgdc:Bounds>
                </bpmndi:BPMNShape>
                <bpmndi:BPMNShape bpmnElement="fillTask" id="BPMNShape_fillTask">
                    <omgdc:Bounds height="80.0" width="100.0" x="405.0" y="110.0"></omgdc:Bounds>
                </bpmndi:BPMNShape>
                <bpmndi:BPMNShape bpmnElement="judgeTask" id="BPMNShape_judgeTask">
                    <omgdc:Bounds height="40.0" width="40.0" x="585.0" y="130.0"></omgdc:Bounds>
                </bpmndi:BPMNShape>
                <bpmndi:BPMNShape bpmnElement="directorTak" id="BPMNShape_directorTak">
                    <omgdc:Bounds height="80.0" width="100.0" x="735.0" y="110.0"></omgdc:Bounds>
                </bpmndi:BPMNShape>
                <bpmndi:BPMNShape bpmnElement="bossTask" id="BPMNShape_bossTask">
                    <omgdc:Bounds height="80.0" width="100.0" x="555.0" y="255.0"></omgdc:Bounds>
                </bpmndi:BPMNShape>
                <bpmndi:BPMNShape bpmnElement="end" id="BPMNShape_end">
                    <omgdc:Bounds height="28.0" width="28.0" x="771.0" y="281.0"></omgdc:Bounds>
                </bpmndi:BPMNShape>
                <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
                    <omgdi:waypoint x="315.0" y="150.0"></omgdi:waypoint>
                    <omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
                <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
                    <omgdi:waypoint x="505.0" y="150.16611295681062"></omgdi:waypoint>
                    <omgdi:waypoint x="585.4333333333333" y="150.43333333333334"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
                <bpmndi:BPMNEdge bpmnElement="judgeLess" id="BPMNEdge_judgeLess">
                    <omgdi:waypoint x="624.5530726256983" y="150.44692737430168"></omgdi:waypoint>
                    <omgdi:waypoint x="735.0" y="150.1392757660167"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
                <bpmndi:BPMNEdge bpmnElement="directorNotPassFlow" id="BPMNEdge_directorNotPassFlow">
                    <omgdi:waypoint x="785.0" y="110.0"></omgdi:waypoint>
                    <omgdi:waypoint x="785.0" y="37.0"></omgdi:waypoint>
                    <omgdi:waypoint x="455.0" y="37.0"></omgdi:waypoint>
                    <omgdi:waypoint x="455.0" y="110.0"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
                <bpmndi:BPMNEdge bpmnElement="bossPassFlow" id="BPMNEdge_bossPassFlow">
                    <omgdi:waypoint x="655.0" y="295.0"></omgdi:waypoint>
                    <omgdi:waypoint x="771.0" y="295.0"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
                <bpmndi:BPMNEdge bpmnElement="judgeMore" id="BPMNEdge_judgeMore">
                    <omgdi:waypoint x="605.4340277777778" y="169.56597222222223"></omgdi:waypoint>
                    <omgdi:waypoint x="605.1384083044983" y="255.0"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
                <bpmndi:BPMNEdge bpmnElement="directorPassFlow" id="BPMNEdge_directorPassFlow">
                    <omgdi:waypoint x="785.0" y="190.0"></omgdi:waypoint>
                    <omgdi:waypoint x="785.0" y="281.0"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
                <bpmndi:BPMNEdge bpmnElement="bossNotPassFlow" id="BPMNEdge_bossNotPassFlow">
                    <omgdi:waypoint x="555.0" y="295.0"></omgdi:waypoint>
                    <omgdi:waypoint x="455.0" y="295.0"></omgdi:waypoint>
                    <omgdi:waypoint x="455.0" y="190.0"></omgdi:waypoint>
                </bpmndi:BPMNEdge>
            </bpmndi:BPMNPlane>
        </bpmndi:BPMNDiagram>
    </definitions>

    其中的两个代理类为:

    import org.flowable.engine.delegate.TaskListener;
    import org.flowable.task.service.delegate.DelegateTask;
    
    public class ManagerTaskHandler implements TaskListener {
    
        @Override
        public void notify(DelegateTask delegateTask) {
            delegateTask.setAssignee("经理");
        }
    
    }
    public class BossTaskHandler implements TaskListener {
    
        @Override
        public void notify(DelegateTask delegateTask) {
            delegateTask.setAssignee("老板");
        }
    
    }

    为了方便,也可以去掉这两个JAVA类,将其对应的task改写为如下的形式:

    <userTask id="holidayApprovedTask" name="Holiday approved" flowable:assignee="${employee}"/>

    尽管上面的BPMN文件很长,但放心,毕竟那是通过相关的工具生成出来的,对于核心的逻辑部分也很少(主要在process 标签内) ,如需要详细了解的可自行学习下BPMN的标签即可!当然,在flowable的使用文档中也有相关的描述,详见:Creating a ProcessEngine

    如上定义好一个流程文件后,将其命令为ExpenseProcess.bpmn20.xml并将其放于项目中的resource目录下的processes(如此目录不存在自行创建)目录下就可以了。

    like this:

    这样当此框架启动的时候它会默认加载resource目录下的processes时就可以将此流程配置加载到数据库进行持久化了

    测试controller

    为了方便这里通过一个controller来完成此DEMO的快速编写

    @Controller
    @RequestMapping(value = "expense")
    public class ExpenseController {
        @Autowired
        private RuntimeService runtimeService;
        @Autowired
        private TaskService taskService;
        @Autowired
        private RepositoryService repositoryService;
        @Autowired
        private ProcessEngine processEngine;
    
    /***************此处为业务代码******************/
    }

    写一个controller,并注入由flowable框架启动时自动注册的几个bean,下面的功能将会用到!

    开始流程

        /**
         * 添加报销
         *
         * @param userId    用户Id
         * @param money     报销金额
         * @param descption 描述
         */
        @RequestMapping(value = "add")
        @ResponseBody
        public String addExpense(String userId, Integer money, String descption) {
            //启动流程
            HashMap<String, Object> map = new HashMap<>();
            map.put("taskUser", userId);
            map.put("money", money);
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Expense", map);
            return "提交成功.流程Id为:" + processInstance.getId();
        }

    上面的代码通过接收用户的一个请求传入用户的ID和金额以及描述信息来开启一个报销流程,并返回给用户这个流程的Id

    查询流程列表,待办列表

        /**
         * 获取审批管理列表
         */
        @RequestMapping(value = "/list")
        @ResponseBody
        public Object list(String userId) {
            List<Task> tasks = taskService.createTaskQuery().taskAssignee(userId).orderByTaskCreateTime().desc().list();
            for (Task task : tasks) {
                System.out.println(task.toString());
            }
            return tasks.toArray().toString();
        }

    通过上面的代码获取出此用户需要处理的流程

    批准,同意

        /**
         * 批准
         *
         * @param taskId 任务ID
         */
        @RequestMapping(value = "apply")
        @ResponseBody
        public String apply(String taskId) {
            Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
            if (task == null) {
                throw new RuntimeException("流程不存在");
            }
            //通过审核
            HashMap<String, Object> map = new HashMap<>();
            map.put("outcome", "通过");
            taskService.complete(taskId, map);
            return "processed ok!";
        }

    通过前端传入的任务ID来对此流程进行同意处理

    拒绝,不同意

        /**
         * 拒绝
         */
        @ResponseBody
        @RequestMapping(value = "reject")
        public String reject(String taskId) {
            HashMap<String, Object> map = new HashMap<>();
            map.put("outcome", "驳回");
            taskService.complete(taskId, map);
            return "reject";
        } 

    生成当前流程图表

        /**
         * 生成流程图
         *
         * @param processId 任务ID
         */
        @RequestMapping(value = "processDiagram")
        public void genProcessDiagram(HttpServletResponse httpServletResponse, String processId) throws Exception {
            ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processId).singleResult();
    
            //流程走完的不显示图
            if (pi == null) {
                return;
            }
            Task task = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();
            //使用流程实例ID,查询正在执行的执行对象表,返回流程实例对象
            String InstanceId = task.getProcessInstanceId();
            List<Execution> executions = runtimeService
                    .createExecutionQuery()
                    .processInstanceId(InstanceId)
                    .list();
    
            //得到正在执行的Activity的Id
            List<String> activityIds = new ArrayList<>();
            List<String> flows = new ArrayList<>();
            for (Execution exe : executions) {
                List<String> ids = runtimeService.getActiveActivityIds(exe.getId());
                activityIds.addAll(ids);
            }
    
            //获取流程图
            BpmnModel bpmnModel = repositoryService.getBpmnModel(pi.getProcessDefinitionId());
            ProcessEngineConfiguration engconf = processEngine.getProcessEngineConfiguration();
            ProcessDiagramGenerator diagramGenerator = engconf.getProcessDiagramGenerator();
            InputStream in = diagramGenerator.generateDiagram(bpmnModel, "png", activityIds, flows, engconf.getActivityFontName(), engconf.getLabelFontName(), engconf.getAnnotationFontName(), engconf.getClassLoader(), 1.0);
            OutputStream out = null;
            byte[] buf = new byte[1024];
            int legth = 0;
            try {
                out = httpServletResponse.getOutputStream();
                while ((legth = in.read(buf)) != -1) {
                    out.write(buf, 0, legth);
                }
            } finally {
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
            }
        } 

    通过传入流程ID生成当前流程的流程图给前端,如果流程中使用到中文且生成的图片是乱码的,则需要进配置下字体:

    /**
     * @author haiyangp
     * date:  2018/4/7
     * desc: flowable配置----为放置生成的流程图中中文乱码
     */
    @Configuration
    public class FlowableConfig implements EngineConfigurationConfigurer<SpringProcessEngineConfiguration> {
    
    
        @Override
        public void configure(SpringProcessEngineConfiguration engineConfiguration) {
            engineConfiguration.setActivityFontName("宋体");
            engineConfiguration.setLabelFontName("宋体");
            engineConfiguration.setAnnotationFontName("宋体");
        }
    }

    整体演示

    上面的代码写好后就可以演示下整体流程了

    1.先启动好此项目,然后创建一个流程:

    访问:http://localhost:8080/expense/add?userId=123&money=123321

    返回:提交成功.流程Id为:2501

     

    2.查询待办列表:

    访问:http://localhost:8080/expense/list?userId=123

    输出:Task[id=2507, name=出差报销]

     

    3.同意:

    访问:http://localhost:8080/expense/apply?taskId=2507

    返回:processed ok!

     

    4.生成流程图:

    访问:http://localhost:8080/expense/processDiagram?processId=2501

    返回如下图片:

    整体流程截图如下:

    总结

    通过springBoot与flowable的整合体验到了工作流的开发原来如此简单方便。

    给此框架点赞,向巨人们致敬!

     

    本文源码地址:https://github.com/puhaiyang/flowable-springboot

    文末推荐一个关于flowable的QQ群!

    QQ群:242771252

    点击链接加入群【flowable学习交流】:https://jq.qq.com/?_wv=1027&k=5DKcjgU

    展开全文
  • 你明白工作流是什么、怎么用了吗?

    万次阅读 多人点赞 2015-12-20 23:42:47
    我们可以将工作流理解为工作流程,它在IT领域不算是“新人”了,工作流思想在上世纪60年代就有人提出过;70年代就有人开始尝试,但是由于当时许多的限制,工作流一直没有成功的被实现;80年代才出现第一批成功的工作...

    ·概念

      今天小编将和大家分享一个新的知识点——工作流。我们可以将工作流理解为工作流程,它在IT领域不算是“新人”了,工作流思想在上世纪60年代就有人提出过;70年代就有人开始尝试,但是由于当时许多的限制,工作流一直没有成功的被实现;80年代才出现第一批成功的工作流系统;90年代工作流技术走向了第一个发展高峰期;90年代后至今工作流出现了很多版本,但是主旨还是不变的,为了使我们的工作变得更加高效。

    WfMC(Workflow Management Coalition)工作流管理联盟对工作流的定义是这样的:工作流是指一类能够完全自动执行的经营过程,根据一系列过程规则,将文档、信息或任务在不同的执行者之间进行传递与执行。说的直白一点工作流就是封装好的一种框架,我们利用这种框架来解决需要多个人或者多个部门协同完成的某项工作。工作流框架有许多都是开源的,我们可以尽情的拿来学习、研究最终运用到我们的系统中。

    ·分类

      正如我们有许多程序设计语言一样,工作流也分为几类,下面就让我们来认识几种比较常见的工作流:
    第一个我们要介绍微软的一款工作流软件——WWF(Microsoft Windows Workflow Foundation),这是微软出的一款框架,这款框架是和微软的VS兼容的,而且它是一款可扩展的框架。在VS中我们可以创建一个工作流项目,小编下午实验了一个小时没有实现,但是后面会进行再次尝试的。
    以下内容为小编从网上找到的一些资源,供大家参考:.Net 三款工作流引擎比较:WWF、netBPM 和 ccflow

    公司有两级领导,一级为主管Chief,一级为老板Boss
    场景描述:

      在某公司中,部门员工休假需要主管Chief的批准。 
      如果休假天数大于10天,则 在部门主管同意后,还必须老板Boss批准。 
      如果是部门主管请假则直接提交老板批准。 
      在休假被批准之前,申请人可以撤销休假申请。 
      申请批准后,对休假天数进行修改(也可以是其他业务数据处理)。 每次休假申请结束之 后,不管通过未通过或是否取消,都必须记录下来。 
      流程结束时,系统要把请假的结果信息Email给申请人。

      对于大于10天的申请,如果部门主管已批准同意而上级主管还未批准,这时申请人撤销申请后,系统应发Email通知部门主管申请已撤销。

    使用WWF创建流程:
    1. 启动VS2010,创建一个顺序工作流控制台的程序。
    2. 输入项目名称,点击确定,将自动进入流程设计界面。
    3. 自动生成的Workflow1.cs是一个工作流组件。
    4. 工具箱中拖放一个IfElse活动组件到设计界面上。
    5. 此时就需要较多的编码工作和表单界面设计工作,如在idelseBranchActivitiy1左侧分支,用以判断请假人是否新申请请假还是取消请假,激活Conditiong属性,并且添加内部事件EvaluateQingJiaNoValidCode,并激活,在内部输入逻辑代码根据数据库记录判断请假是否通过,未通过则取消请假。也可以走另一分支EvaluateQingJiaCode继续申请新的请假;
    6. 拖放parallelActivity1组件在IfElse节点后,用以判断请假人是否为Chief,设置sequenceActivity1中的codeActivity3属性的ExecuteCode处理程序为EvaluateChiefNoValidCode,并激活,内部代码用以判断不是Chief的情况,另一分支sequenceActivity1中则判断是Chief的情况;
    7.如果不是Chief请假,则需要在EvaluateChiefNoValidCode中进行逻辑判断和表单的设计,填写请假申请单, 并拖放IfElse组件,实现其中的codeActivity6代码用以判断大于10天的情况。
    8.F5即可运行控制台程序,其中的通过未通过或是否取消的数据需要记录,需要通过代码和设计数据库来实现,发送Email也需要代码实现,WWF没有提供该功能。

                                                                         


    第二个我们介绍一下BMP,这个工作流全称是Business Process Management(业务流程管理)。它分为两款java版(JBPM)和.net版(NETBPM),它是开源的框架我们同样可以在网络上学习。在百科中有人阐述到JBPM是西方思想的结晶,跟中国理解的业务存在一定的差距。
    JBPM的另一个特色是它使用Hibernate来管理它的数据库。Hibernate是目前Java领域非常流行的一种数据存储层解决方案,只要是 Hibernate 支持的数据库, JBPM 也就支持。通过Hibernate,JBPM将数据的管理职能分离出去,自己专注于业务逻辑的处理。
    因为对hibernate不太理解,所以重要的理解工作还是留到后面有机会的情况下继续学习,推荐一篇看到的博客:工作流技术jbpm学习总结
    BPM工作流的工作原理用图来表示的话如下所示:(场景类似上一个例子)
                                                                                                            
    第三个工作流小编和大家说说Activiti工作流,这个工作流是从JBPM中发展而来的,老师上课的时候说过一句学校用的也是这个工作流,但是上网搜了一些资料,发现自己还是不太懂,只是能够理解它的意思。


    这次就先跟大家聊到这里,等下次我们深入了解一下工作流。

    PS:给大家推荐一篇师哥写的文章:从程序员的角度来看为什么我们需要工作流
    展开全文
  • 工作流入门(基础概念篇)

    万次阅读 2018-08-30 10:56:25
    1、 工作流管理系统基本概念 近两年随着电子商务环境不断演进(例如阿里巴巴的B2B电子商务平台),从原来支持企业内部单系统的业务流程、到企业内部应用、服务的集成,再进一步向企业与合作伙伴之间业务交互,工作...
  • 一套完整的工作流源码,加上自己深刻的工作流理解,以及工作流的学习笔记。外加web端工作流开发的研究生论文。是工作流的学习帮助十分之大,是一份非常好的工作流学习资料。
  • C#工作流引擎源码(绝对好!!)

    千次下载 热门讨论 2008-12-30 14:31:23
    C#工作流引擎源码,不用多说了,看看就知道了。很经典的源码!
  • 一套完整自定义工作流的实现

    万次阅读 2018-07-31 15:41:52
    工作流以一套金融软件业务处理流程为例,实现功能包括:流程自定义、步骤自定义、步骤重复次数、步骤类型(顺序/并行)、定义排序功能,完全使用数据库实现,本文将详细分析业务流程、系统设计及实现细节
  • 工作流

    万次阅读 2018-10-17 10:10:54
    一、 什么是工作流  以请假为例,现在大多数公司的请假流程是这样的  员工打电话(或网聊)向上级提出请假申请——上级口头同意——上级将请假记录下来——月底将请假记录上交公司——公司将请假录入电脑  ...
  • 工作流(Workflow) -- 工作流简介

    千次阅读 2018-09-08 21:05:00
    ## 工作流引擎 ProcessEngine对象 这是Activiti工作的核心。负责生成流程运行时的各种实例及数据、监控和管理流程的运行。 工作流的API所有的调用都要用到工作流引擎。 数据库 Activiti的后台是有数据库的支持,...
  • 工作流(Workflow)

    万次阅读 2017-12-22 13:46:43
    工作流(Workflow)是对工作流程及其各操作步骤之间业务规则的抽象、概括描述。工作流建模,即将工作流程中的工作如何前后组织在一起的逻辑和规则,在计算机中以恰当的模型表达并对其实施计算。工作流要解决的主要...
  • 三分钟明白 Activiti工作流 -- java运用

    万次阅读 多人点赞 2017-06-14 18:03:03
    一、 什么是工作流 以请假为例,现在大多数公司的请假流程是这样的 员工打电话(或网聊)向上级提出请假申请——上级口头同意——上级将请假记录下来——月底将请假记录上交公司——公司将请假录入电脑 采用工作...
  • 手把手教你如何玩转Activiti工作流

    万次阅读 多人点赞 2018-01-30 19:51:36
    一:Activiti的介绍 场景:学校 主角:阿毛 , 班主任 ,教务处处长 问题:有一天,阿毛到学校,感觉到身体不舒服,然后想跟班主任请假,然后班主任告诉阿毛说,你想请假,那么就必须要请假条,这个上面必须要我...
  • 盘古BPM工作流平台(DMN)是国内首款开源的互联网决策引擎系统,可以无缝对接Activiti/Flowable/Zeebe/Drools等多种工作流系统。拥有独立的DMN1.3标准设计器、解析器、决策引擎、支持决策表(decision table)、DRD、...
  • Activiti工作流教程

    万次阅读 多人点赞 2017-03-03 17:43:32
    1:工作流的概念说明:1) 假设:这两张图就是华谊兄弟的请假流程图2) 图的组成部分:A. 人物:范冰冰 冯小刚王中军B. 事件(动作):请假、批准、不批准 工作流(Workflow),就是“业务过程的部分或整体在计算机...
  • activiti工作流-概述

    万次阅读 热门讨论 2018-06-12 10:57:23
    1应用场景1.1业务流程采购系统完成了企业的日常采购管理,包括采购单管理、采购单审核、入库、结算等模块。用户角色包括:员工、部门经理、总经理、财务。基本业务流程如下:1.2业务的概念什么是业务?...
  • 工作流引擎

    万次阅读 2015-07-24 14:24:53
    工作流的概念起源于生产组织和办公自动化领域。它是针对日常工作中具有固定程序的活动而提出得一个概念。它的主要特点是使处理过程自动化,通过将工作分解成定义良好的任务、角色,按照一定的规则和过程来执行这些...
  • spring工作流引擎

    千次阅读 2005-10-09 16:50:00
    在对工作流简单介绍之后,将要介绍在基本工作流场景中基于Spring的工作流API的使用。(2,800个英文单词; 2005/4/11) 许多J2EE应用程序要求在一个和主机分离的上下文中执行处理过程。在许多情况下,这些后台的进程...
  • 工作流

    千次阅读 2018-01-02 17:59:17
    共有90款 工作流引擎开源软件驰骋工作流引擎 ccflow 开源的驰骋工作流引擎简介 驰骋工作流引擎研发与2003年,具有.net与java两个版本,它们代码结构、数据库结构、设计思想、功能组成、操作手册完全相同。流程表单...
  • 分布式工作流引擎

    千次阅读 2007-01-31 21:57:00
    可自管理的分布式工作流引擎的设计与实现 摘要:针对当前企业和政府对分布式工作流应用的需求趋势,给出了一个基于JMX(Java Management Extensions)-Java管理扩展框架和Observer观察者模式的可自管理的分布式...

空空如也

1 2 3 4 5 ... 20
收藏数 1,095,286
精华内容 438,114
关键字:

工作流