Bootstrap and Configuration

/**
 * Main bootstrap class for MyBatis-Flex framework initialization
 */
public class MybatisFlexBootstrap {
    /**
     * Get singleton instance of the bootstrap
     * @return MybatisFlexBootstrap instance
     */
    public static MybatisFlexBootstrap getInstance();
    
    /**
     * Set the primary datasource
     * @param dataSource DataSource instance
     * @return bootstrap instance for chaining
     */
    public MybatisFlexBootstrap setDataSource(DataSource dataSource);
    
    /**
     * Add named datasource for multi-datasource scenarios
     * @param key datasource key/name
     * @param dataSource DataSource instance
     * @return bootstrap instance for chaining
     */
    public MybatisFlexBootstrap addDataSource(String key, DataSource dataSource);
    
    /**
     * Register mapper class
     * @param mapperClass mapper interface class
     * @return bootstrap instance for chaining
     */
    public MybatisFlexBootstrap addMapper(Class<?> mapperClass);
    
    /**
     * Start the MyBatis-Flex framework
     * @return bootstrap instance
     */
    public MybatisFlexBootstrap start();
    
    /**
     * Get mapper instance by class
     * @param mapperClass mapper interface class
     * @return mapper instance
     */
    public <T> T getMapper(Class<T> mapperClass);
    
    /**
     * Get MyBatis Configuration object
     * @return Configuration instance
     */
    public Configuration getConfiguration();
}

import com.mybatisflex.core.MybatisFlexBootstrap;
import com.zaxxer.hikari.HikariDataSource;

// Create datasource
HikariDataSource dataSource = new HikariDataSource();
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/testdb");
dataSource.setUsername("root");
dataSource.setPassword("password");

// Initialize MyBatis-Flex
MybatisFlexBootstrap bootstrap = MybatisFlexBootstrap.getInstance()
    .setDataSource(dataSource)
    .addMapper(UserMapper.class)
    .addMapper(OrderMapper.class)
    .start();

// Get mapper instances
UserMapper userMapper = bootstrap.getMapper(UserMapper.class);
OrderMapper orderMapper = bootstrap.getMapper(OrderMapper.class);

// Multiple datasources
MybatisFlexBootstrap.getInstance()
    .setDataSource(primaryDataSource)           // Primary datasource
    .addDataSource("read", readOnlyDataSource)  // Read-only replica
    .addDataSource("analytics", analyticsDataSource) // Analytics DB
    .addMapper(UserMapper.class)
    .start();

/**
 * Global configuration for MyBatis-Flex framework
 */
public class FlexGlobalConfig {
    /**
     * Get default global configuration
     * @return default FlexGlobalConfig instance
     */
    public static FlexGlobalConfig getDefaultConfig();
    
    /**
     * Set configuration for specific environment
     * @param configId configuration identifier
     * @param config FlexGlobalConfig instance
     * @param isDefault whether this is the default config
     */
    public static void setConfig(String configId, FlexGlobalConfig config, boolean isDefault);
    
    /**
     * Get database type
     * @return DbType enum value
     */
    public DbType getDbType();
    
    /**
     * Set database type for SQL dialect
     * @param dbType database type
     */
    public void setDbType(DbType dbType);
    
    /**
     * Get key generation configuration
     * @return KeyConfig instance
     */
    public KeyConfig getKeyConfig();
    
    /**
     * Set key generation configuration
     * @param keyConfig key generation settings
     */
    public void setKeyConfig(KeyConfig keyConfig);
    
    /**
     * Get entity listeners configuration
     * @return entity listeners
     */
    public EntityListeners getEntityListeners();
    
    /**
     * Set entity listeners for lifecycle events
     * @param entityListeners listeners configuration
     */
    public void setEntityListeners(EntityListeners entityListeners);
    
    /**
     * Check if optimistic locking is enabled
     * @return true if enabled
     */
    public boolean isOptimisticLockEnabled();
    
    /**
     * Enable or disable optimistic locking
     * @param enabled enable flag
     */
    public void setOptimisticLockEnabled(boolean enabled);
}

import com.mybatisflex.core.FlexGlobalConfig;
import com.mybatisflex.core.dialect.DbType;
import com.mybatisflex.core.keygen.KeyGenerators;

// Create custom configuration
FlexGlobalConfig config = new FlexGlobalConfig();
config.setDbType(DbType.MYSQL);

// Configure key generation
config.getKeyConfig().setKeyGenerator(KeyGenerators.snowFlakeId);

// Set as default configuration
FlexGlobalConfig.setConfig("default", config, true);

/**
 * Key generation configuration
 */
public static class KeyConfig {
    /**
     * Get key generator
     * @return IKeyGenerator instance
     */
    public IKeyGenerator getKeyGenerator();
    
    /**
     * Set key generator strategy
     * @param keyGenerator key generator implementation
     */
    public void setKeyGenerator(IKeyGenerator keyGenerator);
    
    /**
     * Check if key generation before insert is enabled
     * @return true if enabled
     */
    public boolean isKeyGeneratorBefore();
    
    /**
     * Set whether to generate keys before insert
     * @param keyGeneratorBefore enable flag
     */
    public void setKeyGeneratorBefore(boolean keyGeneratorBefore);
}

/**
 * Entity lifecycle listeners
 */
public static class EntityListeners {
    /**
     * Get insert listener
     * @return InsertListener instance
     */
    public InsertListener getInsertListener();
    
    /**
     * Set insert listener for before/after insert events
     * @param insertListener listener implementation
     */
    public void setInsertListener(InsertListener insertListener);
    
    /**
     * Get update listener
     * @return UpdateListener instance
     */
    public UpdateListener getUpdateListener();
    
    /**
     * Set update listener for before/after update events
     * @param updateListener listener implementation
     */
    public void setUpdateListener(UpdateListener updateListener);
    
    /**
     * Get set listener
     * @return SetListener instance
     */
    public SetListener getSetListener();
    
    /**
     * Set field value listener
     * @param setListener listener implementation
     */
    public void setSetListener(SetListener setListener);
}

// Listener interfaces
public interface InsertListener {
    void onInsert(Object entity);
}

public interface UpdateListener {
    void onUpdate(Object entity);
}

public interface SetListener {
    Object onSet(Object entity, String property, Object value);
}

// Key generation
public interface IKeyGenerator {
    Object generate(Object entity, String keyProperty);
}