Зачем нужны паттерны проектирования?

# Зачем нужны паттерны проектирования?

Паттерны проектирования (Design Patterns) — это проверенные и переиспользуемые решения типичных проблем при разработке программного обеспечения. Это не код, а описание подхода к решению. За 10+ лет разработки я убедился, что знание паттернов кардинально повышает качество кода.

Основное назначение паттернов

1. Переиспользование знаний - не изобретать велосипед
2. Общий язык в команде - просто сказать "используй Singleton"
3. Лучший дизайн - решения от опытных разработчиков
4. Масштабируемость - код легче расширять
5. Maintainability - проще поддерживать и изменять

Самые важные паттерны в Java

1. Singleton

Гарантирует только один экземпляр класса на всё приложение.

// БЕЗ паттерна - проблема
public class DatabaseConnection {
    public DatabaseConnection() {
        // Каждый раз создаётся новое подключение
        // Это дорого и опасно
    }
}

// С паттерном - правильно
public class DatabaseConnection {
    private static DatabaseConnection instance;
    
    private DatabaseConnection() {
        // Приватный конструктор
    }
    
    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

// Использование
DatabaseConnection db1 = DatabaseConnection.getInstance();
DatabaseConnection db2 = DatabaseConnection.getInstance();
// db1 == db2 - тот же объект!

Когда использовать:

• Логирование
• Конфигурация приложения
• Пулы подключений к БД
• Cache

2. Factory

Отделяет создание объектов от их использования.

// БЕЗ паттерна - плотная связь
public class ReportGenerator {
    public void generateReport(String type) {
        if (type.equals("pdf")) {
            PdfReport report = new PdfReport();  // Зависит от PdfReport
            report.generate();
        } else if (type.equals("excel")) {
            ExcelReport report = new ExcelReport();  // Зависит от ExcelReport
            report.generate();
        }
    }
}

// С паттерном - свободная связь
public class ReportFactory {
    public static Report createReport(String type) {
        switch(type) {
            case "pdf":
                return new PdfReport();
            case "excel":
                return new ExcelReport();
            case "csv":
                return new CsvReport();
            default:
                throw new IllegalArgumentException("Unknown type: " + type);
        }
    }
}

public class ReportGenerator {
    public void generateReport(String type) {
        Report report = ReportFactory.createReport(type);
        report.generate();  // Не зависит от конкретной реализации
    }
}

Когда использовать:

• Создание объектов по типам
• Когда тип известен в runtime
• Spring внедрение зависимостей

3. Observer

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

// Интерфейс наблюдателя
public interface EventListener {
    void update(Event event);
}

// Конкретный наблюдатель
public class EmailNotification implements EventListener {
    @Override
    public void update(Event event) {
        System.out.println("Отправить email: " + event.getMessage());
    }
}

// Издатель события
public class Order {
    private List<EventListener> listeners = new ArrayList<>();
    
    public void subscribe(EventListener listener) {
        listeners.add(listener);
    }
    
    public void checkout() {
        // ... логика оформления заказа
        notifyListeners(new Event("Order confirmed"));
    }
    
    private void notifyListeners(Event event) {
        for (EventListener listener : listeners) {
            listener.update(event);
        }
    }
}

// Использование
Order order = new Order();
order.subscribe(new EmailNotification());
order.subscribe(new SmsNotification());
order.checkout();  // Уведомления отправятся автоматически

Когда использовать:

• Event-driven архитектура
• Уведомления
• Реактивное программирование
• MVC - модель уведомляет представление

4. Strategy

Делает алгоритмы interchangeable.

// БЕЗ паттерна - большая функция
public class PaymentProcessor {
    public void pay(PaymentMethod method, BigDecimal amount) {
        if (method == PaymentMethod.CREDIT_CARD) {
            // Логика для карты
        } else if (method == PaymentMethod.BANK_TRANSFER) {
            // Логика для банка
        } else if (method == PaymentMethod.CRYPTO) {
            // Логика для крипто
        }
    }
}

// С паттерном - подменяемые стратегии
public interface PaymentStrategy {
    void pay(BigDecimal amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Платёж по кредитной карте: " + amount);
    }
}

public class BankTransferPayment implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Банковский перевод: " + amount);
    }
}

public class PaymentProcessor {
    private PaymentStrategy strategy;
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void pay(BigDecimal amount) {
        strategy.pay(amount);
    }
}

// Использование
PaymentProcessor processor = new PaymentProcessor();
processor.setStrategy(new CreditCardPayment());
processor.pay(BigDecimal.valueOf(100));  // Платёж по карте

processor.setStrategy(new BankTransferPayment());
processor.pay(BigDecimal.valueOf(500));  // Банковский перевод

Когда использовать:

• Несколько способов выполнить операцию
• Алгоритмы меняются в runtime
• Сортировка, фильтрация, сжатие данных

5. Decorator

Добавляет функциональность к объекту динамически.

