AbstractEngineConfiguration (Flowable - Engine Common 6.4.2 API)

java.lang.Object
- org.flowable.common.engine.impl.AbstractEngineConfiguration

public abstract class AbstractEngineConfiguration
extends Object

Field Summary

Fields
Modifier and Type	Field and Description
`protected List<EventDispatchAction>`	`additionalEventDispatchActions`
`protected List<EngineConfigurator>`	`allConfigurators`
`protected boolean`	`alwaysLookupLatestDefinitionVersion` Set to true if the latest version of a definition should be retrieved, ignoring a possible parent deployment id value
`protected Map<Object,Object>`	`beans`
`protected ClassLoader`	`classLoader`
`protected Clock`	`clock`
`protected CommandContextFactory`	`commandContextFactory`
`protected CommandExecutor`	`commandExecutor`
`protected List<CommandInterceptor>`	`commandInterceptors`
`protected CommandInterceptor`	`commandInvoker`
`protected SchemaManager`	`commonSchemaManager`
`protected List<EngineConfigurator>`	`configurators`
`protected List<org.apache.ibatis.plugin.Interceptor>`	`customMybatisInterceptors`
`protected Set<Class<?>>`	`customMybatisMappers`
`protected Set<String>`	`customMybatisXMLMappers`
`protected List<CommandInterceptor>`	`customPostCommandInterceptors`
`protected List<EngineDeployer>`	`customPostDeployers`
`protected List<CommandInterceptor>`	`customPreCommandInterceptors`
`protected List<EngineDeployer>`	`customPreDeployers`
`protected List<SessionFactory>`	`customSessionFactories`
`static String`	`DATABASE_TYPE_COCKROACHDB`
`static String`	`DATABASE_TYPE_DB2`
`static String`	`DATABASE_TYPE_H2`
`static String`	`DATABASE_TYPE_HSQL`
`static String`	`DATABASE_TYPE_MSSQL`
`static String`	`DATABASE_TYPE_MYSQL`
`static String`	`DATABASE_TYPE_ORACLE`
`static String`	`DATABASE_TYPE_POSTGRES`
`protected String`	`databaseCatalog` database catalog to use
`protected String`	`databaseSchema` 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`	`databaseSchemaUpdate`
`protected String`	`databaseTablePrefix` Allows configuring a database table prefix which is used for all runtime operations of the process engine.
`protected String`	`databaseType`
`protected Properties`	`databaseTypeMappings`
`protected String`	`databaseWildcardEscapeCharacter` Escape character for doing wildcard searches.
`protected DataSource`	`dataSource`
`protected String`	`dataSourceJndiName`
`static String`	`DB_SCHEMA_UPDATE_CREATE`
`static String`	`DB_SCHEMA_UPDATE_CREATE_DROP`
`static String`	`DB_SCHEMA_UPDATE_DROP_CREATE` Creates the schema when the form engine is being created and drops the schema when the form engine is being closed.
`static String`	`DB_SCHEMA_UPDATE_FALSE` Checks the version of the DB schema against the library when the form engine is being created and throws an exception if the versions don't match.
`static String`	`DB_SCHEMA_UPDATE_TRUE` Upon building of the process engine, a check is performed and an update of the schema is performed if it is necessary.
`protected DbSqlSessionFactory`	`dbSqlSessionFactory`
`static int`	`DEFAULT_GENERIC_MAX_LENGTH_STRING`
`int`	`DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER`
`static int`	`DEFAULT_ORACLE_MAX_LENGTH_STRING`
`protected CommandConfig`	`defaultCommandConfig`
`protected Collection<? extends CommandInterceptor>`	`defaultCommandInterceptors`
`protected DefaultTenantProvider`	`defaultTenantProvider` Default tenant provider that is executed when looking up definitions, in case the global or local fallback to default tenant value is true
`protected List<MybatisTypeAliasConfigurator>`	`dependentEngineMybatisTypeAliasConfigs`
`protected List<MybatisTypeHandlerConfigurator>`	`dependentEngineMybatisTypeHandlerConfigs`
`protected Set<String>`	`dependentEngineMyBatisXmlMappers`
`protected List<EngineDeployer>`	`deployers`
`protected boolean`	`enableConfiguratorServiceLoader`
`protected boolean`	`enableEventDispatcher`
`protected boolean`	`enableLogSqlExecutionTime` Enables the MyBatis plugin that logs the execution time of sql statements.
`protected Map<String,AbstractEngineConfiguration>`	`engineConfigurations`
`protected FlowableEventDispatcher`	`eventDispatcher`
`protected List<FlowableEventListener>`	`eventListeners`
`protected boolean`	`fallbackToDefaultTenant` 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`	`forceCloseMybatisConnectionPool`
`protected IdGenerator`	`idGenerator`
`protected EngineConfigurator`	`idmEngineConfigurator`
`protected boolean`	`isBulkInsertEnabled` If set to true, enables bulk insert (grouping sql inserts together).
`protected boolean`	`isDbHistoryUsed`
`protected int`	`jdbcDefaultTransactionIsolationLevel`
`protected String`	`jdbcDriver`
`protected int`	`jdbcMaxActiveConnections`
`protected int`	`jdbcMaxCheckoutTime`
`protected int`	`jdbcMaxIdleConnections`
`protected int`	`jdbcMaxWaitTime`
`protected String`	`jdbcPassword`
`protected int`	`jdbcPingConnectionNotUsedFor`
`protected boolean`	`jdbcPingEnabled`
`protected String`	`jdbcPingQuery`
`protected String`	`jdbcUrl`
`protected String`	`jdbcUsername`
`protected org.slf4j.Logger`	`logger`
`protected int`	`maxLengthStringVariableType` Define a max length for storing String variable types in the database.
`protected int`	`maxNrOfStatementsInBulkInsert` Some databases have a limit of how many parameters one sql insert can have (eg SQL Server, 2000 params (!= insert statements) ).
`static String`	`NO_TENANT_ID` The tenant id indicating 'no tenant'
`static String`	`PRODUCT_NAME_CRDB`
`static String`	`PRODUCT_NAME_POSTGRES`
`protected CommandConfig`	`schemaCommandConfig`
`protected Command<Void>`	`schemaManagementCmd`
`protected SchemaManager`	`schemaManager`
`protected Map<String,AbstractServiceConfiguration>`	`serviceConfigurations`
`protected Map<Class<?>,SessionFactory>`	`sessionFactories`
`protected org.apache.ibatis.session.SqlSessionFactory`	`sqlSessionFactory`
`protected boolean`	`tablePrefixIsSchema` Set to true in case the defined databaseTablePrefix is a schema-name, instead of an actual table name prefix.
`protected TransactionContextFactory`	`transactionContextFactory`
`protected org.apache.ibatis.transaction.TransactionFactory`	`transactionFactory`
`protected boolean`	`transactionsExternallyManaged`
`protected Map<String,List<FlowableEventListener>>`	`typedEventListeners`
`protected boolean`	`useClassForNameClassLoading` Either use Class.forName or ClassLoader.loadClass for class loading.
`protected boolean`	`usePrefixId`
`protected boolean`	`usingRelationalDatabase` Flag that can be set to configure or not a relational database is used.
`protected boolean`	`usingSchemaMgmt` Flag that can be set to configure whether or not a schema is used.
`protected String`	`xmlEncoding`

Constructor Summary

Constructors
Constructor and Description

AbstractEngineConfiguration()

