Flowable教程

原创 已于 2025-10-10 09:17:19 修改 · 6.8k 阅读 · 38 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #工作流 #Flowable

于 2022-12-28 14:12:22 首次发布

文章目录

一、Flowable介绍

1.简介

Flowable介绍：Flowable 是一个轻量级、开源的工作流和业务流程管理（BPM）平台。它核心是一个用 Java 编写的业务流程引擎。它的主要作用是将现实世界中的业务流程（如请假审批、订单处理、客户 onboarding）转换为可执行的软件模型，并自动化执行这些流程。

Flowable与BPMN：Flowable是驱动流程运行的“执行引擎”（How）,BPMN是用于描述业务的“建模语言”（What），而。二者结合，共同构成了从流程设计到自动化实施的完整解决方案。

  • Flowable官网地址：https://www.flowable.com/open-source
  • BPMN官网地址： https://www.bpmn.org/

2.Activiti、Flowable、Camunda

(1)为什么选这三者比较？
三者都是开源免费、社区活跃度比较高的；
三者都是同一个团队的分支，camunda[kmnd]基于activiti5，flowable基于activiti6，activiti5则是基于更早的jbpm4，最新的是activiti7。

(2)优缺点
①功能比较
在这里插入图片描述

②发展定位情况
Activiti7以后，对于流程引擎本身及相关引擎功能关注度并不高，核心很大精力放在构建其云生态环境（适配Docker、kubernates，适配Jenkins等devops工具）；
Flowable分离出去做了很多引擎相关的完善，专注做高性能引擎；
Camunda则侧重企业级应用与运维， 围绕引擎构建的一整套可视化、监控、管理和运维工具。

③社区活跃度对比
以github作为参考，搜索时间2025.9.24

项目受欢迎程度（Star数）：
Activiti (10.4k) > Flowable (8.7k) > Camunda (3.8k)

社区参与度（Fork数）：
Activiti (7k) > Flowable (2.8k) >> Camunda (691)

④总结
综上所述，Activiti7最大的优势是网上资料多，缺点是功能最少、易用性比较差。camunda最大的优势就是性能比较高，缺点是三者的资料是最少的。flowable平衡了功能、性能和易用性，社区也比较活跃，是一个比较均衡的方案。

二、Flowable实战：集成Flowable Modeler

你也可以选择不集成modeler编辑器，那样的话只需要引入flowable的starter和添加ProcessEngineConfig配置，在后面的流程的创建和使用中也能运行

1.源码下载，后面会用到
地址：https://github.com/flowable/flowable-engine/releases/tag/flowable-6.4.1/

2.引入依赖，我这里用的版本是6.4.1，替换下面的参数即可

       <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.1.3.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- Flowable spring-boot 版套餐 -->
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-spring-boot-starter-basic</artifactId>
            <version>${flowable.version}</version>
        </dependency>
        <!-- flowable 集成依赖 rest，logic，conf -->
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-ui-modeler-rest</artifactId>
            <version>${flowable.version}</version>
        </dependency>
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-ui-modeler-logic</artifactId>
            <version>${flowable.version}</version>
        </dependency>
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-ui-modeler-conf</artifactId>
            <version>${flowable.version}</version>
        </dependency>
        <!-- flowable 集成依赖 engine -->
        <!--<dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-engine</artifactId>
            <version>${flowable.version}</version>
        </dependency>-->
        <!-- Flowable 内部日志采用 SLF4J -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>
        <!-- 配置文件处理器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <version>3.0.1</version>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.24</version>
            <scope>compile</scope>
        </dependency>

        <!--数据库连接-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>
    </dependencies>

3.后端代码集成
需要这些文件，其中Security的包名不能变，否则不能生效，无法免登录
在这里插入图片描述
AppDispatcherServletConfiguration.java

/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.example.flowable.config;

import org.flowable.ui.modeler.rest.app.EditorGroupsResource;
import org.flowable.ui.modeler.rest.app.EditorUsersResource;
import org.flowable.ui.modeler.rest.app.StencilSetResource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.web.servlet.WebMvcRegistrations;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

