FragmentManager и FragmentTransaction: полный разбор для собеседования

Почему этот вопрос задают на собеседовании

«Расскажите, как вы добавите фрагмент на экран» — после вопроса «что такое Fragment» интервьюер почти всегда копает глубже: в FragmentManager и FragmentTransaction. И здесь кандидаты, которые ещё вчера уверенно рассказывали про жизненный цикл, начинают плавать.

Формулировки бывают разные: «как работает addToBackStack», «чем commit отличается от commitNow», «что будет, если вызвать replace без back stack». По сути это один вопрос: понимаете ли вы, как FragmentManager применяет изменения к фрагментам.

Почему это важно для интервьюера? Потому что FragmentManager — сердце навигации на фрагментах. Любое приложение, которое использует фрагменты, на каком-то уровне использует FragmentManager: даже если вы работаете через Jetpack Navigation, он управляет фрагментами через FragmentManager за вас. Официальная документация прямо говорит: понимать, что это такое и как работает, — обязательно, даже если вы не трогаете его напрямую.

В этой статье разберём по полочкам:

• что такое FragmentManager и как его получить;
• как строятся транзакции: add, replace, remove;
• зачем нужен back stack и как он работает;
• чем commit отличается от commitNow и executePendingTransactions;
• типичные ошибки кандидатов, которые я вижу на собеседованиях.

FragmentManager: кто это и как его получить

FragmentManager — это класс, который отвечает за выполнение действий над фрагментами приложения: добавление, удаление, замена и работа с back stack. Он же управляет состоянием фрагментов и восстанавливает их после поворота экрана.

У каждого хоста — свой FragmentManager. Ключевой момент: FragmentManager не один на всё приложение. Иерархия выглядит так:

• supportFragmentManager — доступен в FragmentActivity и его наследниках (например, AppCompatActivity). Управляет фрагментами уровня Activity;
• childFragmentManager — доступен внутри фрагмента, управляет его дочерними фрагментами;
• parentFragmentManager — FragmentManager хоста, в котором живёт текущий фрагмент.

MainActivity.kt
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // FragmentManager уровня Activity
        val manager = supportFragmentManager
    }
}

ExampleFragment.kt
class ExampleFragment : Fragment() {

    private fun getManagers() {
        // Менеджер дочерних фрагментов этого фрагмента
        val childManager = childFragmentManager
        // Менеджер хоста, в котором живёт фрагмент
        val parentManager = parentFragmentManager
    }
}

FragmentManager также отвечает за поиск фрагментов. Часто используют findFragmentById и findFragmentByTag — например, чтобы получить уже созданный фрагмент для удаления или обновления. Возвращать фрагменты можно через generic-версии вроде findFragmentByTag<T>().

FragmentTransaction: add, replace, remove

FragmentManager не меняет фрагменты «напрямую». Вместо этого он создаёт транзакцию — FragmentTransaction, — в которую вы добавляете операции, а затем коммитите её. Транзакция — это атомарный набор изменений: можно добавить или заменить сразу несколько фрагментов, и все они применятся как одно целое.

Получают транзакцию через beginTransaction(), а завершают обязательным вызовом commit(). В Kotlin есть удобное расширение commit { } из модуля fragment-ktx, которое делает и то, и другое.

MainActivity.kt
supportFragmentManager.commit {
    setReorderingAllowed(true)
    replace<ExampleFragment>(R.id.fragment_container)
    addToBackStack("example")
}

Разберём операции, которые можно класть в транзакцию:

• add() — добавляет фрагмент в контейнер. Новый фрагмент переходит в состояние RESUMED. Официальная документация рекомендует, чтобы контейнером был FragmentContainerView, который является частью иерархии представлений.
• replace() — заменяет текущий фрагмент в контейнере на новый. Это фактически remove() старого и add() нового в один и тот же контейнер.
• remove() — удаляет фрагмент. Удалённый фрагмент переходит в состояние DESTROYED, если только транзакция не была добавлена в back stack (об этом ниже).
• hide() / show() — скрывают и показывают view фрагмента, не влияя на его жизненный цикл. Полезно для вкладок, где фрагменты должны сохранять состояние.
• detach() / attach() — уничтожают и заново создают view-иерархию фрагмента, не уничтожая сам фрагмент.

Ещё один нюанс, который стоит упомянуть: порядок операций внутри транзакции важен. Например, setCustomAnimations() применяет анимацию ко всем операциям, которые идут после неё. Поэтому анимации для разных фрагментов в одной транзакции настраивают отдельными вызовами в нужных местах.

Back stack: addToBackStack и popBackStack

По умолчанию изменения, сделанные в транзакции, не сохраняются в back stack. Вызвали replace — старый фрагмент уничтожился, и на кнопке «Назад» пользователь ничего не вернёт. Чтобы транзакцию можно было откатить, нужно явно вызвать addToBackStack().

MainActivity.kt
supportFragmentManager.commit {
    setReorderingAllowed(true)
    add<ExampleFragment>(R.id.fragment_container)
    // Транзакция попадает в back stack
    addToBackStack("example")
}