Constructors
Constructor and Description
`AbstractEngineConfiguration()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`AbstractEngineConfiguration`	`addConfigurator(EngineConfigurator configurator)`
`AbstractEngineConfiguration`	`addCustomSessionFactory(SessionFactory sessionFactory)`
`void`	`addEngineConfiguration(String key, AbstractEngineConfiguration engineConfiguration)`
`void`	`addServiceConfiguration(String key, AbstractServiceConfiguration serviceConfiguration)`
`void`	`addSessionFactory(SessionFactory sessionFactory)`
`void`	`close()`
`void`	`configuratorsAfterInit()`
`void`	`configuratorsBeforeInit()`
`DbSqlSessionFactory`	`createDbSqlSessionFactory()`
`abstract CommandInterceptor`	`createTransactionInterceptor()`
`protected void`	`defaultInitDbSqlSessionFactoryEntitySettings(List<Class<? extends Entity>> insertOrder, List<Class<? extends Entity>> deleteOrder)`
`List<CommandInterceptor>`	`getAdditionalDefaultCommandInterceptors()`
`List<EventDispatchAction>`	`getAdditionalEventDispatchActions()`
`Map<Object,Object>`	`getBeans()`
`ClassLoader`	`getClassLoader()`
`Clock`	`getClock()`
`CommandContextFactory`	`getCommandContextFactory()`
`CommandExecutor`	`getCommandExecutor()`
`List<CommandInterceptor>`	`getCommandInterceptors()`
`CommandInterceptor`	`getCommandInvoker()`
`SchemaManager`	`getCommonSchemaManager()`
`List<EngineConfigurator>`	`getConfigurators()`
`List<org.apache.ibatis.plugin.Interceptor>`	`getCustomMybatisInterceptors()`
`Set<Class<?>>`	`getCustomMybatisMappers()`
`Set<String>`	`getCustomMybatisXMLMappers()`
`List<CommandInterceptor>`	`getCustomPostCommandInterceptors()`
`List<EngineDeployer>`	`getCustomPostDeployers()`
`List<CommandInterceptor>`	`getCustomPreCommandInterceptors()`
`List<EngineDeployer>`	`getCustomPreDeployers()`
`List<SessionFactory>`	`getCustomSessionFactories()`
`String`	`getDatabaseCatalog()`
`String`	`getDatabaseSchema()`
`String`	`getDatabaseSchemaUpdate()`
`String`	`getDatabaseTablePrefix()`
`String`	`getDatabaseType()`
`String`	`getDatabaseWildcardEscapeCharacter()`
`DataSource`	`getDataSource()`
`String`	`getDataSourceJndiName()`
`DbSqlSessionFactory`	`getDbSqlSessionFactory()`
`CommandConfig`	`getDefaultCommandConfig()`
`Collection<? extends CommandInterceptor>`	`getDefaultCommandInterceptors()`
`static Properties`	`getDefaultDatabaseTypeMappings()`
`DefaultTenantProvider`	`getDefaultTenantProvider()`
`String`	`getDefaultTenantValue()` Deprecated. use `getDefaultTenantProvider()` instead
`List<MybatisTypeAliasConfigurator>`	`getDependentEngineMybatisTypeAliasConfigs()`
`List<MybatisTypeHandlerConfigurator>`	`getDependentEngineMybatisTypeHandlerConfigs()`
`Set<String>`	`getDependentEngineMyBatisXmlMappers()`
`List<EngineDeployer>`	`getDeployers()`
`abstract String`	`getEngineCfgKey()`
`Map<String,AbstractEngineConfiguration>`	`getEngineConfigurations()`
`abstract String`	`getEngineName()`
`protected List<EngineConfigurator>`	`getEngineSpecificEngineConfigurators()`
`FlowableEventDispatcher`	`getEventDispatcher()`
`List<FlowableEventListener>`	`getEventListeners()`
`IdGenerator`	`getIdGenerator()`
`EngineConfigurator`	`getIdmEngineConfigurator()`
`int`	`getJdbcDefaultTransactionIsolationLevel()`
`String`	`getJdbcDriver()`
`int`	`getJdbcMaxActiveConnections()`
`int`	`getJdbcMaxCheckoutTime()`
`int`	`getJdbcMaxIdleConnections()`
`int`	`getJdbcMaxWaitTime()`
`String`	`getJdbcPassword()`
`int`	`getJdbcPingConnectionNotUsedFor()`
`String`	`getJdbcPingQuery()`
`String`	`getJdbcUrl()`
`String`	`getJdbcUsername()`
`int`	`getMaxLengthString()`
`int`	`getMaxLengthStringVariableType()`
`int`	`getMaxNrOfStatementsInBulkInsert()`
`abstract InputStream`	`getMyBatisXmlConfigurationStream()`
`protected InputStream`	`getResourceAsStream(String resource)`
`CommandConfig`	`getSchemaCommandConfig()`
`Command<Void>`	`getSchemaManagementCmd()`
`SchemaManager`	`getSchemaManager()`
`Map<String,AbstractServiceConfiguration>`	`getServiceConfigurations()`
`Map<Class<?>,SessionFactory>`	`getSessionFactories()`
`org.apache.ibatis.session.SqlSessionFactory`	`getSqlSessionFactory()`
`TransactionContextFactory`	`getTransactionContextFactory()`
`org.apache.ibatis.transaction.TransactionFactory`	`getTransactionFactory()`
`Map<String,List<FlowableEventListener>>`	`getTypedEventListeners()`
`String`	`getXmlEncoding()`
`void`	`initBeans()`
`void`	`initClock()`
`void`	`initCommandContextFactory()`
`void`	`initCommandExecutor()`
`void`	`initCommandExecutors()`
`void`	`initCommandInterceptors()`
`void`	`initCommandInvoker()`
`void`	`initConfigurators()`
`void`	`initCustomMybatisInterceptors(org.apache.ibatis.session.Configuration configuration)`
`void`	`initCustomMybatisMappers(org.apache.ibatis.session.Configuration configuration)`
`void`	`initDatabaseType()`
`protected void`	`initDataSource()`
`void`	`initDbSqlSessionFactory()`
`protected abstract void`	`initDbSqlSessionFactoryEntitySettings()`
`void`	`initDefaultCommandConfig()`
`protected void`	`initEngineConfigurations()`
`void`	`initIdGenerator()`
`CommandInterceptor`	`initInterceptorChain(List<CommandInterceptor> chain)`
`org.apache.ibatis.session.Configuration`	`initMybatisConfiguration(org.apache.ibatis.mapping.Environment environment, Reader reader, Properties properties)`
`void`	`initMyBatisLogSqlExecutionTimePlugin(org.apache.ibatis.session.Configuration configuration)`
`void`	`initMybatisTypeHandlers(org.apache.ibatis.session.Configuration configuration)`
`void`	`initSchemaCommandConfig()`
`void`	`initSchemaManager()`
`protected void`	`initService(Object service)`
`void`	`initSessionFactories()`
`void`	`initSqlSessionFactory()`
`void`	`initTransactionContextFactory()`
`void`	`initTransactionFactory()`
`boolean`	`isAlwaysLookupLatestDefinitionVersion()`
`boolean`	`isBulkInsertEnabled()`
`boolean`	`isDbHistoryUsed()`
`boolean`	`isEnableConfiguratorServiceLoader()`
`boolean`	`isEnableEventDispatcher()`
`boolean`	`isEnableLogSqlExecutionTime()`
`boolean`	`isFallbackToDefaultTenant()`
`boolean`	`isForceCloseMybatisConnectionPool()`
`boolean`	`isJdbcPingEnabled()`
`boolean`	`isTablePrefixIsSchema()`
`boolean`	`isTransactionsExternallyManaged()`
`boolean`	`isUseClassForNameClassLoading()`
`boolean`	`isUsePrefixId()`
`boolean`	`isUsingRelationalDatabase()`
`boolean`	`isUsingSchemaMgmt()`
`void`	`parseCustomMybatisXMLMappers(org.apache.ibatis.session.Configuration configuration)`
`void`	`parseDependentEngineMybatisXMLMappers(org.apache.ibatis.session.Configuration configuration)`
`org.apache.ibatis.session.Configuration`	`parseMybatisConfiguration(org.apache.ibatis.builder.xml.XMLConfigBuilder parser)`
`protected void`	`parseMybatisXmlMapping(org.apache.ibatis.session.Configuration configuration, String resource)`
`String`	`pathToEngineDbProperties()`
`AbstractEngineConfiguration`	`setAdditionalEventDispatchActions(List<EventDispatchAction> additionalEventDispatchActions)`
`AbstractEngineConfiguration`	`setAlwaysLookupLatestDefinitionVersion(boolean alwaysLookupLatestDefinitionVersion)`
`AbstractEngineConfiguration`	`setBeans(Map<Object,Object> beans)`
`AbstractEngineConfiguration`	`setBulkInsertEnabled(boolean isBulkInsertEnabled)`
`AbstractEngineConfiguration`	`setClassLoader(ClassLoader classLoader)`
`AbstractEngineConfiguration`	`setClock(Clock clock)`
`AbstractEngineConfiguration`	`setCommandContextFactory(CommandContextFactory commandContextFactory)`
`AbstractEngineConfiguration`	`setCommandExecutor(CommandExecutor commandExecutor)`
`AbstractEngineConfiguration`	`setCommandInterceptors(List<CommandInterceptor> commandInterceptors)`
`AbstractEngineConfiguration`	`setCommandInvoker(CommandInterceptor commandInvoker)`
`AbstractEngineConfiguration`	`setCommonSchemaManager(SchemaManager commonSchemaManager)`
`AbstractEngineConfiguration`	`setConfigurators(List<EngineConfigurator> configurators)`
`AbstractEngineConfiguration`	`setCustomMybatisInterceptors(List<org.apache.ibatis.plugin.Interceptor> customMybatisInterceptors)`
`AbstractEngineConfiguration`	`setCustomMybatisMappers(Set<Class<?>> customMybatisMappers)`
`AbstractEngineConfiguration`	`setCustomMybatisXMLMappers(Set<String> customMybatisXMLMappers)`
`AbstractEngineConfiguration`	`setCustomPostCommandInterceptors(List<CommandInterceptor> customPostCommandInterceptors)`
`AbstractEngineConfiguration`	`setCustomPostDeployers(List<EngineDeployer> customPostDeployers)`
`AbstractEngineConfiguration`	`setCustomPreCommandInterceptors(List<CommandInterceptor> customPreCommandInterceptors)`
`AbstractEngineConfiguration`	`setCustomPreDeployers(List<EngineDeployer> customPreDeployers)`
`AbstractEngineConfiguration`	`setCustomSessionFactories(List<SessionFactory> customSessionFactories)`
`AbstractEngineConfiguration`	`setDatabaseCatalog(String databaseCatalog)`
`AbstractEngineConfiguration`	`setDatabaseSchema(String databaseSchema)`
`AbstractEngineConfiguration`	`setDatabaseSchemaUpdate(String databaseSchemaUpdate)`
`AbstractEngineConfiguration`	`setDatabaseTablePrefix(String databaseTablePrefix)`
`AbstractEngineConfiguration`	`setDatabaseType(String databaseType)`
`AbstractEngineConfiguration`	`setDatabaseWildcardEscapeCharacter(String databaseWildcardEscapeCharacter)`
`AbstractEngineConfiguration`	`setDataSource(DataSource dataSource)`
`AbstractEngineConfiguration`	`setDataSourceJndiName(String dataSourceJndiName)`
`AbstractEngineConfiguration`	`setDbHistoryUsed(boolean isDbHistoryUsed)`
`AbstractEngineConfiguration`	`setDbSqlSessionFactory(DbSqlSessionFactory dbSqlSessionFactory)`
`AbstractEngineConfiguration`	`setDefaultCommandConfig(CommandConfig defaultCommandConfig)`
`void`	`setDefaultCommandInterceptors(Collection<? extends CommandInterceptor> defaultCommandInterceptors)`
`AbstractEngineConfiguration`	`setDefaultTenantProvider(DefaultTenantProvider defaultTenantProvider)`
`AbstractEngineConfiguration`	`setDefaultTenantValue(String defaultTenantValue)`
`AbstractEngineConfiguration`	`setDependentEngineMybatisTypeAliasConfigs(List<MybatisTypeAliasConfigurator> dependentEngineMybatisTypeAliasConfigs)`
`AbstractEngineConfiguration`	`setDependentEngineMybatisTypeHandlerConfigs(List<MybatisTypeHandlerConfigurator> dependentEngineMybatisTypeHandlerConfigs)`
`AbstractEngineConfiguration`	`setDependentEngineMyBatisXmlMappers(Set<String> dependentEngineMyBatisXmlMappers)`
`AbstractEngineConfiguration`	`setDeployers(List<EngineDeployer> deployers)`
`AbstractEngineConfiguration`	`setEnableConfiguratorServiceLoader(boolean enableConfiguratorServiceLoader)`
`AbstractEngineConfiguration`	`setEnableEventDispatcher(boolean enableEventDispatcher)`
`void`	`setEnableLogSqlExecutionTime(boolean enableLogSqlExecutionTime)`
`AbstractEngineConfiguration`	`setEngineConfigurations(Map<String,AbstractEngineConfiguration> engineConfigurations)`
`AbstractEngineConfiguration`	`setEventDispatcher(FlowableEventDispatcher eventDispatcher)`
`AbstractEngineConfiguration`	`setEventListeners(List<FlowableEventListener> eventListeners)`
`AbstractEngineConfiguration`	`setFallbackToDefaultTenant(boolean fallbackToDefaultTenant)`
`AbstractEngineConfiguration`	`setForceCloseMybatisConnectionPool(boolean forceCloseMybatisConnectionPool)`
`AbstractEngineConfiguration`	`setIdGenerator(IdGenerator idGenerator)`
`AbstractEngineConfiguration`	`setIdmEngineConfigurator(EngineConfigurator idmEngineConfigurator)`
`AbstractEngineConfiguration`	`setJdbcDefaultTransactionIsolationLevel(int jdbcDefaultTransactionIsolationLevel)`
`AbstractEngineConfiguration`	`setJdbcDriver(String jdbcDriver)`
`AbstractEngineConfiguration`	`setJdbcMaxActiveConnections(int jdbcMaxActiveConnections)`
`AbstractEngineConfiguration`	`setJdbcMaxCheckoutTime(int jdbcMaxCheckoutTime)`
`AbstractEngineConfiguration`	`setJdbcMaxIdleConnections(int jdbcMaxIdleConnections)`
`AbstractEngineConfiguration`	`setJdbcMaxWaitTime(int jdbcMaxWaitTime)`
`AbstractEngineConfiguration`	`setJdbcPassword(String jdbcPassword)`
`AbstractEngineConfiguration`	`setJdbcPingConnectionNotUsedFor(int jdbcPingConnectionNotUsedFor)`
`AbstractEngineConfiguration`	`setJdbcPingEnabled(boolean jdbcPingEnabled)`
`AbstractEngineConfiguration`	`setJdbcPingQuery(String jdbcPingQuery)`
`AbstractEngineConfiguration`	`setJdbcUrl(String jdbcUrl)`
`AbstractEngineConfiguration`	`setJdbcUsername(String jdbcUsername)`
`AbstractEngineConfiguration`	`setMaxLengthStringVariableType(int maxLengthStringVariableType)`
`AbstractEngineConfiguration`	`setMaxNrOfStatementsInBulkInsert(int maxNrOfStatementsInBulkInsert)`
`AbstractEngineConfiguration`	`setSchemaCommandConfig(CommandConfig schemaCommandConfig)`
`AbstractEngineConfiguration`	`setSchemaManagementCmd(Command<Void> schemaManagementCmd)`
`AbstractEngineConfiguration`	`setSchemaManager(SchemaManager schemaManager)`
`AbstractEngineConfiguration`	`setServiceConfigurations(Map<String,AbstractServiceConfiguration> serviceConfigurations)`
`AbstractEngineConfiguration`	`setSessionFactories(Map<Class<?>,SessionFactory> sessionFactories)`
`AbstractEngineConfiguration`	`setSqlSessionFactory(org.apache.ibatis.session.SqlSessionFactory sqlSessionFactory)`
`AbstractEngineConfiguration`	`setTablePrefixIsSchema(boolean tablePrefixIsSchema)`
`AbstractEngineConfiguration`	`setTransactionContextFactory(TransactionContextFactory transactionContextFactory)`
`AbstractEngineConfiguration`	`setTransactionFactory(org.apache.ibatis.transaction.TransactionFactory transactionFactory)`
`AbstractEngineConfiguration`	`setTransactionsExternallyManaged(boolean transactionsExternallyManaged)`
`AbstractEngineConfiguration`	`setTypedEventListeners(Map<String,List<FlowableEventListener>> typedEventListeners)`
`AbstractEngineConfiguration`	`setUseClassForNameClassLoading(boolean useClassForNameClassLoading)`
`AbstractEngineConfiguration`	`setUsePrefixId(boolean usePrefixId)`
`AbstractEngineConfiguration`	`setUsingRelationalDatabase(boolean usingRelationalDatabase)`
`AbstractEngineConfiguration`	`setUsingSchemaMgmt(boolean usingSchema)`
`AbstractEngineConfiguration`	`setXmlEncoding(String xmlEncoding)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- logger
```
protected final org.slf4j.Logger logger
```
- NO_TENANT_ID
```
public static final String NO_TENANT_ID
```
  The tenant id indicating 'no tenant'
  
  See Also:
  
  Constant Field Values
