devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Flowable-SpringBoot项目集成_flowable-spring-boot-starter-process

作者：木道寻08 | 2024-08-15 08:34:37

赞

踩

flowable-spring-boot-starter-process

在前面的介绍中，虽然实现了绘制流程图，然后将流程图存储到数据库中，然后从数据库中获取流程信息，并部署和启动流程，但是部署的流程绘制器是在tomcat中部署的，可能在部分的项目中，需要我们将流程设计器，设置到自己的项目中，这样部署项目就相当于部署了流程设计器，下面对SpringBoot项目集成flowable流程设计器进行简单介绍。

一、项目整合

在前面部署flowable-ui后可以看到，ui界面分为了任务应用程序、建模器应用程序、管理员应用程序和身份管理应用程序。

在这几个应用中，最重要的就是建模器应用程序（flowable-modeler），它主要是用来绘制流程图和流程定义信息，因此，在这里我们是在项目中集成了建模器应用程序，实现在自己的项目中使用flowable-ui官方的建模器具绘制流程图，并将其保存到mysql数据库中。

环境：flowable版本：6.7.2 MySQL版本：5.7

  1. 下载源码

在这里下载对应版本的flowable-ui的源码。

Release Flowable 6.7.2 release · flowable/flowable-engine · GitHub

6.7.2版本的源码：

flowable-engine-flowable-6.7.2.zip

  1. flowable引擎基础配置

由于是 spring-boot 项目，因此直接选择 flowable-spring-boot-starter，里面提供了齐全的 REST API

  1. <!--Flowable的核心依赖-->
  2. <dependency>
  3.   <groupId>org.flowable</groupId>
  4.   <artifactId>flowable-spring-boot-starter-process</artifactId>
  5.   <version>${flowable.version}</version>
  6. </dependency>
  7. <dependency>
  8.   <groupId>org.flowable</groupId>
  9.   <artifactId>flowable-spring-boot-starter</artifactId>
  10.   <version>${flowable.version}</version>
  11. </dependency>
  12. <dependency>
  13.   <groupId>org.flowable</groupId>
  14.   <artifactId>flowable-json-converter</artifactId>
  15.   <version>${flowable.version}</version>
  16. </dependency>
  17. <dependency>
  18.   <groupId>org.flowable</groupId>
  19.   <artifactId>flowable-bpmn-layout</artifactId>
  20.   <version>${flowable.version}</version>
  21. </dependency>

添加yml配置：

  1. # flowable config
  2. flowable:
  3.   # 关闭定时任务JOB
  4.   async-executor-activate: true
  5.   # 将databaseSchemaUpdate设置为true。当Flowable发现库与数据库表结构不一致时，会自动将数据库表结构升级至新版本。
  6.   database-schema-update: true
  7.   check-process-definitions: false
  8.   db-history-used: true
  9.   history-level: full

日志配置：

注意：Flowable 使用 SLF4J 作为内部日志框架，所以我们使用 log4j 作为 SLF4J 的实现

添加依赖：

  1. <!--日志-->
  2. <dependency>
  3.   <groupId>org.slf4j</groupId>
  4.   <artifactId>slf4j-api</artifactId>
  5.   <version>1.7.21</version>
  6. </dependency>
  7. <dependency>
  8.   <groupId>org.slf4j</groupId>
  9.   <artifactId>slf4j-log4j12</artifactId>
  10.   <version>1.7.21</version>
  11. </dependency>

resource 目录下新建文件 log4j.properties

  1. log4j.rootLogger=DEBUG, CA
  2.  
  3. log4j.appender.CA=org.apache.log4j.ConsoleAppender
  4. log4j.appender.CA.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.CA.layout.ConversionPattern= %d{hh:mm:ss,SSS} [%t] %-5p %c %x - %m%n
  1. 集成 flowable-modeler 前端

这里为了方便我们开发，将官方的flowable-modeler前端项目直接集成到了后端中。

从刚刚下载的源码中获取flowable-modeler的statci文件，6.7.2版本的目录在：

flowable-engine-flowable-6.7.2\modules\flowable-ui\flowable-ui-modeler-frontend\src\main\resources

