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

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

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

Основные причины использования

1. Решение известных проблем

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

// Проблема: нужно создать один объект на всё приложение
// Решение: паттерн Singleton

public class Logger {
    private static Logger instance;
    
    private Logger() {}
    
    public static synchronized Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
    
    public void log(String message) {
        System.out.println(message);
    }
}

// Использование
Logger logger = Logger.getInstance();
logger.log("Application started");

2. Улучшение читаемости и поддерживаемости кода

Когда разработчики знают паттерны, они быстро понимают намерение кода:

// Observer паттерн — сразу видна структура
public interface Observer {
    void update(Event event);
}

public class EventSource {
    private List<Observer> observers = new ArrayList<>();
    
    public void subscribe(Observer observer) {
        observers.add(observer);
    }
    
    public void notifyObservers(Event event) {
        observers.forEach(o -> o.update(event));
    }
}

public class EmailNotifier implements Observer {
    @Override
    public void update(Event event) {
        sendEmail(event);
    }
}

public class LogNotifier implements Observer {
    @Override
    public void update(Event event) {
        logEvent(event);
    }
}

3. Облегчение расширения функциональности

Шаблоны помогают строить гибкую архитектуру:

// Strategy паттерн — легко добавлять новые стратегии

public interface PaymentStrategy {
    void pay(double amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying via credit card: " + amount);
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying via PayPal: " + amount);
    }
}

public class Order {
    private PaymentStrategy paymentStrategy;
    
    public Order(PaymentStrategy strategy) {
        this.paymentStrategy = strategy;
    }
    
    public void checkout(double amount) {
        paymentStrategy.pay(amount);
    }
}

// Использование
Order order = new Order(new CreditCardPayment());
order.checkout(100);

// Легко добавить новый способ оплаты
order = new Order(new PayPalPayment());
order.checkout(100);

4. Уменьшение связанности кода (Loose Coupling)

Паттерны помогают разделить ответственность:

// Без паттерна — жесткая связь
public class Report {
    private PDFGenerator pdf = new PDFGenerator();  // Зависимость жестко закодирована
    
    public void generate() {
        pdf.generate();
    }
}

// С Factory паттерном — гибкая система
public interface ReportGenerator {
    void generate();
}

public class ReportFactory {
    public static ReportGenerator create(String type) {
        switch(type) {
            case "PDF":
                return new PDFGenerator();
            case "Excel":
                return new ExcelGenerator();
            default:
                throw new IllegalArgumentException();
        }
    }
}

public class Report {
    private ReportGenerator generator;
    
    public Report(String type) {
        this.generator = ReportFactory.create(type);
    }
    
    public void generate() {
        generator.generate();
    }
}

5. Улучшение взаимодействия в команде

Паттерны — это общий язык для разработчиков:

Одна фраза вместо 100 строк объяснения:

— Используем Singleton для конфигурации
— Применим Factory паттерн для создания объектов
— Адаптер нужен для интеграции со старой системой

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

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

// Singleton
public class Config {
    private static Config instance;
    private Config() {}
    public static Config getInstance() {
        if (instance == null) instance = new Config();
        return instance;
    }
}

// Factory
public class DataSourceFactory {
    public static DataSource create(String dbType) {
        if ("MySQL".equals(dbType)) return new MySQLDataSource();
        if ("PostgreSQL".equals(dbType)) return new PostgreSQLDataSource();
        throw new IllegalArgumentException();
    }
}

// Builder
public class UserBuilder {
    private String name;
    private String email;
    private int age;
    
    public UserBuilder withName(String name) {
        this.name = name;
        return this;
    }
    
    public User build() {
        return new User(name, email, age);
    }
}

Structural (Структурные) — построение объектов и классов

// Adapter
public class LegacyAdapter implements ModernInterface {
    private LegacySystem legacySystem = new LegacySystem();
    
    @Override
    public void modernMethod() {
        legacySystem.oldMethod();
    }
}

// Decorator
public class EncryptedDataSource implements DataSource {
    private DataSource dataSource;
    
    public EncryptedDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    public void save(String data) {
        String encrypted = encrypt(data);
        dataSource.save(encrypted);
    }
}

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

// Observer
public class EventBus {
    private List<Observer> observers = new ArrayList<>();
    
    public void subscribe(Observer observer) {
        observers.add(observer);
    }
    
    public void publish(Event event) {
        observers.forEach(o -> o.onEvent(event));
    }
}

// Strategy
public class DataProcessor {
    private SortingStrategy sortingStrategy;
    
    public void setStrategy(SortingStrategy strategy) {
        this.sortingStrategy = strategy;
    }
    
    public List process(List data) {
        return sortingStrategy.sort(data);
    }
}

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

// ❌ Overengineering — паттерн для простой задачи
// Простая утилита для форматирования
public class SimpleFormatter {
    public static String format(String text) {
        return text.toUpperCase();
    }
}
// Не нужны Factory, Singleton и т.д.

// ✅ KISS — Просто и понятно
public String format(String text) {
    return text.toUpperCase();
}

Заключение

Шаблоны проектирования — это инвестиция в качество кода. Они предоставляют:

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

Однако ключ к их успешному использованию — применение их к месту, без избыточной сложности. Правило KISS (Keep It Simple, Stupid) всегда остается приоритетом.