@Configuration
@ComponentScan(value = {
   
   
        "org.flowable.ui.modeler.rest.app",
        // 不加载 rest，因为 getAccount 接口需要我们自己实现
// "org.flowable.ui.common.rest"
},excludeFilters = {
   
   

        // 移除 EditorUsersResource 与 EditorGroupsResource，因为不使用 IDM 部分
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = EditorUsersResource.class),
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = EditorGroupsResource.class),
        // 配置文件用自己的
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = StencilSetResource.class),
}
)
@EnableAsync
public class AppDispatcherServletConfiguration implements WebMvcRegistrations {
   
   

    private static final Logger LOGGER = LoggerFactory.getLogger(AppDispatcherServletConfiguration.class);

    @Bean
    public SessionLocaleResolver localeResolver() {
   
   
        return new SessionLocaleResolver();
    }

    @Bean
    public LocaleChangeInterceptor localeChangeInterceptor() {
   
   
        LOGGER.debug("Configuring localeChangeInterceptor");
        LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
        localeChangeInterceptor.setParamName("language");
        return localeChangeInterceptor;
    }

    @Override
    public RequestMappingHandlerMapping getRequestMappingHandlerMapping() {
   
   
        LOGGER.debug("Creating requestMappingHandlerMapping");
        RequestMappingHandlerMapping requestMappingHandlerMapping = new RequestMappingHandlerMapping();
        requestMappingHandlerMapping.setUseSuffixPatternMatch(false);
        requestMappingHandlerMapping.setRemoveSemicolonContent(false);
        Object[] interceptors = {
   
    localeChangeInterceptor() };
        requestMappingHandlerMapping.setInterceptors(interceptors);
        return requestMappingHandlerMapping;
    }
}

ApplicationConfiguration.java

/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.example.flowable.config;

import org.flowable.ui.common.service.idm.RemoteIdmService;
import org.flowable.ui.modeler.properties.FlowableModelerAppProperties;
import org.flowable.ui.modeler.servlet.ApiDispatcherServletConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
@Configuration
@EnableConfigurationProperties(FlowableModelerAppProperties.class)
@ComponentScan(basePackages = {
   
   

// "org.flowable.ui.modeler.conf", // 不引入 conf
        "org.flowable.ui.modeler.repository",
        "org.flowable.ui.modeler.service",
// "org.flowable.ui.modeler.security", //授权方面的都不需要
// "org.flowable.ui.common.conf", // flowable 开发环境内置的数据库连接
// "org.flowable.ui.common.filter", // IDM 方面的过滤器
        "org.flowable.ui.common.service",
        "org.flowable.ui.common.repository",
        //
// "org.flowable.ui.common.security",//授权方面的都不需要
        "org.flowable.ui.common.tenant" },excludeFilters = {
   
   

        // 移除 RemoteIdmService
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = RemoteIdmService.class)
}
)
public class ApplicationConfiguration {
   
   


    @Bean
    public ServletRegistrationBean modelerApiServlet(ApplicationContext applicationContext) {
   
   

        AnnotationConfigWebApplicationContext dispatcherServletConfiguration = new AnnotationConfigWebApplicationContext();
        dispatcherServletConfiguration.setParent(applicationContext);
        dispatcherServletConfiguration.register(ApiDispatcherServletConfiguration.class);
        DispatcherServlet servlet = new DispatcherServlet(dispatcherServletConfiguration);
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(servlet, "/api/*");
        registrationBean.setName("Flowable Modeler App API Servlet");
        registrationBean.setLoadOnStartup(1);
        registrationBean.setAsyncSupported(true);
        return registrationBean;
    }
}

FlowableStencilSetResource.java

/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.example.flowable.config;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.flowable.ui.common.service.exception.InternalServerErrorException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/app")
public class FlowableStencilSetResource {
   
   

    private static final Logger LOGGER = LoggerFactory.getLogger(FlowableStencilSetResource.class);

    @Autowired
    protected ObjectMapper objectMapper;

    @RequestMapping(value = "/rest/stencil-sets/editor", method = RequestMethod.GET, produces = "application/json")
    public JsonNode getStencilSetForEditor() {
   
   
        try {
   
   
            JsonNode stencilNode = objectMapper.readTree(this.getClass().getClassLoader().getResourceAsStream("stencilset/stencilset_bpmn.json"));
            return stencilNode;
        } catch (Exception e) {
   
   
            LOGGER.error("Error reading bpmn stencil set json", e);
            throw new InternalServerErrorException("Error reading bpmn stencil set json");
        }
    }

