Java设计模式-行为型设计模式-观察者模式

发布时间:2024-01-01 13:00

Java设计模式-行为型设计模式-观察者模式

从这一专栏开始将学习设计模式,上课学习和自己总结归纳的笔记将总结出来供大家参考。
参考书籍:《设计模式就该这样学》

其他文章:

Java设计模式-UML类图 Java设计模式-七大架构设计原则-开闭原则
Java设计模式-七大架构设计原则-依赖倒置原则 Java设计模式-七大架构设计原则-单一职责原则
Java设计模式-七大架构设计原则-接口隔离原则 Java设计模式-七大架构设计原则-最少知道原则(迪米特法则)
Java设计模式-七大架构设计原则-里氏替换原则和合成复用原则 Java设计模式-创建型设计模式-简单工厂模式
Java设计模式-创建型设计模式-工厂方法模式(工厂模式) Java设计模式-创建型设计模式-抽象工厂模式
Java设计模式-创建型设计模式-建造者模式 Java设计模式-创建型设计模式-原型模式
Java设计模式-创建型设计模式-单例模式 Java设计模式-结构型设计模式-适配器模式
Java设计模式-行为型设计模式-观察者模式

文章目录

  • Java设计模式-行为型设计模式-观察者模式
    • 一、行为型设计模式
    • 二、观察者模式
      • 1.观察者模式定义
      • 2.观察者模式的角色
      • 3.观察者模式的特点
      • 4.观察者模式的类图
      • 5.观察者模式的通用写法
      • 6.观察者模式在Spring框架中的应用
        • Spring中观察者模式的四个角色
        • 1.环境搭建
          • 1.1创建配置类ExtConfig
          • 1.2创建MyApplicationListener实现ApplicationListener接口
          • 1.3测试代码和结果
        • 2.源码分析-ApplicationListener原理
          • 2.1ContextRefreshedEvent事件
          • 2.2IocTest$1事件
          • 2.3ContextClosedEvent事件

一、行为型设计模式

在GOF23种设计模式中,有三种类型的设计模式,分别是:创建型设计模式、结构型设计模式、行为型设计模式

在GoF23种设计模式中属于行为型设计模式:

Chain of Responsibility ( 责任链模式 )、Command ( 命令模式 )、Interpreter ( 解释器模式 ) 、Iterator ( 迭代器模式 )、Mediator ( 中介者模式 ) 、Memento ( 备忘录模式 ) 、Observer ( 观察者模式 )、State ( 状态模式 ) 、Strategy ( 策略模式 )、TemplateMethod ( 模板方法 )、Visitor ( 访问者模式 )11种模式。

二、观察者模式

1.观察者模式定义

观察者模式(Observer Pattern):又叫做发布-订阅模式(Publish/Subscribe pattern)、模型-视图(Model/View pattern)。定义一种一对多的依赖关系,一个主题对象可以被多个观察值对象同时监听,使得每当主题对象状态变化时,所有依赖它的对象都会得到通知并被自动更新。

在GoF23种设计模式中属于行为型设计模式:

其中包括:Chain of Responsibility ( 责任链模式 )、Command ( 命令模式 )、Interpreter ( 解释器模式 ) 、Iterator ( 迭代器模式 )、Mediator ( 中介者模式 ) 、Memento ( 备忘录模式 ) 、Observer ( 观察者模式 )、State ( 状态模式 ) 、Strategy ( 策略模式 )、TemplateMethod ( 模板方法 )、Visitor ( 访问者模式 )11种模式。

2.观察者模式的角色

抽象主题(ISubject):指被观察的对象,一般是一个抽象类或者是接口,定义了增加、删除、通知观察者对象的方法。

具体主题(ConcreteSubject):具体被观察的对象,当其内部状态变化的时候,会通。已注册的观察者。

抽象观察者(IObserver):定义了响应通知的更新方法。

具体观察者(ConcreteObserver):当得到状态更新的通知时,会自动做出响应。

3.观察者模式的特点

优点:

观察者和被观察者是松耦合的,符合依赖倒置原则(高层模块不应该依赖底层模块,二者都应该依赖其抽象。抽象不应该依赖细节,细节应该依赖抽象);

