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

RuoYi 集成flowable 6.7.0+flowable-modeler_ruoyi flowable

作者：寸_铁 | 2024-07-19 16:06:04

赞

踩

ruoyi flowable

  1. 集成flowable

1.1导入maven依赖

  1. <flowable.version>6.7.0</flowable.version>
  2. <!--flowable 主依赖-->
  3. <dependency>
  4.     <groupId>org.flowable</groupId>
  5.     <artifactId>flowable-spring-boot-starter</artifactId>
  6.     <version>${flowable.version}</version>
  7. </dependency>

  1. 集成flowable-modeler

2.1 maven依赖

  1. <!-- flowable 集成依赖conf ,包内包含 rest，logic -->
  2. <dependency>
  3.     <groupId>org.flowable</groupId>
  4.     <artifactId>flowable-ui-modeler-conf</artifactId>
  5.     <version>${flowable.version}</version>
  6.     <exclusions>
  7.         <exclusion>
  8.             <groupId>org.mybatis</groupId>
  9.             <artifactId>mybatis</artifactId>
  10.         </exclusion>
  11.         <exclusion>
  12.             <groupId>org.mybatis</groupId>
  13.             <artifactId>mybatis-spring</artifactId>
  14.         </exclusion>
  15.     </exclusions>
  16. </dependency>

前端下载

地址：GitHub - flowable/flowable-engine: A compact and highly efficient workflow and Business Process Management (BPM) platform for developers, system admins and business users.

直接将github上flowable-engine项目（GitHub - flowable/flowable-engine: A compact and highly efficient workflow and Business Process Management (BPM) platform for developers, system admins and business users.）version 6.7.0 （分支 origin/flowable-release-6.7.0）的前端代码拷贝到自己项目中，路径保持相同：flowable-engine-6.7.0\modules\flowable-ui-modeler\flowable-ui-modeler-app\src\main\resources

2.2 flowable的yml配置

  1. flowable:
  2.   # 关闭异步，不关闭历史数据的插入就是异步的，会在同一个事物里面，无法回滚
  3.   # 开发可开启会提高些效率，上线需要关闭
  4.   database-schema-update: true
  5.   process-definition-location-prefix: classpath*:/processes/
  6.   process-definition-location-suffixes: "**.bpmn20.xml, **.bpmn"
  7.   common:
  8.     app:
  9.       idm-url: http://localhost:${server.port}/flowable-idm1
  10.       idm-admin:
  11.         user: admin
  12.         password: test
  13.   #解决乱码问题
  14.   activity-font-name: 宋体
  15.   label-font-name: 宋体
  16.   annotation-font-name: 宋体
  17.   #关闭定时任务JOB
  18.   async-executor-activate: false

2.3路径重定向配置

（用于路径跳转直接可免去index.html）

  1.  
  2.     @Override
  3.     public void addViewControllers(ViewControllerRegistry registry) {
  4.         registry.addViewController("/").setViewName("forward:" + indexUrl);
  5.         registry.addViewController("/modeler").setViewName("forward:/modeler/index.html");
  6.     }

2.4免登录配置

类名随意定，如FlowableSecurityConfiguration.class，包路径与flowable相同：org.flowable.ui.modeler.conf

  1.  
  2. import org.flowable.ui.common.security.SecurityConstants;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.core.annotation.Order;
  5. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  6. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  7. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  8.  
  9. @Configuration(proxyBeanMethods = false)
  10. @EnableWebSecurity
  11. public class FlowableSecurityConfiguration {
  12.  
  13.     @Configuration
  14.     @Order(SecurityConstants.TASK_API_SECURITY_ORDER)
  15.     public static class ModelerApiWebSecurityConfigurationAdapter extends WebSecurityConfigurerAdapter {
  16.  
  17.         @Override
  18.         protected void configure(HttpSecurity http) throws Exception {
  19.             http
  20.                     //必须要将csrf设置为disable，不然后面发送POST请求时会报403错误
  21.                     .csrf().disable()
  22.                     //为了简单起见，简单粗暴方式直接放行modeler下面所有请求
  23.                     .authorizeRequests().antMatchers("/modeler/**").permitAll();
  24.             //解决iframe无法访问问题
  25.             http.csrf().disable().headers().frameOptions().sameOrigin();
  26.         }
  27.     }
  28. }

2.5 数据库链接配置