    @RequestMapping(value = "/rest/stencil-sets/cmmneditor", method = RequestMethod.GET, produces = "application/json")
    public JsonNode getCmmnStencilSetForEditor() {
   
   
        try {
   
   
            JsonNode stencilNode = objectMapper.readTree(this.getClass().getClassLoader().getResourceAsStream("stencilset/stencilset_cmmn.json"));
            return stencilNode;
        } catch (Exception e) {
   
   
            LOGGER.error("Error reading bpmn stencil set json", e);
            throw new InternalServerErrorException("Error reading bpmn stencil set json");
        }
    }
}

ProcessEngineConfig.java

package com.example.flowable.config;

import lombok.Data;
import org.flowable.engine.ProcessEngine;
import org.flowable.engine.ProcessEngineConfiguration;
import org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/** * 流程引擎配置文件 * @author: jijh * @create: 2022-12-12 16:49 **/
@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
@Data
public class ProcessEngineConfig {
   
   


    private Logger logger = LoggerFactory.getLogger(ProcessEngineConfig.class);

    private String url;

    private String driverClassName;

    private String username;

    private String password;

    private String publicKey;

    /** * 初始化流程引擎 * @return */
    @Primary
    @Bean(name = "processEngine")
    public ProcessEngine initProcessEngine() {
   
   

        logger.info("=============================ProcessEngineBegin=============================");

        // 流程引擎配置
        ProcessEngineConfiguration cfg = null;

        try {
   
   

            cfg = new StandaloneProcessEngineConfiguration()
                    .setJdbcUrl(url)
                    .setJdbcUsername(username)
                    //.setJdbcPassword(ConfigTools.decrypt(publicKey, password))
                    .setJdbcPassword(password)
                    .setJdbcDriver(driverClassName)
                    // 初始化基础表，不需要的可以改为 DB_SCHEMA_UPDATE_FALSE
                    .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE)
                    // 默认邮箱配置
                    // 发邮件的主机地址，先用 QQ 邮箱
                    //.setMailServerHost("smtp.qq.com")
                    // POP3/SMTP服务的授权码
                    //.setMailServerPassword("xxxxxxx")
                    // 默认发件人
                    //.setMailServerDefaultFrom("836369078@qq.com")
                    // 设置发件人用户名
                    //.setMailServerUsername("管理员")
                    // 解决流程图乱码
                    .setActivityFontName("宋体")
                    .setLabelFontName("宋体")
                    .setAnnotationFontName("宋体");
        } catch (Exception e) {
   
   

            e.printStackTrace();
        }
        // 初始化流程引擎对象
        ProcessEngine processEngine = cfg.buildProcessEngine();
        logger.info("=============================ProcessEngineEnd=============================");
        return processEngine;
    }
}

FlowableApplication.java

package com.example.flowable;

import com.example.flowable.config.AppDispatcherServletConfiguration;
import com.example.flowable.config.ApplicationConfiguration;
import org.flowable.ui.modeler.conf.DatabaseConfiguration;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
import org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Import;

//启用全局异常拦截器
@Import(value={
   
   

        // 引入修改的配置
        ApplicationConfiguration.class,
        AppDispatcherServletConfiguration.class,
        // 引入 DatabaseConfiguration 表更新转换
        DatabaseConfiguration.class})
// Eureka 客户端
@EnableDiscoveryClient
@MapperScan("com.example.*.dao")
// 移除 Security 自动配置
// Spring Cloud 为 Finchley 版本
// @SpringBootApplication(exclude={SecurityAutoConfiguration.class})
// Spring Cloud 为 Greenwich 版本
@SpringBootApplication(exclude={
   
   
        SecurityAutoConfiguration.class, ManagementWebSecurityAutoConfiguration.class, SecurityFilterAutoConfiguration.class})

public class FlowableApplication {
   
   

    public static void main(String[] args) {
   
   
        SpringApplication.run(FlowableApplication.class, args);
    }

}

SecurityUtils.java

/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.flowable.ui.common.security;

import org.flowable.idm.api.User;
import org.flowable.ui.common.model.RemoteUser;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;