- DB_SCHEMA_UPDATE_FALSE
```
public static final String DB_SCHEMA_UPDATE_FALSE
```
  Checks the version of the DB schema against the library when the form engine is being created and throws an exception if the versions don't match.
  
  See Also:
  
  Constant Field Values
- DB_SCHEMA_UPDATE_CREATE
```
public static final String DB_SCHEMA_UPDATE_CREATE
```
  See Also:
  
  Constant Field Values
- DB_SCHEMA_UPDATE_CREATE_DROP
```
public static final String DB_SCHEMA_UPDATE_CREATE_DROP
```
  See Also:
  
  Constant Field Values
- DB_SCHEMA_UPDATE_DROP_CREATE
```
public static final String DB_SCHEMA_UPDATE_DROP_CREATE
```
  Creates the schema when the form engine is being created and drops the schema when the form engine is being closed.
  
  See Also:
  
  Constant Field Values
- DB_SCHEMA_UPDATE_TRUE
```
public static final String DB_SCHEMA_UPDATE_TRUE
```
  Upon building of the process engine, a check is performed and an update of the schema is performed if it is necessary.
  
  See Also:
  
  Constant Field Values
- forceCloseMybatisConnectionPool
```
protected boolean forceCloseMybatisConnectionPool
```
- databaseType
```
protected String databaseType
```
- jdbcDriver
```
protected String jdbcDriver
```
- jdbcUrl
```
protected String jdbcUrl
```
- jdbcUsername
```
protected String jdbcUsername
```
- jdbcPassword
```
protected String jdbcPassword
```
- dataSourceJndiName
```
protected String dataSourceJndiName
```
- jdbcMaxActiveConnections
```
protected int jdbcMaxActiveConnections
```
- jdbcMaxIdleConnections
```
protected int jdbcMaxIdleConnections
```
- jdbcMaxCheckoutTime
```
protected int jdbcMaxCheckoutTime
```
- jdbcMaxWaitTime
```
protected int jdbcMaxWaitTime
```
- jdbcPingEnabled
```
protected boolean jdbcPingEnabled
```
- jdbcPingQuery
```
protected String jdbcPingQuery
```
- jdbcPingConnectionNotUsedFor
```
protected int jdbcPingConnectionNotUsedFor
```
- jdbcDefaultTransactionIsolationLevel
```
protected int jdbcDefaultTransactionIsolationLevel
```
- dataSource
```
protected DataSource dataSource
```
- commonSchemaManager
```
protected SchemaManager commonSchemaManager
```
- schemaManager
```
protected SchemaManager schemaManager
```
- schemaManagementCmd
```
protected Command<Void> schemaManagementCmd
```
- databaseSchemaUpdate
```
protected String databaseSchemaUpdate
```
- xmlEncoding
```
protected String xmlEncoding
```
- commandExecutor
```
protected CommandExecutor commandExecutor
```
- defaultCommandInterceptors
```
protected Collection<? extends CommandInterceptor> defaultCommandInterceptors
```
- defaultCommandConfig
```
protected CommandConfig defaultCommandConfig
```
- schemaCommandConfig
```
protected CommandConfig schemaCommandConfig
```
- commandContextFactory
```
protected CommandContextFactory commandContextFactory
```
- commandInvoker
```
protected CommandInterceptor commandInvoker
```
- customPreCommandInterceptors
```
protected List<CommandInterceptor> customPreCommandInterceptors
```
- customPostCommandInterceptors
```
protected List<CommandInterceptor> customPostCommandInterceptors
```
- commandInterceptors
```
protected List<CommandInterceptor> commandInterceptors
```
- engineConfigurations
```
protected Map<String,AbstractEngineConfiguration> engineConfigurations
```
- serviceConfigurations
```
protected Map<String,AbstractServiceConfiguration> serviceConfigurations
```
- classLoader
```
protected ClassLoader classLoader
```
- useClassForNameClassLoading
```
protected boolean useClassForNameClassLoading
```
  Either use Class.forName or ClassLoader.loadClass for class loading. See http://forums.activiti.org/content/reflectutilloadclass-and-custom- classloader