类名随意定，如DatabaseConfiguration.class

  1.  
  2. import liquibase.Liquibase;
  3. import liquibase.database.Database;
  4. import liquibase.database.DatabaseConnection;
  5. import liquibase.database.DatabaseFactory;
  6. import liquibase.database.jvm.JdbcConnection;
  7. import liquibase.exception.DatabaseException;
  8. import liquibase.resource.ClassLoaderResourceAccessor;
  9. import org.apache.ibatis.session.SqlSessionFactory;
  10. import org.flowable.common.engine.api.FlowableException;
  11. import org.flowable.ui.common.service.exception.InternalServerErrorException;
  12. import org.flowable.ui.common.util.LiquibaseUtil;
  13. import org.flowable.ui.modeler.properties.FlowableModelerAppProperties;
  14. import org.mybatis.spring.SqlSessionFactoryBean;
  15. import org.mybatis.spring.SqlSessionTemplate;
  16. import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
  17. import org.slf4j.Logger;
  18. import org.slf4j.LoggerFactory;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.beans.factory.annotation.Qualifier;
  21. import org.springframework.context.annotation.Bean;
  22. import org.springframework.context.annotation.Configuration;
  23. import org.springframework.context.annotation.Primary;
  24. import org.springframework.core.io.Resource;
  25. import org.springframework.core.io.ResourceLoader;
  26. import org.springframework.core.io.support.ResourcePatternResolver;
  27. import org.springframework.core.io.support.ResourcePatternUtils;
  28.  
  29. import javax.sql.DataSource;
  30. import java.sql.Connection;
  31. import java.sql.DatabaseMetaData;
  32. import java.sql.SQLException;
  33. import java.util.ArrayList;
  34. import java.util.Arrays;
  35. import java.util.List;
  36. import java.util.Properties;
  37.  
  38. @Configuration
  39. public class DatabaseConfiguration {
  40.  
  41.     private static final Logger LOGGER = LoggerFactory.getLogger(ModelerDatabaseConfiguration.class);
  42.  
  43.     protected static final String LIQUIBASE_CHANGELOG_PREFIX = "ACT_DE_";
  44.  
  45.     @Autowired
  46.     protected FlowableModelerAppProperties modelerAppProperties;
  47.     @Autowired
  48.     protected MybatisProperties mybatisProperties;
  49.  
  50.     @Autowired
  51.     protected ResourceLoader resourceLoader;
  52.  
  53.     protected static Properties databaseTypeMappings = getDefaultDatabaseTypeMappings();
  54.  
  55.     public static final String DATABASE_TYPE_H2 = "h2";
  56.     public static final String DATABASE_TYPE_HSQL = "hsql";
  57.     public static final String DATABASE_TYPE_MYSQL = "mysql";
  58.     public static final String DATABASE_TYPE_ORACLE = "oracle";
  59.     public static final String DATABASE_TYPE_POSTGRES = "postgres";
  60.     public static final String DATABASE_TYPE_MSSQL = "mssql";
  61.     public static final String DATABASE_TYPE_DB2 = "db2";
  62.  
  63.     public static Properties getDefaultDatabaseTypeMappings() {
  64.         Properties databaseTypeMappings = new Properties();
  65.         databaseTypeMappings.setProperty("H2", DATABASE_TYPE_H2);
  66.         databaseTypeMappings.setProperty("HSQL Database Engine", DATABASE_TYPE_HSQL);
  67.         databaseTypeMappings.setProperty("MySQL", DATABASE_TYPE_MYSQL);
  68.         databaseTypeMappings.setProperty("MariaDB", DATABASE_TYPE_MYSQL);
  69.         databaseTypeMappings.setProperty("Oracle", DATABASE_TYPE_ORACLE);
  70.         databaseTypeMappings.setProperty("PostgreSQL", DATABASE_TYPE_POSTGRES);
  71.         databaseTypeMappings.setProperty("Microsoft SQL Server", DATABASE_TYPE_MSSQL);
  72.         databaseTypeMappings.setProperty(DATABASE_TYPE_DB2, DATABASE_TYPE_DB2);
  73.         databaseTypeMappings.setProperty("DB2", DATABASE_TYPE_DB2);
  74.         databaseTypeMappings.setProperty("DB2/NT", DATABASE_TYPE_DB2);
  75.         databaseTypeMappings.setProperty("DB2/NT64", DATABASE_TYPE_DB2);
  76.         databaseTypeMappings.setProperty("DB2 UDP", DATABASE_TYPE_DB2);
  77.         databaseTypeMappings.setProperty("DB2/LINUX", DATABASE_TYPE_DB2);
  78.         databaseTypeMappings.setProperty("DB2/LINUX390", DATABASE_TYPE_DB2);
  79.         databaseTypeMappings.setProperty("DB2/LINUXX8664", DATABASE_TYPE_DB2);
  80.         databaseTypeMappings.setProperty("DB2/LINUXZ64", DATABASE_TYPE_DB2);
  81.         databaseTypeMappings.setProperty("DB2/LINUXPPC64", DATABASE_TYPE_DB2);
  82.         databaseTypeMappings.setProperty("DB2/LINUXPPC64LE", DATABASE_TYPE_DB2);
  83.         databaseTypeMappings.setProperty("DB2/400 SQL", DATABASE_TYPE_DB2);
  84.         databaseTypeMappings.setProperty("DB2/6000", DATABASE_TYPE_DB2);
  85.         databaseTypeMappings.setProperty("DB2 UDB iSeries", DATABASE_TYPE_DB2);
  86.         databaseTypeMappings.setProperty("DB2/AIX64", DATABASE_TYPE_DB2);
  87.         databaseTypeMappings.setProperty("DB2/HPUX", DATABASE_TYPE_DB2);
  88.         databaseTypeMappings.setProperty("DB2/HP64", DATABASE_TYPE_DB2);
  89.         databaseTypeMappings.setProperty("DB2/SUN", DATABASE_TYPE_DB2);
  90.         databaseTypeMappings.setProperty("DB2/SUN64", DATABASE_TYPE_DB2);
  91.         databaseTypeMappings.setProperty("DB2/PTX", DATABASE_TYPE_DB2);
  92.         databaseTypeMappings.setProperty("DB2/2", DATABASE_TYPE_DB2);
  93.         databaseTypeMappings.setProperty("DB2 UDB AS400", DATABASE_TYPE_DB2);
  94.         return databaseTypeMappings;
  95.     }
  96.  
  97.     @Bean
  98.     @Qualifier("flowableModeler")
  99.     @Primary
  100.     public SqlSessionFactory modelerSqlSessionFactory(DataSource dataSource) {
  101.         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
  102.         sqlSessionFactoryBean.setDataSource(dataSource);
  103.         String databaseType = initDatabaseType(dataSource);
  104.         if (databaseType == null) {
  105.             throw new FlowableException("couldn't deduct database type");
  106.         }
  107.  
  108.         try {
  109.             Properties properties = new Properties();
  110.             properties.put("prefix", modelerAppProperties.getDataSourcePrefix());
  111.             properties.put("blobType", "BLOB");
  112.             properties.put("boolValue", "TRUE");
  113.  
  114.             properties.load(this.getClass().getClassLoader().getResourceAsStream("org/flowable/db/properties/" + databaseType + ".properties"));
  115.  
  116.             sqlSessionFactoryBean.setConfigurationProperties(properties);
  117.             //这个是原始代码，只添加flowable的扫描路径
  118. //            sqlSessionFactoryBean
  119. //                    .setMapperLocations(ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources("classpath:/META-INF/modeler-mybatis-mappings/*.xml"));
  120.             //由于后面要设置该SqlSessionFactory为主要的SqlSessionFactory，
  121.             // 然后Ruoyi中使用时Mybatis自动注入，所以在这个地方就需要添加Ruoyi配置扫描
  122.             ResourcePatternResolver resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
  123.  
  124.             List<Resource> allResourceList = new ArrayList<>();
  125.             List<String> mapperLocations = new ArrayList<>();
  126.             //先添加
  127.             mapperLocations.add("classpath:/META-INF/modeler-mybatis-mappings/*.xml");
  128.             mapperLocations.add("classpath*:/mapper/**/*Mapper.xml");
  129.             mapperLocations.add("mapper/*/*.xml");
  130.             mapperLocations.add("classpath*:mapper/*.xml");
  131.             for (String mapperLocation : mapperLocations) {
  132.                 try {
  133.                     Resource[] resources = resourcePatternResolver.getResources(mapperLocation);
  134.                     allResourceList.addAll(Arrays.asList(resources));
  135.                 } catch (Exception ex) {
  136.                     throw new FlowableException("Could not create sqlSessionFactory", ex);
  137.                 }
  138.             }
  139.             Resource[] allResourceArr = allResourceList.toArray(new Resource[allResourceList.size()]);
  140.             //因为若依中使用了类别名基础包，所以需要在这个地方进行添加
  141.             sqlSessionFactoryBean.setTypeAliasesPackage(mybatisProperties.getTypeAliasesPackage());
  142.             sqlSessionFactoryBean.setMapperLocations(allResourceArr);
  143.             sqlSessionFactoryBean.afterPropertiesSet();
  144.             return sqlSessionFactoryBean.getObject();
  145.         } catch (Exception e) {
  146.             throw new FlowableException("Could not create sqlSessionFactory", e);
  147.         }
  148.  
  149.     }
  150.  
  151.     @Bean(destroyMethod = "clearCache")
  152.     // destroyMethod: see https://github.com/mybatis/old-google-code-issues/issues/778
  153.     @Qualifier("flowableModeler")
  154.     @Primary
  155.     public SqlSessionTemplate modelerSqlSessionTemplate(@Qualifier("flowableModeler") SqlSessionFactory sqlSessionFactory) {
  156.         return new SqlSessionTemplate(sqlSessionFactory);
  157.     }
  158.  
  159.     @Bean
  160.     @Qualifier("flowableModeler")
  161.     public Liquibase modelerLiquibase(DataSource dataSource) {
  162.         LOGGER.info("Configuring Liquibase");
  163.  
  164.         try {
  165.             return LiquibaseUtil.runInFlowableScope(() -> createAndUpdateLiquibase(dataSource));
  166.         } catch (Exception e) {
  167.             throw new InternalServerErrorException("Error creating liquibase database", e);
  168.         }
  169.     }
  170.  
  171.     protected Liquibase createAndUpdateLiquibase(DataSource dataSource) {
  172.         Liquibase liquibase = null;
  173.         try {
  174.             DatabaseConnection connection = new JdbcConnection(dataSource.getConnection());
  175.             Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(connection);
  176.             database.setDatabaseChangeLogTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogTableName());
  177.             database.setDatabaseChangeLogLockTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogLockTableName());
  178.  
  179.             liquibase = new Liquibase("META-INF/liquibase/flowable-modeler-app-db-changelog.xml", new ClassLoaderResourceAccessor(), database);
  180.             liquibase.update("flowable");
  181.             return liquibase;
  182.  
  183.         } catch (Exception e) {
  184.             throw new InternalServerErrorException("Error creating liquibase database", e);
  185.         } finally {
  186.             closeDatabase(liquibase);
  187.         }
  188.     }
  189.  
  190.     protected String initDatabaseType(DataSource dataSource) {
  191.         String databaseType = null;
  192.         Connection connection = null;
  193.         try {
  194.             connection = dataSource.getConnection();
  195.             DatabaseMetaData databaseMetaData = connection.getMetaData();
  196.             String databaseProductName = databaseMetaData.getDatabaseProductName();
  197.             LOGGER.info("database product name: '{}'", databaseProductName);
  198.             databaseType = databaseTypeMappings.getProperty(databaseProductName);
  199.             if (databaseType == null) {
  200.                 throw new FlowableException("couldn't deduct database type from database product name '" + databaseProductName + "'");
  201.             }
  202.             LOGGER.info("using database type: {}", databaseType);
  203.  
  204.         } catch (SQLException e) {
  205.             LOGGER.error("Exception while initializing Database connection", e);
  206.         } finally {
  207.             try {
  208.                 if (connection != null) {
  209.                     connection.close();
  210.                 }
  211.             } catch (SQLException e) {
  212.                 LOGGER.error("Exception while closing the Database connection", e);
  213.             }
  214.         }
  215.  
  216.         return databaseType;
  217.     }
  218.  
  219.     private void closeDatabase(Liquibase liquibase) {
  220.         if (liquibase != null) {
  221.             Database database = liquibase.getDatabase();
  222.             if (database != null) {
  223.                 try {
  224.                     database.close();
  225.                 } catch (DatabaseException e) {
  226.                     LOGGER.warn("Error closing database", e);
  227.                 }
  228.             }
  229.         }
  230.     }
  231. }

