eventRegistryEventConsumers = new HashMap<>();
+
+ // MYBATIS SQL SESSION FACTORY /////////////////////////////////////
+
+ protected boolean isDbHistoryUsed = true;
+
+ protected DbSqlSessionFactory dbSqlSessionFactory;
+
+ protected SqlSessionFactory sqlSessionFactory;
+
+ protected TransactionFactory transactionFactory;
+
+ protected TransactionContextFactory transactionContextFactory;
+
+ /**
+ * If set to true, enables bulk insert (grouping sql inserts together). Default true.
+ * For some databases (eg DB2+z/OS) needs to be set to false.
+ */
+ protected boolean isBulkInsertEnabled = true;
+
+ /**
+ * Some databases have a limit of how many parameters one sql insert can have (eg SQL
+ * Server, 2000 params (!= insert statements) ). Tweak this parameter in case of
+ * exceptions indicating too much is being put into one bulk insert, or make it higher
+ * if your database can cope with it and there are inserts with a huge amount of data.
+ *
+ * By default: 100 (55 for mssql server as it has a hard limit of 2000 parameters in a
+ * statement)
+ */
+ protected int maxNrOfStatementsInBulkInsert = 100;
+
+ public int DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER = 55; // currently
+ // Execution
+ // has most
+ // params
+ // (35). 2000
+ // / 35 = 57.
+
+ protected String mybatisMappingFile;
+
+ protected Set> customMybatisMappers;
+
+ protected Set customMybatisXMLMappers;
+
+ protected List customMybatisInterceptors;
+
+ protected Set dependentEngineMyBatisXmlMappers;
+
+ protected List dependentEngineMybatisTypeAliasConfigs;
+
+ protected List dependentEngineMybatisTypeHandlerConfigs;
+
+ // SESSION FACTORIES ///////////////////////////////////////////////
+ protected List customSessionFactories;
+
+ protected Map, SessionFactory> sessionFactories;
+
+ protected boolean enableEventDispatcher = true;
+
+ protected FlowableEventDispatcher eventDispatcher;
+
+ protected List eventListeners;
+
+ protected Map> typedEventListeners;
+
+ protected List additionalEventDispatchActions;
+
+ protected LoggingListener loggingListener;
+
+ protected boolean transactionsExternallyManaged;
+
+ /**
+ * Flag that can be set to configure or not a relational database is used. This is
+ * useful for custom implementations that do not use relational databases at all.
+ *
+ * If true (default), the
+ * {@link AbstractEngineConfiguration#getDatabaseSchemaUpdate()} value will be used to
+ * determine what needs to happen wrt the database schema.
+ *
+ * If false, no validation or schema creation will be done. That means that the
+ * database schema must have been created 'manually' before but the engine does not
+ * validate whether the schema is correct. The
+ * {@link AbstractEngineConfiguration#getDatabaseSchemaUpdate()} value will not be
+ * used.
+ */
+ protected boolean usingRelationalDatabase = true;
+
+ /**
+ * Flag that can be set to configure whether or not a schema is used. This is useful
+ * for custom implementations that do not use relational databases at all. Setting
+ * {@link #usingRelationalDatabase} to true will automatically imply using a schema.
+ */
+ protected boolean usingSchemaMgmt = true;
+
+ /**
+ * Allows configuring a database table prefix which is used for all runtime operations
+ * of the process engine. For example, if you specify a prefix named 'PRE1.', Flowable
+ * will query for executions in a table named 'PRE1.ACT_RU_EXECUTION_'.
+ *
+ *
+ * NOTE: the prefix is not respected by automatic database schema management.
+ * If you use {@link AbstractEngineConfiguration#DB_SCHEMA_UPDATE_CREATE_DROP} or
+ * {@link AbstractEngineConfiguration#DB_SCHEMA_UPDATE_TRUE}, Flowable will create the
+ * database tables using the default names, regardless of the prefix configured
+ * here.
+ */
+ protected String databaseTablePrefix = "";
+
+ /**
+ * Escape character for doing wildcard searches.
+ *
+ * This will be added at then end of queries that include for example a LIKE clause.
+ * For example: SELECT * FROM table WHERE column LIKE '%\%%' ESCAPE '\';
+ */
+ protected String databaseWildcardEscapeCharacter;
+
+ /**
+ * database catalog to use
+ */
+ protected String databaseCatalog = "";
+
+ /**
+ * In some situations you want to set the schema to use for table checks / generation
+ * if the database metadata doesn't return that correctly, see
+ * https://jira.codehaus.org/browse/ACT-1220,
+ * https://jira.codehaus.org/browse/ACT-1062
+ */
+ protected String databaseSchema;
+
+ /**
+ * Set to true in case the defined databaseTablePrefix is a schema-name, instead of an
+ * actual table name prefix. This is relevant for checking if Flowable-tables exist,
+ * the databaseTablePrefix will not be used here - since the schema is taken into
+ * account already, adding a prefix for the table-check will result in wrong
+ * table-names.
+ */
+ protected boolean tablePrefixIsSchema;
+
+ /**
+ * Set to true if the latest version of a definition should be retrieved, ignoring a
+ * possible parent deployment id value
+ */
+ protected boolean alwaysLookupLatestDefinitionVersion;
+
+ /**
+ * Set to true if by default lookups should fallback to the default tenant (an empty
+ * string by default or a defined tenant value)
+ */
+ protected boolean fallbackToDefaultTenant;
+
+ /**
+ * Default tenant provider that is executed when looking up definitions, in case the
+ * global or local fallback to default tenant value is true
+ */
+ protected DefaultTenantProvider defaultTenantProvider = (tenantId, scope, scopeKey) -> NO_TENANT_ID;
+
+ /**
+ * Enables the MyBatis plugin that logs the execution time of sql statements.
+ */
+ protected boolean enableLogSqlExecutionTime;
+
+ protected Properties databaseTypeMappings = getDefaultDatabaseTypeMappings();
+
+ /**
+ * Duration between the checks when acquiring a lock.
+ */
+ protected Duration lockPollRate = Duration.ofSeconds(10);
+
+ /**
+ * Duration to wait for the DB Schema lock before giving up.
+ */
+ protected Duration schemaLockWaitTime = Duration.ofMinutes(5);
+
+ // DATA MANAGERS //////////////////////////////////////////////////////////////////
+
+ protected PropertyDataManager propertyDataManager;
+
+ protected ByteArrayDataManager byteArrayDataManager;
+
+ protected TableDataManager tableDataManager;
+
+ // ENTITY MANAGERS ////////////////////////////////////////////////////////////////
+
+ protected PropertyEntityManager propertyEntityManager;
+
+ protected ByteArrayEntityManager byteArrayEntityManager;
+
+ protected List customPreDeployers;
+
+ protected List customPostDeployers;
+
+ protected List deployers;
+
+ // CONFIGURATORS ////////////////////////////////////////////////////////////
+
+ protected boolean enableConfiguratorServiceLoader = true; // Enabled by default. In
+ // certain environments
+ // this should be set to
+ // false (eg osgi)
+
+ protected List configurators; // The injected configurators
+
+ protected List allConfigurators; // Including auto-discovered
+ // configurators
+
+ protected EngineConfigurator idmEngineConfigurator;
+
+ protected EngineConfigurator eventRegistryConfigurator;
+
+ public static final String PRODUCT_NAME_POSTGRES = "PostgreSQL";
+
+ public static final String PRODUCT_NAME_CRDB = "CockroachDB";
+
+ 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 final String DATABASE_TYPE_COCKROACHDB = "cockroachdb";
+
+ 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("MariaDB", DATABASE_TYPE_MYSQL);
+ databaseTypeMappings.setProperty("Oracle", DATABASE_TYPE_ORACLE);
+ databaseTypeMappings.setProperty(PRODUCT_NAME_POSTGRES, 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/LINUXPPC64LE", 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);
+ databaseTypeMappings.setProperty("DM DBMS",DATABASE_TYPE_MYSQL);//扩展支持达梦数据
+ databaseTypeMappings.setProperty(PRODUCT_NAME_CRDB, DATABASE_TYPE_COCKROACHDB);
+ return databaseTypeMappings;
+ }
+
+ protected Map beans;
+
+ protected IdGenerator idGenerator;
+
+ protected boolean usePrefixId;
+
+ protected Clock clock;
+
+ protected ObjectMapper objectMapper;
+
+ // Variables
+
+ public static final int DEFAULT_GENERIC_MAX_LENGTH_STRING = 4000;
+
+ public static final int DEFAULT_ORACLE_MAX_LENGTH_STRING = 2000;
+
+ /**
+ * Define a max length for storing String variable types in the database. Mainly used
+ * for the Oracle NVARCHAR2 limit of 2000 characters
+ */
+ protected int maxLengthStringVariableType = -1;
+
+ protected void initEngineConfigurations() {
+ addEngineConfiguration(getEngineCfgKey(), getEngineScopeType(), this);
+ }
+
+ // DataSource
+ // ///////////////////////////////////////////////////////////////
+
+ protected void initDataSource() {
+ if (dataSource == null) {
+ if (dataSourceJndiName != null) {
+ try {
+ dataSource = (DataSource) new InitialContext().lookup(dataSourceJndiName);
+ }
+ catch (Exception e) {
+ throw new FlowableException(
+ "couldn't lookup datasource from " + dataSourceJndiName + ": " + e.getMessage(), e);
+ }
+
+ }
+ else if (jdbcUrl != null) {
+ if ((jdbcDriver == null) || (jdbcUsername == null)) {
+ throw new FlowableException(
+ "DataSource or JDBC properties have to be specified in a process engine configuration");
+ }
+
+ logger.debug("initializing datasource to db: {}", jdbcUrl);
+
+ if (logger.isInfoEnabled()) {
+ logger.info("Configuring Datasource with following properties (omitted password for security)");
+ logger.info("datasource driver : {}", jdbcDriver);
+ logger.info("datasource url : {}", jdbcUrl);
+ logger.info("datasource user name : {}", jdbcUsername);
+ }
+
+ PooledDataSource pooledDataSource = new PooledDataSource(this.getClass().getClassLoader(), jdbcDriver,
+ jdbcUrl, jdbcUsername, jdbcPassword);
+
+ if (jdbcMaxActiveConnections > 0) {
+ pooledDataSource.setPoolMaximumActiveConnections(jdbcMaxActiveConnections);
+ }
+ if (jdbcMaxIdleConnections > 0) {
+ pooledDataSource.setPoolMaximumIdleConnections(jdbcMaxIdleConnections);
+ }
+ if (jdbcMaxCheckoutTime > 0) {
+ pooledDataSource.setPoolMaximumCheckoutTime(jdbcMaxCheckoutTime);
+ }
+ if (jdbcMaxWaitTime > 0) {
+ pooledDataSource.setPoolTimeToWait(jdbcMaxWaitTime);
+ }
+ if (jdbcPingEnabled) {
+ pooledDataSource.setPoolPingEnabled(true);
+ if (jdbcPingQuery != null) {
+ pooledDataSource.setPoolPingQuery(jdbcPingQuery);
+ }
+ pooledDataSource.setPoolPingConnectionsNotUsedFor(jdbcPingConnectionNotUsedFor);
+ }
+ if (jdbcDefaultTransactionIsolationLevel > 0) {
+ pooledDataSource.setDefaultTransactionIsolationLevel(jdbcDefaultTransactionIsolationLevel);
+ }
+ dataSource = pooledDataSource;
+ }
+ }
+
+ if (databaseType == null) {
+ initDatabaseType();
+ }
+ }
+
+ public void initDatabaseType() {
+ Connection connection = null;
+ try {
+ connection = dataSource.getConnection();
+ DatabaseMetaData databaseMetaData = connection.getMetaData();
+ String databaseProductName = databaseMetaData.getDatabaseProductName();
+ logger.debug("database product name: '{}'", databaseProductName);
+
+ // CRDB does not expose the version through the jdbc driver, so we need to
+ // fetch it through version().
+ if (PRODUCT_NAME_POSTGRES.equalsIgnoreCase(databaseProductName)) {
+ try (PreparedStatement preparedStatement = connection.prepareStatement("select version() as version;");
+ ResultSet resultSet = preparedStatement.executeQuery()) {
+ String version = null;
+ if (resultSet.next()) {
+ version = resultSet.getString("version");
+ }
+
+ if (StringUtils.isNotEmpty(version)
+ && version.toLowerCase().startsWith(PRODUCT_NAME_CRDB.toLowerCase())) {
+ databaseProductName = PRODUCT_NAME_CRDB;
+ logger.info("CockroachDB version '{}' detected", version);
+ }
+ }
+ }
+
+ databaseType = databaseTypeMappings.getProperty(databaseProductName);
+ if (databaseType == null) {
+ throw new FlowableException(
+ "couldn't deduct database type from database product name '" + databaseProductName + "'");
+ }
+ logger.debug("using database type: {}", databaseType);
+
+ }
+ catch (SQLException e) {
+ throw new RuntimeException("Exception while initializing Database connection", e);
+ }
+ finally {
+ try {
+ if (connection != null) {
+ connection.close();
+ }
+ }
+ catch (SQLException e) {
+ logger.error("Exception while closing the Database connection", e);
+ }
+ }
+
+ // Special care for MSSQL, as it has a hard limit of 2000 params per statement
+ // (incl bulk statement).
+ // Especially with executions, with 100 as default, this limit is passed.
+ if (DATABASE_TYPE_MSSQL.equals(databaseType)) {
+ maxNrOfStatementsInBulkInsert = DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER;
+ }
+ }
+
+ public void initSchemaManager() {
+ if (this.commonSchemaManager == null) {
+ this.commonSchemaManager = new CommonDbSchemaManager();
+ }
+ }
+
+ // session factories ////////////////////////////////////////////////////////
+
+ public void addSessionFactory(SessionFactory sessionFactory) {
+ sessionFactories.put(sessionFactory.getSessionType(), sessionFactory);
+ }
+
+ public void initCommandContextFactory() {
+ if (commandContextFactory == null) {
+ commandContextFactory = new CommandContextFactory();
+ }
+ }
+
+ public void initTransactionContextFactory() {
+ if (transactionContextFactory == null) {
+ transactionContextFactory = new StandaloneMybatisTransactionContextFactory();
+ }
+ }
+
+ public void initCommandExecutors() {
+ initDefaultCommandConfig();
+ initSchemaCommandConfig();
+ initCommandInvoker();
+ initCommandInterceptors();
+ initCommandExecutor();
+ }
+
+ public void initDefaultCommandConfig() {
+ if (defaultCommandConfig == null) {
+ defaultCommandConfig = new CommandConfig();
+ }
+ }
+
+ public void initSchemaCommandConfig() {
+ if (schemaCommandConfig == null) {
+ schemaCommandConfig = new CommandConfig();
+ }
+ }
+
+ public void initCommandInvoker() {
+ if (commandInvoker == null) {
+ commandInvoker = new DefaultCommandInvoker();
+ }
+ }
+
+ public void initCommandInterceptors() {
+ if (commandInterceptors == null) {
+ commandInterceptors = new ArrayList<>();
+ if (customPreCommandInterceptors != null) {
+ commandInterceptors.addAll(customPreCommandInterceptors);
+ }
+ commandInterceptors.addAll(getDefaultCommandInterceptors());
+ if (customPostCommandInterceptors != null) {
+ commandInterceptors.addAll(customPostCommandInterceptors);
+ }
+ commandInterceptors.add(commandInvoker);
+ }
+ }
+
+ public Collection getDefaultCommandInterceptors() {
+ if (defaultCommandInterceptors == null) {
+ List interceptors = new ArrayList<>();
+ interceptors.add(new LogInterceptor());
+
+ if (DATABASE_TYPE_COCKROACHDB.equals(databaseType)) {
+ interceptors.add(new CrDbRetryInterceptor());
+ }
+
+ CommandInterceptor transactionInterceptor = createTransactionInterceptor();
+ if (transactionInterceptor != null) {
+ interceptors.add(transactionInterceptor);
+ }
+
+ if (commandContextFactory != null) {
+ String engineCfgKey = getEngineCfgKey();
+ CommandContextInterceptor commandContextInterceptor = new CommandContextInterceptor(
+ commandContextFactory, classLoader, useClassForNameClassLoading, clock, objectMapper);
+ engineConfigurations.put(engineCfgKey, this);
+ commandContextInterceptor.setEngineCfgKey(engineCfgKey);
+ commandContextInterceptor.setEngineConfigurations(engineConfigurations);
+ interceptors.add(commandContextInterceptor);
+ }
+
+ if (transactionContextFactory != null) {
+ interceptors.add(new TransactionContextInterceptor(transactionContextFactory));
+ }
+
+ List additionalCommandInterceptors = getAdditionalDefaultCommandInterceptors();
+ if (additionalCommandInterceptors != null) {
+ interceptors.addAll(additionalCommandInterceptors);
+ }
+
+ defaultCommandInterceptors = interceptors;
+ }
+ return defaultCommandInterceptors;
+ }
+
+ public abstract String getEngineCfgKey();
+
+ public abstract String getEngineScopeType();
+
+ public List getAdditionalDefaultCommandInterceptors() {
+ return null;
+ }
+
+ public void initCommandExecutor() {
+ if (commandExecutor == null) {
+ CommandInterceptor first = initInterceptorChain(commandInterceptors);
+ commandExecutor = new CommandExecutorImpl(getDefaultCommandConfig(), first);
+ }
+ }
+
+ public CommandInterceptor initInterceptorChain(List chain) {
+ if (chain == null || chain.isEmpty()) {
+ throw new FlowableException("invalid command interceptor chain configuration: " + chain);
+ }
+ for (int i = 0; i < chain.size() - 1; i++) {
+ chain.get(i).setNext(chain.get(i + 1));
+ }
+ return chain.get(0);
+ }
+
+ public abstract CommandInterceptor createTransactionInterceptor();
+
+ public void initBeans() {
+ if (beans == null) {
+ beans = new HashMap<>();
+ }
+ }
+
+ // id generator
+ // /////////////////////////////////////////////////////////////
+
+ public void initIdGenerator() {
+ if (idGenerator == null) {
+ idGenerator = new StrongUuidGenerator();
+ }
+ }
+
+ public void initObjectMapper() {
+ if (objectMapper == null) {
+ objectMapper = new ObjectMapper();
+ objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+ }
+ }
+
+ public void initClock() {
+ if (clock == null) {
+ clock = new DefaultClockImpl();
+ }
+ }
+
+ // Data managers ///////////////////////////////////////////////////////////
+
+ public void initDataManagers() {
+ if (propertyDataManager == null) {
+ propertyDataManager = new MybatisPropertyDataManager(idGenerator);
+ }
+
+ if (byteArrayDataManager == null) {
+ byteArrayDataManager = new MybatisByteArrayDataManager(idGenerator);
+ }
+ }
+
+ // Entity managers //////////////////////////////////////////////////////////
+
+ public void initEntityManagers() {
+ if (propertyEntityManager == null) {
+ propertyEntityManager = new PropertyEntityManagerImpl(this, propertyDataManager);
+ }
+
+ if (byteArrayEntityManager == null) {
+ byteArrayEntityManager = new ByteArrayEntityManagerImpl(byteArrayDataManager, getEngineCfgKey(),
+ this::getEventDispatcher);
+ }
+
+ if (tableDataManager == null) {
+ tableDataManager = new TableDataManagerImpl(this);
+ }
+ }
+
+ // services
+ // /////////////////////////////////////////////////////////////////
+
+ protected void initService(Object service) {
+ if (service instanceof CommonEngineServiceImpl) {
+ ((CommonEngineServiceImpl) service).setCommandExecutor(commandExecutor);
+ }
+ }
+
+ // myBatis SqlSessionFactory
+ // ////////////////////////////////////////////////
+
+ public void initSessionFactories() {
+ if (sessionFactories == null) {
+ sessionFactories = new HashMap<>();
+
+ if (usingRelationalDatabase) {
+ initDbSqlSessionFactory();
+ }
+
+ addSessionFactory(new GenericManagerFactory(EntityCache.class, EntityCacheImpl.class));
+
+ if (isLoggingSessionEnabled()) {
+ if (!sessionFactories.containsKey(LoggingSession.class)) {
+ LoggingSessionFactory loggingSessionFactory = new LoggingSessionFactory();
+ loggingSessionFactory.setLoggingListener(loggingListener);
+ loggingSessionFactory.setObjectMapper(objectMapper);
+ sessionFactories.put(LoggingSession.class, loggingSessionFactory);
+ }
+ }
+
+ commandContextFactory.setSessionFactories(sessionFactories);
+
+ }
+ else {
+ if (usingRelationalDatabase) {
+ initDbSqlSessionFactoryEntitySettings();
+ }
+ }
+
+ if (customSessionFactories != null) {
+ for (SessionFactory sessionFactory : customSessionFactories) {
+ addSessionFactory(sessionFactory);
+ }
+ }
+ }
+
+ public void initDbSqlSessionFactory() {
+ if (dbSqlSessionFactory == null) {
+ dbSqlSessionFactory = createDbSqlSessionFactory();
+ }
+ dbSqlSessionFactory.setDatabaseType(databaseType);
+ dbSqlSessionFactory.setSqlSessionFactory(sqlSessionFactory);
+ dbSqlSessionFactory.setDbHistoryUsed(isDbHistoryUsed);
+ dbSqlSessionFactory.setDatabaseTablePrefix(databaseTablePrefix);
+ dbSqlSessionFactory.setTablePrefixIsSchema(tablePrefixIsSchema);
+ dbSqlSessionFactory.setDatabaseCatalog(databaseCatalog);
+ dbSqlSessionFactory.setDatabaseSchema(databaseSchema);
+ dbSqlSessionFactory.setMaxNrOfStatementsInBulkInsert(maxNrOfStatementsInBulkInsert);
+
+ initDbSqlSessionFactoryEntitySettings();
+
+ addSessionFactory(dbSqlSessionFactory);
+ }
+
+ public DbSqlSessionFactory createDbSqlSessionFactory() {
+ return new DbSqlSessionFactory(usePrefixId);
+ }
+
+ protected abstract void initDbSqlSessionFactoryEntitySettings();
+
+ protected void defaultInitDbSqlSessionFactoryEntitySettings(List> insertOrder,
+ List> deleteOrder) {
+ if (insertOrder != null) {
+ for (Class clazz : insertOrder) {
+ dbSqlSessionFactory.getInsertionOrder().add(clazz);
+
+ if (isBulkInsertEnabled) {
+ dbSqlSessionFactory.getBulkInserteableEntityClasses().add(clazz);
+ }
+ }
+ }
+
+ if (deleteOrder != null) {
+ for (Class clazz : deleteOrder) {
+ dbSqlSessionFactory.getDeletionOrder().add(clazz);
+ }
+ }
+ }
+
+ public void initTransactionFactory() {
+ if (transactionFactory == null) {
+ if (transactionsExternallyManaged) {
+ transactionFactory = new ManagedTransactionFactory();
+ Properties properties = new Properties();
+ properties.put("closeConnection", "false");
+ this.transactionFactory.setProperties(properties);
+ }
+ else {
+ transactionFactory = new JdbcTransactionFactory();
+ }
+ }
+ }
+
+ public void initSqlSessionFactory() {
+ if (sqlSessionFactory == null) {
+ InputStream inputStream = null;
+ try {
+ inputStream = getMyBatisXmlConfigurationStream();
+
+ Environment environment = new Environment("default", transactionFactory, dataSource);
+ Reader reader = new InputStreamReader(inputStream);
+ Properties properties = new Properties();
+ properties.put("prefix", databaseTablePrefix);
+
+ String wildcardEscapeClause = "";
+ if ((databaseWildcardEscapeCharacter != null) && (databaseWildcardEscapeCharacter.length() != 0)) {
+ wildcardEscapeClause = " escape '" + databaseWildcardEscapeCharacter + "'";
+ }
+ properties.put("wildcardEscapeClause", wildcardEscapeClause);
+
+ // set default properties
+ properties.put("limitBefore", "");
+ properties.put("limitAfter", "");
+ properties.put("limitBetween", "");
+ properties.put("limitBeforeNativeQuery", "");
+ properties.put("limitAfterNativeQuery", "");
+ properties.put("blobType", "BLOB");
+ properties.put("boolValue", "TRUE");
+
+ if (databaseType != null) {
+ properties.load(getResourceAsStream(pathToEngineDbProperties()));
+ }
+
+ Configuration configuration = initMybatisConfiguration(environment, reader, properties);
+ sqlSessionFactory = new DefaultSqlSessionFactory(configuration);
+
+ }
+ catch (Exception e) {
+ throw new FlowableException("Error while building ibatis SqlSessionFactory: " + e.getMessage(), e);
+ }
+ finally {
+ IoUtil.closeSilently(inputStream);
+ }
+ }
+ else {
+ // This is needed when the SQL Session Factory is created by another engine.
+ // When custom XML Mappers are registered with this engine they need to be
+ // loaded in the configuration as well
+ applyCustomMybatisCustomizations(sqlSessionFactory.getConfiguration());
+ }
+ }
+
+ public String pathToEngineDbProperties() {
+ return "org/flowable/common/db/properties/" + databaseType + ".properties";
+ }
+
+ public Configuration initMybatisConfiguration(Environment environment, Reader reader, Properties properties) {
+ XMLConfigBuilder parser = new XMLConfigBuilder(reader, "", properties);
+ Configuration configuration = parser.getConfiguration();
+
+ if (databaseType != null) {
+ configuration.setDatabaseId(databaseType);
+ }
+
+ configuration.setEnvironment(environment);
+
+ initMybatisTypeHandlers(configuration);
+ initCustomMybatisInterceptors(configuration);
+ if (isEnableLogSqlExecutionTime()) {
+ initMyBatisLogSqlExecutionTimePlugin(configuration);
+ }
+
+ configuration = parseMybatisConfiguration(parser);
+ return configuration;
+ }
+
+ public void initCustomMybatisMappers(Configuration configuration) {
+ if (getCustomMybatisMappers() != null) {
+ for (Class clazz : getCustomMybatisMappers()) {
+ if (!configuration.hasMapper(clazz)) {
+ configuration.addMapper(clazz);
+ }
+ }
+ }
+ }
+
+ public void initMybatisTypeHandlers(Configuration configuration) {
+ // When mapping into Map there is currently a problem with
+ // MyBatis.
+ // It will return objects which are driver specific.
+ // Therefore we are registering the mappings between Object.class and the specific
+ // jdbc type here.
+ // see https://github.com/mybatis/mybatis-3/issues/2216 for more info
+ TypeHandlerRegistry handlerRegistry = configuration.getTypeHandlerRegistry();
+
+ handlerRegistry.register(Object.class, JdbcType.BOOLEAN, new BooleanTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.BIT, new BooleanTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.TINYINT, new ByteTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.SMALLINT, new ShortTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.INTEGER, new IntegerTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.FLOAT, new FloatTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.DOUBLE, new DoubleTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.CHAR, new StringTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.CLOB, new ClobTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.VARCHAR, new StringTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.NVARCHAR, new NStringTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.NCHAR, new NStringTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.NCLOB, new NClobTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.BIGINT, new LongTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.REAL, new BigDecimalTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.DECIMAL, new BigDecimalTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.NUMERIC, new BigDecimalTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.BLOB, new BlobInputStreamTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.DATE, new DateOnlyTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.TIME, new TimeOnlyTypeHandler());
+ handlerRegistry.register(Object.class, JdbcType.TIMESTAMP, new DateTypeHandler());
+
+ handlerRegistry.register(Object.class, JdbcType.SQLXML, new SqlxmlTypeHandler());
+ }
+
+ public void initCustomMybatisInterceptors(Configuration configuration) {
+ if (customMybatisInterceptors != null) {
+ for (Interceptor interceptor : customMybatisInterceptors) {
+ configuration.addInterceptor(interceptor);
+ }
+ }
+ }
+
+ public void initMyBatisLogSqlExecutionTimePlugin(Configuration configuration) {
+ configuration.addInterceptor(new LogSqlExecutionTimePlugin());
+ }
+
+ public Configuration parseMybatisConfiguration(XMLConfigBuilder parser) {
+ Configuration configuration = parser.parse();
+
+ applyCustomMybatisCustomizations(configuration);
+ return configuration;
+ }
+
+ protected void applyCustomMybatisCustomizations(Configuration configuration) {
+ initCustomMybatisMappers(configuration);
+
+ if (dependentEngineMybatisTypeAliasConfigs != null) {
+ for (MybatisTypeAliasConfigurator typeAliasConfig : dependentEngineMybatisTypeAliasConfigs) {
+ typeAliasConfig.configure(configuration.getTypeAliasRegistry());
+ }
+ }
+ if (dependentEngineMybatisTypeHandlerConfigs != null) {
+ for (MybatisTypeHandlerConfigurator typeHandlerConfig : dependentEngineMybatisTypeHandlerConfigs) {
+ typeHandlerConfig.configure(configuration.getTypeHandlerRegistry());
+ }
+ }
+
+ parseDependentEngineMybatisXMLMappers(configuration);
+ parseCustomMybatisXMLMappers(configuration);
+ }
+
+ public void parseCustomMybatisXMLMappers(Configuration configuration) {
+ if (getCustomMybatisXMLMappers() != null) {
+ for (String resource : getCustomMybatisXMLMappers()) {
+ parseMybatisXmlMapping(configuration, resource);
+ }
+ }
+ }
+
+ public void parseDependentEngineMybatisXMLMappers(Configuration configuration) {
+ if (getDependentEngineMyBatisXmlMappers() != null) {
+ for (String resource : getDependentEngineMyBatisXmlMappers()) {
+ parseMybatisXmlMapping(configuration, resource);
+ }
+ }
+ }
+
+ protected void parseMybatisXmlMapping(Configuration configuration, String resource) {
+ // see XMLConfigBuilder.mapperElement()
+ XMLMapperBuilder mapperParser = new XMLMapperBuilder(getResourceAsStream(resource), configuration, resource,
+ configuration.getSqlFragments());
+ mapperParser.parse();
+ }
+
+ protected InputStream getResourceAsStream(String resource) {
+ ClassLoader classLoader = getClassLoader();
+ if (classLoader != null) {
+ return getClassLoader().getResourceAsStream(resource);
+ }
+ else {
+ return this.getClass().getClassLoader().getResourceAsStream(resource);
+ }
+ }
+
+ public void setMybatisMappingFile(String file) {
+ this.mybatisMappingFile = file;
+ }
+
+ public String getMybatisMappingFile() {
+ return mybatisMappingFile;
+ }
+
+ public abstract InputStream getMyBatisXmlConfigurationStream();
+
+ public void initConfigurators() {
+
+ allConfigurators = new ArrayList<>();
+ allConfigurators.addAll(getEngineSpecificEngineConfigurators());
+
+ // Configurators that are explicitly added to the config
+ if (configurators != null) {
+ allConfigurators.addAll(configurators);
+ }
+
+ // Auto discovery through ServiceLoader
+ if (enableConfiguratorServiceLoader) {
+ ClassLoader classLoader = getClassLoader();
+ if (classLoader == null) {
+ classLoader = ReflectUtil.getClassLoader();
+ }
+
+ ServiceLoader configuratorServiceLoader = ServiceLoader.load(EngineConfigurator.class,
+ classLoader);
+ int nrOfServiceLoadedConfigurators = 0;
+ for (EngineConfigurator configurator : configuratorServiceLoader) {
+ allConfigurators.add(configurator);
+ nrOfServiceLoadedConfigurators++;
+ }
+
+ if (nrOfServiceLoadedConfigurators > 0) {
+ logger.info("Found {} auto-discoverable Process Engine Configurator{}", nrOfServiceLoadedConfigurators,
+ nrOfServiceLoadedConfigurators > 1 ? "s" : "");
+ }
+
+ if (!allConfigurators.isEmpty()) {
+
+ // Order them according to the priorities (useful for dependent
+ // configurator)
+ allConfigurators.sort(new Comparator() {
+
+ @Override
+ public int compare(EngineConfigurator configurator1, EngineConfigurator configurator2) {
+ int priority1 = configurator1.getPriority();
+ int priority2 = configurator2.getPriority();
+
+ if (priority1 < priority2) {
+ return -1;
+ }
+ else if (priority1 > priority2) {
+ return 1;
+ }
+ return 0;
+ }
+ });
+
+ // Execute the configurators
+ logger.info("Found {} Engine Configurators in total:", allConfigurators.size());
+ for (EngineConfigurator configurator : allConfigurators) {
+ logger.info("{} (priority:{})", configurator.getClass(), configurator.getPriority());
+ }
+
+ }
+
+ }
+ }
+
+ public void close() {
+ if (forceCloseMybatisConnectionPool && dataSource instanceof PooledDataSource) {
+ /*
+ * When the datasource is created by a Flowable engine (i.e. it's an instance
+ * of PooledDataSource), the connection pool needs to be closed when closing
+ * the engine. Note that calling forceCloseAll() multiple times (as is the
+ * case when running with multiple engine) is ok.
+ */
+ ((PooledDataSource) dataSource).forceCloseAll();
+ }
+ }
+
+ protected List getEngineSpecificEngineConfigurators() {
+ // meant to be overridden if needed
+ return Collections.emptyList();
+ }
+
+ public void configuratorsBeforeInit() {
+ for (EngineConfigurator configurator : allConfigurators) {
+ logger.info("Executing beforeInit() of {} (priority:{})", configurator.getClass(),
+ configurator.getPriority());
+ configurator.beforeInit(this);
+ }
+ }
+
+ public void configuratorsAfterInit() {
+ for (EngineConfigurator configurator : allConfigurators) {
+ logger.info("Executing configure() of {} (priority:{})", configurator.getClass(),
+ configurator.getPriority());
+ configurator.configure(this);
+ }
+ }
+
+ public LockManager getLockManager(String lockName) {
+ return new LockManagerImpl(commandExecutor, lockName, getLockPollRate(), getEngineCfgKey());
+ }
+
+ // getters and setters
+ // //////////////////////////////////////////////////////
+
+ public abstract String getEngineName();
+
+ public ClassLoader getClassLoader() {
+ return classLoader;
+ }
+
+ public AbstractEngineConfiguration setClassLoader(ClassLoader classLoader) {
+ this.classLoader = classLoader;
+ return this;
+ }
+
+ public boolean isUseClassForNameClassLoading() {
+ return useClassForNameClassLoading;
+ }
+
+ public AbstractEngineConfiguration setUseClassForNameClassLoading(boolean useClassForNameClassLoading) {
+ this.useClassForNameClassLoading = useClassForNameClassLoading;
+ return this;
+ }
+
+ public void addEngineLifecycleListener(EngineLifecycleListener engineLifecycleListener) {
+ if (this.engineLifecycleListeners == null) {
+ this.engineLifecycleListeners = new ArrayList<>();
+ }
+ this.engineLifecycleListeners.add(engineLifecycleListener);
+ }
+
+ public List getEngineLifecycleListeners() {
+ return engineLifecycleListeners;
+ }
+
+ public AbstractEngineConfiguration setEngineLifecycleListeners(
+ List engineLifecycleListeners) {
+ this.engineLifecycleListeners = engineLifecycleListeners;
+ return this;
+ }
+
+ public String getDatabaseType() {
+ return databaseType;
+ }
+
+ public AbstractEngineConfiguration setDatabaseType(String databaseType) {
+ this.databaseType = databaseType;
+ return this;
+ }
+
+ public DataSource getDataSource() {
+ return dataSource;
+ }
+
+ public AbstractEngineConfiguration setDataSource(DataSource dataSource) {
+ this.dataSource = dataSource;
+ return this;
+ }
+
+ public SchemaManager getSchemaManager() {
+ return schemaManager;
+ }
+
+ public AbstractEngineConfiguration setSchemaManager(SchemaManager schemaManager) {
+ this.schemaManager = schemaManager;
+ return this;
+ }
+
+ public SchemaManager getCommonSchemaManager() {
+ return commonSchemaManager;
+ }
+
+ public AbstractEngineConfiguration setCommonSchemaManager(SchemaManager commonSchemaManager) {
+ this.commonSchemaManager = commonSchemaManager;
+ return this;
+ }
+
+ public Command getSchemaManagementCmd() {
+ return schemaManagementCmd;
+ }
+
+ public AbstractEngineConfiguration setSchemaManagementCmd(Command schemaManagementCmd) {
+ this.schemaManagementCmd = schemaManagementCmd;
+ return this;
+ }
+
+ public String getJdbcDriver() {
+ return jdbcDriver;
+ }
+
+ public AbstractEngineConfiguration setJdbcDriver(String jdbcDriver) {
+ this.jdbcDriver = jdbcDriver;
+ return this;
+ }
+
+ public String getJdbcUrl() {
+ return jdbcUrl;
+ }
+
+ public AbstractEngineConfiguration setJdbcUrl(String jdbcUrl) {
+ this.jdbcUrl = jdbcUrl;
+ return this;
+ }
+
+ public String getJdbcUsername() {
+ return jdbcUsername;
+ }
+
+ public AbstractEngineConfiguration setJdbcUsername(String jdbcUsername) {
+ this.jdbcUsername = jdbcUsername;
+ return this;
+ }
+
+ public String getJdbcPassword() {
+ return jdbcPassword;
+ }
+
+ public AbstractEngineConfiguration setJdbcPassword(String jdbcPassword) {
+ this.jdbcPassword = jdbcPassword;
+ return this;
+ }
+
+ public int getJdbcMaxActiveConnections() {
+ return jdbcMaxActiveConnections;
+ }
+
+ public AbstractEngineConfiguration setJdbcMaxActiveConnections(int jdbcMaxActiveConnections) {
+ this.jdbcMaxActiveConnections = jdbcMaxActiveConnections;
+ return this;
+ }
+
+ public int getJdbcMaxIdleConnections() {
+ return jdbcMaxIdleConnections;
+ }
+
+ public AbstractEngineConfiguration setJdbcMaxIdleConnections(int jdbcMaxIdleConnections) {
+ this.jdbcMaxIdleConnections = jdbcMaxIdleConnections;
+ return this;
+ }
+
+ public int getJdbcMaxCheckoutTime() {
+ return jdbcMaxCheckoutTime;
+ }
+
+ public AbstractEngineConfiguration setJdbcMaxCheckoutTime(int jdbcMaxCheckoutTime) {
+ this.jdbcMaxCheckoutTime = jdbcMaxCheckoutTime;
+ return this;
+ }
+
+ public int getJdbcMaxWaitTime() {
+ return jdbcMaxWaitTime;
+ }
+
+ public AbstractEngineConfiguration setJdbcMaxWaitTime(int jdbcMaxWaitTime) {
+ this.jdbcMaxWaitTime = jdbcMaxWaitTime;
+ return this;
+ }
+
+ public boolean isJdbcPingEnabled() {
+ return jdbcPingEnabled;
+ }
+
+ public AbstractEngineConfiguration setJdbcPingEnabled(boolean jdbcPingEnabled) {
+ this.jdbcPingEnabled = jdbcPingEnabled;
+ return this;
+ }
+
+ public int getJdbcPingConnectionNotUsedFor() {
+ return jdbcPingConnectionNotUsedFor;
+ }
+
+ public AbstractEngineConfiguration setJdbcPingConnectionNotUsedFor(int jdbcPingConnectionNotUsedFor) {
+ this.jdbcPingConnectionNotUsedFor = jdbcPingConnectionNotUsedFor;
+ return this;
+ }
+
+ public int getJdbcDefaultTransactionIsolationLevel() {
+ return jdbcDefaultTransactionIsolationLevel;
+ }
+
+ public AbstractEngineConfiguration setJdbcDefaultTransactionIsolationLevel(
+ int jdbcDefaultTransactionIsolationLevel) {
+ this.jdbcDefaultTransactionIsolationLevel = jdbcDefaultTransactionIsolationLevel;
+ return this;
+ }
+
+ public String getJdbcPingQuery() {
+ return jdbcPingQuery;
+ }
+
+ public AbstractEngineConfiguration setJdbcPingQuery(String jdbcPingQuery) {
+ this.jdbcPingQuery = jdbcPingQuery;
+ return this;
+ }
+
+ public String getDataSourceJndiName() {
+ return dataSourceJndiName;
+ }
+
+ public AbstractEngineConfiguration setDataSourceJndiName(String dataSourceJndiName) {
+ this.dataSourceJndiName = dataSourceJndiName;
+ return this;
+ }
+
+ public CommandConfig getSchemaCommandConfig() {
+ return schemaCommandConfig;
+ }
+
+ public AbstractEngineConfiguration setSchemaCommandConfig(CommandConfig schemaCommandConfig) {
+ this.schemaCommandConfig = schemaCommandConfig;
+ return this;
+ }
+
+ public boolean isTransactionsExternallyManaged() {
+ return transactionsExternallyManaged;
+ }
+
+ public AbstractEngineConfiguration setTransactionsExternallyManaged(boolean transactionsExternallyManaged) {
+ this.transactionsExternallyManaged = transactionsExternallyManaged;
+ return this;
+ }
+
+ public Map getBeans() {
+ return beans;
+ }
+
+ public AbstractEngineConfiguration setBeans(Map beans) {
+ this.beans = beans;
+ return this;
+ }
+
+ public IdGenerator getIdGenerator() {
+ return idGenerator;
+ }
+
+ public AbstractEngineConfiguration setIdGenerator(IdGenerator idGenerator) {
+ this.idGenerator = idGenerator;
+ return this;
+ }
+
+ public boolean isUsePrefixId() {
+ return usePrefixId;
+ }
+
+ public AbstractEngineConfiguration setUsePrefixId(boolean usePrefixId) {
+ this.usePrefixId = usePrefixId;
+ return this;
+ }
+
+ public String getXmlEncoding() {
+ return xmlEncoding;
+ }
+
+ public AbstractEngineConfiguration setXmlEncoding(String xmlEncoding) {
+ this.xmlEncoding = xmlEncoding;
+ return this;
+ }
+
+ public CommandConfig getDefaultCommandConfig() {
+ return defaultCommandConfig;
+ }
+
+ public AbstractEngineConfiguration setDefaultCommandConfig(CommandConfig defaultCommandConfig) {
+ this.defaultCommandConfig = defaultCommandConfig;
+ return this;
+ }
+
+ public CommandExecutor getCommandExecutor() {
+ return commandExecutor;
+ }
+
+ public AbstractEngineConfiguration setCommandExecutor(CommandExecutor commandExecutor) {
+ this.commandExecutor = commandExecutor;
+ return this;
+ }
+
+ public CommandContextFactory getCommandContextFactory() {
+ return commandContextFactory;
+ }
+
+ public AbstractEngineConfiguration setCommandContextFactory(CommandContextFactory commandContextFactory) {
+ this.commandContextFactory = commandContextFactory;
+ return this;
+ }
+
+ public CommandInterceptor getCommandInvoker() {
+ return commandInvoker;
+ }
+
+ public AbstractEngineConfiguration setCommandInvoker(CommandInterceptor commandInvoker) {
+ this.commandInvoker = commandInvoker;
+ return this;
+ }
+
+ public AgendaOperationRunner getAgendaOperationRunner() {
+ return agendaOperationRunner;
+ }
+
+ public AbstractEngineConfiguration setAgendaOperationRunner(AgendaOperationRunner agendaOperationRunner) {
+ this.agendaOperationRunner = agendaOperationRunner;
+ return this;
+ }
+
+ public List getCustomPreCommandInterceptors() {
+ return customPreCommandInterceptors;
+ }
+
+ public AbstractEngineConfiguration setCustomPreCommandInterceptors(
+ List customPreCommandInterceptors) {
+ this.customPreCommandInterceptors = customPreCommandInterceptors;
+ return this;
+ }
+
+ public List getCustomPostCommandInterceptors() {
+ return customPostCommandInterceptors;
+ }
+
+ public AbstractEngineConfiguration setCustomPostCommandInterceptors(
+ List customPostCommandInterceptors) {
+ this.customPostCommandInterceptors = customPostCommandInterceptors;
+ return this;
+ }
+
+ public List getCommandInterceptors() {
+ return commandInterceptors;
+ }
+
+ public AbstractEngineConfiguration setCommandInterceptors(List commandInterceptors) {
+ this.commandInterceptors = commandInterceptors;
+ return this;
+ }
+
+ public Map getEngineConfigurations() {
+ return engineConfigurations;
+ }
+
+ public AbstractEngineConfiguration setEngineConfigurations(
+ Map engineConfigurations) {
+ this.engineConfigurations = engineConfigurations;
+ return this;
+ }
+
+ public void addEngineConfiguration(String key, String scopeType, AbstractEngineConfiguration engineConfiguration) {
+ if (engineConfigurations == null) {
+ engineConfigurations = new HashMap<>();
+ }
+ engineConfigurations.put(key, engineConfiguration);
+ engineConfigurations.put(scopeType, engineConfiguration);
+ }
+
+ public Map getServiceConfigurations() {
+ return serviceConfigurations;
+ }
+
+ public AbstractEngineConfiguration setServiceConfigurations(
+ Map serviceConfigurations) {
+ this.serviceConfigurations = serviceConfigurations;
+ return this;
+ }
+
+ public void addServiceConfiguration(String key, AbstractServiceConfiguration serviceConfiguration) {
+ if (serviceConfigurations == null) {
+ serviceConfigurations = new HashMap<>();
+ }
+ serviceConfigurations.put(key, serviceConfiguration);
+ }
+
+ public Map getEventRegistryEventConsumers() {
+ return eventRegistryEventConsumers;
+ }
+
+ public AbstractEngineConfiguration setEventRegistryEventConsumers(
+ Map eventRegistryEventConsumers) {
+ this.eventRegistryEventConsumers = eventRegistryEventConsumers;
+ return this;
+ }
+
+ public void addEventRegistryEventConsumer(String key, EventRegistryEventConsumer eventRegistryEventConsumer) {
+ if (eventRegistryEventConsumers == null) {
+ eventRegistryEventConsumers = new HashMap<>();
+ }
+ eventRegistryEventConsumers.put(key, eventRegistryEventConsumer);
+ }
+
+ public AbstractEngineConfiguration setDefaultCommandInterceptors(
+ Collection defaultCommandInterceptors) {
+ this.defaultCommandInterceptors = defaultCommandInterceptors;
+ return this;
+ }
+
+ public SqlSessionFactory getSqlSessionFactory() {
+ return sqlSessionFactory;
+ }
+
+ public AbstractEngineConfiguration setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
+ this.sqlSessionFactory = sqlSessionFactory;
+ return this;
+ }
+
+ public boolean isDbHistoryUsed() {
+ return isDbHistoryUsed;
+ }
+
+ public AbstractEngineConfiguration setDbHistoryUsed(boolean isDbHistoryUsed) {
+ this.isDbHistoryUsed = isDbHistoryUsed;
+ return this;
+ }
+
+ public DbSqlSessionFactory getDbSqlSessionFactory() {
+ return dbSqlSessionFactory;
+ }
+
+ public AbstractEngineConfiguration setDbSqlSessionFactory(DbSqlSessionFactory dbSqlSessionFactory) {
+ this.dbSqlSessionFactory = dbSqlSessionFactory;
+ return this;
+ }
+
+ public TransactionFactory getTransactionFactory() {
+ return transactionFactory;
+ }
+
+ public AbstractEngineConfiguration setTransactionFactory(TransactionFactory transactionFactory) {
+ this.transactionFactory = transactionFactory;
+ return this;
+ }
+
+ public TransactionContextFactory getTransactionContextFactory() {
+ return transactionContextFactory;
+ }
+
+ public AbstractEngineConfiguration setTransactionContextFactory(
+ TransactionContextFactory transactionContextFactory) {
+ this.transactionContextFactory = transactionContextFactory;
+ return this;
+ }
+
+ public int getMaxNrOfStatementsInBulkInsert() {
+ return maxNrOfStatementsInBulkInsert;
+ }
+
+ public AbstractEngineConfiguration setMaxNrOfStatementsInBulkInsert(int maxNrOfStatementsInBulkInsert) {
+ this.maxNrOfStatementsInBulkInsert = maxNrOfStatementsInBulkInsert;
+ return this;
+ }
+
+ public boolean isBulkInsertEnabled() {
+ return isBulkInsertEnabled;
+ }
+
+ public AbstractEngineConfiguration setBulkInsertEnabled(boolean isBulkInsertEnabled) {
+ this.isBulkInsertEnabled = isBulkInsertEnabled;
+ return this;
+ }
+
+ public Set> getCustomMybatisMappers() {
+ return customMybatisMappers;
+ }
+
+ public AbstractEngineConfiguration setCustomMybatisMappers(Set> customMybatisMappers) {
+ this.customMybatisMappers = customMybatisMappers;
+ return this;
+ }
+
+ public Set getCustomMybatisXMLMappers() {
+ return customMybatisXMLMappers;
+ }
+
+ public AbstractEngineConfiguration setCustomMybatisXMLMappers(Set customMybatisXMLMappers) {
+ this.customMybatisXMLMappers = customMybatisXMLMappers;
+ return this;
+ }
+
+ public Set getDependentEngineMyBatisXmlMappers() {
+ return dependentEngineMyBatisXmlMappers;
+ }
+
+ public AbstractEngineConfiguration setCustomMybatisInterceptors(List customMybatisInterceptors) {
+ this.customMybatisInterceptors = customMybatisInterceptors;
+ return this;
+ }
+
+ public List getCustomMybatisInterceptors() {
+ return customMybatisInterceptors;
+ }
+
+ public AbstractEngineConfiguration setDependentEngineMyBatisXmlMappers(
+ Set dependentEngineMyBatisXmlMappers) {
+ this.dependentEngineMyBatisXmlMappers = dependentEngineMyBatisXmlMappers;
+ return this;
+ }
+
+ public List getDependentEngineMybatisTypeAliasConfigs() {
+ return dependentEngineMybatisTypeAliasConfigs;
+ }
+
+ public AbstractEngineConfiguration setDependentEngineMybatisTypeAliasConfigs(
+ List dependentEngineMybatisTypeAliasConfigs) {
+ this.dependentEngineMybatisTypeAliasConfigs = dependentEngineMybatisTypeAliasConfigs;
+ return this;
+ }
+
+ public List getDependentEngineMybatisTypeHandlerConfigs() {
+ return dependentEngineMybatisTypeHandlerConfigs;
+ }
+
+ public AbstractEngineConfiguration setDependentEngineMybatisTypeHandlerConfigs(
+ List dependentEngineMybatisTypeHandlerConfigs) {
+ this.dependentEngineMybatisTypeHandlerConfigs = dependentEngineMybatisTypeHandlerConfigs;
+ return this;
+ }
+
+ public List getCustomSessionFactories() {
+ return customSessionFactories;
+ }
+
+ public AbstractEngineConfiguration addCustomSessionFactory(SessionFactory sessionFactory) {
+ if (customSessionFactories == null) {
+ customSessionFactories = new ArrayList<>();
+ }
+ customSessionFactories.add(sessionFactory);
+ return this;
+ }
+
+ public AbstractEngineConfiguration setCustomSessionFactories(List customSessionFactories) {
+ this.customSessionFactories = customSessionFactories;
+ return this;
+ }
+
+ public boolean isUsingRelationalDatabase() {
+ return usingRelationalDatabase;
+ }
+
+ public AbstractEngineConfiguration setUsingRelationalDatabase(boolean usingRelationalDatabase) {
+ this.usingRelationalDatabase = usingRelationalDatabase;
+ return this;
+ }
+
+ public boolean isUsingSchemaMgmt() {
+ return usingSchemaMgmt;
+ }
+
+ public AbstractEngineConfiguration setUsingSchemaMgmt(boolean usingSchema) {
+ this.usingSchemaMgmt = usingSchema;
+ return this;
+ }
+
+ public String getDatabaseTablePrefix() {
+ return databaseTablePrefix;
+ }
+
+ public AbstractEngineConfiguration setDatabaseTablePrefix(String databaseTablePrefix) {
+ this.databaseTablePrefix = databaseTablePrefix;
+ return this;
+ }
+
+ public String getDatabaseWildcardEscapeCharacter() {
+ return databaseWildcardEscapeCharacter;
+ }
+
+ public AbstractEngineConfiguration setDatabaseWildcardEscapeCharacter(String databaseWildcardEscapeCharacter) {
+ this.databaseWildcardEscapeCharacter = databaseWildcardEscapeCharacter;
+ return this;
+ }
+
+ public String getDatabaseCatalog() {
+ return databaseCatalog;
+ }
+
+ public AbstractEngineConfiguration setDatabaseCatalog(String databaseCatalog) {
+ this.databaseCatalog = databaseCatalog;
+ return this;
+ }
+
+ public String getDatabaseSchema() {
+ return databaseSchema;
+ }
+
+ public AbstractEngineConfiguration setDatabaseSchema(String databaseSchema) {
+ this.databaseSchema = databaseSchema;
+ return this;
+ }
+
+ public boolean isTablePrefixIsSchema() {
+ return tablePrefixIsSchema;
+ }
+
+ public AbstractEngineConfiguration setTablePrefixIsSchema(boolean tablePrefixIsSchema) {
+ this.tablePrefixIsSchema = tablePrefixIsSchema;
+ return this;
+ }
+
+ public boolean isAlwaysLookupLatestDefinitionVersion() {
+ return alwaysLookupLatestDefinitionVersion;
+ }
+
+ public AbstractEngineConfiguration setAlwaysLookupLatestDefinitionVersion(
+ boolean alwaysLookupLatestDefinitionVersion) {
+ this.alwaysLookupLatestDefinitionVersion = alwaysLookupLatestDefinitionVersion;
+ return this;
+ }
+
+ public boolean isFallbackToDefaultTenant() {
+ return fallbackToDefaultTenant;
+ }
+
+ public AbstractEngineConfiguration setFallbackToDefaultTenant(boolean fallbackToDefaultTenant) {
+ this.fallbackToDefaultTenant = fallbackToDefaultTenant;
+ return this;
+ }
+
+ /**
+ * @return name of the default tenant
+ * @deprecated use {@link AbstractEngineConfiguration#getDefaultTenantProvider()}
+ * instead
+ */
+ @Deprecated
+ public String getDefaultTenantValue() {
+ return getDefaultTenantProvider().getDefaultTenant(null, null, null);
+ }
+
+ public AbstractEngineConfiguration setDefaultTenantValue(String defaultTenantValue) {
+ this.defaultTenantProvider = (tenantId, scope, scopeKey) -> defaultTenantValue;
+ return this;
+ }
+
+ public DefaultTenantProvider getDefaultTenantProvider() {
+ return defaultTenantProvider;
+ }
+
+ public AbstractEngineConfiguration setDefaultTenantProvider(DefaultTenantProvider defaultTenantProvider) {
+ this.defaultTenantProvider = defaultTenantProvider;
+ return this;
+ }
+
+ public boolean isEnableLogSqlExecutionTime() {
+ return enableLogSqlExecutionTime;
+ }
+
+ public void setEnableLogSqlExecutionTime(boolean enableLogSqlExecutionTime) {
+ this.enableLogSqlExecutionTime = enableLogSqlExecutionTime;
+ }
+
+ public Map, SessionFactory> getSessionFactories() {
+ return sessionFactories;
+ }
+
+ public AbstractEngineConfiguration setSessionFactories(Map, SessionFactory> sessionFactories) {
+ this.sessionFactories = sessionFactories;
+ return this;
+ }
+
+ public String getDatabaseSchemaUpdate() {
+ return databaseSchemaUpdate;
+ }
+
+ public AbstractEngineConfiguration setDatabaseSchemaUpdate(String databaseSchemaUpdate) {
+ this.databaseSchemaUpdate = databaseSchemaUpdate;
+ return this;
+ }
+
+ public boolean isUseLockForDatabaseSchemaUpdate() {
+ return useLockForDatabaseSchemaUpdate;
+ }
+
+ public AbstractEngineConfiguration setUseLockForDatabaseSchemaUpdate(boolean useLockForDatabaseSchemaUpdate) {
+ this.useLockForDatabaseSchemaUpdate = useLockForDatabaseSchemaUpdate;
+ return this;
+ }
+
+ public boolean isEnableEventDispatcher() {
+ return enableEventDispatcher;
+ }
+
+ public AbstractEngineConfiguration setEnableEventDispatcher(boolean enableEventDispatcher) {
+ this.enableEventDispatcher = enableEventDispatcher;
+ return this;
+ }
+
+ public FlowableEventDispatcher getEventDispatcher() {
+ return eventDispatcher;
+ }
+
+ public AbstractEngineConfiguration setEventDispatcher(FlowableEventDispatcher eventDispatcher) {
+ this.eventDispatcher = eventDispatcher;
+ return this;
+ }
+
+ public List getEventListeners() {
+ return eventListeners;
+ }
+
+ public AbstractEngineConfiguration setEventListeners(List eventListeners) {
+ this.eventListeners = eventListeners;
+ return this;
+ }
+
+ public Map> getTypedEventListeners() {
+ return typedEventListeners;
+ }
+
+ public AbstractEngineConfiguration setTypedEventListeners(
+ Map> typedEventListeners) {
+ this.typedEventListeners = typedEventListeners;
+ return this;
+ }
+
+ public List getAdditionalEventDispatchActions() {
+ return additionalEventDispatchActions;
+ }
+
+ public AbstractEngineConfiguration setAdditionalEventDispatchActions(
+ List additionalEventDispatchActions) {
+ this.additionalEventDispatchActions = additionalEventDispatchActions;
+ return this;
+ }
+
+ public void initEventDispatcher() {
+ if (this.eventDispatcher == null) {
+ this.eventDispatcher = new FlowableEventDispatcherImpl();
+ }
+
+ initAdditionalEventDispatchActions();
+
+ this.eventDispatcher.setEnabled(enableEventDispatcher);
+
+ initEventListeners();
+ initTypedEventListeners();
+ }
+
+ protected void initEventListeners() {
+ if (eventListeners != null) {
+ for (FlowableEventListener listenerToAdd : eventListeners) {
+ this.eventDispatcher.addEventListener(listenerToAdd);
+ }
+ }
+ }
+
+ protected void initAdditionalEventDispatchActions() {
+ if (this.additionalEventDispatchActions == null) {
+ this.additionalEventDispatchActions = new ArrayList<>();
+ }
+ }
+
+ protected void initTypedEventListeners() {
+ if (typedEventListeners != null) {
+ for (Map.Entry> listenersToAdd : typedEventListeners.entrySet()) {
+ // Extract types from the given string
+ FlowableEngineEventType[] types = FlowableEngineEventType.getTypesFromString(listenersToAdd.getKey());
+
+ for (FlowableEventListener listenerToAdd : listenersToAdd.getValue()) {
+ this.eventDispatcher.addEventListener(listenerToAdd, types);
+ }
+ }
+ }
+ }
+
+ public boolean isLoggingSessionEnabled() {
+ return loggingListener != null;
+ }
+
+ public LoggingListener getLoggingListener() {
+ return loggingListener;
+ }
+
+ public void setLoggingListener(LoggingListener loggingListener) {
+ this.loggingListener = loggingListener;
+ }
+
+ public Clock getClock() {
+ return clock;
+ }
+
+ public AbstractEngineConfiguration setClock(Clock clock) {
+ this.clock = clock;
+ return this;
+ }
+
+ public ObjectMapper getObjectMapper() {
+ return objectMapper;
+ }
+
+ public AbstractEngineConfiguration setObjectMapper(ObjectMapper objectMapper) {
+ this.objectMapper = objectMapper;
+ return this;
+ }
+
+ public int getMaxLengthString() {
+ if (maxLengthStringVariableType == -1) {
+ if ("oracle".equalsIgnoreCase(databaseType)) {
+ return DEFAULT_ORACLE_MAX_LENGTH_STRING;
+ }
+ else {
+ return DEFAULT_GENERIC_MAX_LENGTH_STRING;
+ }
+ }
+ else {
+ return maxLengthStringVariableType;
+ }
+ }
+
+ public int getMaxLengthStringVariableType() {
+ return maxLengthStringVariableType;
+ }
+
+ public AbstractEngineConfiguration setMaxLengthStringVariableType(int maxLengthStringVariableType) {
+ this.maxLengthStringVariableType = maxLengthStringVariableType;
+ return this;
+ }
+
+ public PropertyDataManager getPropertyDataManager() {
+ return propertyDataManager;
+ }
+
+ public Duration getLockPollRate() {
+ return lockPollRate;
+ }
+
+ public AbstractEngineConfiguration setLockPollRate(Duration lockPollRate) {
+ this.lockPollRate = lockPollRate;
+ return this;
+ }
+
+ public Duration getSchemaLockWaitTime() {
+ return schemaLockWaitTime;
+ }
+
+ public void setSchemaLockWaitTime(Duration schemaLockWaitTime) {
+ this.schemaLockWaitTime = schemaLockWaitTime;
+ }
+
+ public AbstractEngineConfiguration setPropertyDataManager(PropertyDataManager propertyDataManager) {
+ this.propertyDataManager = propertyDataManager;
+ return this;
+ }
+
+ public PropertyEntityManager getPropertyEntityManager() {
+ return propertyEntityManager;
+ }
+
+ public AbstractEngineConfiguration setPropertyEntityManager(PropertyEntityManager propertyEntityManager) {
+ this.propertyEntityManager = propertyEntityManager;
+ return this;
+ }
+
+ public ByteArrayDataManager getByteArrayDataManager() {
+ return byteArrayDataManager;
+ }
+
+ public AbstractEngineConfiguration setByteArrayDataManager(ByteArrayDataManager byteArrayDataManager) {
+ this.byteArrayDataManager = byteArrayDataManager;
+ return this;
+ }
+
+ public ByteArrayEntityManager getByteArrayEntityManager() {
+ return byteArrayEntityManager;
+ }
+
+ public AbstractEngineConfiguration setByteArrayEntityManager(ByteArrayEntityManager byteArrayEntityManager) {
+ this.byteArrayEntityManager = byteArrayEntityManager;
+ return this;
+ }
+
+ public TableDataManager getTableDataManager() {
+ return tableDataManager;
+ }
+
+ public AbstractEngineConfiguration setTableDataManager(TableDataManager tableDataManager) {
+ this.tableDataManager = tableDataManager;
+ return this;
+ }
+
+ public List getDeployers() {
+ return deployers;
+ }
+
+ public AbstractEngineConfiguration setDeployers(List deployers) {
+ this.deployers = deployers;
+ return this;
+ }
+
+ public List getCustomPreDeployers() {
+ return customPreDeployers;
+ }
+
+ public AbstractEngineConfiguration setCustomPreDeployers(List customPreDeployers) {
+ this.customPreDeployers = customPreDeployers;
+ return this;
+ }
+
+ public List getCustomPostDeployers() {
+ return customPostDeployers;
+ }
+
+ public AbstractEngineConfiguration setCustomPostDeployers(List customPostDeployers) {
+ this.customPostDeployers = customPostDeployers;
+ return this;
+ }
+
+ public boolean isEnableConfiguratorServiceLoader() {
+ return enableConfiguratorServiceLoader;
+ }
+
+ public AbstractEngineConfiguration setEnableConfiguratorServiceLoader(boolean enableConfiguratorServiceLoader) {
+ this.enableConfiguratorServiceLoader = enableConfiguratorServiceLoader;
+ return this;
+ }
+
+ public List getConfigurators() {
+ return configurators;
+ }
+
+ public AbstractEngineConfiguration addConfigurator(EngineConfigurator configurator) {
+ if (configurators == null) {
+ configurators = new ArrayList<>();
+ }
+ configurators.add(configurator);
+ return this;
+ }
+
+ /**
+ * @return All {@link EngineConfigurator} instances. Will only contain values after
+ * init of the engine. Use the {@link #getConfigurators()} or
+ * {@link #addConfigurator(EngineConfigurator)} methods otherwise.
+ */
+ public List getAllConfigurators() {
+ return allConfigurators;
+ }
+
+ public AbstractEngineConfiguration setConfigurators(List configurators) {
+ this.configurators = configurators;
+ return this;
+ }
+
+ public EngineConfigurator getIdmEngineConfigurator() {
+ return idmEngineConfigurator;
+ }
+
+ public AbstractEngineConfiguration setIdmEngineConfigurator(EngineConfigurator idmEngineConfigurator) {
+ this.idmEngineConfigurator = idmEngineConfigurator;
+ return this;
+ }
+
+ public EngineConfigurator getEventRegistryConfigurator() {
+ return eventRegistryConfigurator;
+ }
+
+ public AbstractEngineConfiguration setEventRegistryConfigurator(EngineConfigurator eventRegistryConfigurator) {
+ this.eventRegistryConfigurator = eventRegistryConfigurator;
+ return this;
+ }
+
+ public AbstractEngineConfiguration setForceCloseMybatisConnectionPool(boolean forceCloseMybatisConnectionPool) {
+ this.forceCloseMybatisConnectionPool = forceCloseMybatisConnectionPool;
+ return this;
+ }
+
+ public boolean isForceCloseMybatisConnectionPool() {
+ return forceCloseMybatisConnectionPool;
+ }
+
+}
diff --git a/pigx-flow/pigx-flow-engine/pigx-flow-engine-biz/src/main/resources/application.yml b/pigx-flow/pigx-flow-engine/pigx-flow-engine-biz/src/main/resources/application.yml
index c8907744f..11ed644f2 100644
--- a/pigx-flow/pigx-flow-engine/pigx-flow-engine-biz/src/main/resources/application.yml
+++ b/pigx-flow/pigx-flow-engine/pigx-flow-engine-biz/src/main/resources/application.yml
@@ -16,3 +16,5 @@ spring:
import:
- optional:nacos:application-@profiles.active@.yml
- optional:nacos:${spring.application.name}-@profiles.active@.yml
+ liquibase:
+ enabled: false
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/Process.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/Process.java
index 96c17b517..be790cbe8 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/Process.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/Process.java
@@ -24,88 +24,88 @@ public class Process {
/**
* 表单ID
*/
- @TableField("`flow_id`")
+ @TableField("flow_id")
private String flowId;
/**
* 表单名称
*/
- @TableField("`name`")
+ @TableField("name")
private String name;
/**
* 图标配置
*/
- @TableField("`logo`")
+ @TableField("logo")
private String logo;
/**
* 设置项
*/
- @TableField("`settings`")
+ @TableField("settings")
private String settings;
/**
* 分组ID
*/
- @TableField("`group_id`")
+ @TableField("group_id")
private Long groupId;
/**
* 表单设置内容
*/
- @TableField("`form_items`")
+ @TableField("form_items")
private String formItems;
/**
* 流程设置内容
*/
- @TableField("`process`")
+ @TableField("process")
private String process;
/**
* 备注
*/
- @TableField("`remark`")
+ @TableField("remark")
private String remark;
- @TableField("`sort`")
+ @TableField("sort")
private Integer sort;
/**
* 0 正常 1=隐藏
*/
- @TableField("`is_hidden`")
+ @TableField("is_hidden")
private Boolean hidden;
/**
* 0 正常 1=停用
*/
- @TableField("`is_stop`")
+ @TableField("is_stop")
private Boolean stop;
/**
* 流程管理员
*/
- @TableField("`admin_id`")
+ @TableField("admin_id")
private Long adminId;
/**
* 唯一性id
*/
- @TableField("`unique_id`")
+ @TableField("unique_id")
private String uniqueId;
/**
* 管理员
*/
- @TableField("`admin`")
- private String admin;
+ @TableField("admin_list")
+ private String adminList;
/**
* 范围描述显示
*/
- @TableField("`range_show`")
+ @TableField("range_show")
private String rangeShow;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessCopy.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessCopy.java
index d918ef5cd..6ef5a54e2 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessCopy.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessCopy.java
@@ -30,73 +30,73 @@ public class ProcessCopy {
/**
* 流程发起时间
*/
- @TableField("`start_time`")
+ @TableField("start_time")
private LocalDateTime startTime;
/**
* 当前节点时间
*/
- @TableField("`node_time`")
+ @TableField("node_time")
private LocalDateTime nodeTime;
/**
* 发起人
*/
- @TableField("`start_user_id`")
+ @TableField("start_user_id")
private Long startUserId;
/**
* 流程id
*/
- @TableField("`flow_id`")
+ @TableField("flow_id")
private String flowId;
/**
* 实例id
*/
- @TableField("`process_instance_id`")
+ @TableField("process_instance_id")
private String processInstanceId;
/**
* 节点id
*/
- @TableField("`node_id`")
+ @TableField("node_id")
private String nodeId;
/**
* 分组id
*/
- @TableField("`group_id`")
+ @TableField("group_id")
private Long groupId;
/**
* 分组名称
*/
- @TableField("`group_name`")
+ @TableField("group_name")
private String groupName;
/**
* 流程名称
*/
- @TableField("`process_name`")
+ @TableField("process_name")
private String processName;
/**
* 节点 名称
*/
- @TableField("`node_name`")
+ @TableField("node_name")
private String nodeName;
/**
* 表单数据
*/
- @TableField("`form_data`")
+ @TableField("form_data")
private String formData;
/**
* 抄送人id
*/
- @TableField("`user_id`")
+ @TableField("user_id")
private Long userId;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessGroup.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessGroup.java
index 2de556b74..df004a0fb 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessGroup.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessGroup.java
@@ -24,13 +24,13 @@ public class ProcessGroup {
/**
* 分组名
*/
- @TableField("`group_name`")
+ @TableField("group_name")
private String groupName;
/**
* 排序
*/
- @TableField("`sort`")
+ @TableField("sort")
private Integer sort;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessInstanceRecord.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessInstanceRecord.java
index f99822958..3295fe7da 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessInstanceRecord.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessInstanceRecord.java
@@ -25,67 +25,67 @@ public class ProcessInstanceRecord {
/**
* 流程名字
*/
- @TableField("`name`")
+ @TableField("name")
private String name;
/**
* 头像
*/
- @TableField("`logo`")
+ @TableField("logo")
private String logo;
/**
* 用户id
*/
- @TableField("`user_id`")
+ @TableField("user_id")
private Long userId;
/**
* 流程id
*/
- @TableField("`flow_id`")
+ @TableField("flow_id")
private String flowId;
/**
* 流程实例id
*/
- @TableField("`process_instance_id`")
+ @TableField("process_instance_id")
private String processInstanceId;
/**
* 表单数据
*/
- @TableField("`form_data`")
+ @TableField("form_data")
private String formData;
/**
* 组id
*/
- @TableField("`group_id`")
+ @TableField("group_id")
private Long groupId;
/**
* 组名称
*/
- @TableField("`group_name`")
+ @TableField("group_name")
private String groupName;
/**
* 状态
*/
- @TableField("`status`")
+ @TableField("status")
private Integer status;
/**
* 结束时间
*/
- @TableField("`end_time`")
+ @TableField("end_time")
private Date endTime;
/**
* 上级流程实例id
*/
- @TableField("`parent_process_instance_id`")
+ @TableField("parent_process_instance_id")
private String parentProcessInstanceId;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeData.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeData.java
index f05d20c55..c7aa4f1fb 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeData.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeData.java
@@ -24,16 +24,16 @@ public class ProcessNodeData {
/**
* 流程id
*/
- @TableField("`flow_id`")
+ @TableField("flow_id")
private String flowId;
/**
* 表单数据
*/
- @TableField("`data`")
+ @TableField("data")
private String data;
- @TableField("`node_id`")
+ @TableField("node_id")
private String nodeId;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecord.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecord.java
index 027b8c5f4..c5f57b365 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecord.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecord.java
@@ -25,58 +25,58 @@ public class ProcessNodeRecord {
/**
* 流程id
*/
- @TableField("`flow_id`")
+ @TableField("flow_id")
private String flowId;
/**
* 流程实例id
*/
- @TableField("`process_instance_id`")
+ @TableField("process_instance_id")
private String processInstanceId;
/**
* 表单数据
*/
- @TableField("`data`")
+ @TableField("data")
private String data;
- @TableField("`node_id`")
+ @TableField("node_id")
private String nodeId;
/**
* 节点类型
*/
- @TableField("`node_type`")
+ @TableField("node_type")
private String nodeType;
/**
* 节点名字
*/
- @TableField("`node_name`")
+ @TableField("node_name")
private String nodeName;
/**
* 节点状态
*/
- @TableField("`status`")
+ @TableField("status")
private Integer status;
/**
* 开始时间
*/
- @TableField("`start_time`")
+ @TableField("start_time")
private Date startTime;
/**
* 结束时间
*/
- @TableField("`end_time`")
+ @TableField("end_time")
private Date endTime;
/**
* 执行id
*/
- @TableField("`execution_id`")
+ @TableField("execution_id")
private String executionId;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecordAssignUser.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecordAssignUser.java
index 574e0ba24..9424137a0 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecordAssignUser.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessNodeRecordAssignUser.java
@@ -24,82 +24,82 @@ public class ProcessNodeRecordAssignUser {
/**
* 流程id
*/
- @TableField("`flow_id`")
+ @TableField("flow_id")
private String flowId;
/**
* 流程实例id
*/
- @TableField("`process_instance_id`")
+ @TableField("process_instance_id")
private String processInstanceId;
/**
* 表单数据
*/
- @TableField("`data`")
+ @TableField("data")
private String data;
- @TableField("`node_id`")
+ @TableField("node_id")
private String nodeId;
/**
* 用户id
*/
- @TableField("`user_id`")
+ @TableField("user_id")
private String userId;
/**
* 节点状态
*/
- @TableField("`status`")
+ @TableField("status")
private Integer status;
/**
* 开始时间
*/
- @TableField("`start_time`")
+ @TableField("start_time")
private LocalDateTime startTime;
/**
* 结束时间
*/
- @TableField("`end_time`")
+ @TableField("end_time")
private LocalDateTime endTime;
/**
* 执行id
*/
- @TableField("`execution_id`")
+ @TableField("execution_id")
private String executionId;
/**
* 任务id
*/
- @TableField("`task_id`")
+ @TableField("task_id")
private String taskId;
/**
* 审批意见
*/
- @TableField("`approve_desc`")
+ @TableField("approve_desc")
private String approveDesc;
/**
* 节点名称
*/
- @TableField("`node_name`")
+ @TableField("node_name")
private String nodeName;
/**
* 任务类型
*/
- @TableField("`task_type`")
+ @TableField("task_type")
private String taskType;
/**
* 表单本地数据
*/
- @TableField("`local_data`")
+ @TableField("local_data")
private String localData;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessStarter.java b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessStarter.java
index f76e89d12..c29cdaf16 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessStarter.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-api/src/main/java/com/pig4cloud/pigx/flow/task/entity/ProcessStarter.java
@@ -24,19 +24,19 @@ public class ProcessStarter {
/**
* 用户id或者部门id
*/
- @TableField("`type_id`")
+ @TableField("type_id")
private Long typeId;
/**
* 类型 user dept
*/
- @TableField("`type`")
+ @TableField("type")
private String type;
/**
* 流程id
*/
- @TableField("`process_id`")
+ @TableField("process_id")
private Long processId;
/**
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-biz/pom.xml b/pigx-flow/pigx-flow-task/pigx-flow-task-biz/pom.xml
index 53f1f8f3c..26dbabd9b 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-biz/pom.xml
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-biz/pom.xml
@@ -98,6 +98,10 @@
org.springframework.boot
spring-boot-starter-test
+
+ com.dameng
+ DmJdbcDriver18
+
diff --git a/pigx-flow/pigx-flow-task/pigx-flow-task-biz/src/main/java/com/pig4cloud/pigx/flow/task/service/impl/ProcessServiceImpl.java b/pigx-flow/pigx-flow-task/pigx-flow-task-biz/src/main/java/com/pig4cloud/pigx/flow/task/service/impl/ProcessServiceImpl.java
index 8a569728b..dd487bb7f 100644
--- a/pigx-flow/pigx-flow-task/pigx-flow-task-biz/src/main/java/com/pig4cloud/pigx/flow/task/service/impl/ProcessServiceImpl.java
+++ b/pigx-flow/pigx-flow-task/pigx-flow-task-biz/src/main/java/com/pig4cloud/pigx/flow/task/service/impl/ProcessServiceImpl.java
@@ -166,7 +166,7 @@ public class ProcessServiceImpl extends ServiceImpl impl
return R.failed(r.getMsg());
}
String flowId = r.getData();
- NodeUser nodeUser = objectMapper.readValue(process.getAdmin(), new TypeReference>() {
+ NodeUser nodeUser = objectMapper.readValue(process.getAdminList(), new TypeReference>() {
}).get(0);
// 更新流程
@@ -217,7 +217,7 @@ public class ProcessServiceImpl extends ServiceImpl impl
p.setStop(false);
p.setAdminId(nodeUser.getId());
p.setUniqueId(IdUtil.fastSimpleUUID());
- p.setAdmin(process.getAdmin());
+ p.setAdminList(process.getAdminList());
p.setRangeShow(stringBuilder.toString());
this.save(p);
diff --git a/pigx-register/src/main/resources/application.yml b/pigx-register/src/main/resources/application.yml
index d62e442d6..05cff5071 100644
--- a/pigx-register/src/main/resources/application.yml
+++ b/pigx-register/src/main/resources/application.yml
@@ -6,10 +6,13 @@ server:
include-message: always
db:
num: 1
- user: ${MYSQL_USER:root}
- password: ${MYSQL_PWD:root}
+ user: SYSDBA
+ password: SYSDBA
url:
- 0: jdbc:mysql://${MYSQL_HOST:pigx-mysql}:${MYSQL_PORT:3306}/${MYSQL_DB:pigxx_config}?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
+ 0: jdbc:dm://home:35236
+ pool:
+ config:
+ driver-class-name: dm.jdbc.driver.DmDriver
nacos:
core:
@@ -26,7 +29,7 @@ nacos:
spring:
datasource:
- platform: mysql #这个过期属性不能修改，nacos 代码对此有硬编码
+ platform: dameng #这个过期属性不能修改，nacos 代码对此有硬编码
security:
enabled: true
boot: # 接入 spring boot admin