用activiti 工作流 实现简单的请假 附带源码 / SSM整合Activiti工作流(不错，可以看看)

最新推荐文章于 2024-03-12 13:16:04 发布
置顶 最新推荐文章于 2024-03-12 13:16:04 发布
阅读量1.5w 收藏 53
点赞数 9

http://blog.csdn.net/lvsehuoyan/article/details/38408649

新建一个Maven项目

项目结构

pom.xml


[html] view plain copy
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.     <modelVersion>4.0.0</modelVersion>  
  4.   
  5.     <groupId>com.dengkun.activiti</groupId>  
  6.   <artifactId>Test1</artifactId>  
  7.   <version>0.0.1-SNAPSHOT</version>  
  8.     <packaging>jar</packaging>  
  9.     <name>Test1Name</name>  
  10.   <description>Test1d</description>  
  11.   
  12.     <properties>  
  13.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  14.     </properties>  
  15.   
  16.     <dependencies>  
  17.         <dependency>  
  18.           <groupId>org.vaadin.addons</groupId>  
  19.           <artifactId>dcharts-widget</artifactId>  
  20.           <version>0.10.0</version>  
  21.           <type>jar</type>  
  22.         </dependency>  
  23.         <!-- Activiti -->  
  24.         <dependency>  
  25.             <groupId>org.activiti</groupId>  
  26.             <artifactId>activiti-engine</artifactId>  
  27.             <version>5.15.1</version>  
  28.         </dependency>  
  29.         <dependency>  
  30.             <groupId>org.activiti</groupId>  
  31.             <artifactId>activiti-spring</artifactId>  
  32.             <version>5.15.1</version>  
  33.         </dependency>  
  34.         <dependency>  
  35.             <groupId>org.activiti</groupId>  
  36.             <artifactId>activiti-explorer</artifactId>  
  37.             <version>5.15.1</version>  
  38.         </dependency>  
  39.         <!-- Database -->  
  40.         <dependency>  
  41.             <groupId>commons-dbcp</groupId>  
  42.             <artifactId>commons-dbcp</artifactId>  
  43.             <version>1.4</version>  
  44.         </dependency>  
  45.         <dependency>  
  46.             <groupId>mysql</groupId>  
  47.             <artifactId>mysql-connector-java</artifactId>  
  48.             <version>5.1.29</version>  
  49.         </dependency>  
  50.         <!-- spring -->  
  51.         <dependency>  
  52.             <groupId>org.springframework</groupId>  
  53.             <artifactId>spring-core</artifactId>  
  54.             <version>4.0.6.RELEASE</version>  
  55.         </dependency>  
  56.         <dependency>  
  57.             <groupId>org.springframework</groupId>  
  58.             <artifactId>spring-beans</artifactId>  
  59.             <version>4.0.6.RELEASE</version>  
  60.         </dependency>  
  61.         <dependency>  
  62.             <groupId>org.springframework</groupId>  
  63.             <artifactId>spring-test</artifactId>  
  64.             <version>4.0.6.RELEASE</version>  
  65.         </dependency>  
  66.         <dependency>  
  67.             <groupId>org.springframework</groupId>  
  68.             <artifactId>spring-context</artifactId>  
  69.             <version>4.0.6.RELEASE</version>  
  70.         </dependency>  
  71.         <dependency>  
  72.             <groupId>org.springframework</groupId>  
  73.             <artifactId>spring-context-support</artifactId>  
  74.             <version>4.0.6.RELEASE</version>  
  75.         </dependency>  
  76.         <dependency>  
  77.             <groupId>org.springframework</groupId>  
  78.             <artifactId>spring-tx</artifactId>  
  79.             <version>4.0.6.RELEASE</version>  
  80.         </dependency>  
  81.         <dependency>  
  82.             <groupId>org.springframework</groupId>  
  83.             <artifactId>spring-orm</artifactId>  
  84.             <version>4.0.6.RELEASE</version>  
  85.         </dependency>  
  86.         <!-- mybatis -->  
  87.         <dependency>  
  88.             <groupId>org.mybatis</groupId>  
  89.             <artifactId>mybatis</artifactId>  
  90.             <version>3.2.5</version>  
  91.         </dependency>  
  92.         <dependency>  
  93.             <groupId>org.mybatis</groupId>  
  94.             <artifactId>mybatis-spring</artifactId>  
  95.             <version>1.2.2</version>  
  96.         </dependency>  
  97.         <!-- junit -->  
  98.         <dependency>  
  99.             <groupId>junit</groupId>  
  100.             <artifactId>junit</artifactId>  
  101.             <version>4.11</version>  
  102.         </dependency>  
  103.         <!-- log -->  
  104.         <dependency>  
  105.             <groupId>log4j</groupId>  
  106.             <artifactId>log4j</artifactId>  
  107.             <version>1.2.4</version>  
  108.         </dependency>  
  109.         <dependency>  
  110.             <groupId>org.slf4j</groupId>  
  111.             <artifactId>slf4j-api</artifactId>  
  112.             <version>1.7.6</version>  
  113.         </dependency>  
  114.         <dependency>  
  115.             <groupId>org.slf4j</groupId>  
  116.             <artifactId>jcl-over-slf4j</artifactId>  
  117.             <version>1.7.6</version>  
  118.         </dependency>  
  119.         <dependency>  
  120.             <groupId>org.slf4j</groupId>  
  121.             <artifactId>slf4j-log4j12</artifactId>  
  122.             <version>1.7.6</version>  
  123.         </dependency>  
  124.         <!-- commons -->  
  125.         <dependency>  
  126.             <groupId>org.apache.commons</groupId>  
  127.             <artifactId>commons-lang3</artifactId>  
  128.             <version>3.1</version>  
  129.         </dependency>  
  130.         <dependency>  
  131.             <groupId>commons-io</groupId>  
  132.             <artifactId>commons-io</artifactId>  
  133.             <version>2.4</version>  
  134.         </dependency>  
  135.         <dependency>  
  136.             <groupId>commons-fileupload</groupId>  
  137.             <artifactId>commons-fileupload</artifactId>  
  138.             <version>1.2.2</version>  
  139.         </dependency>  
  140.         <!-- other -->  
  141.         <dependency>  
  142.             <groupId>javax.annotation</groupId>  
  143.             <artifactId>javax.annotation-api</artifactId>  
  144.             <version>1.2</version>  
  145.         </dependency>  
  146.         <dependency>  
  147.             <groupId>joda-time</groupId>  
  148.             <artifactId>joda-time</artifactId>  
  149.             <version>2.1</version>  
  150.         </dependency>  
  151.           
  152.     </dependencies>  
  153. </project>  