- isDbHistoryUsed
```
protected boolean isDbHistoryUsed
```
- dbSqlSessionFactory
```
protected DbSqlSessionFactory dbSqlSessionFactory
```
- sqlSessionFactory
```
protected org.apache.ibatis.session.SqlSessionFactory sqlSessionFactory
```
- transactionFactory
```
protected org.apache.ibatis.transaction.TransactionFactory transactionFactory
```
- transactionContextFactory
```
protected TransactionContextFactory transactionContextFactory
```
- isBulkInsertEnabled
```
protected boolean isBulkInsertEnabled
```
  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.
- maxNrOfStatementsInBulkInsert
```
protected int maxNrOfStatementsInBulkInsert
```
  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 (75 for mssql server as it has a hard limit of 2000 parameters in a statement)
- DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER
```
public int DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER
```
- customMybatisMappers
```
protected Set<Class<?>> customMybatisMappers
```
- customMybatisXMLMappers
```
protected Set<String> customMybatisXMLMappers
```
- customMybatisInterceptors
```
protected List<org.apache.ibatis.plugin.Interceptor> customMybatisInterceptors
```
- dependentEngineMyBatisXmlMappers
```
protected Set<String> dependentEngineMyBatisXmlMappers
```
- dependentEngineMybatisTypeAliasConfigs
```
protected List<MybatisTypeAliasConfigurator> dependentEngineMybatisTypeAliasConfigs
```
- dependentEngineMybatisTypeHandlerConfigs
```
protected List<MybatisTypeHandlerConfigurator> dependentEngineMybatisTypeHandlerConfigs
```
- customSessionFactories
```
protected List<SessionFactory> customSessionFactories
```
- sessionFactories
```
protected Map<Class<?>,SessionFactory> sessionFactories
```
- enableEventDispatcher
```
protected boolean enableEventDispatcher
```
- eventDispatcher
```
protected FlowableEventDispatcher eventDispatcher
```
- eventListeners
```
protected List<FlowableEventListener> eventListeners
```
- typedEventListeners
```
protected Map<String,List<FlowableEventListener>> typedEventListeners
```
- additionalEventDispatchActions
```
protected List<EventDispatchAction> additionalEventDispatchActions
```
- transactionsExternallyManaged
```
protected boolean transactionsExternallyManaged
```
- usingRelationalDatabase
```
protected boolean usingRelationalDatabase
```
  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 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 getDatabaseSchemaUpdate() value will not be used.