分离了观察者和被观察者,并且建立了一套触发机制,使得被观察者数据的变化可以响应到多个观察者上;

实现了一对多的通信机制,支持事件处理机制,支持兴趣分发机制,当被观察者触发事件时,只有感兴趣的观察者可以接收到通知。

缺点:

如果观察者的数量过多,则事件通知会耗费更多的时长;
事件通知呈线性关系,如果其中一个观察者处理事件卡壳,则会影响后续的观察者修改该事件;
如果观察者和被观察者之间存在循环依赖,则可能导致两者之间循环调用导致系统崩溃。

观察者模式的应用场景:

起床闹钟设置(如果一个人设置了一个闹钟,那么便会被闹钟提醒,那么闹钟就是被观察者,用户就是观察者);

朋友圈点赞提醒(微信朋友圈点赞之后,你就是观察者,微信的那条朋友圈就是被观察者);

网购APP商品降价通知推送(网购平台上,关注某个商品,当商品降价时,会收到通知)。

4.观察者模式的类图

\"Java设计模式-行为型设计模式-观察者模式_第1张图片\"

5.观察者模式的通用写法

/**
 * 抽象观察者
 */
interface Observer{
    void response();
}

/**
 * 具体观察者A
 */
class ConcreteObserverA implements Observer{
    @Override
    public void response() {
        System.out.println(\"具体观察者A作出反应!\");
    }
}

/**
 * 具体观察者B
 */
class ConcreteObserverB implements Observer{
    @Override
    public void response() {
        System.out.println(\"具体观察者B作出反应!\");
    }
}

/**
 * 抽象主题(被观察者)
 */
abstract class Subject{
    protected List observers = new ArrayList<>();

    /**
     * 增加观察者方法
     * @param observer
     */
    public void add(Observer observer){
        observers.add(observer);
    }

    /**
     * 删除观察者方法
     * @param observer
     */
    public void remove(Observer observer){
        observers.remove(observer);
    }

