Spring IOC（十三）Dubbo 与Spring 集成 - EnableDubbo原理

最新推荐文章于 2025-02-24 09:52:15 发布
最新推荐文章于 2025-02-24 09:52:15 发布
阅读量1.3k 收藏
点赞数
分类专栏： Spring Cloud 文章标签： spring spring boot dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/anLA_/article/details/105234788
版权

前面一段时间分析了Spring 和Dubbo，本文将以Dubbo中对Spring 集成为切入点进行分析。

从Spring中 Dubbo的使用上面来看，有两个重要的注解，即@Service 和 @Reference。
对两个注解的解析分别在 ServiceAnnotationBeanPostProcessor 和 ReferenceAnnotationBeanPostProcessor

这类ReferenceAnnotationBeanPostProcessor和前面Spring 中的 AutowiredAnnotationBeanPostProcessor 类似，同样是在实例化后，初始化前，执行 postProcessMergedBeanDefinition 进行注解扫描，而在populateBean 中进行注解属性注入。
本文从以下几个方面展开：
1.

Spring 和 Dubbo集成使用，可以使用 @EnableDubbo，也可以使用 dubbo提供的 dubbo-spring-boot-project 的starter

使用EnableDubbo方式使用

EnableDubbo 注解定义如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@EnableDubboConfig
@DubboComponentScan
@EnableDubboLifecycle
public @interface EnableDubbo {

   @AliasFor(annotation = DubboComponentScan.class, attribute = "basePackages")
   String[] scanBasePackages() default {};
   // 扫描路径
   @AliasFor(annotation = DubboComponentScan.class, attribute = "basePackageClasses")
   Class<?>[] scanBasePackageClasses() default {};

   // 是否多配置
   @AliasFor(annotation = EnableDubboConfig.class, attribute = "multiple")
   boolean multipleConfig() default true;

}

如上面代码，EnableDubbo 中定义的是包路径和multiple配置。该注解无@Import 注解，主要目的是为其他注解做一层包装，是一个组合注解，包括以下注解：

  1. EnableDubboConfig
  2. DubboComponentScan
  3. EnableDubboLifecycle
EnableDubboConfig

EnableDubboConfig 主要是定义一些Dubbo内部组件配置以及值获取方式，包括以下:

  1. ApplicationConfig: dubbo.application
  2. ModuleConfig: dubbo.module
  3. RegistryConfig: dubbo.registry
  4. ProtocolConfig: dubbo.protocol
  5. MonitorConfig: dubbo.monitor
  6. ProviderConfig: dubbo.provider
  7. ConsumerConfig: dubbo.consumer

而如果配置是支持多份配置，则对应的配置文件前缀为:

  1. ApplicationConfig: dubbo.applications
  2. ModuleConfig: dubbo.modules
  3. RegistryConfig: dubbo.registries
  4. ProtocolConfig: dubbo.protocols
  5. MonitorConfig: dubbo.monitors
  6. ProviderConfig: dubbo.providers
  7. ConsumerConfig: dubbo.consumers

上面表达只是 EnableDubboConfig 会帮你做的事，下面看这个注解是如何帮你完成这些事的呢？

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Import(DubboConfigConfigurationRegistrar.class)
public @interface EnableDubboConfig {

    /**
     * 默认是支持多配置
     */
    boolean multiple() default true;

}

看看 @Import 引入的 DubboConfigConfigurationRegistrar，

public class DubboConfigConfigurationRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		// 获取注解参数
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableDubboConfig.class.getName()));
		// 是否支持多配置
        boolean multiple = attributes.getBoolean("multiple");

        // 默认注册 DubboConfigConfiguration.Single.class
        registerBeans(registry, DubboConfigConfiguration.Single.class);
		// 注册 DubboConfigConfiguration.Multiple.class
        if (multiple) { 
            registerBeans(registry, DubboConfigConfiguration.Multiple.class);
        }

        // 注册 DubboConfigAliasPostProcessor
        registerDubboConfigAliasPostProcessor(registry);

        // 注册 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);
    }

}

