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

📚 Паттерны проектирования в разработке на Android

В разработке под Android я активно использую три основные категории паттернов проектирования, которые помогают создавать поддерживаемый, тестируемый и масштабируемый код.

---

🏗️ Основные категории паттернов

1. Порождающие паттерны (Creational Patterns)

Эти паттерны абстрагируют процесс создания объектов, делая систему независимой от способа создания, композиции и представления объектов.

Singleton (Одиночка)

Гарантирует, что у класса есть только один экземпляр, и предоставляет глобальную точку доступа к нему. В Android часто используется для Application-классов, менеджеров (NetworkManager, DatabaseManager) и репозиториев.

object NetworkManager {
    private const val BASE_URL = "https://api.example.com"
    
    fun makeRequest(endpoint: String) {
        // Реализация сетевого запроса
    }
}

// Использование
NetworkManager.makeRequest("/users")

Builder (Строитель)

Отделяет конструирование сложного объекта от его представления. Полезен при создании объектов со многими необязательными параметрами.

data class User(
    val id: Int,
    val name: String,
    val email: String? = null,
    val age: Int? = null
) {
    class Builder(private val id: Int, private val name: String) {
        private var email: String? = null
        private var age: Int? = null
        
        fun setEmail(email: String) = apply { this.email = email }
        fun setAge(age: Int) = apply { this.age = age }
        
        fun build() = User(id, name, email, age)
    }
}

// Использование
val user = User.Builder(1, "Иван")
    .setEmail("ivan@example.com")
    .setAge(30)
    .build()

Factory Method (Фабричный метод)

Определяет интерфейс для создания объекта, но позволяет подклассам изменять тип создаваемых объектов.

interface Vehicle {
    fun drive()
}

class Car : Vehicle {
    override fun drive() { println("Еду на машине") }
}

class Bike : Vehicle {
    override fun drive() { println("Еду на велосипеде") }
}

class VehicleFactory {
    fun createVehicle(type: String): Vehicle {
        return when (type) {
            "car" -> Car()
            "bike" -> Bike()
            else -> throw IllegalArgumentException("Неизвестный тип")
        }
    }
}

2. Структурные паттерны (Structural Patterns)

Помогают организовать классы и объекты в более крупные структуры.

Adapter (Адаптер)

Преобразует интерфейс одного класса в интерфейс, ожидаемый клиентом. В Android часто используется с RecyclerView.Adapter.

class UserAdapter(private val users: List<User>) : RecyclerView.Adapter<UserAdapter.ViewHolder>() {
    
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_user, parent, false)
        return ViewHolder(view)
    }
    
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.bind(users[position])
    }
    
    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        fun bind(user: User) {
            // Привязка данных к View
        }
    }
}

Decorator (Декоратор)

Динамически добавляет объекту новые обязанности. В Android используется в библиотеках для работы с сетью и UI компонентах.

3. Поведенческие паттерны (Behavioral Patterns)

Определяют взаимодействие между объектами и распределение обязанностей.

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

Определяет зависимость "один-ко-многим" между объектами так, что при изменении состояния одного объекта все зависящие от него оповещаются. В Android реализован через LiveData, Flow, и RxJava.

class UserViewModel : ViewModel() {
    private val _userData = MutableLiveData<User>()
    val userData: LiveData<User> = _userData
    
    fun loadUser() {
        // Загрузка данных
        _userData.value = User(1, "Иван")
    }
}

// В Activity/Fragment
viewModel.userData.observe(this) { user ->
    // Обновление UI при изменении данных
}

ViewModel (паттерн представления)

Хотя это и Android Architecture Component, он следует паттерну Presentation Model. Отделяет логику представления от UI контроллеров.

---

🎯 Практическое применение в Android

MVVM (Model-View-ViewModel)

Современный архитектурный паттерн, который активно использует LiveData/StateFlow, ViewModel, и Data Binding.

Преимущества:

• Четкое разделение ответственности
• Легкость тестирования бизнес-логики
• Автоматическое управление жизненным циклом
• Снижение нагрузки на UI-поток

Repository Pattern

Абстрагирует источник данных, предоставляя единый интерфейс для доступа к данным из различных источников (БД, сеть, кэш).

class UserRepository(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) {
    suspend fun getUsers(): List<User> {
        val localUsers = localDataSource.getUsers()
        return if (localUsers.isNotEmpty()) {
            localUsers
        } else {
            val remoteUsers = remoteDataSource.getUsers()
            localDataSource.saveUsers(remoteUsers)
            remoteUsers
        }
    }
}

Dependency Injection (Внедрение зависимостей)

Хотя технически это не классический паттерн проектирования, в Android реализуется через Dagger/Hilt и следует принципам Inversion of Control.

Преимущества:

• Упрощение тестирования
• Повторное использование кода
• Улучшение читаемости
• Упрощение конфигурации

---

🚀 Рекомендации для Android-разработки

1. Используйте ViewModel + LiveData/Flow для управления UI-состоянием
2. Внедряйте зависимости через Hilt для удобного тестирования
3. Применяйте Repository для абстракции источников данных
4. Используйте адаптеры с RecyclerView для эффективной работы со списками
5. Рассмотрите Builder для создания сложных объектов (диалогов, уведомлений)

Правильный выбор паттернов зависит от конкретной задачи, масштаба приложения и требований к поддерживаемости. Важно не просто знать паттерны, но и понимать, когда их применение действительно оправдано, а когда усложнит архитектуру без необходимости.