观察者模式思考

2019-11-28 本文已影响0人追梦小蜗牛

woman-wearing-white-and-red-dress-standing-and-leaning-2789817.jpg

定义：

定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且执行对应的逻辑。

角色：

1、主题：也可以称为被观察者，在一对多的关系中，扮演的是一，一个主题可以有多个观察者。举个例子：约上几个朋友到河南烩面馆去吃烩面，由于人多，需要排队，每人发一个号；这个河南烩面馆就可以理解成一个主题，有自己的状态变化：烩面是否做好。
2、观察者：在一对多的关系中，扮演的是多。上面那个例子中，我和几个朋友都可以看作这家面馆的观者者，一旦我们的饭做好了，我们都会收到对应的通知，服务员会把对应的烩面端过来或者我们自己去拿。

实现原理：

一个主题是有状态的，也就是真正有数据的人，这些状态或者数据在某些场景下都有可能发生变化，当发生变化的时候，如果希望需要响应这些变化的观察者收到通知和数据，那就需要把这些观者者注册到这个主题上面。也就是要在他们之间架起一座桥梁，这两个角色肯定要有某种联系，不管这种联系是怎么实现的，反正要有，不然的话，凭什么你主题一变化，观察者就能知道并且收到对应的变化数据。这个里面采取的方式是在主题类里面保存一个观察者列表，当主题内部状态发生变化的时候，会遍历这个列表，调用观察者的方法。

类图

类图.png

应用场景：

这个模式还是挺实用的，在jdk或者很多开源框架里面都会有这种思想体现或者是这种思想的延伸。像消息队列的发布订阅，其实就是运用的这种模式。spring的event事件通知，也是这种模式，下面会以源码的形式介绍。其他的只要有类似有一个有状态的核心的点，然后其他点的业务变化需要依赖这个核心点的状态变化，都可以借鉴这个模式。

spring的event通知：
spring框架提供的事件处理功能，其实就是通过继承ApplicationEvent和实现ApplicationListener接口来实现的。ApplicationListener接口的实现者其实就是一个观察者，而ApplicationContext就可以理解成主题，每一次当Event被发布到spring上下文的时候，对应event的Listener Bean都会被通知、调用。
spring提供了很多种event，每一种event都有对应的使用场景，例如：ContextRefreshedEvent是在调用ConfigurableApplicationContext的refresh方法中finishRefresh方法中发布的：

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

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

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

    protected void finishRefresh() {
        // Clear context-level resource caches (such as ASM metadata from scanning).
        clearResourceCaches();

        // Initialize lifecycle processor for this context.
        initLifecycleProcessor();

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

        // Publish the final event.
        publishEvent(new ContextRefreshedEvent(this));

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

也就是上面的publishEvent方法实现的。
像ContextStartedEvent和ContextStoppedEvent分别是在调用AbstractApplicationContext的start和stop方法触发发布的，代码如下：

    @Override
    public void start() {
        getLifecycleProcessor().start();
        publishEvent(new ContextStartedEvent(this));
    }

    @Override
    public void stop() {
        getLifecycleProcessor().stop();
        publishEvent(new ContextStoppedEvent(this));
    }

publishEvent最终会调用SimpleApplicationEventMulticaster类的multicastEvent方法，详细代码如下：

    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        Executor executor = getTaskExecutor();
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            }
            else {
                invokeListener(listener, event);
            }
        }
    }

查询和当前event关联的listener（观察者），然后提交给线程池执行，调用onApplicationEvent方法，执行定义的业务逻辑。

Tomcat的Lifecycle：
Tomcat中控制各个组件的生命周期的Lifecycle用的也是这种模式；
比如：StandardServer Server组件
Lifecycle接口：抽象主题
StandardServer类：具体的主题
LifecycleListener接口：抽象观察者
NamingContextListener类：具体的观察者
StandardServer类继承了LifecycleBase抽象类、实现了Server接口。LifecycleBase统一封装了新增、删除Listener（观察者）的方法，还有start()、stop()、destroy()方法的实现；startInternal()这个方法在子类里面实现，里面包含触发Listener执行逻辑的方法，代码如下：

@Override
    protected void startInternal() throws LifecycleException {

        fireLifecycleEvent(CONFIGURE_START_EVENT, null);
        setState(LifecycleState.STARTING);

        globalNamingResources.start();

        // Start our defined Services
        synchronized (servicesLock) {
            for (Service service : services) {
                service.start();
            }
        }

        if (periodicEventDelay > 0) {
            monitorFuture = getUtilityExecutor().scheduleWithFixedDelay(
                    new Runnable() {
                        @Override
                        public void run() {
                            startPeriodicLifecycleEvent();
                        }
                    }, 0, 60, TimeUnit.SECONDS);
        }
    }

然后执行LifecycleListener中的lifecycleEvent()方法，本例指的是NamingContextListener类中的lifecycleEvent方法，里面有很多逻辑。其实这个NamingContextListener的关联是在StandardServer的构造方法里面，如下图：

image.png

StandardServer的类图：

Server类图.png

总结：

感觉java里面的很多模式和写代码思想都可以在现实生活中找到原型，如果碰到一些难懂的思想，可以结合一下生活中是否有对应的场景，结合着去思考，会更好想明白一点。有些东西看着很高深，一旦你决定想深入进去，并且去做了，其实他们的内部实现没那么复杂的，所以要多深入进去学习，多实践，验证。

观察者模式思考

定义：

角色：

实现原理：

类图

应用场景：

总结：

猜你喜欢

热点阅读