Как это работает:

• addToBackStack() кладёт всю транзакцию как единую запись — со всеми её операциями, даже если их несколько.
• Когда пользователь нажимает системную кнопку «Назад» или вызывается popBackStack(), верхняя запись снимается со стека, и все операции транзакции отменяются как одно атомарное действие.
• В addToBackStack() можно передать имя — тогда через popBackStack("name", ...) можно вернуться к конкретной транзакции, а не к самой верхней.

Есть и тонкость, о которой редко говорят: не стоит в одной транзакции смешивать операции, влияющие на back stack, и не влияющие. При pop откатится вся запись целиком — а неожиданные «необратимые» операции внутри неё останутся в истории непредсказуемо.

commit, commitNow и executePendingTransactions

Здесь кандидаты проваливаются чаще всего. Запомните главное:

commit() — асинхронный. Он не выполняет транзакцию немедленно. Транзакция будет запущена в главном потоке (UI-потоке) как только это станет возможным. Обычно это происходит достаточно быстро, но не синхронно с вызовом.

commitNow() — синхронный. Выполняет транзакцию немедленно, в момент вызова, в UI-потоке. Важный нюанс: commitNow() несовместим с addToBackStack() — такую транзакцию нельзя коммитить синхронно.

executePendingTransactions() — принудительно выполняет все отложенные commit()-транзакции, которые ещё не были применены. В отличие от commitNow(), совместим с addToBackStack().

MainActivity.kt
// Асинхронно: транзакция выполнится позже в UI-потоке
supportFragmentManager.commit {
    add<ExampleFragment>(R.id.fragment_container)
}

// Синхронно: выполнится прямо сейчас (нельзя с addToBackStack)
supportFragmentManager.beginTransaction()
    .add(ExampleFragment(), "tag")
    .commitNow()

// Выполнить все ожидающие commit() прямо сейчас
supportFragmentManager.executePendingTransactions()

Также стоит упомянуть setReorderingAllowed(true) — современные транзакции должны его вызывать. Этот флаг позволяет FragmentManager правильно выполнять транзакцию с back stack и анимациями, а также не прогонять промежуточные фрагменты через лишние состояния жизненного цикла, если несколько транзакций выполняются одновременно.

Типичные ошибки кандидатов

Я провожу технические собеседования и вижу одни и те же промахи снова и снова. Вот что чаще всего звучит в ответах.

• «Фрагменты добавляются через Fragment напрямую». Нет: все операции с фрагментами идут через FragmentManager и FragmentTransaction. Fragment сам по себе не может появиться на экране.
• «commit выполняется сразу». Нет: commit() асинхронный, выполняется в UI-потоке позже. Синхронный вариант — commitNow().
• «После replace старый фрагмент всегда уничтожается». Не всегда: если транзакция в back stack, он уходит в STOPPED и возвращается при pop.
• «Можно вызвать commitNow с addToBackStack». Нельзя — это несовместимо. Используйте commit() или executePendingTransactions().
• «Back stack добавляется сам собой». Нет: по умолчанию транзакции в back stack не попадают, нужен явный addToBackStack().
• Путают менеджеры: supportFragmentManager уровня Activity и childFragmentManager внутри фрагмента — это разные объекты.

Отдельно про практику: на собеседованиях я часто прошу «написать навигацию между двумя экранами на фрагментах». Сильный ответ — это commit { replace(...); setReorderingAllowed(true); addToBackStack(...) } с объяснением каждого вызова. Слабый — «ну, через replace в контейнер» без back stack и без понимания, что произойдёт с состоянием.

Если вы готовитесь к собеседованию, добавьте этот вопрос в свой чек-лист: на нём отсеивают много кандидатов уровня junior и младшего middle. А если хотите проверить, какие ещё пробелы у вас есть перед интервью, — ниже есть вариант это сделать.

Итоги

Соберём главное, что нужно сказать на собеседовании про FragmentManager и FragmentTransaction.

FragmentManager — единая точка управления фрагментами. Он добавляет, удаляет, заменяет фрагменты и ведёт back stack. У Activity свой менеджер (supportFragmentManager), у каждого фрагмента — свой для детей (childFragmentManager). Получить менеджер хоста можно через parentFragmentManager.

Транзакция — атомарный набор изменений. FragmentTransaction получают через beginTransaction(), собирают операции (add, replace, remove, show/hide, detach/attach) и завершают commit(). Без addToBackStack() изменения необратимы: удалённый фрагмент уничтожается. С back stack — откатывается нажатием «Назад» как одно целое.

commit() асинхронный, commitNow() синхронный. commitNow несовместим с addToBackStack, а executePendingTransactions() выполняет все отложенные коммиты и совместим с ним. Для большинства случаев хватает commit() — не усложняйте.

Если чувствуете, что путаетесь в подобных вопросах на собеседованиях — не нужно зубрить дальше в одиночку. Напишите в Telegram, разберём вашу ситуацию и составим план, что закрыть в первую очередь.