import java.util.ArrayList;
import java.util.List;

/**
 * Utility class for Spring Security.
 */
public class SecurityUtils {
   
   

    private static User assumeUser;

    private SecurityUtils() {
   
   
    }

    /**
     * Get the login of the current user.
     */
    public static String getCurrentUserId() {
   
   
        User user = getCurrentUserObject();
        if (user != null) {
   
   
            return user.getId();
        }
        return null;
    }

    /**
     * @return the {@link User} object associated with the current logged in user.
     */
    public static User getCurrentUserObject() {
   
   
        if (assumeUser != null) {
   
   

            return assumeUser;
        }

        RemoteUser user = new RemoteUser();
        user.setId("admin");
        user.setDisplayName("Administrator");
        user.setFirstName("Administrator");
        user.setLastName("Administrator");
        user.setEmail("admin@flowable.com");
        user.setPassword("123456");
        List<String> pris = new ArrayList<>();
        pris.add(DefaultPrivileges.ACCESS_MODELER);
        pris.add(DefaultPrivileges.ACCESS_IDM);
        pris.add(DefaultPrivileges.ACCESS_ADMIN);
        pris.add(DefaultPrivileges.ACCESS_TASK);
        pris.add(DefaultPrivileges.ACCESS_REST_API);
        user.setPrivileges(pris);
        return user;
    }

    public static FlowableAppUser getCurrentFlowableAppUser() {
   
   
        FlowableAppUser user = null;
        SecurityContext securityContext = SecurityContextHolder.getContext();
        if (securityContext != null && securityContext.getAuthentication() != null) {
   
   
            Object principal = securityContext.getAuthentication().getPrincipal();
            if (principal instanceof FlowableAppUser) {
   
   
                user = (FlowableAppUser) principal;
            }
        }
        return user;
    }

    public static boolean currentUserHasCapability(String capability) {
   
   
        FlowableAppUser user = getCurrentFlowableAppUser();
        for (GrantedAuthority grantedAuthority : user.getAuthorities()) {
   
   
            if (capability.equals(grantedAuthority.getAuthority())) {
   
   
                return true;
            }
        }
        return false;
    }

    public static void assumeUser(User user) {
   
   
        assumeUser = user;
    }

    public static void clearAssumeUser() {
   
   
        assumeUser = null;
    }

}

4.前端代码集成
目录结构如下：
在这里插入图片描述

static下的代码来自源码包的flowable-engine-flowable-6.4.1\modules\flowable-ui-modeler\flowable-ui-modeler-app\src\main\resources\static下面

resource\static\scripts\configuration\url-conf.js需要修改：

/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
var FLOWABLE = FLOWABLE || {
   
   };

/*
 * Contains methods to retrieve the (mostly) base urls of the different end points.
 * Two of the methods #getImageUrl and #getModelThumbnailUrl are exposed in the $rootScope for usage in the HTML views.
 */