复制包中 resources\static 下所有前端代码文件，复制到我们自己的项目static 文件夹下，项目没有static就在resource目录下新建static文件夹。

添加依赖：

  1. <!--通过下方的配置，加上官方源码中的静态文件，就可以将建模器应用程序集成到项目中-->
  2. <dependency>
  3.   <groupId>org.flowable</groupId>
  4.   <artifactId>flowable-ui-modeler-rest</artifactId>
  5.   <version>${flowable.version}</version>
  6.   <exclusions>
  7.     <exclusion>
  8.       <groupId>org.mybatis</groupId>
  9.       <artifactId>mybatis</artifactId>
  10.     </exclusion>
  11.   </exclusions>
  12. </dependency>
  13. <dependency>
  14.   <groupId>org.flowable</groupId>
  15.   <artifactId>flowable-ui-modeler-conf</artifactId>
  16.   <version>${flowable.version}</version>
  17. </dependency>
  18. <dependency>
  19.   <groupId>org.flowable</groupId>
  20.   <artifactId>flowable-ui-modeler-logic</artifactId>
  21.   <version>${flowable.version}</version>
  22. </dependency>
  23.  
  24. <dependency>
  25.   <groupId>org.liquibase</groupId>
  26.   <artifactId>liquibase-core</artifactId>
  27.   <version>4.4.0</version>
  28. </dependency>

配置文件：

在新版本的flowable-modeler中，需要配置idm，身份认证的相关配置，因此，在配置文件中添加：

  1. # flowable config
  2. flowable:
  3.   # 关闭定时任务JOB
  4.   async-executor-activate: true
  5.   # 将databaseSchemaUpdate设置为true。当Flowable发现库与数据库表结构不一致时，会自动将数据库表结构升级至新版本。
  6.   database-schema-update: true
  7.   check-process-definitions: false
  8.   db-history-used: true
  9.   history-level: full
  10.   common:
  11.     app:
  12.       idm-url: http://localhost:8099/flowable-idm
  13.       idm-admin:
  14.         user: admin
  15.         password: admin

自定义配置类：

DatabaseAutoConfiguration.java

Flowable 是基于 liquibase 进行数据库自动管理与追踪的，因此需要加一个 liquibase 的配置类（可以把org.flowable.ui.modeler.conf.DatabaseConfiguration下的复制下来改一改）

  1. import liquibase.Liquibase;
  2. import liquibase.database.Database;
  3. import liquibase.database.DatabaseConnection;
  4. import liquibase.database.DatabaseFactory;
  5. import liquibase.database.jvm.JdbcConnection;
  6. import liquibase.exception.DatabaseException;
  7. import liquibase.resource.ClassLoaderResourceAccessor;
  8. import org.flowable.ui.common.service.exception.InternalServerErrorException;
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import javax.sql.DataSource;
  14.  
  15. @Configuration
  16. public class DatabaseAutoConfiguration {
  17.  
  18.     private static final Logger LOGGER = LoggerFactory.getLogger(DatabaseAutoConfiguration.class);
  19.  
  20.     protected static final String LIQUIBASE_CHANGELOG_PREFIX = "ACT_DE_";
  21.  
  22.     @Bean
  23.     public Liquibase liquibase(DataSource dataSource) {
  24.         LOGGER.info("Configuring Liquibase");
  25.         Liquibase liquibase = null;
  26.         try {
  27.             DatabaseConnection connection = new JdbcConnection(dataSource.getConnection());
  28.             Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(connection);
  29.             database.setDatabaseChangeLogTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogTableName());
  30.             database.setDatabaseChangeLogLockTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogLockTableName());
  31.  
  32.             liquibase = new Liquibase("META-INF/liquibase/flowable-modeler-app-db-changelog.xml", new ClassLoaderResourceAccessor(), database);
  33.             liquibase.update("flowable");
  34.             return liquibase;
  35.         } catch (Exception e) {
  36.             throw new InternalServerErrorException("Error creating liquibase database", e);
  37.         } finally {
  38.             closeDatabase(liquibase);
  39.         }
  40.     }
  41.  
  42.     private void closeDatabase(Liquibase liquibase) {
  43.         if (liquibase != null) {
  44.             Database database = liquibase.getDatabase();
  45.             if (database != null) {
  46.                 try {
  47.                     database.close();
  48.                 } catch (DatabaseException e) {
  49.                     LOGGER.warn("Error closing database", e);
  50.                 }
  51.             }
  52.         }
  53.     }
  54. }

