一碗油泼面

一碗油泼面

关注
发信
关注(28)粉丝(399)

设计模式-观察者模式（Observer）

一、观察者模式概述

1.1 什么是观察者模式

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

观察者模式包含以下角色：

主题（Subject）：被观察的对象，维护一个观察者列表，提供添加、删除和通知观察者的方法。
观察者（Observer）：观察主题对象的状态变化，实现 Update 方法来更新自己的状态。
具体主题（ConcreteSubject）：继承自抽象主题，实现具体业务逻辑。
具体观察者（ConcreteObserver）：继承自抽象观察者，实现具体业务逻辑。
使用观察者模式可以使得系统更加灵活、可扩展，减少各个模块之间的耦合度。

1.2 简单实现观察者模式

Java观察者模式是一种行为设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

以下是一个简单的Java观察者模式实现：

首先，创建一个观察者接口Observer，包含一个update方法，用于在主题状态发生变化时更新观察者的状态：

public interface Observer {
    void update(String message);
}

然后，创建一个主题接口Subject，包含添加、删除和通知观察者的方法：

import java.util.ArrayList;
import java.util.List;

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

接下来，创建一个具体的主题类ConcreteSubject，实现Subject接口：

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

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

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

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

    public void setState(String state) {
        this.state = state;
        notifyObservers("State changed to: " + state);
    }
}

最后，创建一个具体的观察者类ConcreteObserver，实现Observer接口：

public class ConcreteObserver implements Observer {
    private String name;
    private String state;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
        state = message;
    }
}

使用示例:

public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer observer1 = new ConcreteObserver("Observer1");
        Observer observer2 = new ConcreteObserver("Observer2");
        Observer observer3 = new ConcreteObserver("Observer3");

        subject.addObserver(observer1);
        subject.addObserver(observer2);
        subject.addObserver(observer3);

        subject.setState("New State");
    }
}

运行上述代码，可以看到三个观察者对象分别接收到了主题状态变化的通知。

1.3 使用观察者模式的注意事项

  • 1、主题对象和观察者对象的耦合度要尽可能低，避免出现循环引用的情况。
  • 2、主题对象的通知方式要保持一致，避免出现通知失败或者丢失的情况。
  • 3、观察者对象的 Update 方法的实现要避免过于复杂，尽量保持简单易懂。
  • 4、在添加、删除观察者对象时要考虑到线程安全问题，可以使用同步机制来保证线程安全。
  • 5、当主题对象的状态变化较为频繁时，可能会导致大量的通知操作，从而影响系统的性能。在这种情况下可以考虑使用异步消息队列等技术来优化性能。

二、观察者模式的用途

  • 1、实现了对象之间的解耦。主题对象和观察者对象的耦合度尽可能低，避免了循环引用的情况。
  • 2、支持一种一对多的依赖关系。一个主题对象状态改变时，所有依赖于它的观察者对象都会被自动通知并更新。
  • 3、帮助编写更加松耦合的代码及实现事件的广播通知。尤其在主题对象的状态变化较为频繁时，通过使用观察者模式，可以避免大量的通知操作影响系统性能。
  • 4、适用于多种场景，包括但不限于GUI应用程序、事件处理系统等。如在Java自带的观察者模式中，JDK提供了Observer接口作为监听者，Observable类作为观察者的实现。
  • 5、对高度协作提供了支持。当一个对象（目标对象）的状态发生改变时，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

三、观察者模式实现方式

3.1 使用接口实现观察者模式

观察者模式是一种行为设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时，所有依赖于它的观察者对象都会得到通知并自动更新。

下面是使用 Java 接口实现观察者模式的示例代码：

// 定义观察者接口
interface Observer {
    void update(String message);
}

// 定义主题接口
interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题类
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

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

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

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

// 具体观察者类
class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println("Observer " + name + " received message: " + message);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver("A");
        Observer observer2 = new ConcreteObserver("B");
        Observer observer3 = new ConcreteObserver("C");

        subject.addObserver(observer1);
        subject.addObserver(observer2);
        subject.addObserver(observer3);

        subject.setState("New State");
    }
}

在上面的示例中，我们首先定义了两个接口 Observer 和 Subject，分别表示观察者和主题。然后，我们创建了一个具体的主题类 ConcreteSubject，它实现了 Subject 接口，并维护了一个观察者列表。当主题的状态发生变化时，它会调用 notifyObservers 方法通知所有的观察者。我们还创建了一个具体的观察者类 ConcreteObserver，它实现了 Observer 接口，并在接收到通知时打印一条消息。最后，在测试代码中，我们创建了一个主题对象和三个观察者对象，并将它们添加到主题的观察者列表中。当我们设置主题的状态时，所有的观察者都会收到通知并打印出相应的消息。

3.2 使用抽象类和具体子类实现观察者模式

观察者模式是一种行为设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时，所有依赖于它的观察者对象都会得到通知并自动更新。

下面是使用抽象类和具体子类实现观察者模式的示例代码：

// 定义观察者接口
interface Observer {
    void update(String message);
}

// 定义主题接口
interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题类
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

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

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

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

// 具体观察者类A
class ConcreteObserverA implements Observer {
    private String name;

    public ConcreteObserverA(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println("Observer A received message: " + message);
    }
}

// 具体观察者类B
class ConcreteObserverB implements Observer {
    private String name;