- usingSchemaMgmt
```
protected boolean usingSchemaMgmt
```
  Flag that can be set to configure whether or not a schema is used. This is usefil for custom implementations that do not use relational databases at all. Setting usingRelationalDatabase to true will automotically imply using a schema.
- databaseTablePrefix
```
protected String databaseTablePrefix
```
  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 DB_SCHEMA_UPDATE_CREATE_DROP or DB_SCHEMA_UPDATE_TRUE, Flowable will create the database tables using the default names, regardless of the prefix configured here.
- databaseWildcardEscapeCharacter
```
protected String databaseWildcardEscapeCharacter
```
  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 '\';
- databaseCatalog
```
protected String databaseCatalog
```
  database catalog to use
- databaseSchema
```
protected String databaseSchema
```
  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
- tablePrefixIsSchema
```
protected boolean tablePrefixIsSchema
```
  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.
- alwaysLookupLatestDefinitionVersion
```
protected boolean alwaysLookupLatestDefinitionVersion
```
  Set to true if the latest version of a definition should be retrieved, ignoring a possible parent deployment id value
- fallbackToDefaultTenant
```
protected boolean fallbackToDefaultTenant
```
  Set to true if by default lookups should fallback to the default tenant (an empty string by default or a defined tenant value)
- defaultTenantProvider
```
protected DefaultTenantProvider defaultTenantProvider
```
  Default tenant provider that is executed when looking up definitions, in case the global or local fallback to default tenant value is true
- enableLogSqlExecutionTime
```
protected boolean enableLogSqlExecutionTime
```
  Enables the MyBatis plugin that logs the execution time of sql statements.
- databaseTypeMappings
```
protected Properties databaseTypeMappings
```
- customPreDeployers
```
protected List<EngineDeployer> customPreDeployers
```
- customPostDeployers
```
protected List<EngineDeployer> customPostDeployers
```
- deployers
```
protected List<EngineDeployer> deployers
```
- enableConfiguratorServiceLoader
```
protected boolean enableConfiguratorServiceLoader
```
- configurators
```
protected List<EngineConfigurator> configurators
```
- allConfigurators
```
protected List<EngineConfigurator> allConfigurators
```
- idmEngineConfigurator
```
protected EngineConfigurator idmEngineConfigurator
```
- PRODUCT_NAME_POSTGRES
```
public static final String PRODUCT_NAME_POSTGRES
```
  See Also:
  
  Constant Field Values
