Какие знаешь поведенческие паттерны проектирования?

Поведенческие паттерны проектирования

Поведенческие паттерны — это категория шаблонов проектирования, которые решают задачи эффективного взаимодействия и распределения ответственности между объектами. Они фокусируются на алгоритмах и механизмах делегирования, упрощая коммуникацию в сложных системах. В контексте разработки под Android эти паттерны особенно важны для создания гибкого, поддерживаемого и тестируемого кода. Вот ключевые поведенческие паттерны, которые я активно использую:

1. Observer (Наблюдатель)

Паттерн Observer определяет зависимость "один-ко-многим" между объектами, так что при изменении состояния одного объекта все зависящие от него объекты уведомляются автоматически. В Android он повсеместно используется через механизмы LiveData, Flow в Kotlin или интерфейсы обратных вызовов.

// Пример с LiveData в ViewModel
class UserViewModel : ViewModel() {
    private val _userData = MutableLiveData<User>()
    val userData: LiveData<User> = _userData

    fun updateUser(user: User) {
        _userData.value = user // Изменение состояния уведомляет наблюдателей
    }
}

// Наблюдение в Activity или Fragment
viewModel.userData.observe(this) { user ->
    updateUI(user) // Реакция на изменение данных
}

2. Strategy (Стратегия)

Паттерн Strategy позволяет инкапсулировать семейство алгоритмов и делать их взаимозаменяемыми. Это упрощает добавление новых вариантов поведения без модификации существующего кода. В Android он полезен для реализации различных стратегий сортировки, валидации или сетевых запросов.

interface DiscountStrategy {
    fun applyDiscount(price: Double): Double
}

class RegularDiscount : DiscountStrategy {
    override fun applyDiscount(price: Double) = price * 0.9
}

class PremiumDiscount : DiscountStrategy {
    override fun applyDiscount(price: Double) = price * 0.7
}

class ShoppingCart(private var strategy: DiscountStrategy) {
    fun calculateTotal(price: Double): Double {
        return strategy.applyDiscount(price)
    }
    
    fun setStrategy(newStrategy: DiscountStrategy) {
        strategy = newStrategy // Динамическая смена стратегии
    }
}

3. Command (Команда)

Паттерн Command инкапсулирует запрос как объект, позволяя параметризовать клиентов с различными запросами, ставить их в очередь или поддерживать отмену операций. В Android он применяется в обработчиках действий, таких как Undo/Redo или обработка жестов.

interface Command {
    fun execute()
    fun undo()
}

class AddTextCommand(private val document: Document, private val text: String) : Command {
    private var previousState: String = ""
    
    override fun execute() {
        previousState = document.content
        document.addText(text)
    }
    
    override fun undo() {
        document.content = previousState
    }
}

// Использование
val commandHistory = mutableListOf<Command>()
val addCommand = AddTextCommand(document, "Hello")
addCommand.execute()
commandHistory.add(addCommand) // Возможность отмены

4. State (Состояние)

Паттерн State позволяет объекту изменять свое поведение при изменении внутреннего состояния, создавая иллюзию изменения класса объекта. В Android он эффективен для управления жизненным циклом UI-компонентов, например, состояния загрузки данных.

sealed class DownloadState {
    object Idle : DownloadState()
    data class InProgress(val progress: Int) : DownloadState()
    data class Completed(val file: File) : DownloadState()
    data class Error(val exception: Throwable) : DownloadState()
}

class DownloadManager {
    private var state: DownloadState = DownloadState.Idle
    
    fun setState(newState: DownloadState) {
        state = newState
        updateUI() // Реакция на изменение состояния
    }
}

5. Chain of Responsibility (Цепочка обязанностей)

Паттерн Chain of Responsibility позволяет передавать запрос по цепочке обработчиков, пока один из них не обработает его. В Android он используется в обработке событий касания (View hierarchy) или в middleware для сетевых запросов (например, с OkHttp Interceptors).

abstract class Handler {
    private var next: Handler? = null
    
    fun setNext(handler: Handler): Handler {
        next = handler
        return handler
    }
    
    fun handle(request: String): Boolean {
        return if (canHandle(request)) {
            process(request)
            true
        } else {
            next?.handle(request) ?: false
        }
    }
    
    abstract fun canHandle(request: String): Boolean
    abstract fun process(request: String)
}

6. Template Method (Шаблонный метод)

Паттерн Template Method определяет скелет алгоритма в базовом классе, позволяя подклассам переопределять определенные шаги без изменения структуры алгоритма. В Android он часто применяется в Activity и Fragment жизненных циклах, где фреймворк предоставляет "заготовленные" методы вроде onCreate().

abstract class DataProcessor {
    fun process() {
        loadData()
        transformData()
        saveData()
    }
    
    abstract fun loadData()
    abstract fun transformData()
    
    open fun saveData() {
        // Базовая реализация, может быть переопределена
    }
}

Практическая ценность в Android-разработке

Использование поведенческих паттернов в Android проектах позволяет:

• Уменьшить связанность между компонентами, что критично для тестирования и поддержки.
• Повысить гибкость кода через инкапсуляцию изменяющегося поведения (как в Strategy).
• Упростить обработку событий и асинхронных операций с помощью Observer и Command.
• Управлять сложными состояниями UI, особенно в сочетании с архитектурными подходами (MVVM, MVI).

Например, в современном Android-стеке с Kotlin Coroutines и Jetpack Compose, паттерны вроде Observer (через StateFlow) и State становятся фундаментальными для реактивного UI. Важно выбирать паттерны обдуманно, избегая избыточного усложнения, и сочетать их с принципами SOLID для создания масштабируемых приложений.