在 上面的 DubboConfigConfigurationRegistrar 中，主要注册了4种类型的bean到Spring 的容器中：

  1. DubboConfigConfiguration.Single 和 DubboConfigConfiguration.Multiple。这两个类实际上也是两个包装，具体是通过 EnableConfigurationBeanBinding 将dubbo框架运行所必须的组件进行声明并注入。
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),
            @EnableConfigurationBeanBinding(prefix = "dubbo.ssl", type = SslConfig.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 {

    }
}

而对应的 EnableConfigurationBeanBinding 的 @Import 的 ImportBeanDefinitionRegistrar 为：ConfigurationBeanBindingRegistrar.
在 ConfigurationBeanBindingRegistrar 则是通过以下逻辑，将其初始化并注入到Spring 容器中的：

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {

        AnnotationAttributes attributes = fromMap(metadata.getAnnotationAttributes(ENABLE_CONFIGURATION_BINDING_CLASS_NAME));

        registerConfigurationBeanDefinitions(attributes, registry);
    }

    protected void registerConfigurationBeanDefinitions(AnnotationAttributes attributes, BeanDefinitionRegistry registry) {

        String prefix = environment.resolvePlaceholders(attributes.getString("prefix"));
		// 获取待注入类
        Class<?> configClass = attributes.getClass("type");
		// 获取是否多配置中心
        boolean multiple = attributes.getBoolean("multiple");

        boolean ignoreUnknownFields = attributes.getBoolean("ignoreUnknownFields");

        boolean ignoreInvalidFields = attributes.getBoolean("ignoreInvalidFields");
		// 注册bean
        registerConfigurationBeans(prefix, configClass, multiple, ignoreUnknownFields, ignoreInvalidFields, registry);
    }

下面看看 registerConfigurationBeans 中做了什么：

    private void registerConfigurationBeans(String prefix, Class<?> configClass, boolean multiple,
                                            boolean ignoreUnknownFields, boolean ignoreInvalidFields,
                                            BeanDefinitionRegistry registry) {

        Map<String, Object> configurationProperties = PropertySourcesUtils.getSubProperties(environment.getPropertySources(), environment, prefix);
		// 如果没有配置，那么就直接退出
        if (CollectionUtils.isEmpty(configurationProperties)) {
            if (log.isDebugEnabled()) {
                log.debug("There is no property for binding to configuration class [" + configClass.getName()
                        + "] within prefix [" + prefix + "]");
            }
            return;
        }
		// 获取待注册的配置类的bean名字，此处要注意是单个还是多个bena类名字
        Set<String> beanNames = multiple ? resolveMultipleBeanNames(configurationProperties) :
                singleton(resolveSingleBeanName(configurationProperties, configClass, registry));

        for (String beanName : beanNames) {
        // 注册bean
            registerConfigurationBean(beanName, configClass, multiple, ignoreUnknownFields, ignoreInvalidFields,
                    configurationProperties, registry);
        }
		// 注册数据绑定对象
        registerConfigurationBindingBeanPostProcessor(registry);
    }

registerConfigurationBeans 中前行应该都还好立即，最后一个 registerConfigurationBindingBeanPostProcessor注册数据绑定对象则需要进入深看一番：

    private void registerConfigurationBindingBeanPostProcessor(BeanDefinitionRegistry registry) {
        registerInfrastructureBean(registry, ConfigurationBeanBindingPostProcessor.BEAN_NAME,
                ConfigurationBeanBindingPostProcessor.class);
    }

即向Spring 容器中注册 ConfigurationBeanBindingPostProcessor 类。而 registerInfrastructureBean 方法限定了，只有当容器中没有改beanName类时，才会忘容器中注册，所以不必担心 registerConfigurationBindingBeanPostProcessor 多次调用，多次注册。