之后还需要添加mybatis-plus的相关配置：需要配置扫描 classpath:/META-INF/modeler-mybatis-mappings/*.xml

  1. mybatis-plus:
  2.   mapper-locations: classpath:/mapper/*Mapper.xml, classpath:/META-INF/modeler-mybatis-mappings/*.xml
  3.   configuration:
  4.     map-underscore-to-camel-case: true
  5.     jdbc-type-for-null: null
  6.   # 参数配置
  7.   configuration-properties:
  8.     # 配置流程引擎参数，详情可见 DatabaseConfiguration
  9.     blobType: BLOB
  10.     boolValue: TRUE
  11.     # 不要设置库名，否则会出现双库名 bug
  12.     prefix: ''

汉化配置：

StencilSetResource.java

在源码中找到这俩文件：

在resource下新建stencilset文件夹，将源码中的两个汉化文件放入该文件夹中。

添加类配置，在这里新建类的时候，名称不能为StencilSetResource，会与官方的jar包中的bean冲突，因此，我们新建FlowableStencilSetResource.java。

  1. import com.fasterxml.jackson.databind.JsonNode;
  2. import com.fasterxml.jackson.databind.ObjectMapper;
  3. import org.flowable.ui.common.service.exception.InternalServerErrorException;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RequestMethod;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. /**
  12.  * 汉化 配置
  13.  */
  14. @RestController
  15. @RequestMapping("/app")
  16. public class FlowableStencilSetResource {
  17.  
  18.     private static final Logger LOGGER = LoggerFactory.getLogger(FlowableStencilSetResource.class);
  19.  
  20.     @Autowired
  21.     protected ObjectMapper objectMapper;
  22.  
  23.     @RequestMapping(value = "/rest/stencil-sets/editor", method = RequestMethod.GET, produces = "application/json")
  24.     public JsonNode getStencilSetForEditor() {
  25.         try {
  26.             JsonNode stencilNode = objectMapper.readTree(this.getClass().getClassLoader().getResourceAsStream("stencilset/stencilset_bpmn.json"));
  27.             return stencilNode;
  28.         } catch (Exception e) {
  29.             LOGGER.error("Error reading bpmn stencil set json", e);
  30.             throw new InternalServerErrorException("Error reading bpmn stencil set json");
  31.         }
  32.     }
  33.  
  34.     @RequestMapping(value = "/rest/stencil-sets/cmmneditor", method = RequestMethod.GET, produces = "application/json")
  35.     public JsonNode getCmmnStencilSetForEditor() {
  36.         try {
  37.             JsonNode stencilNode = objectMapper.readTree(this.getClass().getClassLoader().getResourceAsStream("stencilset/stencilset_cmmn.json"));
  38.             return stencilNode;
  39.         } catch (Exception e) {
  40.             LOGGER.error("Error reading bpmn stencil set json", e);
  41.             throw new InternalServerErrorException("Error reading bpmn stencil set json");
  42.         }
  43.     }
  44. }

SecurityUtils配置

注意因为源码中引用了这个类，因此我们在配置的时候，路径需要与源码中的路径保持一致，也就是：org.flowable.ui.common.security 这样在 Jar 中的方法在调用时会覆盖原 Jar 里的工具类