// Базовый интерфейс
public interface Coffee {
    double getCost();
    String getDescription();
}

public class SimpleCoffee implements Coffee {
    @Override
    public double getCost() {
        return 5.0;
    }
    
    @Override
    public String getDescription() {
        return "Simple Coffee";
    }
}

// Декоратор для добавления молока
public class MilkDecorator implements Coffee {
    private Coffee coffee;
    
    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
    
    @Override
    public double getCost() {
        return coffee.getCost() + 1.0;  // Молоко добавляет стоимость
    }
    
    @Override
    public String getDescription() {
        return coffee.getDescription() + ", with milk";
    }
}

// Декоратор для сахара
public class SugarDecorator implements Coffee {
    private Coffee coffee;
    
    public SugarDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
    
    @Override
    public double getCost() {
        return coffee.getCost() + 0.5;
    }
    
    @Override
    public String getDescription() {
        return coffee.getDescription() + ", with sugar";
    }
}

// Использование
Coffee coffee = new SimpleCoffee();  // Базовый кофе
coffee = new MilkDecorator(coffee);  // Добавили молоко
coffee = new SugarDecorator(coffee);  // Добавили сахар

System.out.println(coffee.getDescription());  // "Simple Coffee, with milk, with sugar"
System.out.println(coffee.getCost());  // 6.5

Когда использовать:

• Добавление функциональности в runtime
• Альтернатива наследованию
• Декоратор вместо сложной иерархии классов

6. Adapter

Делает несовместимые интерфейсы совместимыми.

// Старый интерфейс
public interface OldPaymentGateway {
    void processPayment(String accountNumber, double amount);
}

// Новый интерфейс
public interface NewPaymentGateway {
    void pay(PaymentRequest request);
}

// Адаптер
public class PaymentAdapter implements NewPaymentGateway {
    private OldPaymentGateway oldGateway;
    
    public PaymentAdapter(OldPaymentGateway oldGateway) {
        this.oldGateway = oldGateway;
    }
    
    @Override
    public void pay(PaymentRequest request) {
        // Приводим новый формат к старому
        oldGateway.processPayment(
            request.getAccountNumber(),
            request.getAmount()
        );
    }
}

Когда использовать:

• Работа с legacy кодом
• Интеграция сторонних библиотек
• Миграция между API версиями

Классификация паттернов

Порождающие (Creational) - создание объектов

• Singleton - один экземпляр
• Factory - создание по типам
• Builder - пошаговое создание
• Prototype - копирование объектов
• Abstract Factory - семейства объектов

Структурные (Structural) - отношения между объектами

• Adapter - совместимость интерфейсов
• Decorator - добавление функциональности
• Facade - упрощение сложной системы
• Proxy - контролируемый доступ
• Bridge - разделение абстракции и реализации

Поведенческие (Behavioral) - взаимодействие объектов

• Observer - подписка на события
• Strategy - подменяемые алгоритмы
• Command - инкапсуляция команд
• Template Method - шаблон алгоритма
• State - поведение зависит от состояния

Почему паттерны важны?

1. Экономия времени

Без паттернов:
Думать о дизайне → Пробовать варианты → Находить проблемы → Переделывать

С паттернами:
Выбрать паттерн → Применить → Готово

2. Меньше ошибок

Паттерны проверены тысячами разработчиков. Они знают проблемы и решения.

3. Лучше коммуникация

// Плохо
"У нас есть класс который создаёт объекты по типам"

// Хорошо
"Мы используем Factory Pattern"

Реальные примеры в Java

// Singleton
SpringApplication.getInstance();
Runtime.getRuntime();
ThreadLocal.get();

// Factory
List<String> list = Arrays.asList(...);  // Factory method
getConnection();  // Connection factory

// Observer
Button.addActionListener(listener);  // Observer pattern
Observable.subscribe(observer);

// Strategy
Collections.sort(list, comparator);  // Strategy
ExecutorService.submit(task);  // Strategy

// Decorator
BufferedInputStream stream = new BufferedInputStream(fileInputStream);
compressedStream = new GZIPInputStream(bufferedStream);

Когда НЕ использовать паттерны?

❌ Over-engineering - не усложняй просто код ❌ YAGNI - не используй паттерн "на будущее" ❌ Не все ситуации требуют паттерны

Лучшие практики

1. Выучи основные паттерны - Singleton, Factory, Observer, Strategy, Decorator
2. Понимай проблему прежде всего - паттерн должен её решать
3. Начни просто - добавляй complexity только когда нужна
4. Читай чужой код - видишь паттерн в production коде? Изучи
5. Не переусложняй - простое решение лучше сложного паттерна

Заключение

Паттерны проектирования нужны для:

• Решения типичных проблем проверенными способами
• Повышения качества и гибкости кода
• Улучшения коммуникации в команде
• Уменьшения времени на разработку
• Облегчения поддержки и расширения кода

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