    public ConcreteObserverB(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println("Observer B received message: " + message);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observerA = new ConcreteObserverA("A");
        Observer observerB = new ConcreteObserverB("B");

        subject.addObserver(observerA);
        subject.addObserver(observerB);

        subject.setState("New State");
    }
}

在上面的示例中，我们首先定义了观察者接口 Observer 和主题接口 Subject，然后创建了一个具体的主题类 ConcreteSubject，它实现了 Subject 接口，并维护了一个观察者列表。当主题的状态发生变化时，它会调用 notifyObservers 方法通知所有的观察者。我们还创建了两个具体的观察者类 ConcreteObserverA 和 ConcreteObserverB，它们都实现了 Observer 接口，并在接收到通知时打印出相应的消息。最后，在测试代码中，我们创建了一个主题对象和两个观察者对象，并将它们添加到主题的观察者列表中。当我们设置主题的状态时，所有的观察者都会收到通知并打印出相应的消息。

3.3 使用 Java 内置的 Observable 和 Observer 类实现观察者模式

要使用Java内置的Observable和Observer类实现观察者模式，首先需要创建一个继承要使用Java内置的Observable和Observer类实现观察者模式，首先需要创建一个继承自Observable的类，然后在该类中定义一个或多个状态变量。当这些状态变量发生变化时，调用setChanged()方法通知所有观察者。接下来，创建一个继承自Observer的类，重写update()方法以处理状态变化的通知。

以下是一个简单的示例：

创建一个继承自Observable的类，例如Subject：

import java.util.Observable;

public class Subject extends Observable {
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
        setChanged(); // 通知观察者状态已改变
        notifyObservers(state); // 传递新状态给观察者
    }
}

创建一个继承自Observer的类，例如MyObserver：

import java.util.Observer;

public class MyObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof Subject) {
            System.out.println("状态已更新为：" + arg);
        }
    }
}

在主程序中使用这两个类：

public class Main {
    public static void main(String[] args) {
        Subject subject = new Subject();
        MyObserver observer = new MyObserver();

        subject.addObserver(observer); // 添加观察者

        subject.setState("状态1"); // 设置状态并通知观察者
        subject.setState("状态2"); // 设置状态并通知观察者
    }
}

运行上述代码，将看到以下输出:

状态已更新为：状态1
状态已更新为：状态2

3.4 使用事件监听器实现观察者模式

在Java中，可以使用事件监听器实现观察者模式。以下是一个简单的示例：

首先，创建一个事件类Event，用于传递事件信息：

public class Event {
    private Object source;

    public Event(Object source) {
        this.source = source;
    }

    public Object getSource() {
        return source;
    }
}

然后，创建一个事件监听器接口EventListener，用于处理事件：

public interface EventListener {
    void handleEvent(Event event);
}

接下来，创建一个具体的事件源类EventSource，用于注册和触发事件

import java.util.ArrayList;
import java.util.List;

public class EventSource {
    private List<EventListener> listeners = new ArrayList<>();

    public void addEventListener(EventListener listener) {
        listeners.add(listener);
    }

    public void removeEventListener(EventListener listener) {
        listeners.remove(listener);
    }

    public void fireEvent(Event event) {
        for (EventListener listener : listeners) {
            listener.handleEvent(event);
        }
    }
}

最后，创建一个具体的观察者类ConcreteObserver，实现EventListener接口

public class ConcreteObserver implements EventListener {
    @Override
    public void handleEvent(Event event) {
        System.out.println("收到事件：" + event.getSource());
    }
}

在主程序中使用这些类：

public class Main {
    public static void main(String[] args) {
        EventSource eventSource = new EventSource();
        ConcreteObserver observer = new ConcreteObserver();

        eventSource.addEventListener(observer);

        eventSource.fireEvent(new Event("事件1"));
        eventSource.fireEvent(new Event("事件2"));
    }
}

运行上述代码，将看到以下输出：

收到事件：事件1
收到事件：事件2

3.5 使用发布-订阅模式实现观察者模式

在Java中，可以使用java.util.Observable类和java.util.Observer接口实现发布-订阅模式。以下是一个简单的示例：

首先，创建一个继承自java.util.Observable的类，例如Publisher：

import java.util.Observable;

public class Publisher extends Observable {
    private String message;

    public void setMessage(String message) {
        this.message = message;
        setChanged(); // 标记状态已改变
        notifyObservers(message); // 通知所有观察者
    }
}

然后，创建一个实现java.util.Observer接口的类，例如Subscriber：

import java.util.Observer;

public class Subscriber implements Observer {
    private String name;

    public Subscriber(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + "收到消息： " + arg);
    }
}

最后，在主程序中使用这两个类：

public class Main {
    public static void main(String[] args) {
        Publisher publisher = new Publisher();
        Subscriber subscriber1 = new Subscriber("订阅者1");
        Subscriber subscriber2 = new Subscriber("订阅者2");

        publisher.addObserver(subscriber1);
        publisher.addObserver(subscriber2);

        publisher.setMessage("Hello, World!");
    }
}

运行这个程序，你将看到以下输出：

订阅者1收到消息： Hello, World!
订阅者2收到消息： Hello, World!
11-14 07:41
Powered by LMLPHP ©2024 一碗油泼面 0.001835