本人使用的是开源中国的库，dcharts-widget  路径不同，所以要复制到本地的私服库，注意名字不能错。(  http://download.csdn.NET/detail/lvsehuoyan/9555324)


activiti.cfg.xml:

[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">  
  5.       
  6.     <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">  
  7.         <property name="jdbcUrl" value="jdbc:mysql:///myactiviti" />  
  8.         <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />  
  9.         <property name="jdbcUsername" value="root" />  
  10.         <property name="jdbcPassword" value="123456" />  
  11.         <property name="databaseSchemaUpdate" value="true" />  
  12.     </bean>  
  13. </beans>  

在 resource 下新建Activiti Diagram

可以通过这个地址安装插件  《Activiti BPMN 2.0 designer - http://activiti.org/designer/update/ 》(如果是公司需要代理才能连接外网，请注意设置代理)



将UserTask分别修改成入下图所示



修改好ID 和 NAME然后在修改Main config中的Assignee，员工请假修改为张三，老板审批修改为老板



点击Window--->Preferences--->Activiti--->Save Actions:将Create process definition image when saving the diagram勾选

然后保存bpmn文件的时候会自动帮你截图

通过ProcessEngines.getDefaultProcessEngine获取流程引擎

注：请先在MySQL建立数据库myactiviti，使用默认设置即可，然后运行App.Java 中的main函数，当获取到的processEngine对象不为空时   就会在数据库创建关于activiti的23张表，要保证数据库连接正常。


[java] view plain copy
  1. public class App {  
  2.     public static void main(String[] arg){  
  3.         ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();   
  4.     }  
  5. }  

通过源码可以看到  getDefaultProcessEngine方法会通过默认的activiti.cfg.xml文件名或者是activiti-context.xml文件名读取xml文件





具体作用如下：


跟详细的情况可以去下面这个地址了解:

http://www.cnblogs.com/llzgzljl/archive/2013/10/07/3356108.html

此时你可以在数据库中看到act_ge_property表中插入了3条数据

将MyLeave.bpmn和MyLeave.png打包成myleave.zip文件（一定要是zip别压缩成rar）

执行以下方法，发布请假流程：

MyTest.java

附录的项目的代码，建议执行一个函数看下数据库再执行下一个，能比较快速上手数据库。

注：保证数据库链接正常，否则processEngine会报空指针。

[java] view plain copy
  1. /** 
  2.  * 发布流程 
  3.  * 发布流程后，流程文件会保存到数据库中 
  4.  */  
  5. @Test  
  6. public void deployFlow(){  
  7.     RepositoryService repositoryService = processEngine.getRepositoryService();  
  8.       
  9.     //获取在classpath下的流程文件  
  10.     InputStream in = this.getClass().getClassLoader().getResourceAsStream("myleave.zip");  
  11.     ZipInputStream zipInputStream = new ZipInputStream(in);  
  12.     //使用deploy方法发布流程  
  13.     repositoryService.createDeployment()  
  14.                      .addZipInputStream(zipInputStream)  
  15.                      .name("Myleave")  
  16.                      .deploy();  
  17. }  

查看数据库  发布的流程文件信息会保存在下面的三张表中：

 

我们可以通过RepositoryService获取详细的流程定义信息

[html] view plain copy
  1. @Test  
  2. public void queryProcdef(){  
  3.     RepositoryService repositoryService = processEngine.getRepositoryService();  
  4.     //创建查询对象  
  5.     ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();  
  6.     //添加查询条件  
  7.     query.processDefinitionKey("myProcess");//通过key获取  
  8.         // .processDefinitionName("My process")//通过name获取  
  9.         // .orderByProcessDefinitionId()//根据ID排序  
  10.     //执行查询获取流程定义明细  
  11.     List<ProcessDefinition> pds = query.list();  
  12.     for (ProcessDefinition pd : pds) {  
  13.         System.out.println("ID:"+pd.getId()+",NAME:"+pd.getName()+",KEY:"+pd.getKey()+",VERSION:"+pd.getVersion()+",RESOURCE_NAME:"+pd.getResourceName()+",DGRM_RESOURCE_NAME:"+pd.getDiagramResourceName());  
  14.     }  
  15. }  

key 和 name 就是我们原先画bpmn时候声明的：

 

使用流程定义的Key发布一个请假流程：

[java] view plain copy
  1. /** 
  2.      * 发布流程 
  3.      */  
  4.     @Test  
  5.     public void startFlow(){  
  6.           
  7.         RuntimeService runtimeService = processEngine.getRuntimeService();  
  8.         /** 
  9.          * 启动请假单流程  并获取流程实例 
  10.          * 因为该请假单流程可以会启动多个所以每启动一个请假单流程都会在数据库中插入一条新版本的流程数据 
  11.          * 通过key启动的流程就是当前key下最新版本的流程 
  12.          *  
  13.          */  
  14.         ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess");  
  15.         System.out.println("id:"+processInstance.getId()+",activitiId:"+processInstance.getActivityId());  
  16.     }  

流程发布后在  act_ru_task ，act_ru_execution， act_ru_identitylink 表中插入流程数据

接下来就可以通过用户ID去查看该用户的任务了

[java] view plain copy
  1. /** 
  2.  * 查看任务 
  3.  */  
  4. @Test  
  5. public void queryTask(){  
  6.     //获取任务服务对象  
  7.     TaskService taskService = processEngine.getTaskService();  
  8.     //根据接受人获取该用户的任务  
  9.     List<Task> tasks = taskService.createTaskQuery()  
  10.                                 .taskAssignee("张三")  
  11.                                 .list();  
  12.     for (Task task : tasks) {  
  13.         System.out.println("ID:"+task.getId()+",姓名:"+task.getName()+",接收人:"+task.getAssignee()+",开始时间:"+task.getCreateTime());  
  14.     }  
  15. }  

提出请假申请，启动流程

[java] view plain copy
  1. @Test  
  2. public void startTask(){  
  3.     TaskService taskService = processEngine.getTaskService();  
  4.     //taskId 就是查询任务中的 ID  
  5.     String taskId = "204";  
  6.     //完成请假申请任务  
  7.     taskService.complete(taskId );  
  8. }  

查看数据库变化 可以看到 表中的数据已经变成了老板审批相关数据

老板查看任务 ，并审批请假

[java] view plain copy
  1. /** 
  2.  * 查看任务 
  3.  */  
  4. @Test  
  5. public void queryTask(){  
  6.     //获取任务服务对象  
  7.     TaskService taskService = processEngine.getTaskService();  
  8.     //根据接受人获取该用户的任务  
  9.     List<Task> tasks = taskService.createTaskQuery()  
  10.                                 .taskAssignee("老板")  
  11.                                 .list();  
  12.     for (Task task : tasks) {  
  13.         System.out.println("ID:"+task.getId()+",姓名:"+task.getName()+",接收人:"+task.getAssignee()+",开始时间:"+task.getCreateTime());  
  14.     }  
  15. }  

[java] view plain copy
  1. @Test  
  2. public void startTask(){  
  3.     TaskService taskService = processEngine.getTaskService();  
  4.     //taskId 就是查询任务中的 ID  
  5.     String taskId = "302";  
  6.     //完成请假申请任务  
  7.     taskService.complete(taskId );  
  8. }  

流程完毕，可以再act_hi_actinst表中看到整个请假流程

 

整个流程的过程是  1.发布流程 --->2.启动流程--->3.相关人查看任务完成并完成

数据都是存放在数据库中


具体详情可以查看Activiti 用户手册

http://www.mossle.com/docs/activiti/#


博文原址为：http://blog.csdn.net/a67474506/article/details/38266129感谢原博主的博文，让我3个小时就搞明白，之前看了陆陆续续看了几个月的说明书，还是没有入门，看此文让我顿时明悟。原文没有附录项目源码，我顺手上传我的，希望能让帮助更多的朋友！ 奋斗  


源码下载路径：http://download.csdn.net/detail/lvsehuoyan/7733429


======================================================================================================


http://blog.csdn.net/lovemenghaibin/article/details/50569606


在工作流中，我们一切工作流的基本就是工作引擎（ProcessEngine），继承于EngineService接口，包括流程部署，数据库连接都是靠着ProcessEngine来实现的。而ProcessEngineConfiguration：流程引擎配置，可以设置数据库等，默认的数据库是h2，持久化实现使用的Mybatis，这里我们用的是MySQL。

       那么既然无论是jbpm或者是activiti都需要ProcessEngine来驱动，那么我们就说一下工作流引擎的使用吧。

       流程部署

       当我们将我们的业务画成图的时候，然后利用工作流引擎部署，也就是将我们的流程图信息放到数据库，图和代码如下：

        

[java] view plain copy
  1. /**部署流程定义*/  
  2.     @Test  
  3.     public void deploymentProcessDefinition(){  
  4.         Deployment deployment = processEngine.getRepositoryService()  //用于流程定义和部署相关对象的Service  
  5.                         .createDeployment()   //创建一个部署对象  
  6.                         .name("leaveBill部门程序")  
  7.                         .addClasspathResource("diagrams/LeaveBill.bpmn") //从ClassPath资源中加载，一次只能加载一个文件  
  8.                         .addClasspathResource("diagrams/LeaveBill.png")  //从ClassPath资源中加载，一次只能加载一个文件  
  9.                         .deploy();  
  10.           
  11.         System.out.println("deployment" + deployment.getId());   //1  
  12.         System.out.println("deployment" + deployment.getName());//部门程序  
  13.       
  14.     }  
      打印结果如下：

      deployment1
      deploymenthellworld部门程序

      数据库（部署相关表）解析

      我们看一下数据库的表会发现，每次部署都是涉及的那三张表，act_re_deployment（流程部署表）

      该表包含了流程部署的名称，ID，和部署时间

         act_re_procdef（流程定义表）

      该表有流程定义的主键key，版本（version）源文件名和图示，还有流程定义ID（key + 版本号+随机生成的数字）

     act_ge_bytearray（资源文件表）    

       保存了资源的位置和存储方式和部署ID，版本号ID等信息

      act_ge_property：主键生成策略表

         定义了主键生成的策略信息

        执行流程

        顾名思义，就是当我们有一个人开始申请请假的时候我们就要执行该请假的流程实例了

[java] view plain copy
  1. /** 
  2.  * 执行流程实例 
  3.  */  
  4. @Test  
  5. public void startProcessInstance(){  
  6.     String processInstanceKey = "LeaveBill";  
  7.     ProcessInstance pi = processEngine.getRuntimeService()  
  8.                         .startProcessInstanceByKey(processInstanceKey);  
  9.     System.out.println("流程实例id：" + pi.getId());  //流程实例id  101  
  10.     System.out.println("流程定义id：" + pi.getProcessDefinitionId());   //流程定义ID helloworld:1:4  
  11. }  
        这样我们的流程实例就启动起来了，那么接下来我们看一下在启动流程实例的时候我们涉及到的表信息

      数据库分析（实例表）分析

       act_ru_execution： 正在执行的执行对象表，侧重流程实例，对象，任务

       包含了实例ID，流程定义ID，要执行的任务名称（usertask1）等信息

       act_ru_task：正在执行的任务表，对具体的任务而言，任务执行到哪里了

      

     act_ru_identitylink流程信息变量act_hi_taskinst：已经执行完的历史任务信息

act_hi_taskinst：已经执行完的历史任务信息
act_hi_procinst：流程实例的历史表，存放执行完毕的流程实例信息

act_hi_actinst：存放历史所有完成的活动

           现在我们对表有一个大致的了解，那么接下来我们就按照我们既定的流程去执行我们的请假，例如第一个项目经理叫张三，那么这个流程实例已启动，首先需要张三去执行操作，那么我们我们看一下张三的执行任务的详情，代码如下：

[java] view plain copy
  1. /** 
  2.      * 查找个人当前的要执行的任务 
  3.      */  
  4.     @Test  
  5.     public void findMyTaskInfo(){  
  6.         String assignee = "张三";  
  7.         List<Task> listTask = processEngine.getTaskService()  
  8.             .createTaskQuery()  
  9.             .taskAssignee(assignee)  
  10.             .list();  
  11.           
  12.         if (listTask!= null && listTask.size() >0) {  
  13.             for (Task task : listTask) {  
  14.                 System.out.println("任务ID：" + task.getId());  
  15.                 System.out.println("任务名称：" + task.getName());  
  16.                 System.out.println("任务时间：" + task.getCreateTime());  
  17.                 System.out.println("任务的班里人：" + task.getAssignee());  
  18.                 System.out.println("任务的实例ID：" + task.getProcessDefinitionId());  
  19.                 System.out.println("执行对象的ID：" + task.getExecutionId());  
  20.                 System.out.println("任务的班里人：" + task.getAssignee());  
  21.                 System.out.println("流程定义ID：" + task.getProcessInstanceId());  
  22.             }  
  23.         }  
  24.               
  25.           
  26.     }  
       打印信息如下：任务ID：304，任务名称：【项目经理】审批，任务时间：Sat Jan 23 14:54:35 CST 2016，任务的班里人：张三 任务的实例ID：LeaveBill:2:204     执行对象的ID：301   任务的班里人：张三  流程定义ID：301

       任务完成

        那么接下来我就把任务ID为304的一个流程结束，也就是项目经理同意请假，代码如下：

[java] view plain copy
  1. /**完成任务*/  
  2. @Test  
  3. public void completeMyPersoinTask() {  
  4.     String taskId = "304";  
  5.     processEngine.getTaskService()  
  6.     .complete(taskId);  
  7.       
  8.     System.out.println("完成任务，任务ID：" + taskId);  
  9. }  
        然后我继续执行查询个人任务的时候，我们只能查到主任的任务了，因为项目经理已经执行完毕，所以当前执行的任务是看不到的，但是在历史信息中是存在的。

       如果我们启动了实例的话，查询当前信息的话，实在act_ru_*的表中查询，根据任务有关的服务，都是taskService,当然Activiti还有很多的服务，例如RepositoryService，RuntimeService， HistoryService等服务。

      大致总结一下，就是先部署，再启动，个人登陆系统后，根据个人姓名，查到任务ID，完成个人任务，直到全部完成，就是这么简单。


==========================================================================================================================


http://blog.csdn.net/lifupingcn/article/details/62423739


学完Activiti所有的知识点了，现在可以用一个小项目实战一下。

本来自己想写一个简单点的流程，但是发现项目太小有些知识点用不上，所有就写了一个流程比较长、复杂点。

把我前面博客中写的知识点多用上了，也巩固一下前面所掌握的。


 通过

首先介绍一下项目的流程：

1.员工发起请假申请——>项目组长进行初步审批——>就进入 并行网关 未通过就直接结束流程

2.并行网关 ：需要相关的节点多同意才进入下一步流程

3.这一步就需要：项目经理、项目总监审批通过才进入下一步，其中如果有一个人不同意及流程结束。

4. 到了人事部处理审批——>到了排他网关 ：是对条件进行判断然后在进入对应的审批人

5.注意点：并行网关：是相关审批人多同意才进入一下步。（外观是个 “ +” 号）

   排他网关：是根据已给条件进行判断，然后在进入对应审批人。(外观是插号)

6.根据请假天数判断是谁审批———>最后结束流程

先展示一下项目效果吧：

用户登入界面：选择员工角色登入


员工角色：有基本的系统管理、请假申请等功能。



开始发起请假申请：


点击确定：


然后提交请假申请，状态发生了改变。


跟着流程走，接着切换项目组长审批：（测试的时候确定一个人切换账号巨麻烦）


点击任务管理——>待办任务：就有刚才发起的请假申请


点击办理任务：


然后填写批注：可以随便写点什么——>点击批注（同意）或者是驳回（不同意）


之后可以点击任务管理————>已办任务查看：


这就是刚才审批的请假任务，多可以点击：

查看历史批注：


查看流程执行过程：

以及任务管理————>历史任务查看：


然后切换账号为项目经理登入，审批请假任务：

还是一样的操作：


我就不一个个截图试了。

并行网关，这就需要项目经理、项目总监多同意审批才能接着下去。

请假任务现在执行到项目经理、项目总监审批，如果你用人事、总裁等账号登入：

因为请假流程还没有执行到那一步，所以没有任务。


我就跳过中间步骤：现在是人事部处理


现在是进入：排他网关判断请假天数，大于等于7天是总裁审批，小于7天是副总裁审批。

这里请假天数是10天，现在使用副总裁的角色登入系统看看：


没有待办任务，说明正确的执行了排他网关。

好接着使用总裁角色登入系统结束任务：



现在流程正常走完了，如果在中间有任何一个角色审批不同意流程当立即结束。

在回到张三这个员工登入系统看看：


请假流程基本就结束了，接着使用管理员角色登入系统：


管理员角色：基础数据管理模块 

1.用户管理,批量删除用户，新增、修改用户等等。

2.角色管理，批量删除角色，新增、修改角色等等。

3.角色权限管理，赋予用户角色，每个用户可以拥有多个角色，

删除用户角色等等。


流程管理模块：流程部署管理（就是流程图管理）

1.以ZIP压缩包的形式添加流程图

2.批量删除流程


流程定义管理：

1.一些新增、修改、查询等等。

2.查看流程图



下面还有一些功能就不说了，重点还是Activiti工作流嘛。

我会在下一章博客中在说说代码。要下班了大笑。

下一章博客：

http://blog.csdn.net/lifupingcn/article/details/62882476



u011277123
关注
  • 9
    点赞
  • 踩
  • 53
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
RuoYi-activitiRuoYi-activitiRuoYi-activiti
06-24
RuoYi-activitiRuoYi-activitiRuoYi-activiti
ruoyi-activiti版本——安装部署
鲸鱼姐的专栏
08-29 4952
一 下载danny/ruoyi-vue-activiti代码 https://gitee.com/smell2/ruoyi-vue-activiti 二 后端运行 1. 创建数据库activiti，导入ruoyi-vue-activiti7.sql文件 2. 修改ruoyi-admin模块下application-dev.yml数据库名和账户密码 url: jdbc:mysql://localhost:3306/activiti username: ro...
SpringBoot + Activiti 工作流搭建与实现【附源码和配套文档】
2301_81867536的博客
03-12 804
springboot+vue+activiti集成了activiti在线编辑器，流行的前后端分离部署开发模式，快速开发平台，可插拔工作流服务。工作流表单可平滑的接入自定义表单，接入后进行业务审批流转。本项目集成了工作流所有的功能，并做了一个测试的表单进行审批演示。工作流部分功能含：流程图在线绘制，在线发布，工作流权限设置，审批节点设置（角色，直接指定人，部门等），业务表单关联，提交，撤回，与签或签，同意，驳回（支持驳回到任意岗），审批委托，流程挂起，流程图实时跟踪，审批提醒，可接入钉钉进行钉钉通知，企业微信
基于若依开发管理项目中引入工作流引擎activiti7，包含前后端（原创）
Koikoi12的博客
08-11 1万+
原项目中用到了工作流引擎，使用若依框架开发， 原二开使用项目：https://gitee.com/y_project/RuoYi-Vue 基于activiti7地址：https://gitee.com/smell2/ruoyi-vue-activiti 导入模块到原二开项目中 使用步骤 admin导入bpmn文件，或者绘制工作流，并激活。 post为普通员工进入我的审批可以查看所有审批（经销商角色） 数据会存入历史表和任务表 历史表展现全部任务数据，task会展示对应岗位的相应条数据 登录商管账号，进入
若依Activiti工作流入门
10-19 1万+
若依Activiti工作流版本和Activiti工作流引擎的简单接触和学习
activiti流程例子:详解员工请假流程的实现
热门推荐
fly_fly_fly_pig的博客
08-15 2万+
在开始之前,先说一下刚开始学习工作流的时候遇到的问题,感觉比较困惑,经过这两天的学习,也算有所收获 1. 部署了多个流程变量,如何准确开启特定的流程 2. 在一个流程的执行过程中,怎么确定执行到哪一步,即执行到哪个任务了 3. 在有多种情况的条件下,怎么判断要去的方向 先不急着解决,来看看我的工程 工程模拟情况 员工请假流程 1. 员工发起申请,附带请假信息(请...
Activiti（二）简单请假流程实现
weihao_的博客
10-21 3768
在SpringBoot2集成Activiti6的环境中，实现简单的请假流程。编写请假业务流程。流程业务为： 1，员工请假，先创建请假流程 2，员工填写请假申请，也可以不填写，直接结束流程 3，提交给直接主管审批，如果直接主管拒绝，则重新填写，如果直接主管同意，再到部门主管审批， 4，部门主管审批部门主管同意，则请假流程结束，请假成功，如果部门主管不同意，返回员工重新提交申请。 创建流程文...
maven项目出现missing artifact错误
OceanStar的博客
12-14 1107
比如错误：missing artifact org.vaadin.addons.dcharts-widget-0.10.0-dcharts-widget-0.10.0.jar 解决方案： 1、从本地的maven库中删除相关的jar包 2、更新maven：右单击项目—> Maven --> Update Project…去更新你的项目，如果还不行请记得在点更新之前勾上 Force...
Activiti工作流进阶-搭建一个MVC项目并实现请假流程
changgongcheng_yq的博客
06-24 1346
目录 一：简介 二：创建流程引擎 2.1创建一个web项目 2.2编写初始化引擎配置代码 2.3生成28张activiti任务表 三：使用activiti-spring-boot-starter-basic开发activiti项目 3.1开发准备工作 3.2请假流程图绘制 3.3登录和拦截器 3.4前端页面绘制和前端框架选型 3.5开始流程，请假表单创建和提交 3.6角色查...
activiti 工作流实例-实现请假流程
01-13
这个是Activiti开发的请假流程实例，可以作为用Activiti开发工作流的参考；项目采用spring+hibernate+strus2+activity开发，可以运行；数据库采用oracle，其中 QingJia 和 QingJiaHis 是自己的业务表，分别表示 请假实体表和请假审批历史记录表，需要自己建。此项目还包含了拦截器的技术（未登录用户不给访问系统），实测可以启动流程，审批流程及查看流程图，还有历史审批查看等功能。
SpringBoot+Activiti6+JPA+Vue+ElementUi--完整小案例--4
Lv_vI的博客
08-12 956
文章目录1. 说明2. 案例42.1 对比案例3，增加的内容（后台IDEA）2.2 对比案例3，增加的内容（前台VUE） 1. 说明 在案例3的基础上进行完善，案例3，点击打开 2. 案例4 2.1 对比案例3，增加的内容（后台IDEA） 对比案例3，改善原来的一个角色多个人审批，更改为会签，在项目中体现为： 有多个项目经理可以进行审批，需要所有的项目经理全部同意，请假单通过；所有的项目经理不同意，驳回到填写请假单重新填写提交。 （对更改后的方式进行一系列的代码逻辑更改，例如：同意和不同意的时候对申请人的状
关于审批流程的数据结构设计（以请假审批流程为例）
04-21
这个数据结构通用性是很强的，大多数流程都可以采用这个流程，因为它是可配置的。为这个流程我可是抓狂了很久，最后还是在高手的指导下完成的，当然我做的不是请假审批流程，是另外一个更复杂的，希望对看到它的人有帮助。
Activiti工作流示例Activiti Demo（带完整源码）非常实用
02-16
Activiti工作流示例ActivitiDemo 本示例带有全部源码，详细使用Canvas动画演示了Activiti工作流引擎的使用。非常实用，非常先进和完整。希望您会喜欢。
SpringBoot集成Activiti完整工作流管理系统源码及SQL
01-11
SpringBoot集成Activiti完整工作流管理系统源码及SQL 包含如下主要内容： 1、工作流完整案例（请假流程、请假会签流程Demo） 2、系统用户权限、工作流用户和用户组管理 3、支持在线流程模型定义、部署、导出。也可用...
Activiti7工作流引擎资料和源码.zip
07-31
资源内容：Activity知识体系大纲导航图；Activity讲义（PDF格式和MD格式，如流程定义、流程实例、流程变量、流程分叉与...Activity源代码、Activity整合Spring源码、Activity整合SpringBoot源码及Activity项目代码；
Activiti工作流示例源码
12-05
Activiti工作流示例ActivitiDemo 本示例带有全部源码，详细使用Canvas动画演示了Activiti工作流引擎的使用.
springboot(酒店管理系统)
04-25
开发语言：Java JDK版本：JDK1.8（或11） 服务器：tomcat 数据库：mysql 5.6/5.7（或8.0） 数据库工具：Navicat 开发软件：idea 依赖管理包：Maven 代码+数据库保证完整可用，可提供远程调试并指导运行服务（额外付费）～ 如果对系统的中的某些部分感到不合适可提供修改服务，比如题目、界面、功能等等... 声明： 1.项目已经调试过，完美运行 2.需要远程帮忙部署项目，需要额外付费 3.本项目有演示视频，如果需要观看，请联系我 4.调试过程中可帮忙安装IDEA，eclipse，MySQL，JDK，Tomcat等软件 重点： 需要其他Java源码联系我，更多源码任你选，你想要的源码我都有！ 需要加v19306446185
BP神经网络matlab实例.doc
最新发布
04-25
数学模型算法
设计.zip
04-25
设计.zip
提供 ACTIVITI工作流源码
04-01
ACTIVITI工作流源码可以在官方GitHub仓库中获取。这里提供的是最新版本的源码链接： https://github.com/Activiti/Activiti/tree/master/modules/activiti-engine 可以通过该链接访问ACTIVITI的主要引擎源代码。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值