MybatisPlus整合Flowable出現(xiàn)的坑及解決
更新時間：2023年03月30日 09:48:31 作者：夕夕夕兮
這篇文章主要介紹了MybatisPlus整合Flowable出現(xiàn)的坑及解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
摘要：現(xiàn)在在項目中使用的MybatisPlus，最近研究了一下流程框架Flowable,看了很多技術文檔博客，打算直接整合進去，先記錄一下遇到的問題：
問題
Description:
file [D:\project\carshow-server\server-flowable\flowable-admin\target\classes\com\carshow\flowable\mapper\IFlowableCommentMapper.class] required a single bean, but 2 were found:
- sqlSessionFactory: defined by method 'sqlSessionFactory' in class path resource [com/baomidou/mybatisplus/autoconfigure/MybatisPlusAutoConfiguration.class]
- modelerSqlSessionFactory: defined by method 'modelerSqlSessionFactory' in class path resource [org/flowable/ui/modeler/conf/ModelerDatabaseConfiguration.class]
Action:Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed
原因
整合的bean沖突，spring找到了兩個
查看兩個類源碼找到對應的bean
MybatisPlus： MybatisPlusAutoConfiguration.class
Flowable：ModelerDatabaseConfiguration.class
注解解釋
@ConditionalOnMissingBean：它是修飾bean的一個注解，主要實現(xiàn)的是，當你的bean被注冊之后，如果有注冊相同類型的bean，就不會成功，它會保證你的bean只有一個，即你的實例只有一個，當你注冊多個相同的bean時，會出現(xiàn)異常，以此來告訴開發(fā)人員。
所以問題就來了，找到了這兩個bean沖突，接下來如何進行解決呢，查看了一下源碼并查閱了其他大佬的技術博客，記錄一下
1. 環(huán)境：Flowable6.6
2. 解決：
- 重寫mybatis-plus 自動配置類（由于 flowable-modeler 引入時候，會初始化 mybatis的Template和SqlFactory，這導致 mybatis-plus 本身的autoconfig 無法生效，所以需要重寫），從源碼中拆寫代碼：
import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
import com.baomidou.mybatisplus.autoconfigure.SpringBootVFS;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.mapping.DatabaseIdProvider;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.StringUtils;
import javax.sql.DataSource;
import java.util.List;
/**
* @author xw
* @description 重寫mybatis-plus 自動配置類
* @date 2022/1/7 14:06
*/
public class AbstractMybatisPlusConfiguration {
protected SqlSessionFactory getSqlSessionFactory(
DataSource dataSource,
MybatisPlusProperties properties,
ResourceLoader resourceLoader,
Interceptor[] interceptors,
DatabaseIdProvider databaseIdProvider,
ApplicationContext applicationContext
) throws Exception {
MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
factory.setDataSource(dataSource);
factory.setVfs(SpringBootVFS.class);
if (StringUtils.hasText(properties.getConfigLocation())) {
factory.setConfigLocation(resourceLoader.getResource(properties.getConfigLocation()));
}
applyConfiguration(factory, properties);
if (properties.getConfigurationProperties() != null) {
factory.setConfigurationProperties(properties.getConfigurationProperties());
}
if (!ObjectUtils.isEmpty(interceptors)) {
factory.setPlugins(interceptors);
}
if (databaseIdProvider != null) {
factory.setDatabaseIdProvider(databaseIdProvider);
}
if (StringUtils.hasLength(properties.getTypeAliasesPackage())) {
factory.setTypeAliasesPackage(properties.getTypeAliasesPackage());
}
// TODO 自定義枚舉包
if (StringUtils.hasLength(properties.getTypeEnumsPackage())) {
factory.setTypeEnumsPackage(properties.getTypeEnumsPackage());
}
if (properties.getTypeAliasesSuperType() != null) {
factory.setTypeAliasesSuperType(properties.getTypeAliasesSuperType());
}
if (StringUtils.hasLength(properties.getTypeHandlersPackage())) {
factory.setTypeHandlersPackage(properties.getTypeHandlersPackage());
}
if (!ObjectUtils.isEmpty(properties.resolveMapperLocations())) {
factory.setMapperLocations(properties.resolveMapperLocations());
}
// TODO 此處必為非 NULL
GlobalConfig globalConfig = properties.getGlobalConfig();
//注入填充器
if (applicationContext.getBeanNamesForType(MetaObjectHandler.class,
false, false).length > 0) {
MetaObjectHandler metaObjectHandler = applicationContext.getBean(MetaObjectHandler.class);
globalConfig.setMetaObjectHandler(metaObjectHandler);
}
//注入主鍵生成器
if (applicationContext.getBeanNamesForType(IKeyGenerator.class, false,
false).length > 0) {
IKeyGenerator keyGenerator = applicationContext.getBean(IKeyGenerator.class);
globalConfig.getDbConfig().setKeyGenerators((List<IKeyGenerator>) keyGenerator);
}
//注入sql注入器
if (applicationContext.getBeanNamesForType(ISqlInjector.class, false,
false).length > 0) {
ISqlInjector iSqlInjector = applicationContext.getBean(ISqlInjector.class);
globalConfig.setSqlInjector(iSqlInjector);
}
factory.setGlobalConfig(globalConfig);
return factory.getObject();
}
private void applyConfiguration(MybatisSqlSessionFactoryBean factory, MybatisPlusProperties properties) {
MybatisConfiguration configuration = properties.getConfiguration();
if (configuration == null && !StringUtils.hasText(properties.getConfigLocation())) {
configuration = new MybatisConfiguration();
}
// if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
// for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
// customizer.customize(configuration);
// }
// }
factory.setConfiguration(configuration);
}
public SqlSessionTemplate getSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, MybatisPlusProperties properties) {
ExecutorType executorType = properties.getExecutorType();
if (executorType != null) {
return new SqlSessionTemplate(sqlSessionFactory, executorType);
} else {
return new SqlSessionTemplate(sqlSessionFactory);
}
}
}
- 繼承重寫的配置類
import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ResourceLoader;
import javax.sql.DataSource;
/**
* @author xw
* @description
* @date 2022/1/7 16:24
*/
@MapperScan(
sqlSessionTemplateRef = "mySqlSessionTemplate",
sqlSessionFactoryRef = "mySqlSessionFactory"
)
@EnableConfigurationProperties(MybatisPlusProperties.class)
@Configuration
public class MybatisPlusConfiguration extends AbstractMybatisPlusConfiguration {
@Bean(name = "mySqlSessionFactory")
public SqlSessionFactory sqlSessionFactoryBean(DataSource dataSource,
MybatisPlusProperties properties,
ResourceLoader resourceLoader,
ApplicationContext applicationContext) throws Exception {
return getSqlSessionFactory(dataSource,
properties,
resourceLoader,
null,
null,
applicationContext);
}
@Bean(name = "mySqlSessionTemplate")
public SqlSessionTemplate sqlSessionTemplate(MybatisPlusProperties properties,
@Qualifier("mySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
return getSqlSessionTemplate(sqlSessionFactory, properties);
}
}
- 重寫 flowable-modeler 中 ModelerDatabaseConfiguration,用 @Primary 指定框架內(nèi)部的mybatis 作為默認的
import liquibase.Liquibase;
import liquibase.database.Database;
import liquibase.database.DatabaseConnection;
import liquibase.database.DatabaseFactory;
import liquibase.database.jvm.JdbcConnection;
import liquibase.exception.DatabaseException;
import liquibase.resource.ClassLoaderResourceAccessor;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.flowable.common.engine.api.FlowableException;
import org.flowable.ui.common.service.exception.InternalServerErrorException;
import org.flowable.ui.modeler.properties.FlowableModelerAppProperties;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.ResourcePatternUtils;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.Properties;
/**
* @author xw
* @description 重寫 flowable-modeler 中 ModelerDatabaseConfiguration
* @date 2022/1/7 16:31
*/
@Configuration
@Slf4j
public class DatabaseConfiguration {
protected static final String LIQUIBASE_CHANGELOG_PREFIX = "ACT_DE_";
@Autowired
protected FlowableModelerAppProperties modelerAppProperties;
@Autowired
protected ResourceLoader resourceLoader;
protected static Properties databaseTypeMappings = getDefaultDatabaseTypeMappings();
public static final String DATABASE_TYPE_H2 = "h2";
public static final String DATABASE_TYPE_HSQL = "hsql";
public static final String DATABASE_TYPE_MYSQL = "mysql";
public static final String DATABASE_TYPE_ORACLE = "oracle";
public static final String DATABASE_TYPE_POSTGRES = "postgres";
public static final String DATABASE_TYPE_MSSQL = "mssql";
public static final String DATABASE_TYPE_DB2 = "db2";
public static Properties getDefaultDatabaseTypeMappings() {
Properties databaseTypeMappings = new Properties();
databaseTypeMappings.setProperty("H2", DATABASE_TYPE_H2);
databaseTypeMappings.setProperty("HSQL Database Engine", DATABASE_TYPE_HSQL);
databaseTypeMappings.setProperty("MySQL", DATABASE_TYPE_MYSQL);
databaseTypeMappings.setProperty("Oracle", DATABASE_TYPE_ORACLE);
databaseTypeMappings.setProperty("PostgreSQL", DATABASE_TYPE_POSTGRES);
databaseTypeMappings.setProperty("Microsoft SQL Server", DATABASE_TYPE_MSSQL);
databaseTypeMappings.setProperty(DATABASE_TYPE_DB2, DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/NT", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/NT64", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2 UDP", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/LINUX", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/LINUX390", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/LINUXX8664", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/LINUXZ64", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/LINUXPPC64", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/400 SQL", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/6000", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2 UDB iSeries", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/AIX64", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/HPUX", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/HP64", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/SUN", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/SUN64", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/PTX", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2/2", DATABASE_TYPE_DB2);
databaseTypeMappings.setProperty("DB2 UDB AS400", DATABASE_TYPE_DB2);
return databaseTypeMappings;
}
@Bean
@Primary
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
String databaseType = initDatabaseType(dataSource);
if (databaseType == null) {
throw new FlowableException("couldn't deduct database type");
}
try {
Properties properties = new Properties();
properties.put("prefix", modelerAppProperties.getDataSourcePrefix());
properties.put("blobType", "BLOB");
properties.put("boolValue", "TRUE");
properties.load(this.getClass().getClassLoader().getResourceAsStream("org/flowable/db/properties/" + databaseType + ".properties"));
sqlSessionFactoryBean.setConfigurationProperties(properties);
sqlSessionFactoryBean
.setMapperLocations(ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources("classpath:/META-INF/modeler-mybatis-mappings/*.xml"));
sqlSessionFactoryBean.afterPropertiesSet();
return sqlSessionFactoryBean.getObject();
} catch (Exception e) {
throw new FlowableException("Could not create sqlSessionFactory", e);
}
}
@Primary
@Bean(destroyMethod = "clearCache") // destroyMethod: see https://github.com/mybatis/old-google-code-issues/issues/778
public SqlSessionTemplate SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
return new SqlSessionTemplate(sqlSessionFactory);
}
@Bean
public Liquibase liquibase(DataSource dataSource) {
log.info("Configuring Liquibase");
Liquibase liquibase = null;
try {
DatabaseConnection connection = new JdbcConnection(dataSource.getConnection());
Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(connection);
database.setDatabaseChangeLogTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogTableName());
database.setDatabaseChangeLogLockTableName(LIQUIBASE_CHANGELOG_PREFIX + database.getDatabaseChangeLogLockTableName());
liquibase = new Liquibase("META-INF/liquibase/flowable-modeler-app-db-changelog.xml", new ClassLoaderResourceAccessor(), database);
liquibase.update("flowable");
return liquibase;
} catch (Exception e) {
throw new InternalServerErrorException("Error creating liquibase database", e);
} finally {
closeDatabase(liquibase);
}
}
protected String initDatabaseType(DataSource dataSource) {
String databaseType = null;
Connection connection = null;
try {
connection = dataSource.getConnection();
DatabaseMetaData databaseMetaData = connection.getMetaData();
String databaseProductName = databaseMetaData.getDatabaseProductName();
log.info("database product name: '{}'", databaseProductName);
databaseType = databaseTypeMappings.getProperty(databaseProductName);
if (databaseType == null) {
throw new FlowableException("couldn't deduct database type from database product name '" + databaseProductName + "'");
}
log.info("using database type: {}", databaseType);
} catch (SQLException e) {
log.error("Exception while initializing Database connection", e);
} finally {
try {
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
log.error("Exception while closing the Database connection", e);
}
}
return databaseType;
}
private void closeDatabase(Liquibase liquibase) {
if (liquibase != null) {
Database database = liquibase.getDatabase();
if (database != null) {
try {
database.close();
} catch (DatabaseException e) {
log.warn("Error closing database", e);
}
}
}
}
}
總結(jié)
以上關于Mybatis-Plus整合Flowable的坑就處理完啦，重啟ok! - 之后也會找個時間記錄SpringCloud微服務中整合Flowable服務的流程，加油！希望能給大家一個參考，也希望大家多多支持腳本之家。
相關文章
Java?Lombok實現(xiàn)手機號碼校驗的示例代碼
手機號碼校驗通常是系統(tǒng)開發(fā)中最基礎的功能之一，本文主要介紹了Java?Lombok實現(xiàn)手機號碼校驗的示例代碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2023-07-07
java.lang.ExceptionInInitializerError初始化程序中的異常錯誤的解決
java.lang.ExceptionInInitializerError?異常在?Java?中表示一個錯誤,該錯誤發(fā)生在嘗試初始化一個類的靜態(tài)變量、靜態(tài)代碼塊或枚舉常量時,本文就來介紹并解決一下,感興趣的可以了解一下2024-05-05
這篇文章主要給大家介紹了關于struts2中Action名字大小寫問題的相關資料，文中介紹的非常詳細，對大家具有一定的參考學習價值，需要的朋友們下面跟著小編一起來學習學習吧。2017-06-06
這篇文章主要介紹了 Java保留兩位小數(shù)的實現(xiàn)方法的相關資料,需要的朋友可以參考下2017-06-06
IDEA2020.2.3中創(chuàng)建JavaWeb工程的完整步驟記錄
這篇文章主要給大家介紹了關于IDEA2020.2.3中創(chuàng)建JavaWeb工程的完整步驟，文中通過圖文介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-12-12
java中將漢字轉(zhuǎn)換成拼音的實現(xiàn)代碼
java中將漢字轉(zhuǎn)換成拼音的實現(xiàn)代碼。需要的朋友可以過來參考下，希望對大家有所幫助2013-10-10
Jackson是一個用于處理Json數(shù)據(jù)的Java庫，它提供了一系列功能，包括Json序列化和反序列化，所以本文就來講講如何利用利用Jackson解決Json序列化和反序列化的問題吧2023-05-05
Springboot打成war包并在tomcat中運行的部署方法
這篇文章主要介紹了Springboot打成war包并在tomcat中運行，在文中還給大家介紹了SpringBoot war包tomcat運行啟動報錯（Cannot determine embedded database driver class for database type NONE）的解決方法,需要的朋友可以參考下2018-01-01
詳解springboot + profile（不同環(huán)境讀取不同配置）
本篇文章主要介紹了springboot + profile（不同環(huán)境讀取不同配置），具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-05-05
基于java swing實現(xiàn)答題系統(tǒng)
這篇文章主要為大家詳細介紹了基于java swing實現(xiàn)答題系統(tǒng)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-01-01