下面看看 ConfigurationBeanBindingPostProcessor 以及它重写的方法：

public class ConfigurationBeanBindingPostProcessor implements BeanFactoryPostProcessor, BeanPostProcessor {
}

ConfigurationBeanBindingPostProcessor 实现了 BeanFactoryPostProcessor 和 BeanPostProcessor 接口
所以有以下几个方法会执行

  1. 在bean进行完全扫描之后，即在Spring 的 refresh中 invokeBeanFactoryPostProcessors 中 执行 postProcessBeanFactory
  2. 在 getBean 阶段的 initializeBean中，在每个bean初始化之前执行 postProcessBeforeInitialization ，每个bean初始化后执行 postProcessAfterInitialization

可以猜测下 ConfigurationBeanBindingPostProcessor 目的。
了解Dubbo的同学应该知道，Dubbo有多种类型组件，本文上面也有提到过，都是以 AbstractConfig 为父类，前面可以将Dubbo中需要的组件注册成Spring 的bean，但是呢，Dubbo的各个组件内部都是需要拥有对其他组件引用。
例如，一个接口(Service)暴露了，里面有对 Application的引用，对Register的应用 ，对Module的引用。正式因为这样的设计，Dubbo才能支持多注册中心，并且可以动态制定多份配置。
后面文章分析Spring 数据绑定时，再深入分析这里。

DubboComponentScan

接下来看 DubboComponentScan 中目的，直接看其 引入的 DubboComponentScanRegistrar 类。

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		// 获取 扫描包路径
        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
		// 注册 ServiceAnnotationBeanPostProcessor 
        registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
 		// 注册 ReferenceAnnotationBeanPostProcessor
        registerReferenceAnnotationBeanPostProcessor(registry);

    }

关于 ServiceAnnotationBeanPostProcessor 和 ReferenceAnnotationBeanPostProcessor 作用原理，看博主下篇文章分析。

EnableDubboLifecycle

还是直接看 引入的 DubboLifecycleComponentRegistrar ：

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        registerBeans(registry, DubboLifecycleComponentApplicationListener.class);
        registerBeans(registry, DubboBootstrapApplicationListener.class);
    }

注册了两个bean DubboLifecycleComponentApplicationListener 和 DubboBootstrapApplicationListener.
两个类都继承了 OneTimeExecutionApplicationContextEventListener ，而 最终是实现了 ApplicationListener 接口，即监听了Spring 的声明周期事件。
对于 DubboBootstrapApplicationListener 来说，则是通过Spring 事件对 DubboBootstrap 进行操作：

    @Override
    public void onApplicationContextEvent(ApplicationContextEvent event) {
    // 不同事件不同操作
        if (event instanceof ContextRefreshedEvent) {
            onContextRefreshedEvent((ContextRefreshedEvent) event);
        } else if (event instanceof ContextClosedEvent) {
            onContextClosedEvent((ContextClosedEvent) event);
        }
    }
    private void onContextRefreshedEvent(ContextRefreshedEvent event) {
        dubboBootstrap.start();
    }

    private void onContextClosedEvent(ContextClosedEvent event) {
        dubboBootstrap.stop();
    }

在 start方法中，做了一下几件事：

    public DubboBootstrap start() {
        if (started.compareAndSet(false, true)) {
            initialize();
            if (logger.isInfoEnabled()) {
                logger.info(NAME + " is starting...");
            }
            // 1. export Dubbo Services
            exportServices();

            // Not only provider register
            if (!isOnlyRegisterProvider() || hasExportedServices()) {
                // 2. export MetadataService
                exportMetadataService();
                //3. Register the local ServiceInstance if required
                registerServiceInstance();
            }

            referServices();

            if (logger.isInfoEnabled()) {
                logger.info(NAME + " has started.");
            }
        }
        return this;
    }
  1. 执行 initialize 确保初始化了所有配置。
  2. 将所有要暴露的服务进行具体暴露，即 exportServices
  3. 暴露元数据中心 exportMetadataService
  4. 执行所有ReferenceBean 的具体refer方法