2.6修改框架原有mybatis配置

2.6.1重写自动化读取

类名随意定，

  1.  
  2. import org.apache.ibatis.mapping.DatabaseIdProvider;
  3. import org.apache.ibatis.plugin.Interceptor;
  4. import org.apache.ibatis.session.Configuration;
  5. import org.apache.ibatis.session.ExecutorType;
  6. import org.apache.ibatis.session.SqlSessionFactory;
  7. import org.mybatis.spring.SqlSessionFactoryBean;
  8. import org.mybatis.spring.SqlSessionTemplate;
  9. import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
  10. import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
  11. import org.springframework.context.ApplicationContext;
  12. import org.springframework.core.io.ResourceLoader;
  13. import org.springframework.util.ObjectUtils;
  14. import org.springframework.util.StringUtils;
  15.  
  16. import javax.sql.DataSource;
  17.  
  18. public class AbsMybatisAutoConfiguration {
  19.  
  20.     protected SqlSessionFactory getSqlSessionFactory(
  21.             DataSource dataSource,
  22.             MybatisProperties properties,
  23.             ResourceLoader resourceLoader,
  24.             Interceptor[] interceptors,
  25.             DatabaseIdProvider databaseIdProvider,
  26.             ApplicationContext applicationContext
  27.     ) throws Exception {
  28.         SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
  29.         factory.setDataSource(dataSource);
  30.         factory.setVfs(SpringBootVFS.class);
  31.         if (StringUtils.hasText(properties.getConfigLocation())) {
  32.             factory.setConfigLocation(resourceLoader.getResource(properties.getConfigLocation()));
  33.         }
  34.         Configuration configuration = properties.getConfiguration();
  35.         if (configuration == null && !StringUtils.hasText(properties.getConfigLocation())) {
  36.             configuration = new Configuration();
  37.         }
  38.  
  39.         factory.setConfiguration(configuration);
  40.         if (properties.getConfigurationProperties() != null) {
  41.             factory.setConfigurationProperties(properties.getConfigurationProperties());
  42.         }
  43.         if (!ObjectUtils.isEmpty(interceptors)) {
  44.             factory.setPlugins(interceptors);
  45.         }
  46.         if (databaseIdProvider != null) {
  47.             factory.setDatabaseIdProvider(databaseIdProvider);
  48.         }
  49.         if (StringUtils.hasLength(properties.getTypeAliasesPackage())) {
  50.             factory.setTypeAliasesPackage(properties.getTypeAliasesPackage());
  51.         }
  52.         if (StringUtils.hasLength(properties.getTypeHandlersPackage())) {
  53.             factory.setTypeHandlersPackage(properties.getTypeHandlersPackage());
  54.         }
  55.         if (!ObjectUtils.isEmpty(properties.resolveMapperLocations())) {
  56.             factory.setMapperLocations(properties.resolveMapperLocations());
  57.         }
  58.  
  59.         return factory.getObject();
  60.     }
  61.  
  62.     private void applyConfiguration(SqlSessionFactoryBean factory, MybatisProperties properties) {
  63.         Configuration configuration = properties.getConfiguration();
  64.         if (configuration == null && !StringUtils.hasText(properties.getConfigLocation())) {
  65.             configuration = new Configuration();
  66.         }
  67.  
  68.         factory.setConfiguration(configuration);
  69.     }
  70.  
  71.     public SqlSessionTemplate getSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, MybatisProperties properties) {
  72.         ExecutorType executorType = properties.getExecutorType();
  73.         if (executorType != null) {
  74.             return new SqlSessionTemplate(sqlSessionFactory, executorType);
  75.         } else {
  76.             return new SqlSessionTemplate(sqlSessionFactory);
  77.         }
  78.     }
  79. }

