设计模式-观察者模式(Observer)
-
- 一、观察者模式概述
-
- 1.1 什么是观察者模式
- 1.2 简单实现观察者模式
- 1.3 使用观察者模式的注意事项
- 二、观察者模式的用途
- 三、观察者模式实现方式
-
- 3.1 使用接口实现观察者模式
- 3.2 使用抽象类和具体子类实现观察者模式
- 3.3 使用 Java 内置的 Observable 和 Observer 类实现观察者模式
- 3.4 使用事件监听器实现观察者模式
- 3.5 使用发布-订阅模式实现观察者模式
一、观察者模式概述
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 ListObserver> 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 ListObserver> 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 ListObserver> 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 eve服务器托管网nt);
}
接下来,创建一个具体的事件源类EventSource,用于注册和触发事件
import java.util.ArrayList;
import java.util.List;
public class EventSource {
private ListEventListener> 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!
服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net
文章目录 一、什么是代理 二、正向代理 三、反向代理 四、正向和反向代理模拟复服务器托管网现 一、什么是代理 代理服务器英文全称是Proxy Server,其功能就是代理网络用户去取得网络信息。 形象的说:它是网络信息的中转站。在一般情况下,我们使用网络浏览器…