FLOWABLE.APP_URL = {
   
   

    /* ACCOUNT URLS */

    getAccountUrl: function () {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/login/rest/account';
    },

    getLogoutUrl: function () {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/logout';
    },

    /* MODEL URLS */

    getModelsUrl: function (query) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models' + (query || "");
    },

    getModelUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId;
    },

    getModelModelJsonUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/model-json';
    },

    getModelBpmn20ExportUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/bpmn20?version=' + Date.now();
    },

    getCloneModelsUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/clone';
    },

    getModelHistoriesUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/history';
    },

    getModelHistoryUrl: function (modelId, modelHistoryId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/history/' + modelHistoryId;
    },

    getModelHistoryModelJsonUrl: function (modelId, modelHistoryId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/history/' + modelHistoryId + '/model-json';
    },

    getModelHistoryBpmn20ExportUrl: function (modelId, modelHistoryId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/history/' + modelHistoryId + '/bpmn20?version=' + Date.now();
    },

    getCmmnModelDownloadUrl: function (modelId, modelHistoryId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + (modelHistoryId ? '/history/' + modelHistoryId : '') + '/cmmn?version=' + Date.now();
    },

    getModelParentRelationsUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models/' + modelId + '/parent-relations';
    },

    /* APP DEFINITION URLS  */

    getAppDefinitionImportUrl: function (renewIdmIds) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/import?renewIdmEntries=' + renewIdmIds;
    },

    getAppDefinitionTextImportUrl: function (renewIdmIds) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/text/import?renewIdmEntries=' + renewIdmIds;
    },

    getAppDefinitionUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/' + modelId;
    },

    getAppDefinitionModelImportUrl: function (modelId, renewIdmIds) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/' + modelId + '/import?renewIdmEntries=' + renewIdmIds;
    },

    getAppDefinitionModelTextImportUrl: function (modelId, renewIdmIds) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/' + modelId + '/text/import?renewIdmEntries=' + renewIdmIds;
    },

    getAppDefinitionPublishUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/' + modelId + '/publish';
    },

    getAppDefinitionExportUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/' + modelId + '/export?version=' + Date.now();
    },

    getAppDefinitionBarExportUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/' + modelId + '/export-bar?version=' + Date.now();
    },

    getAppDefinitionHistoryUrl: function (modelId, historyModelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/app-definitions/' + modelId + '/history/' + historyModelId;
    },

    getModelsForAppDefinitionUrl: function () {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/models-for-app-definition';
    },

    getCmmnModelsForAppDefinitionUrl: function () {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/cmmn-models-for-app-definition';
    },

    /* PROCESS INSTANCE URLS */

    getProcessInstanceModelJsonUrl: function (modelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot + '/app/rest/process-instances/' + modelId + '/model-json';
    },

    getProcessInstanceModelJsonHistoryUrl: function (historyModelId) {
   
   
        return FLOWABLE.CONFIG.contextRoot +<
最低0.47元/天 解锁文章
Flowable基本操作
04-27 885
flowable
Flowable第一篇、快速上手（Flowable安装、配置、集成）
Du_XiaoNan的博客
11-21 1万+
Flowable是一个轻量级、高效可扩展的工作流和业务流程管理（BPM）引擎，支持在Java应用程序中实现复杂的工作流自动化。Flowable最初是作为Activiti项目的一个分支发展而来的，但它现在已经成为一个独立的开源项目，并在企业级应用中得到了广泛使用
flowable实战教程.pdf
12-14
251页原创flowable实战教程
从 0 到 1 精通 Flowable：让你的业务流程自动化如丝般顺滑
最新发布
果酱 の 博客
10-07 2300
本文全面介绍了Flowable流程引擎的核心技术与实战应用。作为现代企业流程自动化的首选方案，Flowable实现了BPMN2.0规范，通过RepositoryService、RuntimeService等核心组件提供流程管理能力。文章详细讲解了环境搭建、流程定义与实例管理、任务操作等基础功能，并展示了完整的请假流程案例实现。同时深入探讨了高级特性如监听器、历史查询和超时处理，以及SpringBoot集成的最佳实践。最后提供了常见问题的解决方案，帮助开发者从零掌握Flowable的应用开发。
2、Flowable 详解：概念、作用、场景与 Spring Boot 3 集成指南
python15397的博客
09-30 1643
Flowable是一个轻量级、高性能、开源的业务流程管理（BPM）和工作流引擎，使用 Java 编写，完全兼容BPMN 2.0（业务流程建模与标注）、DMN 1.3（决策模型与标注）和CMMN 1.1（案例管理模型与标注）国际标准。🔍 起源：Flowable 最初是Activiti项目的分支（2016 年），由原 Activiti 核心团队创建，旨在提供更稳定、更灵活、更现代化的工作流解决方案。在目录下创建。
flowable简介
热门推荐
qq_35466392的博客
09-02 2万+
lowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。这个章节将用一个可以在你自己的开发环境中使用的例子，逐步介绍各种概念与API
Flowable工作流（flowable 数据库表结构）
Itissohardtog的博客
08-17 1万+
Flowable工作流概念Flowable是什么Flowable与Activiti数据库表分析Flowable数据库表命名规则数据库表结构通用数据库流程定义存储表身份数据表运行时流程数据表历史流程数据表核心表部署内容表：act_ge_bytearray 概念 Flowable是什么 1、 Flowable是一个流行的轻量级的采用Java开发的业务流程引擎。通过Flowable流程引擎，我们可以部署BPMN2.0的流程定义(一般为XML文件)，通过流程定义创建流程实例，查询和访问流程相关的实例与数据，等等。
工作流框架Flowable
靖节先生的博客
04-03 7203
工作流框架Flowable1. Flowable概述1.1 Flowable简介1.2 Flowable与Activiti的区别2. Flowable说明 1. Flowable概述 1.1 Flowable简介 Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。 TKJohn.github.io：https://tkjoh
Flowable工作流详细使用介绍+配置详解
pshdhx的博客
05-12 1万+
flowbale工作流各个表和字段的介绍:https://www.cnblogs.com/phyger/p/14067201.html 运行官方demo:https://blog.youkuaiyun.com/u013972652/article/details/109990809 flowable使用流程: 1.首先画流程图,给流程图绑定流程变量; 2.部署流程图,产生流程定义. 3.开启流程实例 流程部署之后:act_re_deployment记录数+1;act_re_procdef记录数+1; ac
Flowable 之基础教程
qq15035899256的博客
09-06 7359
本文是对Flowable的学习，认识了工作流的用途，学习了flowable部署流程的操作，以及FlowableUI流程设计器的使用。之后的学习内容将持续更新！！！
Flowable 工作流使用教程
翱翔-蓝天
02-26 6323
设计阶段使用建模工具创建 BPMN 文件定义流程变量和表单配置任务处理人和候选组设置业务规则和条件表达式部署阶段验证流程定义的正确性解析 BPMN 文件生成流程资源文件存储到数据库中版本控制多版本并存机制版本升级策略历史版本处理在目录下创建。
Flowable 教程
06-07
**Flowable教程简介：** 1. **安装和配置**: 学习如何在本地或云平台上安装Flowable，并配置基本环境，如Spring Boot集成或Docker容器部署。 2. **流程设计**: 使用图形化工具如BPMN Studio设计业务流程图，了解...
flowable教程
07-28
您可以通过搜索关键词"Flowable教程"或"Flowable入门"来找到相关资源。 4. 在线视频教程：在一些在线教育平台（如慕课网、网易云课堂等）上，也有一些Flowable的视频教程可供学习。您可以搜索相关平台上的Flowable...
flowable 教程
01-10
### Flowable 入门教程和使用指南 #### 了解 Flowable 平台 Flowable 是一款紧凑且高效的业务流程管理和工作流平台，适用于开发者、系统管理员以及业务用户。该平台支持多种功能，包括但不限于工作流管理、业务流程...
Flowable入门
qq_29648139的博客
02-15 5025
Flowable入门 1） flowable整合springboot 2） 移除flowable权限校验，加入微服务项目本身权限校验 3） 常用的API接口(查看流程图、部署流程、我的待办、我的已办、完结任务、审批历史等)
【Flowable】Flowable工作流教程
Syals的博客
10-14 1万+
我们要构建的流程是一个非常简单的请假流程。Flowable引擎需要流程定义为BPMN 2.0格式，这是一个业界广泛接受的XML标准。在Flowable术语中，我们将其称为一个流程定义(process definition)。一个流程定义可以启动多个流程实例(process instance)。流程定义可以看做是重复执行流程的蓝图。在这个例子中，流程定义定义了请假的各个步骤，而一个流程实例对应某个雇员提出的一个请假申请。我们要使用的流程定义为：这个流程应该已经十分自我解释了。
Flowable 基本用法
m0_64269294的博客
04-21 2664
Flowable 是一个用 Java 编写的轻量级业务流程引擎。Flowable 流程引擎允许您部署 BPMN 2.0 流程定义（用于定义流程的行业 XML 标准）、创建这些流程定义的流程实例、运行查询、访问活动或历史流程实例和相关数据Flowable 在将其添加到应用程序、服务、体系结构时非常灵活。您可以将引擎嵌入到您的应用程序或服务中，方法是包含 Flowable 库，该库作为 JAR 提供。因为它是一个 JAR，所以可以很容易地将它添加到任何 Java 环境中：javase；
Flowable学习笔记（一、入门）
三分恶的博客
05-03 4800
一、Flowable简介 1、Flowable是什么 Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。这个章节将用一个可以在你自己的开发环境中使用的例子，逐步介绍各种概念与API。 Flowable可以十分灵...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值