Dubbo源码分析：全透明接入spring和ServiceBean和Referencebean的接口设计与实现

亦凉 2022-04-02 18:36 151阅读 0赞

### Spring Schema XML拓展机制：dubbo全透明融入spring的实现基础 ###

*  在spring项目启动，会加载并解析resources目录下的xml，然后将xml配置文件中的配置加载成spring容器的bean，dubbo需要定义dubbo\_provider.xml或consumer\_provider.xml并加入到applicationContext.xml中。

<?xml version="1.0"encoding="UTF-8"?> 
 <web-app id="WebApp_ID" version="2.4"xmlns="http://java.sun.com/xml/ns/j2ee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> 
 <context-param> 
 <param-name>contextConfigLocation</param-name> 
 <param-value>/WEB-INF/applicationContext.xml,/WEB-INF/controllers.xml,/WEB-INF/service.xml</param-value> 
 </context-param> 
 
 <listener> 
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
 </listener> 
 
 <servlet> 
 <servlet-name>dispatch</servlet> 
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
 <init-param> 
 <param-name>contextConfigLocation</param-name> 
 <param-value>/WEB-INF/applicationContext.xml</param-value> 
 </init-param> 
 </servlet> 
 <servlet-mapping> 
 <servlet-name>dispatch</servlet-name> 
 <servlet-pattern>*.*</servlet-pattern> 
 </servlet-mapping> 
 </web-app>

如applicationContext.xml，如下：

通过import标签导入provider.xml到applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
 
 	
 
 	
 	<dubbo:application name="hello-world-app" />
 
 	
 	<dubbo:registry address="redis://localhost:6379" timeout="30000">
 		
 		
 		<dubbo:parameter key="max.idle" value="10" />
 		<dubbo:parameter key="min.idle" value="5" />
 		<dubbo:parameter key="max.active" value="20" />
 		<dubbo:parameter key="max.total" value="100" />
 	</dubbo:registry>
 
 	
 	<dubbo:protocol name="dubbo" port="20880" accesslog="true" />
 	
 	
 	<bean id="defaultService" class="org.niugang.service.DefaultServiceImpl" />
 	
 	<dubbo:service interface="org.niugang.service.DefaultApiService" ref="defaultService" />
 </beans>

1.  如果是spring boot项目，则通过在@Configuration的config类中使用@ImportResource注解加载xml文件，如下：

@Configuration
    @PropertySource("classpath:dubbo.properties")
    @ImportResource({  "classpath:dubbo_consumer.xml","classpath:dubbo_provider.xml" })
    public class DubboConfig