- PRODUCT_NAME_CRDB
```
public static final String PRODUCT_NAME_CRDB
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_H2
```
public static final String DATABASE_TYPE_H2
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_HSQL
```
public static final String DATABASE_TYPE_HSQL
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_MYSQL
```
public static final String DATABASE_TYPE_MYSQL
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_ORACLE
```
public static final String DATABASE_TYPE_ORACLE
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_POSTGRES
```
public static final String DATABASE_TYPE_POSTGRES
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_MSSQL
```
public static final String DATABASE_TYPE_MSSQL
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_DB2
```
public static final String DATABASE_TYPE_DB2
```
  See Also:
  
  Constant Field Values
- DATABASE_TYPE_COCKROACHDB
```
public static final String DATABASE_TYPE_COCKROACHDB
```
  See Also:
  
  Constant Field Values
- beans
```
protected Map<Object,Object> beans
```
- idGenerator
```
protected IdGenerator idGenerator
```
- usePrefixId
```
protected boolean usePrefixId
```
- clock
```
protected Clock clock
```
- DEFAULT_GENERIC_MAX_LENGTH_STRING
```
public static final int DEFAULT_GENERIC_MAX_LENGTH_STRING
```
  See Also:
  
  Constant Field Values
- DEFAULT_ORACLE_MAX_LENGTH_STRING
```
public static final int DEFAULT_ORACLE_MAX_LENGTH_STRING
```
  See Also:
  
  Constant Field Values
- maxLengthStringVariableType
```
protected int maxLengthStringVariableType
```
  Define a max length for storing String variable types in the database. Mainly used for the Oracle NVARCHAR2 limit of 2000 characters

Constructor Detail
- AbstractEngineConfiguration
```
public AbstractEngineConfiguration()
```

Method Detail

getDefaultDatabaseTypeMappings

public static Properties getDefaultDatabaseTypeMappings()

initEngineConfigurations

protected void initEngineConfigurations()

initDataSource
```
protected void initDataSource()
```

initDatabaseType
```
public void initDatabaseType()
```

initSchemaManager
```
public void initSchemaManager()
```

addSessionFactory

public void addSessionFactory(SessionFactory sessionFactory)

initCommandContextFactory

public void initCommandContextFactory()

initTransactionContextFactory

public void initTransactionContextFactory()

initCommandExecutors
```
public void initCommandExecutors()
```

initDefaultCommandConfig

public void initDefaultCommandConfig()

initSchemaCommandConfig
```
public void initSchemaCommandConfig()
```

initCommandInvoker
```
public void initCommandInvoker()
```

initCommandInterceptors
```
public void initCommandInterceptors()
```

getDefaultCommandInterceptors

public Collection<? extends CommandInterceptor> getDefaultCommandInterceptors()

getEngineCfgKey

public abstract String getEngineCfgKey()

getAdditionalDefaultCommandInterceptors

public List<CommandInterceptor> getAdditionalDefaultCommandInterceptors()

initCommandExecutor
```
public void initCommandExecutor()
```

initInterceptorChain

public CommandInterceptor initInterceptorChain(List<CommandInterceptor> chain)

createTransactionInterceptor

public abstract CommandInterceptor createTransactionInterceptor()

initBeans
```
public void initBeans()
```

initIdGenerator
```
public void initIdGenerator()
```

initClock
```
public void initClock()
```

initService

protected void initService(Object service)

initSessionFactories
```
public void initSessionFactories()
```

initDbSqlSessionFactory
```
public void initDbSqlSessionFactory()
```

createDbSqlSessionFactory

public DbSqlSessionFactory createDbSqlSessionFactory()

initDbSqlSessionFactoryEntitySettings

protected abstract void initDbSqlSessionFactoryEntitySettings()

defaultInitDbSqlSessionFactoryEntitySettings

protected void defaultInitDbSqlSessionFactoryEntitySettings(List<Class<? extends Entity>> insertOrder,
                                                            List<Class<? extends Entity>> deleteOrder)

initTransactionFactory
```
public void initTransactionFactory()
```

initSqlSessionFactory
```
public void initSqlSessionFactory()
```

pathToEngineDbProperties

public String pathToEngineDbProperties()

initMybatisConfiguration

public org.apache.ibatis.session.Configuration initMybatisConfiguration(org.apache.ibatis.mapping.Environment environment,
                                                                        Reader reader,
                                                                        Properties properties)

initCustomMybatisMappers

public void initCustomMybatisMappers(org.apache.ibatis.session.Configuration configuration)

initMybatisTypeHandlers

public void initMybatisTypeHandlers(org.apache.ibatis.session.Configuration configuration)

initCustomMybatisInterceptors

public void initCustomMybatisInterceptors(org.apache.ibatis.session.Configuration configuration)

initMyBatisLogSqlExecutionTimePlugin

public void initMyBatisLogSqlExecutionTimePlugin(org.apache.ibatis.session.Configuration configuration)

parseMybatisConfiguration

public org.apache.ibatis.session.Configuration parseMybatisConfiguration(org.apache.ibatis.builder.xml.XMLConfigBuilder parser)

parseCustomMybatisXMLMappers

public void parseCustomMybatisXMLMappers(org.apache.ibatis.session.Configuration configuration)

parseDependentEngineMybatisXMLMappers

public void parseDependentEngineMybatisXMLMappers(org.apache.ibatis.session.Configuration configuration)

parseMybatisXmlMapping

protected void parseMybatisXmlMapping(org.apache.ibatis.session.Configuration configuration,
                                      String resource)

getResourceAsStream

protected InputStream getResourceAsStream(String resource)

getMyBatisXmlConfigurationStream

public abstract InputStream getMyBatisXmlConfigurationStream()

initConfigurators
```
public void initConfigurators()
```

close
```
public void close()
```

getEngineSpecificEngineConfigurators

protected List<EngineConfigurator> getEngineSpecificEngineConfigurators()

configuratorsBeforeInit
```
public void configuratorsBeforeInit()
```

configuratorsAfterInit
```
public void configuratorsAfterInit()
```

getEngineName

public abstract String getEngineName()

getClassLoader
```
public ClassLoader getClassLoader()
```

setClassLoader

public AbstractEngineConfiguration setClassLoader(ClassLoader classLoader)

isUseClassForNameClassLoading

public boolean isUseClassForNameClassLoading()

setUseClassForNameClassLoading

public AbstractEngineConfiguration setUseClassForNameClassLoading(boolean useClassForNameClassLoading)

getDatabaseType
```
public String getDatabaseType()
```

setDatabaseType

public AbstractEngineConfiguration setDatabaseType(String databaseType)

getDataSource
```
public DataSource getDataSource()
```

setDataSource

public AbstractEngineConfiguration setDataSource(DataSource dataSource)

getSchemaManager

public SchemaManager getSchemaManager()

setSchemaManager

public AbstractEngineConfiguration setSchemaManager(SchemaManager schemaManager)

getCommonSchemaManager

public SchemaManager getCommonSchemaManager()

setCommonSchemaManager

public AbstractEngineConfiguration setCommonSchemaManager(SchemaManager commonSchemaManager)

getSchemaManagementCmd

public Command<Void> getSchemaManagementCmd()

setSchemaManagementCmd

public AbstractEngineConfiguration setSchemaManagementCmd(Command<Void> schemaManagementCmd)

getJdbcDriver
```
public String getJdbcDriver()
```

setJdbcDriver

public AbstractEngineConfiguration setJdbcDriver(String jdbcDriver)

getJdbcUrl
```
public String getJdbcUrl()
```

setJdbcUrl

public AbstractEngineConfiguration setJdbcUrl(String jdbcUrl)

getJdbcUsername
```
public String getJdbcUsername()
```

setJdbcUsername

public AbstractEngineConfiguration setJdbcUsername(String jdbcUsername)

getJdbcPassword
```
public String getJdbcPassword()
```

setJdbcPassword

public AbstractEngineConfiguration setJdbcPassword(String jdbcPassword)

getJdbcMaxActiveConnections

public int getJdbcMaxActiveConnections()

setJdbcMaxActiveConnections

public AbstractEngineConfiguration setJdbcMaxActiveConnections(int jdbcMaxActiveConnections)

getJdbcMaxIdleConnections

public int getJdbcMaxIdleConnections()

setJdbcMaxIdleConnections

public AbstractEngineConfiguration setJdbcMaxIdleConnections(int jdbcMaxIdleConnections)

getJdbcMaxCheckoutTime
```
public int getJdbcMaxCheckoutTime()
```

setJdbcMaxCheckoutTime

public AbstractEngineConfiguration setJdbcMaxCheckoutTime(int jdbcMaxCheckoutTime)

getJdbcMaxWaitTime
```
public int getJdbcMaxWaitTime()
```

setJdbcMaxWaitTime

public AbstractEngineConfiguration setJdbcMaxWaitTime(int jdbcMaxWaitTime)

isJdbcPingEnabled
```
public boolean isJdbcPingEnabled()
```

setJdbcPingEnabled

public AbstractEngineConfiguration setJdbcPingEnabled(boolean jdbcPingEnabled)

getJdbcPingConnectionNotUsedFor

public int getJdbcPingConnectionNotUsedFor()

setJdbcPingConnectionNotUsedFor

public AbstractEngineConfiguration setJdbcPingConnectionNotUsedFor(int jdbcPingConnectionNotUsedFor)

getJdbcDefaultTransactionIsolationLevel

public int getJdbcDefaultTransactionIsolationLevel()

setJdbcDefaultTransactionIsolationLevel

public AbstractEngineConfiguration setJdbcDefaultTransactionIsolationLevel(int jdbcDefaultTransactionIsolationLevel)

getJdbcPingQuery
```
public String getJdbcPingQuery()
```

setJdbcPingQuery

public AbstractEngineConfiguration setJdbcPingQuery(String jdbcPingQuery)

getDataSourceJndiName
```
public String getDataSourceJndiName()
```

setDataSourceJndiName

public AbstractEngineConfiguration setDataSourceJndiName(String dataSourceJndiName)

getSchemaCommandConfig

public CommandConfig getSchemaCommandConfig()

setSchemaCommandConfig

public AbstractEngineConfiguration setSchemaCommandConfig(CommandConfig schemaCommandConfig)

isTransactionsExternallyManaged

public boolean isTransactionsExternallyManaged()

setTransactionsExternallyManaged

public AbstractEngineConfiguration setTransactionsExternallyManaged(boolean transactionsExternallyManaged)

getBeans
```
public Map<Object,Object> getBeans()
```

setBeans

public AbstractEngineConfiguration setBeans(Map<Object,Object> beans)

getIdGenerator
```
public IdGenerator getIdGenerator()
```

setIdGenerator

public AbstractEngineConfiguration setIdGenerator(IdGenerator idGenerator)

isUsePrefixId
```
public boolean isUsePrefixId()
```

setUsePrefixId

public AbstractEngineConfiguration setUsePrefixId(boolean usePrefixId)

getXmlEncoding
```
public String getXmlEncoding()
```

setXmlEncoding

public AbstractEngineConfiguration setXmlEncoding(String xmlEncoding)

getDefaultCommandConfig

public CommandConfig getDefaultCommandConfig()

setDefaultCommandConfig

public AbstractEngineConfiguration setDefaultCommandConfig(CommandConfig defaultCommandConfig)

getCommandExecutor

public CommandExecutor getCommandExecutor()

setCommandExecutor

public AbstractEngineConfiguration setCommandExecutor(CommandExecutor commandExecutor)

getCommandContextFactory

public CommandContextFactory getCommandContextFactory()

setCommandContextFactory

public AbstractEngineConfiguration setCommandContextFactory(CommandContextFactory commandContextFactory)

getCommandInvoker

public CommandInterceptor getCommandInvoker()

setCommandInvoker

public AbstractEngineConfiguration setCommandInvoker(CommandInterceptor commandInvoker)

getCustomPreCommandInterceptors

public List<CommandInterceptor> getCustomPreCommandInterceptors()

setCustomPreCommandInterceptors

public AbstractEngineConfiguration setCustomPreCommandInterceptors(List<CommandInterceptor> customPreCommandInterceptors)

getCustomPostCommandInterceptors

public List<CommandInterceptor> getCustomPostCommandInterceptors()

setCustomPostCommandInterceptors

public AbstractEngineConfiguration setCustomPostCommandInterceptors(List<CommandInterceptor> customPostCommandInterceptors)

getCommandInterceptors

public List<CommandInterceptor> getCommandInterceptors()

setCommandInterceptors

public AbstractEngineConfiguration setCommandInterceptors(List<CommandInterceptor> commandInterceptors)

getEngineConfigurations

public Map<String,AbstractEngineConfiguration> getEngineConfigurations()

setEngineConfigurations

public AbstractEngineConfiguration setEngineConfigurations(Map<String,AbstractEngineConfiguration> engineConfigurations)

addEngineConfiguration

public void addEngineConfiguration(String key,
                                   AbstractEngineConfiguration engineConfiguration)

getServiceConfigurations

public Map<String,AbstractServiceConfiguration> getServiceConfigurations()

setServiceConfigurations

public AbstractEngineConfiguration setServiceConfigurations(Map<String,AbstractServiceConfiguration> serviceConfigurations)

addServiceConfiguration

public void addServiceConfiguration(String key,
                                    AbstractServiceConfiguration serviceConfiguration)

setDefaultCommandInterceptors

public void setDefaultCommandInterceptors(Collection<? extends CommandInterceptor> defaultCommandInterceptors)

getSqlSessionFactory

public org.apache.ibatis.session.SqlSessionFactory getSqlSessionFactory()

setSqlSessionFactory

public AbstractEngineConfiguration setSqlSessionFactory(org.apache.ibatis.session.SqlSessionFactory sqlSessionFactory)

isDbHistoryUsed
```
public boolean isDbHistoryUsed()
```

setDbHistoryUsed

public AbstractEngineConfiguration setDbHistoryUsed(boolean isDbHistoryUsed)

getDbSqlSessionFactory

public DbSqlSessionFactory getDbSqlSessionFactory()

setDbSqlSessionFactory

public AbstractEngineConfiguration setDbSqlSessionFactory(DbSqlSessionFactory dbSqlSessionFactory)

getTransactionFactory

public org.apache.ibatis.transaction.TransactionFactory getTransactionFactory()

setTransactionFactory

public AbstractEngineConfiguration setTransactionFactory(org.apache.ibatis.transaction.TransactionFactory transactionFactory)

getTransactionContextFactory

public TransactionContextFactory getTransactionContextFactory()

setTransactionContextFactory

public AbstractEngineConfiguration setTransactionContextFactory(TransactionContextFactory transactionContextFactory)

getMaxNrOfStatementsInBulkInsert

public int getMaxNrOfStatementsInBulkInsert()

setMaxNrOfStatementsInBulkInsert

public AbstractEngineConfiguration setMaxNrOfStatementsInBulkInsert(int maxNrOfStatementsInBulkInsert)

isBulkInsertEnabled
```
public boolean isBulkInsertEnabled()
```

setBulkInsertEnabled

public AbstractEngineConfiguration setBulkInsertEnabled(boolean isBulkInsertEnabled)

getCustomMybatisMappers

public Set<Class<?>> getCustomMybatisMappers()

setCustomMybatisMappers

public AbstractEngineConfiguration setCustomMybatisMappers(Set<Class<?>> customMybatisMappers)

getCustomMybatisXMLMappers

public Set<String> getCustomMybatisXMLMappers()

setCustomMybatisXMLMappers

public AbstractEngineConfiguration setCustomMybatisXMLMappers(Set<String> customMybatisXMLMappers)

getDependentEngineMyBatisXmlMappers

public Set<String> getDependentEngineMyBatisXmlMappers()

setCustomMybatisInterceptors

public AbstractEngineConfiguration setCustomMybatisInterceptors(List<org.apache.ibatis.plugin.Interceptor> customMybatisInterceptors)

getCustomMybatisInterceptors

public List<org.apache.ibatis.plugin.Interceptor> getCustomMybatisInterceptors()

setDependentEngineMyBatisXmlMappers

public AbstractEngineConfiguration setDependentEngineMyBatisXmlMappers(Set<String> dependentEngineMyBatisXmlMappers)

getDependentEngineMybatisTypeAliasConfigs

public List<MybatisTypeAliasConfigurator> getDependentEngineMybatisTypeAliasConfigs()

setDependentEngineMybatisTypeAliasConfigs

public AbstractEngineConfiguration setDependentEngineMybatisTypeAliasConfigs(List<MybatisTypeAliasConfigurator> dependentEngineMybatisTypeAliasConfigs)

getDependentEngineMybatisTypeHandlerConfigs

public List<MybatisTypeHandlerConfigurator> getDependentEngineMybatisTypeHandlerConfigs()

setDependentEngineMybatisTypeHandlerConfigs

public AbstractEngineConfiguration setDependentEngineMybatisTypeHandlerConfigs(List<MybatisTypeHandlerConfigurator> dependentEngineMybatisTypeHandlerConfigs)

getCustomSessionFactories

public List<SessionFactory> getCustomSessionFactories()

addCustomSessionFactory

public AbstractEngineConfiguration addCustomSessionFactory(SessionFactory sessionFactory)

setCustomSessionFactories

public AbstractEngineConfiguration setCustomSessionFactories(List<SessionFactory> customSessionFactories)

isUsingRelationalDatabase

public boolean isUsingRelationalDatabase()

setUsingRelationalDatabase

public AbstractEngineConfiguration setUsingRelationalDatabase(boolean usingRelationalDatabase)

isUsingSchemaMgmt
```
public boolean isUsingSchemaMgmt()
```

setUsingSchemaMgmt

public AbstractEngineConfiguration setUsingSchemaMgmt(boolean usingSchema)

getDatabaseTablePrefix

public String getDatabaseTablePrefix()

setDatabaseTablePrefix

public AbstractEngineConfiguration setDatabaseTablePrefix(String databaseTablePrefix)

getDatabaseWildcardEscapeCharacter

public String getDatabaseWildcardEscapeCharacter()

setDatabaseWildcardEscapeCharacter

public AbstractEngineConfiguration setDatabaseWildcardEscapeCharacter(String databaseWildcardEscapeCharacter)

getDatabaseCatalog
```
public String getDatabaseCatalog()
```

setDatabaseCatalog

public AbstractEngineConfiguration setDatabaseCatalog(String databaseCatalog)

getDatabaseSchema
```
public String getDatabaseSchema()
```

setDatabaseSchema

public AbstractEngineConfiguration setDatabaseSchema(String databaseSchema)

isTablePrefixIsSchema

public boolean isTablePrefixIsSchema()

setTablePrefixIsSchema

public AbstractEngineConfiguration setTablePrefixIsSchema(boolean tablePrefixIsSchema)

isAlwaysLookupLatestDefinitionVersion

public boolean isAlwaysLookupLatestDefinitionVersion()

setAlwaysLookupLatestDefinitionVersion

public AbstractEngineConfiguration setAlwaysLookupLatestDefinitionVersion(boolean alwaysLookupLatestDefinitionVersion)

isFallbackToDefaultTenant

public boolean isFallbackToDefaultTenant()

setFallbackToDefaultTenant

public AbstractEngineConfiguration setFallbackToDefaultTenant(boolean fallbackToDefaultTenant)

getDefaultTenantValue
```
@Deprecated
public String getDefaultTenantValue()
```
Deprecated. use getDefaultTenantProvider() instead

Returns:

name of the default tenant

setDefaultTenantValue

public AbstractEngineConfiguration setDefaultTenantValue(String defaultTenantValue)

getDefaultTenantProvider

public DefaultTenantProvider getDefaultTenantProvider()

setDefaultTenantProvider

public AbstractEngineConfiguration setDefaultTenantProvider(DefaultTenantProvider defaultTenantProvider)

isEnableLogSqlExecutionTime

public boolean isEnableLogSqlExecutionTime()

setEnableLogSqlExecutionTime

public void setEnableLogSqlExecutionTime(boolean enableLogSqlExecutionTime)

getSessionFactories

public Map<Class<?>,SessionFactory> getSessionFactories()

setSessionFactories

public AbstractEngineConfiguration setSessionFactories(Map<Class<?>,SessionFactory> sessionFactories)

getDatabaseSchemaUpdate

public String getDatabaseSchemaUpdate()

setDatabaseSchemaUpdate

public AbstractEngineConfiguration setDatabaseSchemaUpdate(String databaseSchemaUpdate)

isEnableEventDispatcher

public boolean isEnableEventDispatcher()

setEnableEventDispatcher

public AbstractEngineConfiguration setEnableEventDispatcher(boolean enableEventDispatcher)

getEventDispatcher

public FlowableEventDispatcher getEventDispatcher()

setEventDispatcher

public AbstractEngineConfiguration setEventDispatcher(FlowableEventDispatcher eventDispatcher)

getEventListeners

public List<FlowableEventListener> getEventListeners()

setEventListeners

public AbstractEngineConfiguration setEventListeners(List<FlowableEventListener> eventListeners)

getTypedEventListeners

public Map<String,List<FlowableEventListener>> getTypedEventListeners()

setTypedEventListeners

public AbstractEngineConfiguration setTypedEventListeners(Map<String,List<FlowableEventListener>> typedEventListeners)

getAdditionalEventDispatchActions

public List<EventDispatchAction> getAdditionalEventDispatchActions()

setAdditionalEventDispatchActions

public AbstractEngineConfiguration setAdditionalEventDispatchActions(List<EventDispatchAction> additionalEventDispatchActions)

getClock
```
public Clock getClock()
```

setClock

public AbstractEngineConfiguration setClock(Clock clock)

getMaxLengthString
```
public int getMaxLengthString()
```

getMaxLengthStringVariableType

public int getMaxLengthStringVariableType()

setMaxLengthStringVariableType

public AbstractEngineConfiguration setMaxLengthStringVariableType(int maxLengthStringVariableType)

getDeployers

public List<EngineDeployer> getDeployers()

setDeployers

public AbstractEngineConfiguration setDeployers(List<EngineDeployer> deployers)

getCustomPreDeployers

public List<EngineDeployer> getCustomPreDeployers()

setCustomPreDeployers

public AbstractEngineConfiguration setCustomPreDeployers(List<EngineDeployer> customPreDeployers)

getCustomPostDeployers

public List<EngineDeployer> getCustomPostDeployers()

setCustomPostDeployers

public AbstractEngineConfiguration setCustomPostDeployers(List<EngineDeployer> customPostDeployers)

isEnableConfiguratorServiceLoader

public boolean isEnableConfiguratorServiceLoader()

setEnableConfiguratorServiceLoader

public AbstractEngineConfiguration setEnableConfiguratorServiceLoader(boolean enableConfiguratorServiceLoader)

getConfigurators

public List<EngineConfigurator> getConfigurators()

addConfigurator

public AbstractEngineConfiguration addConfigurator(EngineConfigurator configurator)

setConfigurators

public AbstractEngineConfiguration setConfigurators(List<EngineConfigurator> configurators)

getIdmEngineConfigurator

public EngineConfigurator getIdmEngineConfigurator()

setIdmEngineConfigurator

public AbstractEngineConfiguration setIdmEngineConfigurator(EngineConfigurator idmEngineConfigurator)

setForceCloseMybatisConnectionPool

public AbstractEngineConfiguration setForceCloseMybatisConnectionPool(boolean forceCloseMybatisConnectionPool)

isForceCloseMybatisConnectionPool

public boolean isForceCloseMybatisConnectionPool()

Class AbstractEngineConfiguration

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

NO_TENANT_ID

DB_SCHEMA_UPDATE_FALSE

DB_SCHEMA_UPDATE_CREATE

DB_SCHEMA_UPDATE_CREATE_DROP

DB_SCHEMA_UPDATE_DROP_CREATE

DB_SCHEMA_UPDATE_TRUE

forceCloseMybatisConnectionPool

databaseType

jdbcDriver

jdbcUrl

jdbcUsername

jdbcPassword

dataSourceJndiName

jdbcMaxActiveConnections

jdbcMaxIdleConnections

jdbcMaxCheckoutTime

jdbcMaxWaitTime

jdbcPingEnabled

jdbcPingQuery

jdbcPingConnectionNotUsedFor

jdbcDefaultTransactionIsolationLevel

dataSource

commonSchemaManager

schemaManager

schemaManagementCmd

databaseSchemaUpdate

xmlEncoding

commandExecutor

defaultCommandInterceptors

defaultCommandConfig

schemaCommandConfig

commandContextFactory

commandInvoker

customPreCommandInterceptors

customPostCommandInterceptors

commandInterceptors

engineConfigurations

serviceConfigurations

classLoader

useClassForNameClassLoading

isDbHistoryUsed

dbSqlSessionFactory

sqlSessionFactory

transactionFactory

transactionContextFactory

isBulkInsertEnabled

maxNrOfStatementsInBulkInsert

DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER

customMybatisMappers

customMybatisXMLMappers

customMybatisInterceptors

dependentEngineMyBatisXmlMappers

dependentEngineMybatisTypeAliasConfigs

dependentEngineMybatisTypeHandlerConfigs

customSessionFactories

sessionFactories

enableEventDispatcher

eventDispatcher

eventListeners

typedEventListeners

additionalEventDispatchActions

transactionsExternallyManaged

usingRelationalDatabase

usingSchemaMgmt

databaseTablePrefix

databaseWildcardEscapeCharacter

databaseCatalog

databaseSchema

tablePrefixIsSchema

alwaysLookupLatestDefinitionVersion

fallbackToDefaultTenant

defaultTenantProvider

enableLogSqlExecutionTime