观察者模式

最新推荐文章于 2025-07-22 17:42:40 发布

全力付出

最新推荐文章于 2025-07-22 17:42:40 发布

阅读量949

点赞数

CC 4.0 BY-SA版权

分类专栏：设计模式文章标签：设计模式观察者模式

本文链接：https://blog.youkuaiyun.com/zhengyong15984285623/article/details/44019831

设计模式专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种常用的设计模式——观察者模式，详细解释了其原理和应用场景，并通过自定义实现和Java API自带实现两种方式展示了如何使用观察者模式来解决实际问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 概述

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

本文主要从自定义观察者模式和Java API自带观察者模式作为讲解。

2. 解决的问题

　　将一个系统分割成一个一些类相互协作的类有一个不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。观察者就是解决这类的耦合关系的

3. 自定义观察者应用

3.1 自定义主题接口

package com.xxxx.pattern.observer.myobserver.subject;

import com.xxxx.pattern.observer.myobserver.observer.Observer;

public interface Subject {
    
    public void registerObserver(Observer observer);
    
    public void removeObserver(Observer observer);
    
    public void notifyObservers();

}

3.2 主题接口实现类

package com.xxxx.pattern.observer.myobserver.subject.impl;

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

import com.xxxx.pattern.observer.myobserver.observer.Observer;
import com.xxxx.pattern.observer.myobserver.subject.Subject;

public class ConcreteSubject implements Subject{
    
    public List<Observer> observers;
    
    public ConcreteSubject(){
        this.observers = new ArrayList<Observer>();
    }

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        int index = observers.indexOf(observer);
        if(index >= 0){
            observers.remove(observer);
        }
    }

    public void notifyObservers() {
       if(observers!=null && observers.size()>0){
           for(Observer observer : observers){
               observer.update();
           }
       }
    }

}

3.3 自定义观察者接口

package com.xxxx.pattern.observer.myobserver.observer;

public interface Observer {
    public void update();
}

3.4 观察者实现类A

package com.xxxx.pattern.observer.myobserver.observer.impl;

import com.xxxx.pattern.observer.myobserver.observer.Observer;
import com.xxxx.pattern.observer.myobserver.subject.Subject;

public class ConcerteObserverA implements Observer {
    
    public ConcerteObserverA(Subject subject){
        subject.registerObserver(this);
    }
    
    @Override
    public void update() {
       System.out.println("我是观察者A");
    }

}

3.5 观察者实现类B

package com.xxxx.pattern.observer.myobserver.observer.impl;

import com.xxxx.pattern.observer.myobserver.observer.Observer;
import com.xxxx.pattern.observer.myobserver.subject.Subject;

public class ConcerteObserverB implements Observer {
    
    public ConcerteObserverB(Subject subject){
        subject.registerObserver(this);
    }

    @Override
    public void update() {
       System.out.println("我是观察者B");
    }

}

3.6 测试自定义观察者模式

package com.xxxx.pattern.observer.myobserver;

import com.xxxx.pattern.observer.myobserver.observer.Observer;
import com.xxxx.pattern.observer.myobserver.observer.impl.ConcerteObserverA;
import com.xxxx.pattern.observer.myobserver.observer.impl.ConcerteObserverB;
import com.xxxx.pattern.observer.myobserver.subject.Subject;
import com.xxxx.pattern.observer.myobserver.subject.impl.ConcreteSubject;

/**
 * <p>自定义观察者模式</p>
 *  观察者模式是主题与观察者互相持有各自的对象，主题持有观察者对象集合，观察者持有主题对象
 */
public class TestObserver {

    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer observerA = new ConcerteObserverA(subject);
        Observer observerB = new ConcerteObserverB(subject);
        
        System.out.println("=============通知所有观察者==============");
        subject.notifyObservers();
        
        System.out.println("=========删除观察者A后通知所有观察者=========");
        subject.removeObserver(observerA);
        subject.notifyObservers();
        
        System.out.println("=========添加观察者A后通知所有观察者=========");
        subject.registerObserver(observerA);
        subject.notifyObservers();
    }

}

3.7 测试结果如下:

4. Java API自带观察者应用

4.1 Java API自带主题定义

package com.xxxx.pattern.observer.javaobserver.subject;

import java.util.Observable;

public class ConcreteSubject extends Observable{
    
    /**
     * 发送通知
     */
    public void notifyAllObserver(){
        setChanged();
        notifyObservers("我是主题，我改变了");
    }

}

4.2 Java API自带观察者A的定义

package com.xxxx.pattern.observer.javaobserver.observer;

import java.util.Observable;
import java.util.Observer;

public class ConcreteObserver implements Observer{

    public ConcreteObserver(Observable observers){
        observers.addObserver(this);
    }
    
    @Override
    public void update(Observable o, Object msg) {
        System.out.println("我是观察者A"+"收到信息： "+msg);
    }

}

4.3 Java API自带观察者B的定义

package com.xxxx.pattern.observer.javaobserver.observer;

import java.util.Observable;
import java.util.Observer;

public class ConcreteObserverB implements Observer{

    public ConcreteObserverB(Observable observers){
        observers.addObserver(this);
    }
    
    @Override
    public void update(Observable o, Object msg) {
        System.out.println("我是观察者B"+"收到信息： "+msg);
    }

}

4.3 Java API自带观察者模式测试

package com.xxxx.pattern.observer.javaobserver;

import com.xxxx.pattern.observer.javaobserver.observer.ConcreteObserverA;
import com.xxxx.pattern.observer.javaobserver.observer.ConcreteObserverB;
import com.xxxx.pattern.observer.javaobserver.subject.ConcreteSubject;

public class TestObserver {

    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserverA observerA = new ConcreteObserverA(subject);
        ConcreteObserverB observerB = new ConcreteObserverB(subject);
        subject.notifyAllObserver();
    }
}

4.4 Java API自带观察者模式结果：

我是观察者A收到信息：我是主题，我改变了
我是观察者B收到信息：我是主题，我改变了