对于 DubboLifecycleComponentApplicationListener 类，则是给予Spring 容器声明周期，对Dubbo框架内，所有 org.apache.dubbo.common.context.Lifecycle 的类，进行相关的监听和调用。

觉得博主写的有用，不妨关注博主公众号: 六点A君。
哈哈哈，一起研究Spring：
在这里插入图片描述

Dubbo源码解读-dubbo启动与Spring整合之@ DubboComponentScan
胖墩儿没腹肌
03-04 1382
本文主要@ DubboComponentScan注解功能进行源码说明。上篇我们介绍了Dubbbo整合Spring中的@EnableDubboConfig注解源码分析，地址如下。接着说明，读Dubbo源码最好是先对Spring源码有一定的了解。如果大家需要，我也可以针对Spring框架做一系列源码的解读专栏。不过不用担心，如果需要Spring的源码知识，文章中也会进行Spring源码铺垫介绍的。
Spring整合Dubbo框架过程及原理解析
08-25
主要介绍了Spring整合Dubbo框架过程及原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring与Dubbo整合原理与底层源码分析
沮丧的南瓜
10-31 443
内容： Dubbo中propertie文件解析以及处理原理 Dubbo中@Service注解解析以及处理原理 Dubbo中@Reference注解解析以及处理原理 文章目录一、整体架构和流程二、@EnableDubbo三、 DubboConfigConfigurationRegistrar3.1 DubboConfigBindingRegistrar3.2 DubboConfigBindingBeanPostProcessor3.3 DefaultDubboConfigBinder3.4 总结四、Dub
本地搭建 Dubbo 开发环境及服务配置全攻略
最新发布
一碗黄焖鸡三碗米饭的博客
02-24 916
本文介绍了如何在本地搭建 Dubbo 开发环境，创建和配置 Dubbo 服务，并使用 Zookeeper 或 Nacos 作为注册中心，以及 Spring Cloud Config 作为配置中心。Dubbo 的使用为开发分布式、高并发的微服务应用提供了极大的便利，而 Zookeeper 和 Nacos 等注册中心则帮助实现了服务的动态管理与高可用性。功能使用 Zookeeper使用 Nacos服务注册与发现支持，基于 Zookeeper 的强一致性保障支持，具有更灵活的配置管理和动态服务发现。
Spring整合dubbo原理
DaySurprise的博客
03-18 812
处理properties文件 spring会读取这个文件 会放在enviroment对象里面 然后dubbo从这个对象中取就行了 生成不同的对象 根据 dubbo.application.* 等属性 生成 ApplicationConfig对象 根据 dubbo.protocols.* 等属性 生成 ProtocolConfig对象 根据 dubbo.registers.*等属性 生成RegistryConfig 对象 providerConfig，ConfigCenterConfig,C...
Spring与Dubbo整合原理
1
11-05 359
应用启动类与配置 public class Application { public static void main(String[] args) throws Exception { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class); context.start(); S
Spring与Dubbo整合原理与源码分析
Code The Future
02-28 877
赌博、spring
spring dubbo demo
03-26
Spring的集成使得我们可以利用Spring的IOC（控制反转）和AOP（面向切面编程）特性，轻松地管理服务的生命周期和实现服务的透明化调用。 为了运行这个Demo，你需要先安装Zookeeper，这是一个分布式的、开放源码的...
dubbo2-spring4-mybatis3
09-30
本实例“dubbo2-spring4-mybatis3”旨在展示如何将这三大组件无缝集成，构建高效、灵活的企业级应用。 一、Dubbo简介 Dubbo是一款由阿里巴巴开源的高性能Java RPC框架，它提供服务治理、监控、容错等多种功能，旨在...
Dubbo与Spring等技术整合：dubbo2.5-spring4-mybastis3.2-springmvc4-mongodb-redis项目解析
资源摘要信息: "dubbo2.5-spring4-mybastis3.2-springmvc4-mongodb-redis整合项目是一个综合运用了多个现代流行Java技术框架的系统开发项目。该项目的整合应用了分布式服务框架dubbo2.5，企业级应用框架spring4，...
dubbo-demo-consumer-2.1.5-assembly.tar.gz
07-28
7. **集成Spring**：Dubbo与Spring的深度整合是其一大特点，通过Spring的IOC和AOP，可以使服务的管理更加灵活，同时简化了配置工作。 通过深入研究这个示例包，开发者不仅可以掌握Dubbo的基本用法，还能了解到如何...
spring5+dubbo3集成原理(一)
weixin_43217293的博客
12-09 121
在resources下创建META-INF文件夹创建spring.schemas文件。
springBoot整合dubbo注意事项（注解方式）
编程界的一名小学生
07-08 3814
最近学习springBoot整合dubbo过程中遇到了一些问题，在此记录一下，以作备忘。 至于整合教程网上一堆，这里不做重复搬运。 大概描述一下步骤： 如果使用zookeeper作为注册中心，需要先安装zookeeper并启动 下载dubbo管理控制台（我在网上找的一个，提取码：ddoc），下载后解压， 修改dubbo-admin项目中application.properties文件中dubbo...
dubbo源码系列4——dubbo服务端与Spring整合原理
weixin_47095883的博客
05-03 438
解密dubbo服务端与spring整合之道
Dubbo和Spring集成的原理
yang的博客
05-04 1820
使用Dubbo最方便的地方在于它可以和Spring非常方便的集成，实际上，Dubbo对于配置的优化，也是随着Spring一同发展的，从最早的XML形式到后来的注解方式以及自动装配，都是在不断地简化开发过程来提高开发效率。 在Spring Boot集成Dubbo时，服务发布主要有以下几个步骤： 添加dubbo-spring-boot-starter依赖 定义@org.apache.dubbo.co...
SpringBoot整合Dubbo
tony_stark的博客
07-05 1550
序言：在springboot中使用dubbo，主要使用它的服务远程调用功能，也就是两个项目之间相互通讯，即RPC远程调用。 使用其PRC远程调用，那么至少需要存在三个项目： 1.dubbo-api是服务提供者的接口API(maven项目) 2.dubbo-provider是所谓的服务提供者(springboot项目) 3.dubbo-consumer是服务消费者(springboot项目) 项目结构如下图所示： 1. 在api项目中，主要提供一些接口和实体类等，而具体的实现则交给服务提供者去实现 2. 在
EnableDubbo注解解析（二）------ DubboComponentScan注解
qwerty的博客
07-28 1095
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented @EnableDubboConfig //读取配置文件 创建dubbo配置bean @DubboComponentScan //扫描 @Service（不是spring的sevice注解） @Reference 生成 bean public @interface EnableDubbo { @AliasFor(ann
EnableDubbo注解解析（一）------ EnableDubboConfig注解
qwerty的博客
07-27 2085
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented @EnableDubboConfig //读取配置文件 创建dubbo配置bean @DubboComponentScan //扫描 @Service（不是spring的sevice注解） @Reference 生成 bean public @interface EnableDubbo { @AliasFor(ann
Dubbo源码—— @EnableDubbo注解实现原理分析
my的博客
03-04 1823
highlight: androidstudio 我们知道在使用dubbo时候，(如果是注解方式的话)需要开启 @EnableDubbo注解，并且在服务提供者的类上加上@Service， 在服务调用者类上加上@Referce注解，那么其内部是如何工作的呢？ 1. @EnableDubbo组成 @EnableDubbo=@DubboComponentScan+@EnableDubboC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值