下方的类为6.7.2版本的配置，如果是低版本的配置，可能不同，在旧版本中，flowable使用了FlowableAppUser，但是在新版本的依赖中，转而是：SecurityScope，因此这个配置需要根据自己的flowable版本配置。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import org.flowable.common.engine.api.FlowableIllegalStateException;
  4. import org.flowable.idm.api.User;
  5. import org.flowable.ui.common.model.RemoteUser;
  6. import org.springframework.security.core.Authentication;
  7. import org.springframework.security.core.context.SecurityContext;
  8. import org.springframework.security.core.context.SecurityContextHolder;
  9.  
  10. /**
  11.  * 重构流程编辑器获取用户信息
  12.  */
  13. public class SecurityUtils {
  14.  
  15.   private static User assumeUser;
  16.   
  17.   private static SecurityScopeProvider securityScopeProvider = new FlowableSecurityScopeProvider();
  18.  
  19.   private SecurityUtils() {
  20.   }
  21.  
  22.   /**
  23.    * Get the login of the current user.
  24.    */
  25.   public static String getCurrentUserId() {
  26.     User user = getCurrentUserObject();
  27.     if (user != null) {
  28.       return user.getId();
  29.     }
  30.     return null;
  31.   }
  32.  
  33.   /**
  34.    * @return the {@link User} object associated with the current logged in user.
  35.    */
  36.   public static User getCurrentUserObject() {
  37.     if (assumeUser != null) {
  38.       return assumeUser;
  39.     }
  40.  
  41.     RemoteUser user = new RemoteUser();
  42.     user.setId("admin");
  43.     user.setDisplayName("admin");
  44.     user.setFirstName("admin");
  45.     user.setLastName("admin");
  46.     user.setEmail("admin@flowable.com");
  47.     user.setPassword("123456");
  48.     List<String> pris = new ArrayList<>();
  49.     pris.add(DefaultPrivileges.ACCESS_MODELER);
  50.     pris.add(DefaultPrivileges.ACCESS_IDM);
  51.     pris.add(DefaultPrivileges.ACCESS_ADMIN);
  52.     pris.add(DefaultPrivileges.ACCESS_TASK);
  53.     pris.add(DefaultPrivileges.ACCESS_REST_API);
  54.     user.setPrivileges(pris);
  55.     return user;
  56.   }
  57.   
  58.     public static void setSecurityScopeProvider(SecurityScopeProvider securityScopeProvider) {
  59.         SecurityUtils.securityScopeProvider = securityScopeProvider;
  60.     }
  61.  
  62.     public static SecurityScope getCurrentSecurityScope() {
  63.         SecurityContext securityContext = SecurityContextHolder.getContext();
  64.         if (securityContext != null && securityContext.getAuthentication() != null) {
  65.             return getSecurityScope(securityContext.getAuthentication());
  66.         }
  67.         return null;
  68.     }
  69.  
  70.     public static SecurityScope getSecurityScope(Authentication authentication) {
  71.         return securityScopeProvider.getSecurityScope(authentication);
  72.     }
  73.  
  74.     public static SecurityScope getAuthenticatedSecurityScope() {
  75.         SecurityScope currentSecurityScope = getCurrentSecurityScope();
  76.         if (currentSecurityScope != null) {
  77.             return currentSecurityScope;
  78.         }
  79.         throw new FlowableIllegalStateException("User is not authenticated");
  80.     }
  81.  
  82.   public static void assumeUser(User user) {
  83.     assumeUser = user;
  84.   }
  85.  
  86.   public static void clearAssumeUser() {
  87.     assumeUser = null;
  88.   }
  89. }

认证请求配置

前端 url-config.js 修改

路径：resource\static\scripts\configuration\url-conf.js

将 getAccountUrl 的路径改为上面自己的 getAccount 接口的路径，我们让他使用我们自己的认证

后端添加Controller

添加一个登录认证的FlowModelerController

  1.  
  2. /**
  3.  * flowable-modeler获取默认的管理员信息
  4.  *
  5.  * @Author: yichangqiao
  6.  * @Date: 2024/4/19 16:11
  7.  */
  8. @Slf4j
  9. @RestController
  10. public class FlowModelerController {
  11.  
  12.     /**
  13.      * 获取默认的管理员信息
  14.      * @return
  15.      */
  16.     @RequestMapping(value = "/flow/rest/account", method = RequestMethod.GET, produces = "application/json")
  17.     public UserRepresentation getAccount() {
  18.         UserRepresentation userRepresentation = new UserRepresentation();
  19.         userRepresentation.setId("admin");
  20.         userRepresentation.setEmail("admin@flowable.org");
  21.         userRepresentation.setFullName("Administrator");
  22.         userRepresentation.setLastName("Administrator");
  23.         userRepresentation.setFirstName("Administrator");
  24.         List<String> privileges = new ArrayList<>();
  25.         privileges.add(DefaultPrivileges.ACCESS_MODELER);
  26.         privileges.add(DefaultPrivileges.ACCESS_IDM);
  27.         privileges.add(DefaultPrivileges.ACCESS_ADMIN);
  28.         privileges.add(DefaultPrivileges.ACCESS_TASK);
  29.         privileges.add(DefaultPrivileges.ACCESS_REST_API);
  30.         userRepresentation.setPrivileges(privileges);
  31.         log.info("login init success ..... ");
  32.         return userRepresentation;
  33.     }
  34. }

