Что такое паттерн Наблюдатель и в каких случаях его целесообразно использовать?

Паттерн Наблюдатель относится к поведенческим паттернам проектирования. Он определяет отношение "один ко многим" между объектами, при котором изменение состояния одного объекта (субъекта) автоматически оповещает всех зависимых от него объектов (наблюдателей) и обновляет их.

Принцип работы:

Субъект поддерживает список своих наблюдателей. Когда состояние субъекта меняется, он проходит по списку и вызывает метод обновления у каждого наблюдателя. Каждый наблюдатель реализует определенный интерфейс, который определяет этот метод обновления. Наблюдатели могут "подписываться" на обновления субъекта и "отписываться" от них.

Целесообразность использования:

• При необходимости оповещения множества объектов об изменении состояния одного объекта. Это типично для GUI-приложений, где изменение состояния виджета (например, нажатие кнопки) должно обновить несколько других элементов интерфейса.
• Когда система состоит из множества слабосвязанных объектов, которые должны взаимодействовать, но не знать подробностей реализации друг друга. Субъект не знает конкретных классов наблюдателей, только о том, что они реализуют интерфейс наблюдателя.
• В системах, где событие, происходящее в одном месте, должно вызвать действия в нескольких других местах. Например, при обновлении данных на сервере необходимо обновить отображение этих данных у всех подключенных пользователей.
• При реализации реактивных систем или потоков данных. Наблюдатели реагируют на изменения, как на события в потоке.

Пример структуры (Java):

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

// Интерфейс субъекта
public interface Subject {
    void attach(Observer observer); // Добавить наблюдателя
    void detach(Observer observer); // Удалить наблюдателя
    void notifyObservers(); // Оповестить наблюдателей
}

// Конкретный субъект
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state; // Состояние субъекта

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers(); // Оповестить при изменении состояния
    }

    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

// Конкретный наблюдатель
public class ConcreteObserver implements Observer {
    private ConcreteSubject subject; // Ссылка на субъект

    public ConcreteObserver(ConcreteSubject subject) {
        this.subject = subject;
        this.subject.attach(this); // Подписаться
    }

    @Override
    public void update() {
        // Выполнить действие при обновлении,
        // возможно, получить состояние из субъекта
        int state = subject.getState();
        System.out.println("Наблюдатель обновлен. Состояние субъекта: " + state);
    }
}

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

• Низкая связанность: Субъект не знает конкретные классы наблюдателей.
• Гибкость: Легко добавлять или удалять наблюдателей без изменения субъекта.
• Возможность повторного использования: Наблюдателей можно использовать с различными субъектами.

Недостатки:

• Порядок оповещения не гарантирован: Порядок вызова метода update у наблюдателей может быть неопределенным.
• Проблемы с производительностью: При большом количестве наблюдателей оповещение может занять значительное время.
• Сложность отладки: Трудно отследить поток выполнения, когда многие объекты реагируют на одно событие.