设计模式——观察者模式(Observer Pattern)+ Spring相关源码

这篇具有很好参考价值的文章主要介绍了设计模式——观察者模式(Observer Pattern)+ Spring相关源码。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


一、观察者模式定义

类型:行为型模式
目的:当一个对象的状态发生改变时,其所有依赖者(观察者)都会收到通知并自动更新。


二、例子

2.1 菜鸟教程例子

2.1.1 定义观察者

//观察者
public abstract class Observer {
	//被观察对象
   protected Subject subject;
   public abstract void update();
}
public class BinaryObserver extends Observer{
 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); 
   }
}
public class HexaObserver extends Observer{
 
   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Hex String: "  + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

2.1.2 定义被观察对象

import java.util.ArrayList;
import java.util.List;
//被观察对象 
public class Subject {
   //观察者列表
   private List<Observer> observers = new ArrayList<Observer>();
   
   private int state;
 
   public int getState() {
      return state;
   }
   public void attach(Observer observer){
      observers.add(observer);      
   }
   
   //通知所有观察者
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
 	//修改数据时,通知所有观察者
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
}

2.1.3 使用

public class ObserverPatternDemo {
   public static void main(String[] args) {
   	  //创建被观察对象
      Subject subject = new Subject();
 	  //创建观察者对象
      new HexaObserver(subject);
      new BinaryObserver(subject);
      
 	  //创建被观察对象调用setState时,通知国有观察者
      System.out.println("First state change: 15");   
      subject.setState(15);
      System.out.println("Second state change: 10");  
      subject.setState(10);
   }
}

2.2 JDK源码 —— Observable

2.2.1 观察者接口Observer

public interface Observer {
    void update(Observable o, Object arg);
}

2.2.1 被观察者对象Observable

public class Observable {
    private boolean changed = false;
    
    private Vector<Observer> obs;
    //添加观察者
	public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }
    //通知观察者
    public void notifyObservers(Object arg) {
        Object[] arrLocal;
        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }
}

2.3 Spring源码 —— AbstractApplicationContext

2.3.1 观察者

public class ContextStartedEvent extends ApplicationContextEvent {
    public ContextStartedEvent(ApplicationContext source) {
        super(source);
    }
}

public class ContextStoppedEvent extends ApplicationContextEvent {
    public ContextStoppedEvent(ApplicationContext source) {
        super(source);
    }
}

public class ContextRefreshedEvent extends ApplicationContextEvent {
    public ContextRefreshedEvent(ApplicationContext source) {
        super(source);
    }
}

2.3.2 被观察者

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
	//观察者集合
	private Set<ApplicationEvent> earlyApplicationEvents;
	//添加观察者Event
	public void publishEvent(ApplicationEvent event) {
        this.publishEvent(event, (ResolvableType)null);
    }
	//通知观察者Event
    protected void registerListeners() {
        Iterator var1 = this.getApplicationListeners().iterator();

        while(var1.hasNext()) {
            ApplicationListener<?> listener = (ApplicationListener)var1.next();
            this.getApplicationEventMulticaster().addApplicationListener(listener);
        }

        String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);
        String[] var7 = listenerBeanNames;
        int var3 = listenerBeanNames.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String listenerBeanName = var7[var4];
            this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
            Iterator var9 = earlyEventsToProcess.iterator();

            while(var9.hasNext()) {
                ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
                this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }

    }
}

2.3 Guava源码 —— EventBus

public class EventBus {
	//注册订阅者(观察者)
	public void register(Object object) {
        this.subscribers.register(object);
    }
    //通知订阅者(观察者)
	public void post(Object event) {
        Iterator<Subscriber> eventSubscribers = this.subscribers.getSubscribers(event);
        if (eventSubscribers.hasNext()) {
            this.dispatcher.dispatch(event, eventSubscribers);
        } else if (!(event instanceof DeadEvent)) {
            this.post(new DeadEvent(this, event));
        }

    }
}

三、其他设计模式

创建型模式
结构型模式

  • 1、设计模式——装饰器模式(Decorator Pattern)+ Spring相关源码