mybatis-plus配置

因为flowable自己使用了一个sqlsessionfactory创建SQL会话，但是我们自己的项目中又需要使用mybatis-plus的sqlsessionfactory，在mybatis-plus加载sqlsessionfactory默认是单例的，因此我们需要配置默认的回话连接：

  1. import com.baomidou.mybatisplus.annotation.DbType;
  2. import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
  3. import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
  4. import org.mybatis.spring.annotation.MapperScan;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7.  
  8. @Configuration
  9. @MapperScan(basePackages = {"com.flowable.mapper"},
  10.         sqlSessionFactoryRef = "sqlSessionFactory",
  11.         sqlSessionTemplateRef = "sqlSessionTemplate")
  12. public class MybatisPlusConfig {
  13.     @Bean
  14.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
  15.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  16.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
  17.         return interceptor;
  18.     }
  19. }

配置security

这里我们需要跳过flowable的权限校验，而是使用我们自己的认证框架，因此，需要在项目中配置：

  1. import org.flowable.ui.common.security.SecurityConstants;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.core.annotation.Order;
  4. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  5. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  6.  
  7. @Configuration
  8. public class SecurityConfiguration {
  9.  
  10.     @Configuration(proxyBeanMethods = false)//所以这个地方-1让该配置项在FlowableUiSecurityAutoConfiguration中对应配置项前加载，以跳过授权
  11.     @Order(SecurityConstants.FORM_LOGIN_SECURITY_ORDER - 1)
  12.     public static class FormLoginWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
  13.         @Override
  14.         protected void configure(HttpSecurity http) throws Exception {
  15.             http
  16.                     //必须要将csrf设置为disable，不然后面发送POST请求时会报403错误
  17.                     .csrf().disable()
  18.                     //为了简单起见，简单粗暴方式直接放行modeler下面所有请求
  19.                     .authorizeRequests().antMatchers("/**").permitAll();
  20.         }
  21.     }
  22.  
  23. }

修改Application启动类配置

让spring加载我们自定义的配置bean：FlowableStencilSetResource.class、DatabaseAutoConfiguration.class

  1. import com.yichangqiao.flowable.config.DatabaseAutoConfiguration;
  2. import com.yichangqiao.flowable.config.FlowableStencilSetResource;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.flowable.ui.common.security.ApiHttpSecurityCustomizer;
  5. import org.flowable.ui.common.security.FlowableUiSecurityAutoConfiguration;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.springframework.boot.SpringApplication;
  8. import org.springframework.boot.autoconfigure.SpringBootApplication;
  9. import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
  10. import org.springframework.context.annotation.ComponentScan;
  11. import org.springframework.context.annotation.Import;
  12. import java.time.LocalDateTime;
  13.  
  14. @Slf4j
  15. //启用全局异常拦截器
  16. @Import(value = {
  17.         FlowableStencilSetResource.class,
  18.         // 引入 DatabaseConfiguration 表更新转换,
  19.         DatabaseAutoConfiguration.class
  20. })
  21. @ComponentScan(basePackages = {"com.flowable.*"})
  22. @SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
  23. public class MasterYiFlowableApplication {
  24.  
  25.     public static void main(String[] args) {
  26.         SpringApplication.run(MasterYiFlowableApplication.class, args);
  27.         log.info("flowable模块加载成功 ================> {}", LocalDateTime.now());
  28.     }
  29.  
  30. }

启动项目

启动项目后，访问项目地址：127.0.0.1:端口，就可以访问到我们本地项目中的flowable-modeler了。

三、结语

实际整合过程中，可能存在版本、环境、依赖等影响，导致出现报错，但是大体的思路如上，可以参考整合。

下一节：flowable-整合系统角色人员 Flowable-整合系统角色人员-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/982826
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号