单Activity架构Android应用模块化及Fragment循环依赖处理咨询

Hey there, let's work through how to fix those dependency cycles and modularize your bottom-nav Android app—this is a classic issue when you start with a tightly coupled fragment setup, so I've got some practical steps to sort it out.

1. First, let's diagnose the core problem #

Right now, your fragments are directly referencing each other (e.g., ProductFragment creating a LoginFragment instance) and all relying on MainActivity's pushFragment method directly. This creates tight coupling and easy-to-hit circular dependencies (like ProductFragment → CartFragment → ProfileFragment → ProductFragment). The goal is to decouple these components so they don't need to know about each other's existence.

2. Introduce a Navigation Contract (the key to decoupling) #

Instead of letting fragments create each other directly, define an interface that acts as a "middleman" for navigation. This contract will be implemented by MainActivity, and all fragments will use it to request navigation—no direct fragment references needed.

Step 2.1: Create the Navigation Host Interface #

Put this in a shared core module (like :core:navigation) so all feature modules can depend on it:

// Core navigation contract
interface NavigationHost {
    // Navigate to a destination by tag, with optional arguments
    fun navigateTo(destinationTag: String, args: Bundle? = null)
}

// Define constant tags for each destination to avoid typos
object NavigationDestinations {
    const val PRODUCT = "product_fragment"
    const val LOGIN = "login_fragment"
    const val CART = "cart_fragment"
    const val PROFILE = "profile_fragment"
    const val SEARCH = "search_fragment"
}

Step 2.2: Update MainActivity to Implement the Contract #

MainActivity will handle the actual fragment creation and replacement using your existing pushFragment method:

class MainActivity : AppCompatActivity(), NavigationHost {
    private val fragmentFactory = FragmentFactory()

    override fun navigateTo(destinationTag: String, args: Bundle?) {
        val fragment = fragmentFactory.createFragment(destinationTag)
        args?.let { fragment.arguments = it }
        pushFragment(fragment)
    }

    // Your existing fragment replacement method
    fun pushFragment(fragment: Fragment) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragment_container, fragment)
            .addToBackStack(null)
            .commit()
    }
}

// Fragment factory to handle instantiation (keeps MainActivity clean)
class FragmentFactory {
    fun createFragment(tag: String): Fragment {
        return when(tag) {
            NavigationDestinations.PRODUCT -> ProductFragment()
            NavigationDestinations.LOGIN -> LoginFragment()
            NavigationDestinations.CART -> CartFragment()
            NavigationDestinations.PROFILE -> ProfileFragment()
            NavigationDestinations.SEARCH -> SearchFragment()
            else -> throw IllegalArgumentException("Unknown destination tag: $tag")
        }
    }
}

Step 2.3: Update Fragments to Use the Contract #

Each fragment will get a reference to NavigationHost in onAttach and use it for navigation instead of creating other fragments directly:

class ProductFragment : Fragment() {
    private lateinit var navigationHost: NavigationHost

    override fun onAttach(context: Context) {
        super.onAttach(context)
        // Cast context to NavigationHost (ensure MainActivity implements it!)
        navigationHost = context as NavigationHost
    }

    // Example: Navigate to CartFragment
    private fun openCart() {
        navigationHost.navigateTo(NavigationDestinations.CART)
    }

    // Example: Navigate to LoginFragment with arguments
    private fun openLogin() {
        val args = Bundle().apply {
            putString("USER_ID", currentUserId)
        }
        navigationHost.navigateTo(NavigationDestinations.LOGIN, args)
    }
}

3. Split Your App Into Feature Modules #

Now that we've decoupled navigation, we can split the app into independent feature modules to eliminate cross-module dependencies:

• :feature:products – Contains ProductFragment and product-related logic
• :feature:auth – Contains LoginFragment and authentication logic
• :feature:cart – Contains CartFragment and cart logic
• :feature:profile – Contains ProfileFragment and user profile logic
• :feature:search – Contains SearchFragment and search logic
• :core:navigation – Contains the NavigationHost interface, destination tags, and FragmentFactory

Each feature module only depends on :core:navigation—no feature module depends on another. This completely eliminates circular dependencies because fragments no longer reference each other directly.

4. Bonus: Use Jetpack Navigation (Optional but Highly Recommended) #

If you're open to refactoring your navigation logic further, Jetpack Navigation Component is designed to solve exactly these problems. It uses a navigation graph (XML) to define all destinations and actions, so fragments never need to reference each other:

Step 4.1: Define the Navigation Graph #

<!-- res/navigation/main_nav_graph.xml -->
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/main_nav_graph"
    app:startDestination="@id/productFragment">

    <fragment
        android:id="@+id/productFragment"
        android:name="com.example.products.ProductFragment" />
    <fragment
        android:id="@+id/loginFragment"
        android:name="com.example.auth.LoginFragment" />
    <fragment
        android:id="@+id/cartFragment"
        android:name="com.example.cart.CartFragment" />
    <fragment
        android:id="@+id/profileFragment"
        android:name="com.example.profile.ProfileFragment" />
    <fragment
        android:id="@+id/searchFragment"
        android:name="com.example.search.SearchFragment" />

    <!-- Define navigation actions -->
    <action
        android:id="@+id/action_product_to_cart"
        app:destination="@id/cartFragment" />
    <action
        android:id="@+id/action_product_to_login"
        app:destination="@id/loginFragment" />
</navigation>

Step 4.2: Navigate From Fragments #

No more references to other fragments—just use the NavController:

// In ProductFragment
private fun openCart() {
    findNavController().navigate(R.id.action_product_to_cart)
}

private fun openLogin() {
    val args = Bundle().apply {
        putString("USER_ID", currentUserId)
    }
    findNavController().navigate(R.id.action_product_to_login, args)
}

Jetpack Navigation handles fragment replacement, back stack management, and even bottom navigation integration out of the box—so you can ditch your custom pushFragment method entirely if you want.

Final Recap #

• Decouple navigation with a NavigationHost interface so fragments don't reference each other directly
• Split into feature modules to eliminate cross-module dependencies and circular references
• Use a factory or Jetpack Navigation to handle fragment instantiation and navigation logic
• Remove all direct fragment-to-fragment references—this is the root cause of your cycle issues

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