网站建设找博网,西安营销型网站制作价格,网站备案备注,成都建设网站的公司有哪些目录
一、观察者模式
1.1 模型介绍
1.2 观察者模式Demo
1.2.1 观察者实体
1.2.2 主题实体
1.2.3 测试代码
二、Spring监听器的介绍
2.1 事件#xff08;ApplicationEvent#xff09;
2.1.1 Spring内置事件
2.1.2 Spring内置事件
2.2 事件监听器#xff08;Applic…目录
一、观察者模式
1.1 模型介绍
1.2 观察者模式Demo
1.2.1 观察者实体
1.2.2 主题实体
1.2.3 测试代码
二、Spring监听器的介绍
2.1 事件ApplicationEvent
2.1.1 Spring内置事件
2.1.2 Spring内置事件
2.2 事件监听器ApplicationListener
2.2.1 事件监听器-基于接口
2.2.1.1 SmartApplicationListener
2.2.1.2 GenericApplicationListener
2.2.2 事件监听器-基于注解
2.3 事件发布者ApplicationEventPublisher
2.4 事件广播器ApplicationEventMulticaster
三、Spring监听器的使用
3.1 新建监听器
3.1.1 通过实现ApplicationListener接口创建监听器
3.1.2 使用EventListener注解创建监听器
3.2 内置的事件类型
3.3 自定义事件与监听器Demo
3.3.1 构建两个自定义事件
3.3.2 构建监听
3.3.3 发布事件 一、观察者模式
Spring的监听器用到了观察者模式工厂模式(EventListenerFactory)适配器模式(ApplicationListenerMethodAdapter)而其中最重要的就是基于观察者模式它能实现事件与事件监听者直接的解耦。所以在讲解监听器之前我们先讲一下观察者模式。 1.1 模型介绍
观察者模式Observer Pattern是一种行为设计模式它用于在对象之间建立一对多的依赖关系。在该模式中当一个对象的状态发生变化时它会自动通知其依赖对象称为观察者使它们能够自动更新。
观察者模式的工作原理如下
主题对象维护一个观察者列表并提供方法用于添加和删除观察者。当主题的状态发生变化时监听到某种事件发生它会遍历观察者列表并调用每个观察者的通知方法。观察者接收到通知后根据通知进行相应的更新操作。 以我的理解就是一个主题会去监听一种事件和这个事件相关的观察者都会被加到这个主题对象中。当主题对象监听到这个事件发生了就会去通知自己维护的所有观察者这些观察者就回去执行相应的逻辑。也就是一种主题对应一种事件要观察这个事件的观察者都添加到这个主题中由主题去监听这个事件是否发生事件发生后主题回去通知所有的观察者观察者们再去执行相应的逻辑。
观察者模式角色
Subject抽象主题抽象被观察者抽象主题角色把所有观察者对象保存在一个集合里每个主题都可以有任意数量的观察者抽象主题提供一个接口可以增加和删除观察者对象。ConcreteSubject具体主题具体被观察者该角色将有关状态存入具体观察者对象在具体主题的内部状态发生改变时给所有注册过的观察者发送通知。Observer抽象观察者是观察者者的抽象类它定义了一个更新接口使得在得到主题更改通知时更新自己。ConcrereObserver具体观察者实现抽象观察者定义的更新接口以便在得到主题更改通知时更新自身的状态。
1.2 观察者模式Demo
一个观察者模式demo包括以下部分
观察者实体主题实体
1.2.1 观察者实体
所以我们先写个观察者接口
interface Observer {void update();
}
再构建两个观察者实现类
// 具体观察者A
class ConcreteObserverA implements Observer {Overridepublic void update() {System.out.println(ConcreteObserverA收到更新通知);}
}// 具体观察者B
class ConcreteObserverB implements Observer {Overridepublic void update() {System.out.println(ConcreteObserverB收到更新通知);}
}1.2.2 主题实体
然后定义主题接口
interface Subject {// 注册新的观察者void registerObserver(Observer observer);// 删除指定观察者void removeObserver(Observer observer);// 通知全部观察者void notifyObservers();
}构建一个具体主题
// 具体主题
class ConcreteSubject implements Subject {// 一个主题维护多个观察者private ListObserver observers new ArrayList();Overridepublic void registerObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update();}}public void doSomething() {System.out.println(主题执行某些操作...);// 执行操作后通知观察者notifyObservers(); }
}1.2.3 测试代码
public class ObserverPatternDemo {public static void main(String[] args) {// 创建主题和观察者ConcreteSubject subject new ConcreteSubject();Observer observerA new ConcreteObserverA();Observer observerB new ConcreteObserverB();// 注册观察者subject.registerObserver(observerA);subject.registerObserver(observerB);// 执行主题的操作触发通知subject.doSomething();}
}
最后可以看到结果
主题执行某些操作…
ConcreteObserverA收到更新通知
ConcreteObserverB收到更新通知
二、Spring监听器的介绍
Spring事件体系包括三个组件
事件广播器事件多播器、事件发布器可以理解为就是applicationContext。事件ApplicationEvent。事件监听器ApplicationListener。
实现Spring事件机制主要有4个类
ApplicationEvent事件每个实现类表示一类事件可携带数据。ApplicationListener事件监听器用于接收事件处理时间。ApplicationEventMulticaster事件管理者用于事件监听器的注册和事件的广播。ApplicationEventPublisher事件发布者委托ApplicationEventMulticaster完成事件发布。
2.1 事件ApplicationEvent
事件ApplicationEvent) 是特定事件监听器被触发的原因。
2.1.1 Spring内置事件
内置事件中由系统内部进行发布只需自己注入监听器即可。
Spring容器启动的时候在不同阶段会发布不同事件我们可以根据自己的需求进行监听。阿里的nacos服务自动注册原理就是监听到web容器初始化完成事件完成自动注册发现。例如Spring容器启动完之后会发布一个ContextRefreshedEvent事件我们可以实现自己的监听器进行监听。
Component
// 设置用于监听ContextRefreshedEvent事件的监听器
public class MyListener2 implements ApplicationListenerContextRefreshedEvent {Overridepublic void onApplicationEvent(ContextRefreshedEvent event) {System.out.println(-----------------:event.getSource().getClass());}
}
可以使用Spring内置的事件来对注册到容器中的Bean进行拓展重点看内置的ContextRefreshedEvent和ContextClosedEvent这两个事件一个是在刚完成容器初始化的时候被发布的事件一个是关闭容器时发布的事件。我们只要去编写监听这两个事件的监听器来自定义实现一些逻辑就能做到对注册到容器中的Bean进行拓展了。 内置的事件类型 Event 说明 ContextRefreshedEvent 当容器被实例化或refreshed时发布。如调用refresh()方法此处的实例化是指所有的bean都已被加载后置处理器都被激活所有单例bean都已被实例化所有的容器对象都已准备好可使用。如果容器支持热重载则refresh可以被触发多次(XmlWebApplicatonContext支持热刷新而 GenericApplicationContext则不支持) ContextStartedEvent 当容器启动时发布即调用start()方法已启用意味着所有的Lifecycle bean都已显式接收到了start 信号 ContextStoppedEvent 当容器停止时发布即调用stop()方法即所有的Lifecycle bean都已显式接收到了stop信号关闭的容器可以通过start()方法重启 ContextClosedEven36 当容器关闭时发布即调用close方法关闭意味着所有的单例bean都已被销毁。关闭的容器不能被重启 或refresh RequestHandledEvent 这只在使用spring的DispatcherServlet时有效当一个请求被处理完成时发布 内置事件类型的继承体系 2.1.2 Spring内置事件
事件类需要继承ApplicationEvent抽象类代码如下
public class BigEvent extends ApplicationEvent {private String name;public BigEvent(Object source, String name) {super(source);this.name name;}public String getName() {return name;}
}
这里为了简单测试所以写的很简单。
事件类其实就是一种很简单的pojo除了需要继承ApplicationEvent也没什么了这个类有一个构造方法需要调用super()方法。
2.2 事件监听器ApplicationListener
事件监听器ApplicationListener对应于观察者模式中的观察者。作用为处理事件广播器发布的事件。
在Spring中监听器的实现主要有一下重要组件
ApplicationListener接口事件监听者观察者ApplicationEvent抽象类Spring 事件记录事件源、事件内容、时间等数据EventListener注解除了实现ApplicationListener接口注册监听器也可以使用注解的方式ApplicationEventPublisher接口发布事件
2.2.1 事件监听器-基于接口
Spring提供了继承于java.util.EventListener接口的应用监听器接口 ApplicationListener此接口源码
FunctionalInterface
public interface ApplicationListenerE extends ApplicationEvent extends EventListener {/*** Handle an application event.* param event the event to respond to*/void onApplicationEvent(E event);
}使用接口实现监听器
FunctionalInterface
public interface ApplicationListenerE extends ApplicationEvent extends EventListener {/*** Handle an application event.* param event the event to respond to*/void onApplicationEvent(E event);
}事件监听器需要实现ApplicationListener接口这是个泛型接口泛型类类型就是事件类型其次监听器是需要spring容器托管的bean所以这里加了component只有一个方法就是onApplicationEvent()是事件发生后要触发的操作。
Spring还提供了对ApplicationListener接口的实现SmartApplicationListener接口和GenericApplicationListener接口。
2.2.1.1 SmartApplicationListener
提供了监听器对泛型事件的支持spring3.0 添加的。
源码
public interface SmartApplicationListener extends ApplicationListenerApplicationEvent, Ordered {boolean supportsEventType(Class? extends ApplicationEvent var1);boolean supportsSourceType(Class? var1);
} 2.2.1.2 GenericApplicationListener
增强对泛型事件的支持支持泛型方式不同与SmartApplicationListenerspring4.2 添加的。
源码
public interface GenericApplicationListener extends ApplicationListenerApplicationEvent, Ordered {boolean supportsEventType(ResolvableType var1);boolean supportsSourceType(Class? var1);
}2.2.2 事件监听器-基于注解
Component
public class OrderEventListener {EventListener(OrderEvent.class)public void onApplicationEvent(OrderEvent event) {if(event.getName().equals(减库存)){System.out.println(减库存.......);}}
}
注解是加到onApplicationEvent()方法上的方法名可以自定义这个方法就是监听器监听到事件发生后触发的执行逻辑。
这里要注意加注解的方法不能是private修饰的方法否则会报错。 EventListener的错误尝试
道了EventListener的原理我们其实可以做一些猜测如下:
methodA是正常的用法;
methodB方法的修饰符是private;
methodC则是监听的ContextRefreshedEvent但下面方法的入参却是ContextClosedEvent; 后两者都有问题
可以看到编译器直接黄底提示了methodB的EventListener注解其实从前面我们已经猜到因为最后我们的调用是由监听器ApplicationListenerMethodAdapter对象直接调用的方法ABC所以方法必须可被其他对象调用即public。 而后者会在执行广播响应事件时报参数非法异常也是意料之中。 2.3 事件发布者ApplicationEventPublisher
事件发布者职责为发布事件。
spring的ApplicationContext 本来就实现了ApplicationEventPublisher接口因此应用上下文本来就是
一个事件发布者在AbstractApplicationContext中实现了事件发布的业务。
上下文对象调用publishEvent()方法将事件对象传入即可将该事件发布。
applicationContext.publishEvent(new HelloEvent(this,lgb));
事件发布之后就会被已经注册到Spring容器中对应的事件监听器监听到会触发监听器onApplicationEvent()操作。 2.4 事件广播器ApplicationEventMulticaster
Spring事件机制是观察者模式的一种实现但是除了发布者和监听者者两个角色之外还有一个EventMultiCaster的角色负责把事件转发给监听者。
事件发布器ApplicationEventMulticaster又叫事件发布器、事件多播器。对应于观察者模式中的被观察者/主题 负责通知观察者。对外提供发布事件和增删事件监听器的接口维护事件和事件监听器之间的映射关系并在事件发生时负责通知相关监听器。
其工作流程如下 EventMultiCaster注册着所有的Listener在上面发布事件的代码中发布者调用applicationEventPublisher.publishEvent(msg); 是会将事件发送给了EventMultiCaster然后EventMultiCaster根据事件类型决定转发给那个Listener。
讲完了Spring事件体系中的三个组件我们就明白了他们之间的关系和运作流程。下面我们再详细讲一下如何使用它。 三、Spring监听器的使用
3.1 新建监听器
3.1.1 通过实现ApplicationListener接口创建监听器
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;Component
public class MyContextRefreshedListener implements ApplicationListenerContextRefreshedEvent {Overridepublic void onApplicationEvent(ContextRefreshedEvent event) {System.out.println(应用程序上下文已刷新);// 在这里可以执行一些初始化操作}
}
我们创建了一个名为MyContextRefreshedListener的监听器它实现了ApplicationListener接口并且传入的泛型是ContextRefreshedEvent这意味着这个监听器监听的事件类型是ContextRefreshedEvent。MyContextRefreshedListener重写了 onApplicationEvent 方法。因为Spring会在容器refresh()时发布ContextRefreshedEvent事件所以onApplicationEvent方法在应用程序上下文被刷新时触发。使用 Component 注解将该监听器声明为一个Spring管理的组件这样Spring会自动将其纳入到应用程序上下文中并在适当的时候触发监听。 3.1.2 使用EventListener注解创建监听器
除了手动写个类外我们也可以找个现成的类该类不需要继承或实现任何其他类只需要在它的某个方法上加上 EventListener 注解就可以实现监听器的功能如下
Component
public class MyListener {EventListener(ContextRefreshedEvent.class)public void methodA(ContextRefreshedEvent event) {System.out.println(应用程序上下文已刷新);// 在这里可以执行一些初始化操作}
}
在一个现有的类的某个方法上加上EventListener(ContextRefreshedEvent.class)Spring会在加载这个类时为其创建一个监听器这个监听器监听的事件类型是ContextRefreshedEvent当此事件发生时将触发执行该方法methodA。使用 Component 注解将该类声明为一个Spring管理的组件这样Spring会自动将其纳入到应用程序上下文中并在适当的时候触发监听。我们可以在这个类中写上多个方法每个方法通过注解监听着不同的事件类型这样我们就仅需使用一个类却构建了多个监听器。
上述两种方法的效果是一样的。那么最后我们就完成了Spring中一个内置监听器的简单示例当启动一个基于Spring的应用程序时当应用程序上下文被刷新时ContextRefreshedEvent事件将被触发然后MyContextRefreshedListener监听器的onApplicationEvent方法将被调用。
3.2 内置的事件类型
我们在demo中使用了一个 ContextRefreshedEvent 的事件这个事件是Spring内置的事件除了该事件Spring还内置了一些其他的事件类型分别在以下情况下触发 ContextRefreshedEvent 当应用程序上下文被刷新时触发。这个事件在ApplicationContext初始化或刷新时被发布适用于执行初始化操作和启动后的后续处理。例如初始化缓存、预加载数据等。 ContextStartedEvent
当应用程序上下文启动时触发。这个事件在调用ApplicationContext的start()方法时被发布适用于在应用程序启动时执行特定的操作。例如启动定时任务、启动异步消息处理等。 ContextStoppedEvent
当应用程序上下文停止时触发。这个事件在调用ApplicationContext的stop()方法时被发布适用于在应用程序停止时执行清理操作。例如停止定时任务、关闭数据库连接等。 ContextClosedEvent
当应用程序上下文关闭时触发。这个事件在调用ApplicationContext的close()方法时被发布适用于在应用程序关闭前执行最后的清理工作。例如释放资源、保存日志等。 RequestHandledEvent
在Web应用程序中当一个HTTP请求处理完成后触发。这个事件在Spring的DispatcherServlet处理完请求后被发布适用于记录请求日志、处理统计数据等。 ApplicationEvent
这是一个抽象的基类可以用于定义自定义的应用程序事件。你可以创建自定义事件类继承自ApplicationEvent并定义适合你的应用场景的事件类型。
这些内置监听器是由Spring框架自动发布的。不需要程序员去发布。 3.3 自定义事件与监听器Demo
在学习完上面的内容后我们现在可以手动写个Spring的事件以及对应的监听器的demo了
3.3.1 构建两个自定义事件
Spring通过继承ApplicationEvent抽象类来创建自定义事件。下面我们来建立一个继承自ApplicationEvent的自定义事件类。
// 事件A
public class CustomEventA extends ApplicationEvent {private String message;public CustomEventA(Object source, String message) {super(source);this.message message;}public String getMessage() {return message;}public void setMessage(String message) {this.message message;}
}// 事件B
public class CustomEventB extends ApplicationEvent {private String message;public CustomEventB(Object source, String message) {super(source);this.message message;}public String getMessage() {return message;}public void setMessage(String message) {this.message message;}
}3.3.2 构建监听
我们选用EventListener注解来实现监听器。
Component
public class MyListener {EventListener(CustomEventA.class)public void methodA(CustomEventA event) {System.out.println(我监听到事件A了: event.getMessage());// 在这里可以执行一些其他操作}EventListener(CustomEventB.class)public void methodB(CustomEventB event) {System.out.println(我监听到事件B了: event.getMessage());// 在这里可以执行一些其他操作}
}
3.3.3 发布事件
Component
// 这里将这个CustomEvent事件发布器也设置成一个事件监听器了去监听ContextRefreshedEvent事件当这个时间发生之后就会自动去发布CustomEvent事件
public class CustomEventPublisher implements ApplicationContextAware, ApplicationListenerContextRefreshedEvent {private ApplicationContext applicationContext;Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext applicationContext;}// 利用容器刷新好的消息作为触发去发布两条自定义的事件Overridepublic void onApplicationEvent(ContextRefreshedEvent event) {// 创建事件CustomEventA eventA new CustomEventA(applicationContext , 我是AAAA);CustomEventB eventB new CustomEventB(applicationContext , 我是BBBB);// 发布事件applicationContext.publishEvent(eventA);applicationContext.publishEvent(eventB);}
}
