Android/Koin：如何将功能模块的数据模块动态加载逻辑移出Activity？

Great question—this is a common pain point when trying to stick to Clean Architecture principles while using dynamic dependency injection with Koin. The goal is to keep your feature Activities focused solely on UI interaction, not on managing data layer details. Here are three practical approaches tailored to your dynamic feature module setup:

1. Feature-Specific Module Coordinator (Simplest First Step) #

Create a dedicated coordinator class within your feature's ui module to encapsulate all Koin module loading/unloading logic. This way, your Activity only interacts with the coordinator, never directly referencing data modules.

Step 1: Implement the Coordinator in feature_a_ui #

// feature_a_ui/src/main/kotlin/com/yourcompany/featurea/ui/FeatureAModuleCoordinator.kt
class FeatureAModuleCoordinator {
    // Encapsulate the modules this feature needs (including cross-feature data modules)
    private val requiredModules = listOf(featureAModule, featureBDataModule)

    fun loadDependencies() {
        loadKoinModules(requiredModules)
    }

    fun unloadDependencies() {
        unloadKoinModules(requiredModules)
    }
}

Step 2: Register the Coordinator in the Feature's UI Koin Module #

// feature_a_ui/src/main/kotlin/com/yourcompany/featurea/ui/FeatureAUIModule.kt
val featureAUIModule = module {
    single { FeatureAModuleCoordinator() } // Register the coordinator
    viewModel { FeatureAViewModel(get()) } // Your existing view model binding
}

Step 3: Use the Coordinator in Your Activity #

class FeatureAActivity: AppCompatActivity() {
    val model: FeatureAViewModel by viewModel()
    private val moduleCoordinator: FeatureAModuleCoordinator by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_feature_a)
        moduleCoordinator.loadDependencies() // No direct data module references!
    }

    override fun onDestroy() {
        super.onDestroy()
        moduleCoordinator.unloadDependencies()
    }
}

Why this works: The Activity now only knows about the coordinator (a UI-layer infrastructure component), not the underlying data modules. This adheres to Clean Architecture's dependency rule—UI depends on domain and its own utilities, never directly on data.

2. Abstract Feature Bootstrapper (For Maximum Flexibility) #

Define an abstract interface for feature bootstrapping, then implement it per feature. This lets you swap out module loading logic later without touching Activity code, which is perfect for dynamic feature delivery.

Step 1: Define the Bootstrapper Interface (in ui layer) #

// feature_a_ui/src/main/kotlin/com/yourcompany/featurea/ui/FeatureBootstrapper.kt
interface FeatureBootstrapper {
    fun initializeDependencies()
    fun cleanUpDependencies()
}

Step 2: Implement the Bootstrapper for Feature A #

class FeatureABootstrapper : FeatureBootstrapper {
    private val requiredModules = listOf(featureAModule, featureBDataModule)

    override fun initializeDependencies() = loadKoinModules(requiredModules)
    override fun cleanUpDependencies() = unloadKoinModules(requiredModules)
}

Step 3: Register and Use in Activity #

Same as the coordinator approach—register the bootstrapper in your UI Koin module, then inject and call its methods in the Activity. The key difference is the abstraction: if you later need to add custom logic (like preloading data or logging), you can modify the bootstrapper implementation without changing the Activity.

3. Koin Scope Binding (Automatic Lifecycle Management) #

Koin's built-in scopes let you bind modules directly to your Activity's lifecycle, eliminating manual load/unload calls entirely. This is the most idiomatic Koin solution and keeps your Activity code extremely clean.

Step 1: Define a Feature Scope in feature_a_ui #

// feature_a_ui/src/main/kotlin/com/yourcompany/featurea/ui/FeatureAUIKoinModule.kt
// Bind modules to the FeatureAActivity scope
val featureAScope = scope<FeatureAActivity> {
    modules(featureAModule, featureBDataModule)
}

// Keep your UI module for view models etc.
val featureAUIModule = module {
    viewModel { FeatureAViewModel(get()) }
}

Step 2: Use the Scope in Your Activity #

class FeatureAActivity: AppCompatActivity() {
    // Create or retrieve the scope tied to this Activity
    private val featureScope = getOrCreateScope<FeatureAActivity>()
    // Inject the view model using the feature scope
    val model: FeatureAViewModel by viewModel(scope = featureScope)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_feature_a)
        // No manual module loading needed—Koin handles it when the scope is created
    }

    override fun onDestroy() {
        super.onDestroy()
        featureScope.close() // Automatically unloads all bound modules
    }
}

Why this works: Koin scopes automatically manage module lifecycle. When the Activity is destroyed and the scope closes, Koin unloads all modules bound to that scope. Your Activity never references data modules directly, fully complying with Clean Architecture.

Key Notes for Dynamic Feature Delivery #

• Since each feature's module loading logic is contained within its own ui module, you don't need to hardcode anything in the app module. Dynamic features can be delivered independently, and their bootstrapping/coordinator logic travels with them.
• Cross-feature domain dependencies (like feature_b using feature_a_domain) are still allowed—this follows Clean Architecture's dependency rule (domain layers are independent, and higher-level features can depend on lower-level domains).

内容的提问来源于stack exchange，提问作者starlight