springboot使用观察者模式 spring 观察者模式

1.spring 是一个强大的应用结构，有很多优点，设计模式也是应用的淋淋尽致，一下简单介绍spring 中观察者应用。

首先我们通过源码可以清晰的知道，在我们spring beandefinition等初始化之后，有一个监听器注册的方法

// Check for listener beans and register them.
registerListeners();

这是注册的一个入口，

看上述代码，大致描述下，首先获取实现spplicationlistener接口的所有类，将其注册到容器中，然后创建发布监听，

可以看到，这里做的工作就是启动任务线程，任务的最终调用是调用实现applicationlistener的

onApplicationEvent方法

整个过程就是这样，那么让我们简单实现模拟一个这样的过程

1.编写一个监听器
package com.consult.listen;
import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationListener;public class MyListen implements ApplicationListener {
    public void onApplicationEvent(ApplicationEvent arg0) {
         
         if(arg0 instanceof MyEvent) {
             MyEvent event = (MyEvent)arg0;
             
             System.out.println(this.getClass().getName() + event.getParam1());
             System.out.println(this.getClass().getName() + event.getParam2());
             System.out.println(this.getClass().getName() + event.getSource());
             
         }
     }
     
 }2.监听事件
package com.consult.listen;
import org.springframework.context.ApplicationEvent;
public class MyEvent extends ApplicationEvent {
     
     public String param1;
     
     public String param2;
     
    public MyEvent(Object source,String param1,String param2) {
         super(source);
         this.param1 = param1;
         this.param2 = param2;
     }    public Object getSource() {
         return super.getSource();
     }    public String getParam1() {
         return param1;
     }    public void setParam1(String param1) {
         this.param1 = param1;
     }    public String getParam2() {
         return param2;
     }    public void setParam2(String param2) {
         this.param2 = param2;
     }
     
 }
 注意一定定义一个构造函数，测试类如下：package com.consult.listen;
import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import com.consult.postprocess.Student;
@RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(locations = "classpath:applicationContext.xml")
 public class MyTest implements ApplicationContextAware {
     
     public ApplicationContext context;
     
     @Test
     public void test1(){
         
         Student s = (Student)context.getBean("jackstudent");
         
         System.out.println(s.getUsername());
         System.out.println(s.getPassword());
         System.out.println(s.getSchool());
     }    @Override
     public void setApplicationContext(ApplicationContext arg0)
             throws BeansException {
         this.context = arg0;
         
     }
     
     @Test
     public void test2() {
         MyEvent event = new MyEvent("source","param1","param2");
         context.publishEvent(event);
     }
     
     }

以上测试类配置没有写，搞这个的很简单，大致代码如上述。
好了，整个的源码解析和简单应用就是这样。下面是模式的基础概念：

一. 观察者模式简介
1. 定义
观察者模式：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖它的对象都会得到通知并自动更新。

2. 意义

此设计模式最重要的作用就是 解耦！将观察者与被观察者解耦，使得他们之间的依赖性更小。

Subject：就是“被观察”的角色，它将所有观察者对象的引用保存在一个集合中。
Observer：是抽象的“观察”角色，它定义了一个更新接口，使得在被观察者状态发生改变时通知自己。
ConcreteObserver：具体的观察者。
二. 观察者模式实现
以上理论相信大家并不模式，现在我们来应用到实际中。

1. 被观察者Subject对象
首先是一个Subject类的父类，它实现了维护装有观察者引用集合的功能。

public class Subject {
     //保存注册的观察者对象
     private List<Observer> mObervers = new ArrayList<>();    //注册观察者对象
     public void attach(Observer observer) {
         mObervers.add(observer);
         Log.e("SZH", "attach an observer");
     }    //注销观察者对象
     public void detach(Observer observer) {
         mObervers.remove(observer);
         Log.e("SZH", "detach an observer");
     }    //通知所有注册的观察者对象
     public void notifyEveryOne(String newState) {
         for (Observer observer : mObervers) {
             observer.update(newState);
         }
     }
 }

 接着是一个具体的被观察者对象public class ConcreteSubject extends Subject {
     private String state;    public String getState() {
         return state;
     }    public void change(String newState) {
         state = newState;
         Log.e("SZH", "concreteSubject state:" + newState);        //状态发生改变，通知观察者
         notifyEveryOne(newState);
     }
 }

 2. 观察者Observer对象
 首先是一个接口，抽象出了一个及时更新的方法public interface Observer {
     void update(String newState);
 }
 1
 2
 3
 接着是几个观察者对象。public class ObserverA implements Observer {
    //观察者状态
     private String observerState;    @Override
     public void update(String newState) {
         //更新观察者状态，让它与目标状态一致
         observerState = newState;
         Log.e("SZH", "接收到消息：" + newState + "；我是A模块，快来抢吧！！");
     }
 }public class ObserverB implements Observer {
     //观察者状态
     private String observerState;    @Override
     public void update(String newState) {
         //更新观察者状态，让它与目标状态一致
         observerState = newState;
         Log.e("SZH", "接收到消息：" + newState + "；我是B模块，快来抢吧！！");
     }
 }public class ObserverC implements Observer {
     //观察者状态
     private String observerState;    @Override
     public void update(String newState) {
         //更新观察者状态，让它与目标状态一致
         observerState = newState;
         Log.e("SZH", "接收到消息：" + newState + "；我是C模块，快来抢吧！！");
     }
 }