2.6.2MyBatisConfig.class修改

屏蔽内部所有方法，继承上边的自动化配置类，增加注解和注入bean

  1.  
  2. import org.apache.ibatis.session.SqlSessionFactory;
  3. import org.mybatis.spring.SqlSessionTemplate;
  4. import org.mybatis.spring.annotation.MapperScan;
  5. import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.beans.factory.annotation.Qualifier;
  8. import org.springframework.context.ApplicationContext;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.core.env.Environment;
  12. import org.springframework.core.io.ResourceLoader;
  13. import org.springframework.transaction.annotation.EnableTransactionManagement;
  14.  
  15. import javax.sql.DataSource;
  16.  
  17. /**
  18.  * Mybatis支持*匹配扫描包
  19.  * 
  20.  * @author ruoyi
  21.  */
  22. @EnableTransactionManagement(proxyTargetClass = true)
  23. @Configuration
  24. @MapperScan(sqlSessionFactoryRef = "sqlSessionFactory", sqlSessionTemplateRef = "sqlSessionTemplate")
  25. public class MyBatisConfig extends AbsMybatisAutoConfiguration{
  26.     @Bean(name = "mySqlSessionFactory")
  27.     public SqlSessionFactory sqlSessionFactoryBean(DataSource dataSource,
  28.                                                    MybatisProperties properties,
  29.                                                    ResourceLoader resourceLoader,
  30.                                                    ApplicationContext applicationContext) throws Exception {
  31.         return getSqlSessionFactory(dataSource,
  32.                 properties,
  33.                 resourceLoader,
  34.                 null,
  35.                 null,
  36.                 applicationContext);
  37.     }
  38.  
  39.     @Bean(name = "mySqlSessionTemplate")
  40.     public SqlSessionTemplate sqlSessionTemplate(MybatisProperties properties,
  41.                                                  @Qualifier("mySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
  42.         return getSqlSessionTemplate(sqlSessionFactory, properties);
  43.     }
  44. }

2.6.3yml修改mybatis配置

让其支持BLOB

  1. # MyBatis
  2. mybatis:
  3.   # 搜索指定包别名
  4.   typeAliasesPackage: org.morfly.kdla.pdmp.**.domain
  5.   # 配置mapper的扫描，找到所有的mapper.xml映射文件
  6.   mapperLocations: mapper/*/*.xml,classpath*:mapper/*.xml,classpath:/META-INF/modeler-mybatis-mappings/*.xml
  7.   # 加载全局的配置文件
  8.   configLocation: classpath:mybatis/mybatis-config.xml
  9.   # 参数配置
  10.   configuration-properties:
  11.     # 配置流程引擎参数，详情可见 DatabaseConfiguration
  12.     blobType: BLOB
  13.     boolValue: TRUE
  14.     # 不要设置库名，否则会出现双库名 bug
  15.     prefix: ''

外记：

1.项目集成mybatis-plus

如果项目中的mybatis升级成mybatis-plus，需要对三个配置类修改：MybatisConfiguration.class和MyBatisConfig.class，DatabaseConfiguration.class,内容如下：

AbstractMybatisPlusConfiguration.class

  1.  
  2. import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
  3. import com.baomidou.mybatisplus.autoconfigure.SpringBootVFS;
  4. import com.baomidou.mybatisplus.core.MybatisConfiguration;
  5. import com.baomidou.mybatisplus.core.config.GlobalConfig;
  6. import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
  7. import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
  8. import com.baomidou.mybatisplus.core.injector.ISqlInjector;
  9. import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
  10. import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
  11. import org.apache.ibatis.mapping.DatabaseIdProvider;
  12. import org.apache.ibatis.plugin.Interceptor;
  13. import org.apache.ibatis.session.ExecutorType;
  14. import org.apache.ibatis.session.SqlSessionFactory;
  15. import org.mybatis.spring.SqlSessionTemplate;
  16. import org.springframework.context.ApplicationContext;
  17. import org.springframework.core.io.ResourceLoader;
  18. import org.springframework.util.StringUtils;
  19.  
  20. import javax.sql.DataSource;
  21. import java.util.List;
  22. public class AbstractMybatisPlusConfiguration {
  23.  
  24.     protected SqlSessionFactory getSqlSessionFactory(
  25.             DataSource dataSource,
  26.             MybatisPlusProperties properties,
  27.             ResourceLoader resourceLoader,
  28.             Interceptor[] interceptors,
  29.             DatabaseIdProvider databaseIdProvider,
  30.             ApplicationContext applicationContext
  31.     ) throws Exception {
  32.         MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
  33.         factory.setDataSource(dataSource);
  34.         factory.setVfs(SpringBootVFS.class);
  35.         if (StringUtils.hasText(properties.getConfigLocation())) {
  36.             factory.setConfigLocation(resourceLoader.getResource(properties.getConfigLocation()));
  37.         }
  38.         applyConfiguration(factory, properties);
  39.         if (properties.getConfigurationProperties() != null) {
  40.             factory.setConfigurationProperties(properties.getConfigurationProperties());
  41.         }
  42.         if (!ObjectUtils.isEmpty(interceptors)) {
  43.             factory.setPlugins(interceptors);
  44.         }
  45.         if (databaseIdProvider != null) {
  46.             factory.setDatabaseIdProvider(databaseIdProvider);
  47.         }
  48.         if (StringUtils.hasLength(properties.getTypeAliasesPackage())) {
  49.             factory.setTypeAliasesPackage(properties.getTypeAliasesPackage());
  50.         }
  51.         // TODO 自定义枚举包
  52.         if (StringUtils.hasLength(properties.getTypeEnumsPackage())) {
  53.             factory.setTypeEnumsPackage(properties.getTypeEnumsPackage());
  54.         }
  55.         if (properties.getTypeAliasesSuperType() != null) {
  56.             factory.setTypeAliasesSuperType(properties.getTypeAliasesSuperType());
  57.         }
  58.         if (StringUtils.hasLength(properties.getTypeHandlersPackage())) {
  59.             factory.setTypeHandlersPackage(properties.getTypeHandlersPackage());
  60.         }
  61.         if (!ObjectUtils.isEmpty(properties.resolveMapperLocations())) {
  62.             factory.setMapperLocations(properties.resolveMapperLocations());
  63.         }
  64.         // TODO 此处必为非 NULL
  65.         GlobalConfig globalConfig = properties.getGlobalConfig();
  66.         //注入填充器
  67.         if (applicationContext.getBeanNamesForType(MetaObjectHandler.class,
  68.                 false, false).length > 0) {
  69.             MetaObjectHandler metaObjectHandler = applicationContext.getBean(MetaObjectHandler.class);
  70.             globalConfig.setMetaObjectHandler(metaObjectHandler);
  71.         }
  72.         //注入主键生成器
  73.         if (applicationContext.getBeanNamesForType(IKeyGenerator.class, false,
  74.                 false).length > 0) {
  75.             IKeyGenerator keyGenerator = applicationContext.getBean(IKeyGenerator.class);
  76.             globalConfig.getDbConfig().setKeyGenerators((List<IKeyGenerator>) keyGenerator);
  77.         }
  78.         //注入sql注入器
  79.         if (applicationContext.getBeanNamesForType(ISqlInjector.class, false,
  80.                 false).length > 0) {
  81.             ISqlInjector iSqlInjector = applicationContext.getBean(ISqlInjector.class);
  82.             globalConfig.setSqlInjector(iSqlInjector);
  83.         }
  84.         factory.setGlobalConfig(globalConfig);
  85.         return factory.getObject();
  86.     }
  87.  
  88.     private void applyConfiguration(MybatisSqlSessionFactoryBean factory, MybatisPlusProperties properties) {
  89.         MybatisConfiguration configuration = properties.getConfiguration();
  90.         if (configuration == null && !StringUtils.hasText(properties.getConfigLocation())) {
  91.             configuration = new MybatisConfiguration();
  92.         }
  93. //        if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
  94. //            for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
  95. //                customizer.customize(configuration);
  96. //            }
  97. //        }
  98.         factory.setConfiguration(configuration);
  99.     }
  100.  
  101.     public SqlSessionTemplate getSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, MybatisPlusProperties properties) {
  102.         ExecutorType executorType = properties.getExecutorType();
  103.         if (executorType != null) {
  104.             return new SqlSessionTemplate(sqlSessionFactory, executorType);
  105.         } else {
  106.             return new SqlSessionTemplate(sqlSessionFactory);
  107.         }
  108.     }
  109. }

DatabaseConfiguration.class

  1.  
  2. import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
  3. import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
  4. import liquibase.Liquibase;
  5. import liquibase.database.Database;
  6. import liquibase.database.DatabaseConnection;
  7. import liquibase.database.DatabaseFactory;
  8. import liquibase.database.jvm.JdbcConnection;
  9. import liquibase.exception.DatabaseException;
  10. import liquibase.resource.ClassLoaderResourceAccessor;
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.apache.ibatis.session.SqlSessionFactory;
  13. import org.flowable.common.engine.api.FlowableException;
  14. import org.flowable.ui.common.service.exception.InternalServerErrorException;
  15. import org.flowable.ui.modeler.properties.FlowableModelerAppProperties;
  16. import org.mybatis.spring.SqlSessionTemplate;
  17. import org.springframework.beans.factory.annotation.Autowired;
  18. import org.springframework.beans.factory.annotation.Qualifier;
  19. import org.springframework.context.annotation.Bean;
  20. import org.springframework.context.annotation.Configuration;
  21. import org.springframework.context.annotation.Primary;
  22. import org.springframework.core.io.Resource;
  23. import org.springframework.core.io.ResourceLoader;
  24. import org.springframework.core.io.support.ResourcePatternResolver;
  25. import org.springframework.core.io.support.ResourcePatternUtils;
  26.  
  27. import javax.sql.DataSource;
  28. import java.sql.Connection;
  29. import java.sql.DatabaseMetaData;
  30. import java.sql.SQLException;
  31. import java.util.ArrayList;
  32. import java.util.Arrays;
  33. import java.util.List;
  34. import java.util.Properties;
  35.  
  36. @Configuration
  37. @Slf4j
  38. public class DatabaseConfiguration {
  39.     protected static final String LIQUIBASE_CHANGELOG_PREFIX = "ACT_DE_";
  40.  
  41.     @Autowired
  42.     protected FlowableModelerAppProperties modelerAppProperties;
  43.  
  44.     @Autowired
  45.     protected ResourceLoader resourceLoader;
  46.     @Autowired
  47.     protected MybatisPlusProperties mybatisPlusProperties;
  48.  
  49.     protected static Properties databaseTypeMappings = getDefaultDatabaseTypeMappings();
  50.  
  51.     public static final String DATABASE_TYPE_H2 = "h2";
  52.     public static final String DATABASE_TYPE_HSQL = "hsql";
  53.     public static final String DATABASE_TYPE_MYSQL = "mysql";
  54.     public static final String DATABASE_TYPE_ORACLE = "oracle";
  55.     public static final String DATABASE_TYPE_POSTGRES = "postgres";
  56.     public static final String DATABASE_TYPE_MSSQL = "mssql";
  57.     public static final String DATABASE_TYPE_DB2 = "db2";
  58.  
  59.     public static Properties getDefaultDatabaseTypeMappings() {
  60.         Properties databaseTypeMappings = new Properties();
  61.         databaseTypeMappings.setProperty("H2", DATABASE_TYPE_H2);
  62.         databaseTypeMappings.setProperty("HSQL Database Engine", DATABASE_TYPE_HSQL);
  63.         databaseTypeMappings.setProperty("MySQL", DATABASE_TYPE_MYSQL);
  64.         databaseTypeMappings.setProperty("Oracle", DATABASE_TYPE_ORACLE);
  65.         databaseTypeMappings.setProperty("PostgreSQL", DATABASE_TYPE_POSTGRES);
  66.         databaseTypeMappings.setProperty("Microsoft SQL Server", DATABASE_TYPE_MSSQL);
  67.         databaseTypeMappings.setProperty(DATABASE_TYPE_DB2, DATABASE_TYPE_DB2);
  68.         databaseTypeMappings.setProperty("DB2", DATABASE_TYPE_DB2);
  69.         databaseTypeMappings.setProperty("DB2/NT", DATABASE_TYPE_DB2);
  70.         databaseTypeMappings.setProperty("DB2/NT64", DATABASE_TYPE_DB2);
  71.         databaseTypeMappings.setProperty("DB2 UDP", DATABASE_TYPE_DB2);
  72.         databaseTypeMappings.setProperty("DB2/LINUX", DATABASE_TYPE_DB2);
  73.         databaseTypeMappings.setProperty("DB2/LINUX390", DATABASE_TYPE_DB2);
  74.         databaseTypeMappings.setProperty("DB2/LINUXX8664", DATABASE_TYPE_DB2);
  75.         databaseTypeMappings.setProperty("DB2/LINUXZ64", DATABASE_TYPE_DB2);
  76.         databaseTypeMappings.setProperty("DB2/LINUXPPC64", DATABASE_TYPE_DB2);
  77.         databaseTypeMappings.setProperty("DB2/400 SQL", DATABASE_TYPE_DB2);
  78.         databaseTypeMappings.setProperty("DB2/6000", DATABASE_TYPE_DB2);
  79.         databaseTypeMappings.setProperty("DB2 UDB iSeries", DATABASE_TYPE_DB2);
  80.         databaseTypeMappings.setProperty("DB2/AIX64", DATABASE_TYPE_DB2);
  81.         databaseTypeMappings.setProperty("DB2/HPUX", DATABASE_TYPE_DB2);
  82.         databaseTypeMappings.setProperty("DB2/HP64", DATABASE_TYPE_DB2);
  83.         databaseTypeMappings.setProperty("DB2/SUN", DATABASE_TYPE_DB2);
  84.         databaseTypeMappings.setProperty("DB2/SUN64", DATABASE_TYPE_DB2);
  85.         databaseTypeMappings.setProperty("DB2/PTX", DATABASE_TYPE_DB2);
  86.         databaseTypeMappings.setProperty("DB2/2", DATABASE_TYPE_DB2);
  87.         databaseTypeMappings.setProperty("DB2 UDB AS400", DATABASE_TYPE_DB2);
  88.         return databaseTypeMappings;
  89.     }
  90.  
  91.     @Bean
  92.     @Qualifier("flowableModeler")
  93.     @Primary
  94.     public SqlSessionFactory sqlSessionFactory(DataSource dataSource) {
  95.         MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
  96.         sqlSessionFactoryBean.setDataSource(dataSource);
  97.         String databaseType = initDatabaseType(dataSource);
  98.         if (databaseType == null) {
  99.             throw new FlowableException("couldn't deduct database type");
  100.         }
  101.  
  102.         try {
  103.             Properties properties = new Properties();
  104.             properties.put("prefix", modelerAppProperties.getDataSourcePrefix());
  105.             properties.put("blobType", "BLOB");
  106.             properties.put("boolValue", "TRUE");
  107.             log.info("this.getClass().getClassLoader():{}",databaseType);
  108.             properties.load(this.getClass().getClassLoader().getResourceAsStream("org/flowable/db/properties/" + databaseType + ".properties"));
  109.  
  110.             sqlSessionFactoryBean.setConfigurationProperties(properties);
  111.             //这个是原始代码，只添加flowable的扫描路径
  112. //            sqlSessionFactoryBean
  113. //                    .setMapperLocations(ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources("classpath:/META-INF/modeler-mybatis-mappings/*.xml"));
  114.             //由于后面要设置该SqlSessionFactory为主要的SqlSessionFactory，
  115.             // 然后Ruoyi中使用时Mybatis自动注入，所以在这个地方就需要添加Ruoyi配置扫描
  116.             ResourcePatternResolver resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
  117.  
  118.             List<Resource> allResourceList = new ArrayList<>();
  119.             List<String> mapperLocations = new ArrayList<>();
  120.             //先添加
  121.             mapperLocations.add("classpath:/META-INF/modeler-mybatis-mappings/*.xml");
  122.             mapperLocations.add("classpath*:/mapper/**/*Mapper.xml");
  123.             mapperLocations.add("mapper/*/*.xml");
  124.             mapperLocations.add("classpath*:mapper/*.xml");
  125.             for (String mapperLocation : mapperLocations) {
  126.                 try {
  127.                     Resource[] resources = resourcePatternResolver.getResources(mapperLocation);
  128.                     allResourceList.addAll(Arrays.asList(resources));
  129.                 } catch (Exception ex) {
  130.                     throw new FlowableException("Could not create sqlSessionFactory", ex);
  131.                 }
  132.             }
  133.             Resource[] allResourceArr = allResourceList.toArray(new Resource[allResourceList.size()]);
  134.             //因为若依中使用了类别名基础包，所以需要在这个地方进行添加
  135.             sqlSessionFactoryBean.setTypeAliasesPackage(mybatisPlusProperties.getTypeAliasesPackage());
  136.             sqlSessionFactoryBean.setMapperLocations(allResourceArr);
  137.             sqlSessionFactoryBean.afterPropertiesSet();
  138.             return sqlSessionFactoryBean.getObject();
  139.         } catch (Exception e) {
  140.             throw new FlowableException("Could not create sqlSessionFactory", e);
  141.         }
  142.  
  143.     }
  144.  
  145.     @Primary
  146.     @Bean(destroyMethod = "clearCache") // destroyMethod: see https://github.com/mybatis/old-google-code-issues/issues/778
  147.     public SqlSessionTemplate SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
  148.         return new SqlSessionTemplate(sqlSessionFactory);
  149.     }
  150.  
  151.     @Bean
  152.     public Liquibase liquibase(DataSource dataSource) {
  153.         log.info("Configuring Liquibase");
  154.  
  155.         Liquibase liquibase = null;
  156.         try {
  157.             DatabaseConnection connection = new JdbcConnection(dataSource.getConnection());
  158.             Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(connection);
  159.             database.setDatabaseChangeLogTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogTableName());
  160.             database.setDatabaseChangeLogLockTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogLockTableName());
  161.  
  162.             liquibase = new Liquibase("META-INF/liquibase/flowable-modeler-app-db-changelog.xml", new ClassLoaderResourceAccessor(), database);
  163.             liquibase.update("flowable");
  164.             return liquibase;
  165.  
  166.         } catch (Exception e) {
  167.             throw new InternalServerErrorException("Error creating liquibase database", e);
  168.         } finally {
  169.             closeDatabase(liquibase);
  170.         }
  171.     }
  172.  
  173.     protected String initDatabaseType(DataSource dataSource) {
  174.         String databaseType = null;
  175.         Connection connection = null;
  176.         try {
  177.             connection = dataSource.getConnection();
  178.             DatabaseMetaData databaseMetaData = connection.getMetaData();
  179.             String databaseProductName = databaseMetaData.getDatabaseProductName();
  180.             log.info("database product name: '{}'", databaseProductName);
  181.             databaseType = databaseTypeMappings.getProperty(databaseProductName);
  182.             if (databaseType == null) {
  183.                 throw new FlowableException("couldn't deduct database type from database product name '" + databaseProductName + "'");
  184.             }
  185.             log.info("using database type: {}", databaseType);
  186.  
  187.         } catch (SQLException e) {
  188.             log.error("Exception while initializing Database connection", e);
  189.         } finally {
  190.             try {
  191.                 if (connection != null) {
  192.                     connection.close();
  193.                 }
  194.             } catch (SQLException e) {
  195.                 log.error("Exception while closing the Database connection", e);
  196.             }
  197.         }
  198.  
  199.         return databaseType;
  200.     }
  201.  
  202.     private void closeDatabase(Liquibase liquibase) {
  203.         if (liquibase != null) {
  204.             Database database = liquibase.getDatabase();
  205.             if (database != null) {
  206.                 try {
  207.                     database.close();
  208.                 } catch (DatabaseException e) {
  209.                     log.warn("Error closing database", e);
  210.                 }
  211.             }
  212.         }
  213.     }
  214.  
  215. }

