通过上一遍文章整体架构中已经详细了描述了Dubbo框架的整体设计结构和调用流程,接下来,我还是深入源码,详细分析各个层的实现原理,这一篇主要讲述Config层。
由整体的设计可以知道,Config层抽象了外部配置,各个模块的配置都会在Config层来体现。先看一下它的核心实现为org.apache.dubbo.config.AbstractConfig和org.apache.dubbo.config.ArgumentConfig。
AbstractConfig结构图如下:
从上图可以看到,核心的模块配置都会继承AbstractConfig 。但是既然是配置,那么怎么读取这些配置呢?
Dubbo基于Java注解的配置原理
@EnableDubbo是Dubbo使用注解初始化的核心注解,先看一下源码:
/**
* Enables Dubbo components as Spring Beans, equals
* {@link DubboComponentScan} and {@link EnableDubboConfig} combination.
* <p>
* Note : {@link EnableDubbo} must base on Spring Framework 4.2 and above
*
* @author zhaodongchao
* @see DubboComponentScan
* @see EnableDubboConfig
* @since 2.5.8
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@EnableDubboConfig
@DubboComponentScan
@EnableDubboLifecycle
public @interface EnableDubbo {
/**
* Base packages to scan for annotated @Service classes.
* <p>
* Use {@link #scanBasePackageClasses()} for a type-safe alternative to String-based
* package names.
*
* @return the base packages to scan
* @see DubboComponentScan#basePackages()
*/
@AliasFor(annotation = DubboComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
/**
* Type-safe alternative to {@link #scanBasePackages()} for specifying the packages to
* scan for annotated @Service classes. The package of each class specified will be
* scanned.
*
* @return classes from the base packages to scan
* @see DubboComponentScan#basePackageClasses
*/
@AliasFor(annotation = DubboComponentScan.class, attribute = "basePackageClasses")
Class<?>[] scanBasePackageClasses() default {};
/**
* It indicates whether {@link AbstractConfig} binding to multiple Spring Beans.
*
* @return the default value is <code>false</code>
* @see EnableDubboConfig#multiple()
*/
@AliasFor(annotation = EnableDubboConfig.class, attribute = "multiple")
boolean multipleConfig() default true;
}
本身只是定义了几个配置属性,没有具体的实现逻辑。而它上面有标记了三个注解,如下图:
再在@EnableDubbo注解上的上个额外的注解:
- @EnableDubboConfig
从配置文件中解析配置文件,并实例化相关的config对象到spring 容器中
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Import(DubboConfigConfigurationRegistrar.class)
public @interface EnableDubboConfig {
/**
* It indicates(表明) whether binding to multiple(多个) Spring Beans.
*
* @return the default value is <code>false</code>
* @revised 2.5.9
*/
boolean multiple() default true;
}
到这里似乎发现了新大陆,注意**@Import(DubboConfigConfigurationRegistrar.class)**
这里摘录:https://blog.csdn.net/boling_cavalry/article/details/82530167这篇文章中对@Import用法的说明:
在@Import注解的参数中可以填写类名,例如@Import(Abc.class),根据类Abc的不同类型,spring容器有以下四种处理方式:
- 如果Abc类实现了ImportSelector接口,spring容器就会实例化Abc类,并且调用其selectImports方法;
- DeferredImportSelector是ImportSelector的子类,如果Abc类实现了DeferredImportSelector接口,spring容器就会实例化Abc类,并且调用其selectImports方法,和ImportSelector的实例不同的是,DeferredImportSelector的实例的selectImports方法调用时机晚于ImportSelector的实例,要等到@Configuration注解中相关的业务全部都处理完了才会调用(具体逻辑在ConfigurationClassParser.processDeferredImportSelectors方法中),想了解更多DeferredImportSelector和ImportSelector的区别,请参考《ImportSelector与DeferredImportSelector的区别(spring4) 》;
- 如果Abc类实现了ImportBeanDefinitionRegistrar接口,spring容器就会实例化Abc类,并且调用其registerBeanDefinitions方法;
- 如果Abc没有实现ImportSelector、DeferredImportSelector、ImportBeanDefinitionRegistrar等其中的任何一个,spring容器就会实例化Abc类;
现在再看一下DubboConfigConfigurationRegistrar是属于上面说的四种情况的哪一种?
/**
* Dubbo {@link AbstractConfig Config} {@link ImportBeanDefinitionRegistrar register}, which order can be configured
*
* @see EnableDubboConfig
* @see DubboConfigConfiguration
* @see Ordered
* @since 2.5.8
*/
public class DubboConfigConfigurationRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//获取配置类中@EnableDubboConfig这个注解对象
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
importingClassMetadata.getAnnotationAttributes(EnableDubboConfig.class.getName()));
boolean multiple = attributes.getBoolean("multiple");
// Single Config Bindings
registerBeans(registry, DubboConfigConfiguration.Single.class);
/*是否一个配置的多个属性值,如:
# Single configuration binding
dubbo.protocol.name=dubbo
# Multiple configuration binding
dubbo.protcols.rest.name = rest
*/
if (multiple) { // Since 2.6.6 https://github.com/apache/dubbo/issues/3193
registerBeans(registry, DubboConfigConfiguration.Multiple.class);
}
// Register DubboConfigAliasPostProcessor
registerDubboConfigAliasPostProcessor(registry);
// Register NamePropertyDefaultValueDubboConfigBeanCustomizer
registerDubboConfigBeanCustomizers(registry);
}
private void registerDubboConfigBeanCustomizers(BeanDefinitionRegistry registry) {
registerInfrastructureBean(registry, BEAN_NAME, NamePropertyDefaultValueDubboConfigBeanCustomizer.class);
}
/**
* Register {@link DubboConfigAliasPostProcessor}
*
* @param registry {@link BeanDefinitionRegistry}
* @since 2.7.4 [Feature] https://github.com/apache/dubbo/issues/5093
*/
private void registerDubboConfigAliasPostProcessor(BeanDefinitionRegistry registry) {
registerInfrastructureBean(registry, DubboConfigAliasPostProcessor.BEAN_NAME, DubboConfigAliasPostProcessor.class);
}
}
很明显是属于第三种,实现了ImportBeanDefinitionRegistrar接口。因此在程序启动时会实例化DubboConfigConfigurationRegistrar并调用registerBeanDefinitions方法。
这里面有一个核心的对象:DubboConfigConfiguration 。它定义注册那些配置类到spring容器中的核心配置类。
看源码:
/**
* Dubbo {@link AbstractConfig Config} {@link Configuration}
*
* @revised 2.7.5
* @see Configuration
* @see EnableConfigurationBeanBindings
* @see EnableConfigurationBeanBinding
* @see ApplicationConfig
* @see ModuleConfig
* @see RegistryConfig
* @see ProtocolConfig
* @see MonitorConfig
* @see ProviderConfig
* @see ConsumerConfig
* @see org.apache.dubbo.config.ConfigCenterConfig
* @since 2.5.8
*/
public class DubboConfigConfiguration {
/**
* Single Dubbo {@link AbstractConfig Config} Bean Binding
*/
@EnableConfigurationBeanBindings({
@EnableConfigurationBeanBinding(prefix = "dubbo.application", type = ApplicationConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.module", type = ModuleConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.registry", type = RegistryConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.protocol", type = ProtocolConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.monitor", type = MonitorConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.provider", type = ProviderConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.consumer", type = ConsumerConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.config-center", type = ConfigCenterBean.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.metadata-report", type = MetadataReportConfig.class),
@EnableConfigurationBeanBinding(prefix = "dubbo.metrics", type = MetricsConfig.class)
})
public static class Single {
}
/**
* Multiple Dubbo {@link AbstractConfig Config} Bean Binding
*/
@EnableConfigurationBeanBindings({
@EnableConfigurationBeanBinding(prefix = "dubbo.applications", type = ApplicationConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.modules", type = ModuleConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.registries", type = RegistryConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.protocols", type = ProtocolConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.monitors", type = MonitorConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.providers", type = ProviderConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.consumers", type = ConsumerConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.config-centers", type = ConfigCenterBean.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.metadata-reports", type = MetadataReportConfig.class, multiple = true),
@EnableConfigurationBeanBinding(prefix = "dubbo.metricses", type = MetricsConfig.class, multiple = true)
})
public static class Multiple {
}
}
从源码可以知道,@EnableDubboConfig 的作用就是解析配置文件中前缀为:
dubbo.application / dubbo.applications的配置属性 到ApplicationConfig对象实例中,并注册到spring 容器中
dubbo.module / dubbo.modules的配置属性到ModuleConfig对象实例中,并注册到spring 容器中
dubbo.registrie / dubbo.registries的配置属性到RegistryConfig对象实例中,并注册到spring 容器中
dubbo.protocol / dubbo.protocols的配置属性到ProtocolConfig对象实例中,并注册到spring 容器中
dubbo.monitor / dubbo.monitors的配置属性到MonitorConfig对象实例中,并注册到spring 容器中
dubbo.provider / dubbo.providers的配置属性到ProviderConfig对象实例中,并注册到spring 容器中
dubbo.consumer / dubbo.consumers的配置属性到ConsumerConfig对象实例中,并注册到spring 容器中
dubbo.config-center / dubbo.config-centers的配置属性到ConfigCenterBean对象实例中,并注册到spring 容器中
dubbo.metadata-report / dubbo.metadata-reports的配置属性到MetadataReportConfig对象实例中,并注册到spring 容器中
dubbo.metricse / dubbo.metricses的配置属性到MetricsConfig对象实例中,并注册到spring 容器中
这是重点哦
- @DubboComponentScan dubbo组件扫描
扫描使用注解 @Service和@Reference注解标注的类和属性,自动注册到spring 容器中 。
源码:
/**
* Dubbo Component Scan {@link Annotation},scans the classpath for annotated components that will be auto-registered as
* Spring beans. Dubbo-provided {@link Service} and {@link Reference}.
*
* @see Service
* @see Reference
* @since 2.5.7
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {
/**
* Alias for the {@link #basePackages()} attribute. Allows for more concise annotation
* declarations e.g.: {@code @DubboComponentScan("org.my.pkg")} instead of
* {@code @DubboComponentScan(basePackages="org.my.pkg")}.
*
* @return the base packages to scan
*/
String[] value() default {};
/**
* Base packages to scan for annotated @Service classes. {@link #value()} is an
* alias for (and mutually exclusive with) this attribute.
* <p>
* Use {@link #basePackageClasses()} for a type-safe alternative to String-based
* package names.
*
* @return the base packages to scan
*/
String[] basePackages() default {};
/**
* Type-safe alternative to {@link #basePackages()} for specifying the packages to
* scan for annotated @Service classes. The package of each class specified will be
* scanned.
*
* @return classes from the base packages to scan
*/
Class<?>[] basePackageClasses() default {};
}
这里又用到了@Import ,那就再看一下DubboComponentScanRegistrar源码:
/**
* Dubbo {@link DubboComponentScan} Bean Registrar
*
* @see Service
* @see DubboComponentScan
* @see ImportBeanDefinitionRegistrar
* @see ServiceAnnotationBeanPostProcessor
* @see ReferenceAnnotationBeanPostProcessor
* @since 2.5.7
*/
public class DubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
//处理服务注解
registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
//处理消费注解
registerReferenceAnnotationBeanPostProcessor(registry);
}
/**
* Registers {@link ServiceAnnotationBeanPostProcessor}
*
* @param packagesToScan packages to scan without resolving placeholders
* @param registry {@link BeanDefinitionRegistry}
* @since 2.5.8
*/
private void registerServiceAnnotationBeanPostProcessor(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
BeanDefinitionBuilder builder = rootBeanDefinition(ServiceAnnotationBeanPostProcessor.class);
builder.addConstructorArgValue(packagesToScan);
builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);
}
/**
* Registers {@link ReferenceAnnotationBeanPostProcessor} into {@link BeanFactory}
*
* @param registry {@link BeanDefinitionRegistry}
*/
private void registerReferenceAnnotationBeanPostProcessor(BeanDefinitionRegistry registry) {
// Register @Reference Annotation Bean Processor
registerInfrastructureBean(registry,
ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class);
}
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
metadata.getAnnotationAttributes(DubboComponentScan.class.getName()));
String[] basePackages = attributes.getStringArray("basePackages");
Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
String[] value = attributes.getStringArray("value");
// Appends value array attributes
Set<String> packagesToScan = new LinkedHashSet<String>(Arrays.asList(value));
packagesToScan.addAll(Arrays.asList(basePackages));
for (Class<?> basePackageClass : basePackageClasses) {
packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
}
if (packagesToScan.isEmpty()) {
return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName()));
}
return packagesToScan;
}
}
可以看到,目标很明确,就是处理@Service和@Reference注解,并实例化相关对象。
- @EnableDubboLifecycle Dubbo生命周期管理
/**
* Enables Dubbo {@link Lifecycle} components
*
* @since 2.7.5
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Import(DubboLifecycleComponentRegistrar.class)
public @interface EnableDubboLifecycle {
}
再看DubboLifecycleComponentRegistrar
/**
* A {@link ImportBeanDefinitionRegistrar register} for the {@link Lifecycle Dubbo Lifecycle} components
*
* @since 2.7.5
*/
public class DubboLifecycleComponentRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//注册dubbo组件生命周期监听器到spring容器中,DubboLifecycleComponentApplicationListener是一个ApplicationListener对象
registerBeans(registry, DubboLifecycleComponentApplicationListener.class);
}
}
再看DubboLifecycleComponentApplicationListener :
/**
* A {@link ApplicationListener listener} for the {@link Lifecycle Dubbo Lifecycle} components
*
* @see {@link Lifecycle Dubbo Lifecycle}
* @see SmartApplicationListener
* @since 2.7.5
*/
public class DubboLifecycleComponentApplicationListener implements ApplicationListener {
@Override
public void onApplicationEvent(ApplicationEvent event) {
if (!supportsEvent(event)) {
return;
}
if (event instanceof ContextRefreshedEvent) {
onContextRefreshedEvent((ContextRefreshedEvent) event);
} else if (event instanceof ContextClosedEvent) {
onContextClosedEvent((ContextClosedEvent) event);
}
}
protected void onContextRefreshedEvent(ContextRefreshedEvent event) {
ApplicationContext context = event.getApplicationContext();
DubboBootstrap bootstrap = loadBootsttrapAsBean(context);
if (bootstrap == null) {
bootstrap = DubboBootstrap.getInstance();
}
bootstrap.start();
}
protected void onContextClosedEvent(ContextClosedEvent event) {
DubboShutdownHook.getDubboShutdownHook().doDestroy();
}
private DubboBootstrap loadBootsttrapAsBean(ApplicationContext context) {
Map<String, DubboBootstrap> beans = beansOfTypeIncludingAncestors(context, DubboBootstrap.class);
if (CollectionUtils.isNotEmptyMap(beans)) {
return beans.values().iterator().next();
}
return null;
}
/**
* the specified {@link ApplicationEvent event} must be {@link ApplicationContextEvent} and
* its correlative {@link ApplicationContext} must be root
*
* @param event
* @return
*/
private boolean supportsEvent(ApplicationEvent event) {
return event instanceof ApplicationContextEvent &&
isRootApplicationContext((ApplicationContextEvent) event);
}
private boolean isRootApplicationContext(ApplicationContextEvent event) {
return event.getApplicationContext().getParent() == null;
}
}
可以看到,在生命周期监听器里面维护了两个重要的对象DubboBootstrap和DubboShutdownHook
DubboBootstrap Dubbo启动引导器
被设计单例模式,dubbo程序全局中值存在一个实例。在监听到spring 容器的ContextRefreshedEvent事件时,会获取其实例,并调用start()方法
DubboShutdownHook Dubbo程序关闭钩子,
在监听到spring 容器的关闭事件之后会掉DubboShutdownHook#doDestroy()方法,关闭dubbo容器。
在下一篇,我会详细分析DubboBootstrap启动dubbo的流程