    /**
     * 通知观察者方法
     */
    public abstract void notifyObserver();
}

/**
 * 具体目标(具体被观察者)
 */
class ConcreteSubject extends Subject{
    @Override
    public void notifyObserver() {
        System.out.println(\"具体目标发生改变!\");
        System.out.println(\"----------------\");
        for(Observer obs : observers){
            obs.response();
        }
    }
}

public class ObserverSimpleTest {
    public static void main(String[] args){
        Subject subject = new ConcreteSubject();
        Observer observerA = new ConcreteObserverA();
        Observer observerB = new ConcreteObserverB();
        subject.add(observerA);
        subject.add(observerB);
        subject.notifyObserver();
    }
}

6.观察者模式在Spring框架中的应用

观察者模式在Spring框架中的具体实现就是事件模型驱动开发

Spring中观察者模式的四个角色

1.事件(ApplicationEvent)

\"Java设计模式-行为型设计模式-观察者模式_第2张图片\"

ApplicationEvent 是所有事件对象的父类,类似于被观察者要做的被观察的事情

类似于上面通用写法中的: \"在这里插入图片描述\"

用户可以通过继承ApplicationEvent,实现自定义事件。

下列描述了Spring提供的内置事件

ContextRefreshedEvent:Spring容器刷新完成(所有bean都完成创建)的事件;

ContextClosedEvent:关闭Spring容器的时候的事件。

…等

2.事件发布(ApplicationEventPublisher/ApplicationContext)

\"Java设计模式-行为型设计模式-观察者模式_第3张图片\"

ApplicationContext 是 Spring 中的核心容器,通过它的publishEvent()发布事件的通知给观察者(ApplicationListener)监听到(告诉观察者你需要观察哪个事件),因为事件创建好了不知道会不会被观察者观察到,所以会使用它。

3.事件监听(ApplicationListener)

\"在这里插入图片描述\"

ApplicationListener 事件监听器,也就是抽象观察者。继承自 jdk 的 EventListener,该类中只有一个方法 onApplicationEvent(),通过这个方法就是在事件执行的时候观察者要做的事情, 用户可以实现ApplicationListener接口进行事件监听(创建具体观察者)

4.事件多播器(ApplicationEventMulticaster)

ApplicationEventMulticaster 用于事件监听器的注册和事件的广播。等同于被观察者中的observers属性,监听器的注册、删除、把 Applicationcontext (被观察者)发布的事件广播给它的ApplicationListener(被观察者)列表(让他们进行链式调用)。

\"Java设计模式-行为型设计模式-观察者模式_第4张图片\"

1.环境搭建

1.1创建配置类ExtConfig
@ComponentScan(\"com.wxr.ext\")
@Configuration
public class ExtConfig {
 
}
1.2创建MyApplicationListener实现ApplicationListener接口

这就是用户自定义创建的具体观察者类

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

    /**
     * 当容器中发布此事件以后,该方法出发
     * 监听ApplicationEvent及下面的子事件
     * 根据ApplicationEvent的继承关系:
     * 例如:
	 *		ContextRefreshedEvent:容器刷新完成(所有bean都完成创建)会发布这个事件
     *      ContextClosedEvent:关闭容器的时候会发布这个事件
     * 步骤: 
     *      1.写一个监听器来监听某个事件(ApplicationEvent及其子类)
     *      2.把监听器加入到容器中
     *      3.只要容器中有相应类型的事件发布,我们就监听到这个事件
     * @param event
     */
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println(\"收到事件:\"+event);
    }
}

1.3测试代码和结果
public class IocTest {
    @Test
    public void test02(){
        AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(ExtConfig.class);
        //发布事件
        ioc.publishEvent(new ApplicationEvent(new String(\"我发布的事件\")) {
        });
        System.out.println(\"ioc容器创建完成\");
        ioc.close();
    }
}

\"在这里插入图片描述\"

2.源码分析-ApplicationListener原理

根据三.1的输出结果,我们按照先后顺序从ContextRefreshedEvent,IocTest$1,ContextClosedEvent进行分析

执行步骤:

1.向spring容器中注册事件多播器(ApplicationEventMulticaster)

2.向spring容器中注册事件监听器(ApplicationListener)

3.通过事件发布(ApplicationEventPublisher/ApplicationContext)的publishEvent()告诉监听器需要监听的是哪个事件

     3.1获取事件多播器(ApplicationEventMulticaster),通过它来遍历所有的事件监听器(ApplicationListener),并且调用他们的		   onApplicationEvent()进行事件监听

​	 3.2完成事件监听

2.1ContextRefreshedEvent事件

2.1.1创建IoC容器(调用AnnotationConfigApplicationContext的构造器)

public class IocTest {
    @Test
    public void test02(){
        //2.1.1.1走这里
        AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(ExtConfig.class);
        //发布事件      
        ioc.publishEvent(new ApplicationEvent(new String(\"我发布的事件\")) {
        });
        System.out.println(\"ioc容器创建完成\");
        ioc.close();
    }
}


//AnnotationConfigApplicationContext的构造器
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
   this();
   register(annotatedClasses);
    //2.1.1.1走这里
   refresh();
}

2.1.1.1调用AbstractApplicationContext.refresh()刷新容器

/**
 *这是AbstractApplicationContext.refresh()
 */
@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			
			prepareRefresh();

			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			prepareBeanFactory(beanFactory);

			try {
				postProcessBeanFactory(beanFactory);

                //执行BeanFactoryPostProcessors
				invokeBeanFactoryPostProcessors(beanFactory);

                //注册bean的后置处理器
				registerBeanPostProcessors(beanFactory);
                  
                // 初始化事件的多播器(派发器),在2.1.1.1.1.1.1会提到
				initApplicationEventMulticaster();
                
                
                // 注册所有的监听器,从容器中拿到所有的监听器,把他们注册到applicationEventMulticaster中
				registerListeners();
                
                           
                //调用本类的finishBeanFactoryInitialization(beanFactory)完成BeanFactory的初始化工作
                //实例化剩下的单实例Bean               
				finishBeanFactoryInitialization(beanFactory);
                
                //调用本类的finishRefresh(),容器刷新完成
                //2.1.1.1.1走这里
				finishRefresh();
               
 			}
    }

2.1.1.1.1调用AbstractApplicationContext.finishRefresh()完成容器刷新

protected void finishRefresh() {
   // Initialize lifecycle processor for this context.
   initLifecycleProcessor();

   // Propagate refresh to lifecycle processor first.
   getLifecycleProcessor().onRefresh();

   //发布事件ContextRefreshedEvent刚刚好2.1ContextRefreshedEvent是一样的
   //调用本类下的publishEvent(new ContextRefreshedEvent(this))
    //2.1.1.1.1.1走这里
   publishEvent(new ContextRefreshedEvent(this));

   // Participate in LiveBeansView MBean, if active.
   LiveBeansView.registerApplicationContext(this);
}

2.1.1.1.1.1调用AbstractApplicationContext. publishEvent(new ContextRefreshedEvent(this)) 开始进行ContextRefreshedEvent事件发布

@Override
public void publishEvent(ApplicationEvent event) {
   publishEvent(event, null);
}

protected void publishEvent(Object event, ResolvableType eventType) {
		Assert.notNull(event, \"Event must not be null\");
		if (logger.isTraceEnabled()) {
			logger.trace(\"Publishing event in \" + getDisplayName() + \": \" + event);
		}

		// Decorate event as an ApplicationEvent if necessary
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}
		else {
			applicationEvent = new PayloadApplicationEvent<Object>(this, event);
			if (eventType == null) {
				eventType = ((PayloadApplicationEvent)applicationEvent).getResolvableType();
			}
		}

		// Multicast right now if possible - or lazily once the multicaster is initialized
		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		else {
            //1.获取事件的多播器(派发器):getApplicationEventMulticaster() 2.1.1.1.1.1.1走这里
            //2.派发事件:multicastEvent(applicationEvent, eventType)2.1.1.1.1.1.2走这里
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

		// Publish event via parent context as well...
		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext) {
				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}

2.1.1.1.1.1.1调用getApplicationEventMulticaster()获取事件的多播器(派发器)

ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
   if (this.applicationEventMulticaster == null) {
      throw new IllegalStateException(\"ApplicationEventMulticaster not initialized - \" +
            \"call \'refresh\' before multicasting events via the context: \" + this);
   }
   return this.applicationEventMulticaster;
}

获取方法在refresh()的initApplicationEventMulticaster()中

protected void initApplicationEventMulticaster() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //判断在beanFactory中是否有id=\"applicationEventMulticaster\"的组件
   if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
       //如果有就直接获取
      this.applicationEventMulticaster =        
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
      if (logger.isDebugEnabled()) {
         logger.debug(\"Using ApplicationEventMulticaster [\" + this.applicationEventMulticaster + \"]\");
      }
   }
   else {
       //如果没有那么就自己创建一个新的id=\"applicationEventMulticaster\"并注册到容器中
       //我们可以再其他组件要派发事件的时候,自动注入这个applicationEventMulticaster
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
      if (logger.isDebugEnabled()) {
         logger.debug(\"Unable to locate ApplicationEventMulticaster with name \'\" +
               APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
               \"\': using default [\" + this.applicationEventMulticaster + \"]\");
      }
   }
}

2.1.1.1.1.1.2调用SimpleApplicationEventMulticaster. multicastEvent(final ApplicationEvent event, ResolvableType eventType) 进行派发事件

@Override
public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
   ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    //拿到所有的ApplicationListener挨个遍历
   for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
      Executor executor = getTaskExecutor();
       //如果有异步执行的功能,那么通过多线程的方式异步派发invokeListener(listener, event);
      if (executor != null) {
         executor.execute(new Runnable() {
            @Override
            public void run() {
               invokeListener(listener, event);
            }
         });
      }
      else {
          //否则用同步的方式直接调用本类下的invokeListener(listener, event);
          //2.1.1.1.1.1.2.1走这里
         invokeListener(listener, event);
      }
   }
}

2.1.1.1.1.1.2.1调用SimpleApplicationEventMulticaster.invokeListener(ApplicationListener listener, ApplicationEvent event)

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
   ErrorHandler errorHandler = getErrorHandler();
   if (errorHandler != null) {
      try {
         doInvokeListener(listener, event);
      }
      catch (Throwable err) {
         errorHandler.handleError(err);
      }
   }
   else {
       //这次走这里
      doInvokeListener(listener, event);
   }
}


//再次调用本类下的doInvokeListener(ApplicationListener listener, ApplicationEvent event)
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
		try {
            //2.1.1.1.1.1.2.1.1
            //走这个方法直接回调到我们自己写的MyApplicationListener. onApplicationEvent(ApplicationEvent event) 
			listener.onApplicationEvent(event);
		}
		catch (ClassCastException ex) {
			String msg = ex.getMessage();
			if (msg == null || msg.startsWith(event.getClass().getName())) {
				// Possibly a lambda-defined listener which we could not resolve the generic event type for
				Log logger = LogFactory.getLog(getClass());
				if (logger.isDebugEnabled()) {
					logger.debug(\"Non-matching event type for listener: \" + listener, ex);
				}
			}
			else {
				throw ex;
			}
		}
	}

2.1.1.1.1.1.2.1.1回到我们自己写的MyApplicationListener. onApplicationEvent(ApplicationEvent event)完成事件发布

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println(\"收到事件:\"+event);
    }
}
2.2IocTest$1事件

2.2.1调用自己写的发布时间方法ioc.publishEvent(new ApplicationEvent(new String(“我发布的事件”)) {});

public class IocTest {
    @Test
    public void test02(){
        AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(ExtConfig.class);
        //2.2.1.1走这里       
        ioc.publishEvent(new ApplicationEvent(new String(\"我发布的事件\")) {
        });
        System.out.println(\"ioc容器创建完成\");
        ioc.close();
    }
}

2.2.1.1直接调用AbstractApplicationContext. publishEvent(new ContextRefreshedEvent(this)) 开始进行ContextRefreshedEvent事件发布

@Override
public void publishEvent(ApplicationEvent event) {
   publishEvent(event, null);
}

protected void publishEvent(Object event, ResolvableType eventType) {
		Assert.notNull(event, \"Event must not be null\");
		if (logger.isTraceEnabled()) {
			logger.trace(\"Publishing event in \" + getDisplayName() + \": \" + event);
		}

		// Decorate event as an ApplicationEvent if necessary
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}
		else {
			applicationEvent = new PayloadApplicationEvent<Object>(this, event);
			if (eventType == null) {
				eventType = ((PayloadApplicationEvent)applicationEvent).getResolvableType();
			}
		}

		// Multicast right now if possible - or lazily once the multicaster is initialized
		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		else {
            //1.获取事件的多播器(派发器):getApplicationEventMulticaster()
            //2.派发事件:multicastEvent(applicationEvent, eventType),这次走这里
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

		// Publish event via parent context as well...
		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext) {
				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}

2.2.1.1后面的逻辑和2.1.1.1.1.1.2之后一样了这里就不赘述了

2.3ContextClosedEvent事件

2.3.1调用ioc.close()

public class IocTest {
    @Test
    public void test02(){
        AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(ExtConfig.class);
        //发布事件 
        ioc.publishEvent(new ApplicationEvent(new String(\"我发布的事件\")) {
        });   
        System.out.println(\"ioc容器创建完成\");
        //2.3.1.1走这里
        ioc.close();
    }
}

2.3.1.1调用AbstractApplicationContext.close()关闭容器

@Override
public void close() {
   synchronized (this.startupShutdownMonitor) {
       //这次走这里
      doClose();
      // If we registered a JVM shutdown hook, we don\'t need it anymore now:
      // We\'ve already explicitly closed the context.
      if (this.shutdownHook != null) {
         try {
            Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
         }
         catch (IllegalStateException ex) {
            // ignore - VM is already shutting down
         }
      }
   }
}
protected void doClose() {
     //多余代码省略
      try {
         //发布ContextClosedEvent事件
          //2.3.1.1.1走这里
         publishEvent(new ContextClosedEvent(this));
      }
      //多余代码省略
}

2.3.1.1.1调用AbstractApplicationContext.publishEvent(ApplicationEvent event)发布ContextClosedEvent事件

2.3.1.1.1.1后面的逻辑和2.1.1.1.1.1.2之后一样了这里就不赘述了

ItVuer - 免责声明 - 关于我们 - 联系我们

本网站信息来源于互联网,如有侵权请联系:561261067@qq.com

桂ICP备16001015号