行为型模式文章来源地址https://www.toymoban.com/news/detail-735521.html

  • 1、设计模式——访问者模式(Visitor Pattern)+ Spring相关源码
  • 2、设计模式——中介者模式(Mediator Pattern)+ JDK相关源码
  • 3、设计模式——策略模式(Strategy Pattern)+ Spring相关源码
  • 4、设计模式——状态模式(State Pattern)
  • 5、设计模式——命令模式(Command Pattern)+ Spring相关源码
  • 6、设计模式——观察者模式(Observer Pattern)+ Spring相关源码
  • 7、设计模式——备忘录模式(Memento Pattern)
  • 8、设计模式——模板方法模式(Template Pattern)+ Spring相关源码
  • 9、设计模式——迭代器模式(Iterator Pattern)+ Spring相关源码
  • 10、设计模式——责任链模式(Chain of Responsibility Pattern)+ Spring相关源码
  • 11、设计模式——解释器模式(Interpreter Pattern)+ Spring相关源码

到了这里,关于设计模式——观察者模式(Observer Pattern)+ Spring相关源码的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【设计模式-06】Observer观察者模式

    事件处理模型 场景示例:小朋友睡醒了哭,饿! 核心思路和逻辑 定义事件类 ActionEvent 定义接口类 ActionListener 和接口方法 void actionPerformed(ActionEvent e); 自定义 Button 类,模拟按钮点击事件 自定义监听者 MyActionEventListener 和 MyActionEventListener2 实现接口 void actionPerformed(ActionEvent

    2024年01月17日
    浏览(44)
  • 「观察者(Observer)」设计模式 Swift实现

    观察者设计模式(Observer Pattern)是一种行为型设计模式,它定义了对象之间的一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖于它的对象都会受到通知并自动更新。 在这种模式中,被观察者对象(Subject)存储其观察者对象(Observer)列表,并提供了用

    2024年02月16日
    浏览(38)
  • 行为型-观察者模式(Observer Pattern)

    详细介绍观察者模式(Observer Pattern),并说明优缺点与使用场景: 观察者模式是一种行为型设计模式,它定义了对象之间的一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖它的对象都会自动收到通知并更新。该模式包含两个核心角色:被观察者(Subj

    2024年02月15日
    浏览(63)
  • 【设计模式——学习笔记】23种设计模式——观察者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现)

    有一个天气预报项目,需求如下: 气象站可以将每天测量到的温度、湿度、气压等等以公告的形式发布出去(比如发布到自己的网站或第三方) 需要设计开放型API,便于其他第三方也能接入气象站获取数据 提供温度、气压、湿度的接口 测量数据更新时,要能实时的通知给第三

    2024年02月14日
    浏览(37)
  • (三)行为模式:7、观察者模式(Observer Pattern)(C++示例)

    目录 1、观察者模式(Observer Pattern)含义 2、观察者模式的UML图学习 3、观察者模式的应用场景 4、观察者模式的优缺点 (1)优点: (2)缺点 5、C++实现观察者模式的实例 1、观察者模式(Observer Pattern)含义 观察者模式(Observer)定义了一种一对多的依赖关系,让多个观察者

    2024年02月09日
    浏览(41)
  • 观察者模式(Observer)

    观察着模式是一种行为设计模式,可以用来定义对象间的一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。 观察者模式又叫做发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者

    2024年02月14日
    浏览(38)
  • 观察者模式(Observer)

    事件订阅者者(Event-Subscriber) 监听者(Listener) 观察者 是一种行为设计模式, 允许你定义一种订阅机制, 可在对象事件发生时通知多个“观察”该对象的其他对象。 1. 问题 假如你有两种类型的对象 :“顾客”和“商店”。顾客对某个特定品牌的产品非常感兴趣(例如最

    2024年02月12日
    浏览(36)
  • 设计模式-观察者模式

    观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,其所有依赖者都会收到通知并自动更新。当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知依赖它的对象。观察者

    2024年02月15日
    浏览(57)
  • 【设计模式】观察者模式

    观察者模式(又被称为发布-订阅(Publish/Subscribe)模式,属于行为型模式的一种,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。 Subject:抽象主题(被观察者

    2024年02月13日
    浏览(51)
  • 设计模式——观察者模式

    观察者模式可以分为观察者和被观察者,观察者通过注册到一个被观察者中,也可视为订阅,当被观察者的数据发生改变时,会通知到观察者,观察者可以据此做出反应。 可以类比订阅报纸,报社就是被观察者,订阅者就是观察者,订阅者通过订阅报纸与报社建立联系,而报

    2024年02月15日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包