实现原理是：spring项目启动的时候，加载applicationContext.xml，然后加载dubbo的provider.xml，在加载provider.xml时，解析  
[http://code.alibabatech.com/schema/dubbo，][http_code.alibabatech.com_schema_dubbo]  
即dubbo的标签定义时，会使用dubbo jar包的  
dubbo-config-spring的META-INF的spring.handlers的配置：

http\://dubbo.apache.org/schema/dubbo=org.apache.dubbo.config.spring.schema.DubboNamespaceHandler
    http\://code.alibabatech.com/schema/dubbo=org.apache.dubbo.config.spring.schema.DubboNamespaceHandler

即使用dubbo提供的DubboNamespaceHandler来完成解析和生成spring的bean，从而正式进入dubbo框架。

*  DubboNamespaceHandler：xml文件的解析和注册bean

public class DubboNamespaceHandler extends NamespaceHandlerSupport { 
    
        static { 
            Version.checkDuplicate(DubboNamespaceHandler.class);
        }
    
        @Override
        public void init() { 
            registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
            registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
            registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
            registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
            registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
            registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
            registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
            registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
            registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
            registerBeanDefinitionParser("annotation", new AnnotationBeanDefinitionParser());
        }
    
    }

使用registerBeanDefinitionParser方法解析xml文件配置，生成spring容器的beanDefinition并注册到BeanDefinitionRegistry中。beanDefinition是bean的一个描述类，之后spring容器从BeanDefinitionRegistry中取出beanDefinition，并使用InstantiationStrategy来真正实例化，创建bean实例。

### ServiceBean和Referencebean的接口设计 ###

ServiceBean和ReferenceBean继承了InitializingBean，DisposableBean，FactoryBean等，故当spring使用InstantiationStrategy来进行实例化，创建bean实例时，会根据这里的接口定义，实现bean的自定义实例化过程。

1.  ReferenceBean

public class ReferenceBean<T> extends ReferenceConfig<T> implements FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean

1.  ServiceBean

public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, BeanNameAware

以下是这些接口的作用：

#### InitializingBean：在bean的所有属性都设好值后，自定义bean的实例化过程 ####

package org.springframework.beans.factory;
 
 /** * Interface to be implemented by beans that need to react once all their * properties have been set by a BeanFactory: for example, to perform custom * initialization, or merely to check that all mandatory properties have been set. * * An alternative to implementing InitializingBean is specifying a custom * init-method, for example in an XML bean definition. * For a list of all bean lifecycle methods, see the BeanFactory javadocs. * * @author Rod Johnson * @see BeanNameAware * @see BeanFactoryAware * @see BeanFactory * @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName * @see org.springframework.context.ApplicationContextAware */
 public interface InitializingBean { 
 
 	/** * Invoked by a BeanFactory after it has set all bean properties supplied * (and satisfied BeanFactoryAware and ApplicationContextAware). * This method allows the bean instance to perform initialization only * possible when all bean properties have been set and to throw an * exception in the event of misconfiguration. * @throws Exception in the event of misconfiguration (such * as failure to set an essential property) or if initialization fails. */
 	void afterPropertiesSet() throws Exception;
 
 }

*  提供了一个afterPropertiesSet方法，在bean的所有属性通过Spring的beanFactory设值之后，可以在afterPropertiesSet方法中，自定义一些初始化操作，即
 *  在ServiceBean中是初始化application，module，registries，monitor，path。最后调用export方法进行注册。
 *  在ReferenceBean中，除了进行application，module，monitor等设值外，会调用FactoryBean的getObject生成服务代理proxy。具体看FactoryBean。

#### FactoryBean：spring容器BeanFactory获取bean的实例对象 ####

package org.springframework.beans.factory;
 
 /** * Interface to be implemented by objects used within a {@link BeanFactory} which * are themselves factories for individual objects. If a bean implements this * interface, it is used as a factory for an object to expose, not directly as a * bean instance that will be exposed itself. * * NB: A bean that implements this interface cannot be used as a normal bean. * A FactoryBean is defined in a bean style, but the object exposed for bean * references ({@link #getObject()}) is always the object that it creates. * * FactoryBeans can support singletons and prototypes, and can either create * objects lazily on demand or eagerly on startup. The {@link SmartFactoryBean} * interface allows for exposing more fine-grained behavioral metadata. * * This interface is heavily used within the framework itself, for example for * the AOP {@link org.springframework.aop.framework.ProxyFactoryBean} or the * {@link org.springframework.jndi.JndiObjectFactoryBean}. It can be used for * custom components as well; however, this is only common for infrastructure code. * * {@code FactoryBean} is a programmatic contract. Implementations are not * supposed to rely on annotation-driven injection or other reflective facilities. * {@link #getObjectType()} {@link #getObject()} invocations may arrive early in * the bootstrap process, even ahead of any post-processor setup. If you need access * other beans, implement {@link BeanFactoryAware} and obtain them programmatically. * * Finally, FactoryBean objects participate in the containing BeanFactory's * synchronization of bean creation. There is usually no need for internal * synchronization other than for purposes of lazy initialization within the * FactoryBean itself (or the like). * * @author Rod Johnson * @author Juergen Hoeller * @since 08.03.2003 * @see org.springframework.beans.factory.BeanFactory * @see org.springframework.aop.framework.ProxyFactoryBean * @see org.springframework.jndi.JndiObjectFactoryBean */
 public interface FactoryBean<T> { 
 
 	/** * Return an instance (possibly shared or independent) of the object * managed by this factory. * As with a {@link BeanFactory}, this allows support for both the * Singleton and Prototype design pattern. * If this FactoryBean is not fully initialized yet at the time of * the call (for example because it is involved in a circular reference), * throw a corresponding {@link FactoryBeanNotInitializedException}. * As of Spring 2.0, FactoryBeans are allowed to return {@code null} * objects. The factory will consider this as normal value to be used; it * will not throw a FactoryBeanNotInitializedException in this case anymore. * FactoryBean implementations are encouraged to throw * FactoryBeanNotInitializedException themselves now, as appropriate. * @return an instance of the bean (can be {@code null}) * @throws Exception in case of creation errors * @see FactoryBeanNotInitializedException */
 	T getObject() throws Exception;
 
 	/** * Return the type of object that this FactoryBean creates, * or {@code null} if not known in advance. * This allows one to check for specific types of beans without * instantiating objects, for example on autowiring. * In the case of implementations that are creating a singleton object, * this method should try to avoid singleton creation as far as possible; * it should rather estimate the type in advance. * For prototypes, returning a meaningful type here is advisable too. * This method can be called before this FactoryBean has * been fully initialized. It must not rely on state created during * initialization; of course, it can still use such state if available. * NOTE: Autowiring will simply ignore FactoryBeans that return * {@code null} here. Therefore it is highly recommended to implement * this method properly, using the current state of the FactoryBean. * @return the type of object that this FactoryBean creates, * or {@code null} if not known at the time of the call * @see ListableBeanFactory#getBeansOfType */
 	Class<?> getObjectType();
 
 	/** * Is the object managed by this factory a singleton? That is, * will {@link #getObject()} always return the same object * (a reference that can be cached)? * NOTE: If a FactoryBean indicates to hold a singleton object, * the object returned from {@code getObject()} might get cached * by the owning BeanFactory. Hence, do not return {@code true} * unless the FactoryBean always exposes the same reference. * The singleton status of the FactoryBean itself will generally * be provided by the owning BeanFactory; usually, it has to be * defined as singleton there. * NOTE: This method returning {@code false} does not * necessarily indicate that returned objects are independent instances. * An implementation of the extended {@link SmartFactoryBean} interface * may explicitly indicate independent instances through its * {@link SmartFactoryBean#isPrototype()} method. Plain {@link FactoryBean} * implementations which do not implement this extended interface are * simply assumed to always return independent instances if the * {@code isSingleton()} implementation returns {@code false}. * @return whether the exposed object is a singleton * @see #getObject() * @see SmartFactoryBean#isPrototype() */
 	boolean isSingleton();
 
 }

*  这个接口定义如何来获取指定类型的对象，可以是单例或原型，通过实现这个接口，可以控制该类型bean实例的获取。FactoryBean实例主要是Spring框架自身的BeanFactory调用。所以如果我们想控制某个类型bean实例的获取，即对spring容器BeanFactory的getBean方法如何获取某个类型的bean实例做控制，则可以实现接口，实现它的getObject()，isSingleton方法。
 *  ReferenceBean

1.  由于在客户端是对服务端的Service的引用reference，不是真实的service bean，故获取这个reference时，其实是获取了一个到服务端Service的proxy。故通过spring容器获取这个Service的bean时，需要返回一个proxy。ReferenceBean实现FactoryBean接口，isSingleton方法返回为true，getObject()创建并返回客户端的service proxy，即refer。
2.  为了之后客户端调用的性能考虑，在spring启动时，dubbo提前初始化好refer代理，之后spring容器获取该bean，如在BeanFactory调用getBean方法时，getObject可以直接返回refer代理了，而不是等到调用时再初始化生成refer代理。提前初始化refer的具体实现为在InitializingBean的afterPropertiesSet的方法中调用getObject，getObject最终会调用com.alibaba.dubbo.config.ReferenceConfig\#get方法完成远程服务调用代理类的创建。

*  ServiceBean：没有实现FactoryBean接口，原因是服务端的Service bean就是提高功能的bean了，就跟用@Service描述的bean一样，所以spring就按照正常流程，使用spring内置的FactoryBean接口创建即可。但是由于是rpc服务，跟其他service不一样的是，需要注册到注册中心，并且开启监听端口，监听客户端的连接请求，故需要实现InitializingBean接口，在Service bean的属性设置好之后，在InitializingBean的afterPropertiesSet方法中，调用com.alibaba.dubbo.config.ServiceConfig\#export方法进行服务暴露。
 *  更多关于FactoryBean可以看：[https://www.cnblogs.com/davidwang456/p/3688250.html][https_www.cnblogs.com_davidwang456_p_3688250.html]

#### DisposableBean：自定义spring容器管理的单实例bean的销毁操作 ####

/** * Interface to be implemented by beans that want to release resources * on destruction. A BeanFactory is supposed to invoke the destroy * method if it disposes a cached singleton. An application context * is supposed to dispose all of its singletons on close. * * An alternative to implementing DisposableBean is specifying a custom * destroy-method, for example in an XML bean definition. * For a list of all bean lifecycle methods, see the BeanFactory javadocs. * * @author Juergen Hoeller * @since 12.08.2003 * @see org.springframework.beans.factory.support.RootBeanDefinition#getDestroyMethodName * @see org.springframework.context.ConfigurableApplicationContext#close */
 public interface DisposableBean { 
 
 	/** * Invoked by a BeanFactory on destruction of a singleton. * @throws Exception in case of shutdown errors. * Exceptions will get logged but not rethrown to allow * other beans to release their resources too. */
 	void destroy() throws Exception;
 
 }

*  这个接口主要是针对spring单实例缓存中singleton bean的释放，即在关闭Spring容器，BeanFactory释放和销毁容器中的单例bean时，会调用这个接口的destroy方法。故类可以通过实现这个接口，在destroy方法中自定义如何销毁该类单例实例。
 *  ServiceBean

@Override
    public void destroy() throws Exception { 
        // This will only be called for singleton scope bean, and expected to be called by spring shutdown hook when BeanFactory/ApplicationContext destroys.
        // We will guarantee dubbo related resources being released with dubbo shutdown hook.
        //unexport();
    }

ServiceBean的bean的释放最初设计是通过destroy方法来unexport的，后来被apache孵化后，是通过添加spring的关闭钩子shutdown hook来做的，不在destroy方法中执行（如上代码unexport()注释掉了），如下为spring的shutdown hook：

/** * The shutdown hook thread to do the clean up stuff. * This is a singleton in order to ensure there is only one shutdown hook registered. * Because {@link ApplicationShutdownHooks} use {@link java.util.IdentityHashMap} * to store the shutdown hooks. */
 public class DubboShutdownHook extends Thread { 
 
 private static final Logger logger = LoggerFactory.getLogger(DubboShutdownHook.class);
 
 private static final DubboShutdownHook dubboShutdownHook = new DubboShutdownHook("DubboShutdownHook");
 
 public static DubboShutdownHook getDubboShutdownHook() { 
 return dubboShutdownHook;
 }
 
 /** * Has it already been destroyed or not? */
 private final AtomicBoolean destroyed;
 
 private DubboShutdownHook(String name) { 
 super(name);
 this.destroyed = new AtomicBoolean(false);
 }
 
 @Override
 public void run() { 
 if (logger.isInfoEnabled()) { 
 logger.info("Run shutdown hook now.");
 }
 destroyAll();
 }
 
 /** * Destroy all the resources, including registries and protocols. */
 public void destroyAll() { 
 if (!destroyed.compareAndSet(false, true)) { 
 return;
 }
 // destroy all the registries
 AbstractRegistryFactory.destroyAll();
 // destroy all the protocols
 destroyProtocols();
 }
 
 /** * Destroy all the protocols. */
 private void destroyProtocols() { 
 ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
 for (String protocolName : loader.getLoadedExtensions()) { 
 try { 
 Protocol protocol = loader.getLoadedExtension(protocolName);
 if (protocol != null) { 
 protocol.destroy();
 }
 } catch (Throwable t) { 
 logger.warn(t.getMessage(), t);
 }
 }
 }
 
 }

DubboShutdownHook是在DubboBootstrap中注册的：

/** * A bootstrap class to easily start and stop Dubbo via programmatic API. * The bootstrap class will be responsible to cleanup the resources during stop. */
    public class DubboBootstrap
    // 核心方法：
    public void start() { 
        if (registerShutdownHookOnStart) { 
            registerShutdownHook();
        } else { 
            // DubboShutdown hook has been registered in AbstractConfig,
            // we need to remove it explicitly
            removeShutdownHook();
        }
        for (ServiceConfig serviceConfig: serviceConfigList) { 
            serviceConfig.export();
        }
    }
    
    public void stop() { 
        for (ServiceConfig serviceConfig: serviceConfigList) { 
            serviceConfig.unexport();
        }
        shutdownHook.destroyAll();
        if (registerShutdownHookOnStart) { 
            removeShutdownHook();
        }
    }
    
    /** * Register the shutdown hook */
    public void registerShutdownHook() { 
        Runtime.getRuntime().addShutdownHook(shutdownHook);
    }
    
    /** * Remove this shutdown hook */
    public void removeShutdownHook() { 
        try { 
            Runtime.getRuntime().removeShutdownHook(shutdownHook);
        }
        catch (IllegalStateException ex) { 
            // ignore - VM is already shutting down
        }
    }

而DubboBootstrap自身实例化和启动，是通过在web-fragment.xml注册context-param，在spring启动时，注册ApplicationListener，在spring启动完成后，调用dubboBootstrap.start()，注册钩子，在关闭时，调用dubboBootstrap.stop()，移除钩子：  
dubbo-config-spring下的web-fragment.xml

<web-fragment version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd">
 
 <name>dubbo-fragment</name>
 
 <ordering>
 <before>
 <others/>
 </before>
 </ordering>
 
 <context-param>
 <param-name>contextInitializerClasses</param-name>
 <param-value>org.apache.dubbo.config.spring.initializer.DubboApplicationContextInitializer</param-value>
 </context-param>
 
 <listener>
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 
 </web-fragment>

DubboApplicationContextInitializer和DubboApplicationListener：

/** * Automatically register {@link DubboApplicationListener} to Spring context * A {@link org.springframework.web.context.ContextLoaderListener} class is defined in * src/main/resources/META-INF/web-fragment.xml * In the web-fragment.xml, {@link DubboApplicationContextInitializer} is defined in context params. * This file will be discovered if running under a servlet 3.0+ container. * Even if user specifies {@link org.springframework.web.context.ContextLoaderListener} in web.xml, * it will be merged to web.xml. * If user specifies <metadata-complete="true" /> in web.xml, this will no take effect, * unless user configures {@link DubboApplicationContextInitializer} explicitly in web.xml. */
 public class DubboApplicationContextInitializer implements ApplicationContextInitializer { 
 
 @Override
 public void initialize(ConfigurableApplicationContext applicationContext) { 
 applicationContext.addApplicationListener(new DubboApplicationListener());
 }
 }
 
 /** * An application listener that listens the ContextClosedEvent. * Upon the event, this listener will do the necessary clean up to avoid memory leak. */
 public class DubboApplicationListener implements ApplicationListener<ApplicationEvent> { 
 
 private DubboBootstrap dubboBootstrap;
 
 public DubboApplicationListener() { 
 dubboBootstrap = new DubboBootstrap(false);
 }
 
 public DubboApplicationListener(DubboBootstrap dubboBootstrap) { 
 this.dubboBootstrap = dubboBootstrap;
 }
 
 @Override
 public void onApplicationEvent(ApplicationEvent applicationEvent) { 
 if (applicationEvent instanceof ContextRefreshedEvent) { 
 dubboBootstrap.start();
 } else if (applicationEvent instanceof ContextClosedEvent) { 
 dubboBootstrap.stop();
 }
 }
 }

*  ReferenceBean  
    自身的destroy不做任何事情，是在ReferenceConfig中实现destroy：

public synchronized void destroy() { 
        if (ref == null) { 
            return;
        }
        if (destroyed) { 
            return;
        }
        destroyed = true;
        try { 
            invoker.destroy();
        } catch (Throwable t) { 
            logger.warn("Unexpected err when destroy invoker of ReferenceConfig(" + url + ").", t);
        }
        invoker = null;
        ref = null;
    }

#### ApplicationListener：spring容器监听器 ####

*  观察者设计模式的一种实现，bean可以实现这个接口，并通过指定泛型的实际类型，即ApplicationEvent的实现类，来监听spring容器产生的特定事件，在onApplicationEvent方法中，自定义实现对该特定事件的响应和处理逻辑。

/** * Interface to be implemented by application event listeners. * Based on the standard {@code java.util.EventListener} interface * for the Observer design pattern. * * As of Spring 3.0, an ApplicationListener can generically declare the event type * that it is interested in. When registered with a Spring ApplicationContext, events * will be filtered accordingly, with the listener getting invoked for matching event * objects only. * * @author Rod Johnson * @author Juergen Hoeller * @param <E> the specific ApplicationEvent subclass to listen to * @see org.springframework.context.event.ApplicationEventMulticaster */
 public interface ApplicationListener<E extends ApplicationEvent> extends EventListener { 
 
 	/** * Handle an application event. * @param event the event to respond to */
 	void onApplicationEvent(E event);
 
 }
 
 /** * Event raised when an {@code ApplicationContext} gets initialized or refreshed. * * @author Juergen Hoeller * @since 04.03.2003 * @see ContextClosedEvent */
 @SuppressWarnings("serial")
 public class ContextRefreshedEvent extends ApplicationContextEvent { 
 
 	/** * Create a new ContextRefreshedEvent. * @param source the {@code ApplicationContext} that has been initialized * or refreshed (must not be {@code null}) */
 	public ContextRefreshedEvent(ApplicationContext source) { 
 		super(source);
 	}
 
 }

*  ServiceBean：实现这个接口，并注册ContextRefreshedEvent事件。ContextRefreshedEvent是在spring容器初始化或者刷新时，产生的事件。ServiceBean对该事件的处理是，执行export导出服务，export方法保证了只导出和注册一次，是可以重复调用的。

@Override
    public void onApplicationEvent(ContextRefreshedEvent event) { 
        if (isDelay() && !isExported() && !isUnexported()) { 
            if (logger.isInfoEnabled()) { 
                logger.info("The service ready on spring started. service: " + getInterface());
            }
            export();
        }
    }
    
    // ServiceConfig的export实现：
    public synchronized void export() { 
        if (provider != null) { 
            if (export == null) { 
                export = provider.getExport();
            }
            if (delay == null) { 
                delay = provider.getDelay();
            }
        }
        if (export != null && !export) { 
            return;
        }
    
        if (delay != null && delay > 0) { 
            delayExportExecutor.schedule(new Runnable() { 
                @Override
                public void run() { 
                    doExport();
                }
            }, delay, TimeUnit.MILLISECONDS);
        } else { 
            doExport();
        }
    }

#### ApplicationContextAware：bean获取ApplicationContext对象，从而可以通过ApplicationContext与其他bean交互或者访问其他资源，如resource文件 ####

bean实现这个接口，并在setApplicationContext方法中自定义该bean需要通过ApplicationContext做什么东西。setApplicationContext方法会在bean的属性赋值完成，但在初始化callback调用之前，如InitializingBean的afterPropertiesSet，调用之前，调用。

/** * Interface to be implemented by any object that wishes to be notified * of the {@link ApplicationContext} that it runs in. * * Implementing this interface makes sense for example when an object * requires access to a set of collaborating beans. Note that configuration * via bean references is preferable to implementing this interface just * for bean lookup purposes. * * This interface can also be implemented if an object needs access to file * resources, i.e. wants to call {@code getResource}, wants to publish * an application event, or requires access to the MessageSource. However, * it is preferable to implement the more specific {@link ResourceLoaderAware}, * {@link ApplicationEventPublisherAware} or {@link MessageSourceAware} interface * in such a specific scenario. * * Note that file resource dependencies can also be exposed as bean properties * of type {@link org.springframework.core.io.Resource}, populated via Strings * with automatic type conversion by the bean factory. This removes the need * for implementing any callback interface just for the purpose of accessing * a specific file resource. * * {@link org.springframework.context.support.ApplicationObjectSupport} is a * convenience base class for application objects, implementing this interface. * * For a list of all bean lifecycle methods, see the * {@link org.springframework.beans.factory.BeanFactory BeanFactory javadocs}. * * @author Rod Johnson * @author Juergen Hoeller * @author Chris Beams * @see ResourceLoaderAware * @see ApplicationEventPublisherAware * @see MessageSourceAware * @see org.springframework.context.support.ApplicationObjectSupport * @see org.springframework.beans.factory.BeanFactoryAware */
 public interface ApplicationContextAware extends Aware { 
 
 	/** * Set the ApplicationContext that this object runs in. * Normally this call will be used to initialize the object. * Invoked after population of normal bean properties but before an init callback such * as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()} * or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader}, * {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and * {@link MessageSourceAware}, if applicable. * @param applicationContext the ApplicationContext object to be used by this object * @throws ApplicationContextException in case of context initialization errors * @throws BeansException if thrown by application context methods * @see org.springframework.beans.factory.BeanInitializationException */
 	void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
 
 }

*  ServiceBean：两个作用

1.  将applicationContext放到dubbo自身维护的一个SpringExtensionFactory，即在dubbo中保存spring容器applicationContext的引用，从而可以在dubbo中通过applicationContext引用查找spring容器中的bean。
2.  在applicationContext中注册容器监听器ApplicationListener，监听ContextRefreshedEvent事件，即自身实例，因为ServiceBean实现了ApplicationListener接口，在ApplicationListener接口的onApplicationEvent中调用export（主要是spring容器重启时调用）。

@Override
    public void setApplicationContext(ApplicationContext applicationContext) { 
        this.applicationContext = applicationContext;
        SpringExtensionFactory.addApplicationContext(applicationContext);
        if (applicationContext != null) { 
            SPRING_CONTEXT = applicationContext;
            try { 
                Method method = applicationContext.getClass().getMethod("addApplicationListener", ApplicationListener.class); // backward compatibility to spring 2.0.1
                method.invoke(applicationContext, this);
                supportedApplicationListener = true;
            } catch (Throwable t) { 
                if (applicationContext instanceof AbstractApplicationContext) { 
                    try { 
                        Method method = AbstractApplicationContext.class.getDeclaredMethod("addListener", ApplicationListener.class); // backward compatibility to spring 2.0.1
                        if (!method.isAccessible()) { 
                            method.setAccessible(true);
                        }
                        method.invoke(applicationContext, this);
                        supportedApplicationListener = true;
                    } catch (Throwable t2) { 
                    }
                }
            }
        }
    }

*  ReferenceBean  
    与ServiceBean的第一个作用一样。

[http_code.alibabatech.com_schema_dubbo]: http://code.alibabatech.com/schema/dubbo%EF%BC%8C
[https_www.cnblogs.com_davidwang456_p_3688250.html]: https://www.cnblogs.com/davidwang456/p/3688250.html