MybatisConfig.class改名 MybatisPlusConfig.class

  1.  
  2. import com.baomidou.mybatisplus.annotation.DbType;
  3. import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
  4. import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
  5. import com.baomidou.mybatisplus.extension.plugins.inner.BlockAttackInnerInterceptor;
  6. import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
  7. import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
  8. import org.apache.ibatis.session.SqlSessionFactory;
  9. import org.mybatis.spring.SqlSessionTemplate;
  10. import org.mybatis.spring.annotation.MapperScan;
  11. import org.springframework.beans.factory.annotation.Qualifier;
  12. import org.springframework.context.ApplicationContext;
  13. import org.springframework.context.annotation.Bean;
  14. import org.springframework.context.annotation.Configuration;
  15. import org.springframework.core.io.ResourceLoader;
  16. import org.springframework.transaction.annotation.EnableTransactionManagement;
  17.  
  18. import javax.sql.DataSource;
  19.  
  20. /**
  21.  * Mybatis Plus 配置
  22.  *
  23.  * @author ruoyi
  24.  */
  25. @EnableTransactionManagement(proxyTargetClass = true)
  26. @Configuration
  27. @MapperScan(sqlSessionFactoryRef = "sqlSessionFactory", sqlSessionTemplateRef = "sqlSessionTemplate")
  28. public class MybatisPlusConfig extends AbstractMybatisPlusConfiguration
  29. {
  30.  
  31.     @Bean
  32.     public MybatisPlusInterceptor mybatisPlusInterceptor()
  33.     {
  34.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  35.         // 分页插件
  36.         interceptor.addInnerInterceptor(paginationInnerInterceptor());
  37.         // 乐观锁插件
  38.         interceptor.addInnerInterceptor(optimisticLockerInnerInterceptor());
  39.         // 阻断插件
  40.         interceptor.addInnerInterceptor(blockAttackInnerInterceptor());
  41.         return interceptor;
  42.     }
  43.  
  44.     /**
  45.      * 分页插件，自动识别数据库类型 https://baomidou.com/guide/interceptor-pagination.html
  46.      */
  47.     public PaginationInnerInterceptor paginationInnerInterceptor()
  48.     {
  49.         PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
  50.         // 设置数据库类型为mysql
  51.         paginationInnerInterceptor.setDbType(DbType.MYSQL);
  52.         // 设置最大单页限制数量，默认 500 条，-1 不受限制
  53.         paginationInnerInterceptor.setMaxLimit(-1L);
  54.         return paginationInnerInterceptor;
  55.     }
  56.  
  57.     /**
  58.      * 乐观锁插件 https://baomidou.com/guide/interceptor-optimistic-locker.html
  59.      */
  60.     public OptimisticLockerInnerInterceptor optimisticLockerInnerInterceptor()
  61.     {
  62.         return new OptimisticLockerInnerInterceptor();
  63.     }
  64.  
  65.     /**
  66.      * 如果是对全表的删除或更新操作，就会终止该操作 https://baomidou.com/guide/interceptor-block-attack.html
  67.      */
  68.     public BlockAttackInnerInterceptor blockAttackInnerInterceptor()
  69.     {
  70.         return new BlockAttackInnerInterceptor();
  71.     }
  72.  
  73.     @Bean(name = "mySqlSessionFactory")
  74.     public SqlSessionFactory sqlSessionFactoryBean(DataSource dataSource,
  75.                                                    MybatisPlusProperties properties,
  76.                                                    ResourceLoader resourceLoader,
  77.                                                    ApplicationContext applicationContext) throws Exception {
  78.         return getSqlSessionFactory(dataSource,
  79.                 properties,
  80.                 resourceLoader,
  81.                 null,
  82.                 null,
  83.                 applicationContext);
  84.     }
  85.  
  86.     @Bean(name = "mySqlSessionTemplate")
  87.     public SqlSessionTemplate sqlSessionTemplate(MybatisPlusProperties properties,
  88.                                                  @Qualifier("mySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
  89.         return getSqlSessionTemplate(sqlSessionFactory, properties);
  90.     }
  91. }

主要修改的是配置获取方法。有时mybatis-plus版本不同也会出现一些问题，比如重写的自动化配置在注入主键生成器：

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/852363
推荐阅读
相关标签

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

  

闽ICP备14008679号