观察者模式在Spring中的应用

观察者模式在Spring中的主要体现在事件监听，事件机制的实现需要三个部分,事件源,事件,事件监听器；
1 ApplicationEvent抽象类作为事件的父类，通过source获取事件源。

public abstract class ApplicationEvent extends EventObject {
    private static final long serialVersionUID = 7099057708183571937L;
    private final long timestamp = System.currentTimeMillis();

    public ApplicationEvent(Object source) {
        super(source);
    }

    public final long getTimestamp() {
        return this.timestamp;
    }
}

2 ApplicationListener接口作为事件监听器，继承自EventListener

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

3 ApplicationContext接口作为事件源，在这里可以将监听器注册进应用上下文中，也可以触发指定的事件。在ApplicationContext的父类ApplicationEventPublisher中有这样一个方法publishEvent，用以发布事件，具体的实现类在AbstractApplicationContext中。

default void publishEvent(ApplicationEvent event) {
        this.publishEvent((Object)event);
    }

    void publishEvent(Object var1);

同样在AbstractApplicationContext中有方法registerListeners，可以注册监听器。

    protected void registerListeners() {  
    // Register statically specified listeners first.  
    for (ApplicationListener<?> listener : getApplicationListeners()) {  
    getApplicationEventMulticaster().addApplicationListener(listener);  
    }  
    // Do not initialize FactoryBeans here: We need to leave all regular beans  
    // uninitialized to let post-processors apply to them!  
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);  
    for (String lisName : listenerBeanNames) {  
    getApplicationEventMulticaster().addApplicationListenerBean(lisName);  
    }  
  }  

下面模拟Spring的监听器原理自己实现一个登陆登出事件的监听机制。
1 事件类（ApplicationEvent）

@Data
public class Event implements Serializable {
    //事件源，谁触发的
    private Object source;
    //触发类型的标记
    private String trigger;
    //通知的目标对象
    private Object  target;
    //通知的目标的方法
    private Method callback;

    //触发时间
    private long time;

    public Event() {
    }

    public Event(Object target, Method callback) {
        this.target = target;
        this.callback = callback;
    }
}

2 事件监听抽象类，或者接口（ApplicationListener）

/**
 * 事件监听器
 */
@Slf4j
public abstract class EventListener {
    /**
     * 存放事件
     */
    private List<Event> eventList = new ArrayList<>();

    /**
     * 添加事件监听
     */
    public void addEvent(Object target, Method method) {
        Event event = new Event(target, method);
        eventList.add(event);
    }

    /**
     * 删除事件监听
     */
    public void removeEvent(Event e) {
        eventList.remove(e);
    }

    /**
     * 通过事件触发
     */
    public void trigger(Event event) {
        event.setSource(this);
        event.setTime(System.currentTimeMillis());
        try {
            //调用指定的方法
            event.getCallback().invoke(event.getTarget(), event);
        } catch (Exception e) {
            log.info(e.getMessage());
        }
    }

    /**
     * 通过事件 类型出发，存储事件的集合可以使用Map,自定义类型属性
     */
}

3 具体事件，继承自事件监听抽象类（ApplicationContext）

/**
 * 实例对象，具体的被观察者，即被监听的事件实现类
 */
public class ConcreteSubject extends EventListener {

    /**
     * 模拟登陆推出，异常事件监听
     */
    public void login(Event loginEvent) {
        System.out.println("登陆事件");
        super.trigger(loginEvent);
    }

    public void logout(Event logoutEvent) {
        System.out.println("登出事件");
        super.trigger(logoutEvent);
    }

    public void exception(Event exceptionEvent) {
        System.out.println("异常事件");
        super.trigger(exceptionEvent);
    }

}

4 对于监听到指定事件给出相应的反馈类

/**
 * 观察者方法，模拟观察者观察到指定事件后相应的动作
 */
public class LogEventCallback {

    public void login(Event event) {
        System.out.println("=======用户登陆======" + event);
    }

    public void logout(Event event) {
        System.out.println("=======用户登出======" + event);
    }

    public void exception(Event event) {
        System.out.println("=======异常======" + event);
    }
}

5 测试类，测试登陆事件的监听机制

public class LogEventTest {

    public static void main(String[] args) throws NoSuchMethodException {
        LogEventCallback target = new LogEventCallback();
        //通过反射获取指定的方法
        Method login = target.getClass().getDeclaredMethod("login", Event.class);
        Method logout = target.getClass().getDeclaredMethod("logout", Event.class);
        Method exception = target.getClass().getDeclaredMethod("exception", Event.class);
        ConcreteSubject object = new ConcreteSubject();
        //将监听事件放进监听类中，与Spring中的ApplicationContext功能相同
        object.addEvent(target, logout);
        object.addEvent(target, login);
        object.addEvent(target, exception);

        object.trigger(new Event(target, login));

    }
}