Dubbo之SpringBoot启动源码详解

最新推荐文章于 2024-08-19 02:55:15 发布
最新推荐文章于 2024-08-19 02:55:15 发布
阅读量875 收藏 1
点赞数 2
分类专栏： # dubbo源码解读 文章标签： dubbo java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43988251/article/details/129125844
版权

需要前置知识，了解spring源码，springboot自动加载机制等

DubboBootstrap启动

详细信息可看 学习Dubbo源码需要了解的基础内容源码详解

DubboBootstrap 启动所需要的信息

  1. 添加应用程序配置
  2. 添加注册中心配置
  3. 添加协议配置
  4. 添加服务配置
  5. 启动

SpringBoot启动Dubbo

@EnableDubbo注解 中引用了 @DubboComponentScan和 @EnableDubboConfig注解

@DubboComponentScan注解中引用了 @Import(DubboComponentScanRegistrar.class) 所以以DubboComponentScanRegistrar类为起点

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {
    String[] value() default {};
    String[] basePackages() default {};
    Class<?>[] basePackageClasses() default {};
}

DubboComponentScanRegistrar

实现自 ImportBeanDefinitionRegistrar 重写了 registerBeanDefinitions方法，在SpringBoot源码中会回调 registerBeanDefinitions方法，可见SpringBoot源码

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

    // initialize dubbo beans
    // 核心 初始化环境 包括注册监听器
    DubboSpringInitializer.initialize(registry);

    Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
	// 注册ServiceBean 和dubbo启动信息
    registerServiceAnnotationPostProcessor(packagesToScan, registry);
}

DubboSpringInitializer.initialize(registry) =》 调用 initContext(context, registry, beanFactory) 初始化上下文

initContext(context, registry, beanFactory) =》调用 DubboBeanUtils.registerCommonBeans(registry);注册公共使用Bean对象

DubboBeanUtils.registerCommonBeans(registry);

static void registerCommonBeans(BeanDefinitionRegistry registry) {

    registerInfrastructureBean(registry, ServicePackagesHolder.BEAN_NAME, ServicePackagesHolder.class);

    registerInfrastructureBean(registry, ReferenceBeanManager.BEAN_NAME, ReferenceBeanManager.class);

    // Since 2.5.7 Register @Reference Annotation Bean Processor as an infrastructure Bean
    registerInfrastructureBean(registry, ReferenceAnnotationBeanPostProcessor.BEAN_NAME,
        ReferenceAnnotationBeanPostProcessor.class);

    // TODO Whether DubboConfigAliasPostProcessor can be removed ?
    // Since 2.7.4 [Feature] https://github.com/apache/dubbo/issues/5093
    registerInfrastructureBean(registry, DubboConfigAliasPostProcessor.BEAN_NAME,
        DubboConfigAliasPostProcessor.class);

    // register ApplicationListeners
    // 核心，注册了部署调度监听器和应用程序监听器 
    registerInfrastructureBean(registry, DubboDeployApplicationListener.class.getName(), DubboDeployApplicationListener.class);
    registerInfrastructureBean(registry, DubboConfigApplicationListener.class.getName(), DubboConfigApplicationListener.class);

    // Since 2.7.6 Register DubboConfigDefaultPropertyValueBeanPostProcessor as an infrastructure Bean
    registerInfrastructureBean(registry, DubboConfigDefaultPropertyValueBeanPostProcessor.BEAN_NAME,
        DubboConfigDefaultPropertyValueBeanPostProcessor.class);

    // Dubbo config initializer
    registerInfrastructureBean(registry, DubboConfigBeanInitializer.BEAN_NAME, DubboConfigBeanInitializer.class);

    // register infra bean if not exists later
    registerInfrastructureBean(registry, DubboInfraBeanRegisterPostProcessor.BEAN_NAME, DubboInfraBeanRegisterPostProcessor.class);
}

注册服务配置信息SercviceBean

registerServiceAnnotationPostProcessor(packagesToScan, registry);

注册了 ServiceAnnotationPostProcessor

private void registerServiceAnnotationPostProcessor(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
	// 注册 ServiceAnnotationPostProcessor
    BeanDefinitionBuilder builder = rootBeanDefinition(ServiceAnnotationPostProcessor.class);
    builder.addConstructorArgValue(packagesToScan);
    builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
    BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);
}
ServiceAnnotationPostProcessor

实现了BeanDefinitionRegistryPostProcessor，所以会调用postProcessBeanDefinitionRegistry方法

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    this.registry = registry;
    // 扫描Bean
    scanServiceBeans(resolvedPackagesToScan, registry);
}
scanServiceBeans(resolvedPackagesToScan, registry);

这个方法就包含了注册dubbo配置的bean的逻辑了，需要扫描自定义的注解来注册到spring的ioc容器中的套路大致都是相同的，和Mybatis一样，使用spring的扩展机制来扫描自定义的注解，然后注册为BeanDefinition，即可在Spring中注册为bean

private void scanServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {

    scanned = true;
    if (CollectionUtils.isEmpty(packagesToScan)) {
        if (logger.isWarnEnabled()) {
            logger.warn(CONFIG_NO_BEANS_SCANNED, "", "", "packagesToScan is empty , ServiceBean registry will be ignored!");
        }
        return;
    }

    // 创建扫描包类
    DubboClassPathBeanDefinitionScanner scanner =
            new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);

    BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
    scanner.setBeanNameGenerator(beanNameGenerator);
    // 添加有 @DubboService  @Service  的过滤条件 
    for (Class<? extends Annotation> annotationType : serviceAnnotationTypes) {
        scanner.addIncludeFilter(new AnnotationTypeFilter(annotationType));
    }

    ScanExcludeFilter scanExcludeFilter = new ScanExcludeFilter();
    scanner.addExcludeFilter(scanExcludeFilter);

    for (String packageToScan : packagesToScan) {

        // avoid duplicated scans
        if (servicePackagesHolder.isPackageScanned(packageToScan)) {
            if (logger.isInfoEnabled()) {
                logger.info("Ignore package who has already bean scanned: " + packageToScan);
            }
            continue;
        }

        // Registers @Service Bean first
        // 包扫描，扫描当前包路径下所有类（因为没开 @Indexed注解 ）
        scanner.scan(packageToScan);

        // 查找@Service的所有beandefinitionholder，无论@ComponentScan是否扫描  
        // 包装成 BeanDefinitionHolder 返回
        Set<BeanDefinitionHolder> beanDefinitionHolders =
                findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);

        if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
            if (logger.isInfoEnabled()) {
                List<String> serviceClasses = new ArrayList<>(beanDefinitionHolders.size());
                for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                    serviceClasses.add(beanDefinitionHolder.getBeanDefinition().getBeanClassName());
                }
                logger.info("Found " + beanDefinitionHolders.size() + " classes annotated by Dubbo @Service under package [" + packageToScan + "]: " + serviceClasses);
            }

            for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                // 核心 核心 对 每一个包装的 beanDefinitionHolder 处理
                processScannedBeanDefinition(beanDefinitionHolder);
                servicePackagesHolder.addScannedClass(beanDefinitionHolder.getBeanDefinition().getBeanClassName());
            }
        } else {
            if (logger.isWarnEnabled()) {
                logger.warn(CONFIG_NO_ANNOTATIONS_FOUND,"No annotations were found on the class","","No class annotated by Dubbo @Service was found under package ["
                        + packageToScan + "], ignore re-scanned classes: " + scanExcludeFilter.getExcludedCount());
            }
        }

        servicePackagesHolder.addScannedPackage(packageToScan);
    }
}
@DubboService注解的扫描使用原理

这里保证文档可读性，简单介绍，详情见 Dubbo注解 详细介绍

DubboClassPathBeanDefinitionScanner 扫描包类 实现自 ClassPathBeanDefinitionScanner

在 scanServiceBeans 方法中 通过以下代码添加了 DubboService Service 注解的过滤条件，从而才scan 扫描报的时候根据过滤条件寻找类，Scan扫描包去看Spring扫描包原理

private final static List<Class<? extends Annotation>> serviceAnnotationTypes = asList(
        // @since 2.7.7 Add the @DubboService , the issue : https://github.com/apache/dubbo/issues/6007
        DubboService.class,
        // @since 2.7.0 the substitute @com.alibaba.dubbo.config.annotation.Service
        Service.class,
        // @since 2.7.3 Add the compatibility for legacy Dubbo's @Service , the issue : https://github.com/apache/dubbo/issues/4330
        com.alibaba.dubbo.config.annotation.Service.class
);
// 添加有 @DubboService  @Service  的过滤条件 
for (Class<? extends Annotation> annotationType : serviceAnnotationTypes) {
    scanner.addIncludeFilter(new AnnotationTypeFilter(annotationType));
}
…… 
scanner.scan(packageToScan);
processScannedBeanDefinition
private void processScannedBeanDefinition(BeanDefinitionHolder beanDefinitionHolder) {

    Class<?> beanClass = resolveClass(beanDefinitionHolder);
    // 获取 @DubboService
    Annotation service = findServiceAnnotation(beanClass);
    
    // 获取配置在注解@DubboService上的所有属性
    Map<String, Object> serviceAnnotationAttributes = AnnotationUtils.getAttributes(service, true);
    // 根据注解信息和类信息解析出接口信息
    String serviceInterface = resolveInterfaceName(serviceAnnotationAttributes, beanClass);
    // 拿到 @DubboSerivce修饰的类名
    String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();
    
    // ServiceBean Bean name
    String beanName = generateServiceBeanName(serviceAnnotationAttributes, serviceInterface);
    // 构造了关于Servicebean的 BeanDefinition
    AbstractBeanDefinition serviceBeanDefinition =
        buildServiceBeanDefinition(serviceAnnotationAttributes, serviceInterface, annotatedServiceBeanName);
    // 把 关于Servicebean的 BeanDefinition 添加到spring中
    registerServiceBeanDefinition(beanName, serviceBeanDefinition, serviceInterface);

}

img

buildServiceBeanDefinition

构建了一个BeanDefinition，设置他的BeanClass = ServiceBean， 每个接口都会生成一个BeanDefinition

到这里位置，就已经把所以扫描到@DubboService（包括兼容历史所需要的 @Service ）注解的类，全部注册为了BeanDefinition，开始进行spring bean的初始化，开始初始化设置的ServiceBean

private AbstractBeanDefinition buildServiceBeanDefinition(Map<String, Object> serviceAnnotationAttributes,
                                                          String serviceInterface,
                                                          String refServiceBeanName) {
	// 创建 ServiceBean 的Builder
    BeanDefinitionBuilder builder = rootBeanDefinition(ServiceBean.class);
	
    AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
	// 设置ServiceBean需要的相关参数，例如  protocol，ref 等
    MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();

    String[] ignoreAttributeNames = of("provider", "monitor", "application", "module", "registry", "protocol",
            "methods", "interfaceName", "parameters");
	…… …… ……
    return builder.getBeanDefinition();

}
ServiceBean初始化

初始化会调用 InitializingBean的 afterPropertiesSet 方法，详解见Dubbo前置知识

DubboDeployApplicationListener

在ServiceBean初始化后 DubboDeployApplicationListener 监听器监听了 ContextRefreshedEvent 时间，在spring初始化完成后 该监听器会被执行

onApplicationEvent监听事件
@Override
public void onApplicationEvent(ApplicationContextEvent event) {
    if (nullSafeEquals(applicationContext, event.getSource())) {
        if (event instanceof ContextRefreshedEvent) {
            onContextRefreshedEvent((ContextRefreshedEvent) event);
        } else if (event instanceof ContextClosedEvent) {
            onContextClosedEvent((ContextClosedEvent) event);
        }
    }
}
onContextRefreshedEvent
private void onContextRefreshedEvent(ContextRefreshedEvent event) {
    ModuleDeployer deployer = moduleModel.getDeployer();
    Assert.notNull(deployer, "Module deployer is null");
    // start module
	// 核心 部署器启动
    Future future = deployer.start();

    // if the module does not start in background, await finish
    if (!deployer.isBackground()) {
        try {
            future.get();
        } catch (InterruptedException e) {
            logger.warn(CONFIG_FAILED_START_MODEL, "", "", "Interrupted while waiting for dubbo module start: " + e.getMessage());
        } catch (Exception e) {
            logger.warn(CONFIG_FAILED_START_MODEL, "", "", "An error occurred while waiting for dubbo module start: " + e.getMessage(), e);
        }
    }
}
DefaultModuleDeployer#start

部署器启动

@Override
public Future start() throws IllegalStateException {
    // initialize，maybe deadlock applicationDeployer lock & moduleDeployer lock
    // 初始化部署
    applicationDeployer.initialize();

    return startSync();
}
DefaultApplicationDeployer#initialize

初始化，包括配置中心，应用程序配置，元数据配置等

对应DubboBootstrap 代码启动的加载

@Override
public void initialize() {
    if (initialized) {
        return;
    }
    // Ensure that the initialization is completed when concurrent calls
    synchronized (startLock) {
        if (initialized) {
            return;
        }
        // register shutdown hook
        registerShutdownHook();

        startConfigCenter();

        loadApplicationConfigs();

        initModuleDeployers();

        // @since 2.7.8
        startMetadataCenter();

        initialized = true;

        if (logger.isInfoEnabled()) {
            logger.info(getIdentifier() + " has been initialized!");
        }
    }
}
DefaultModuleDeployer#startSync()
private synchronized Future startSync() throws IllegalStateException {
    if (isStopping() || isStopped() || isFailed()) {
        throw new IllegalStateException(getIdentifier() + " is stopping or stopped, can not start again");
    }

    try {
        if (isStarting() || isStarted()) {
            return startFuture;
        }
    	// 却换模块启动状态 STARTING
        onModuleStarting();

    	//如果为初始化则初始化
        initialize();

        // export services
        //服务暴漏
        exportServices();

        // prepare application instance
        // exclude internal module to avoid wait itself
        if (moduleModel != moduleModel.getApplicationModel().getInternalModule()) {
            applicationDeployer.prepareInternalModule();
        }

        // refer services
        //引用服务
        referServices();

        // if no async export/refer services, just set started
        //非异步启动直接转换状态为STARTED
        if (asyncExportingFutures.isEmpty() && asyncReferringFutures.isEmpty()) {
            onModuleStarted();
        } else {
            //如果是异步启动，等待服务发布和服务引用的回调
            frameworkExecutorRepository.getSharedExecutor().submit(() -> {
                try {
                    // wait for export finish
                    waitExportFinish();
                    // wait for refer finish
                    waitReferFinish();
                } catch (Throwable e) {
                    logger.warn(CONFIG_FAILED_WAIT_EXPORT_REFER, "", "", "wait for export/refer services occurred an exception", e);
                } finally {
                    onModuleStarted();
                }
            });
        }
    } catch (Throwable e) {
        onModuleFailed(getIdentifier() + " start failed: " + e, e);
        throw e;
    }
    return startFuture;
}

服务暴漏和服务拉去见 源码详解

559Jiang
关注
专栏目录
【微服务】springboot整合skywalking使用详解
congge
12-31 1万+
springboot整合skywalking
spring-boot-starter-dubbo:Spring启动启动器dubbo
05-09
项目介绍 自定义的spring-boot的dubbo starter，为spring-boot相关的项目使用dubbo提供简易的方式并集成spring-boot的auto configuration 版本 本项目版本 dubbo版本 1.0.0 dubbox自定义版本2.8.4-banyan 打包 修改相关的maven私服地址 gradle clean install 使用方式 依赖 compile "org.banyan.spring.boot:spring-boot-starter-dubbo:1.0.0" 集成 在spring-boot项目的application.properties文件中加入相关的配置项，并赋予正确的值 spring.service.dubbo.registry.name=xxx spring.service.dubbo.registry.address=ip1:
springboot+dubbo快速启动
haiboSun的博客
03-17 3533
前言 现在用dubbo的太多了，我到现在还不熟悉，这太不应该了，这次好好看了一下dubbo,终于把基本的启动框架搭好了。dubbo的角色宽泛的分未三类provider,comsumer,注册中心。我这里的注册中心用的是zookeeper,并且是在windows环境下做的。 dubbo和springboot整合的依赖： <dependency> <groupId>com.alibaba.boot</groupId> <artifactId>dubbo
Dubbo源码深度解析(六)
最新发布
weixin_41338970的博客
08-19 822
同时也讲了服务消费方的调用链路，这块还是比较复杂的。由前面可知，在Protocol$Adaptive#refer()方法中，由于传入的URL的协议是"dubbo"，因此extension对象实际上是ProtocolFilterWrapper对象，而ProtocolFilterWrapper对象的protocol属性是ProtocolListenerWrapper对象，而ProtocolListenerWrapper对象的protocol属性是DubboProtocol对象。
dubbo启动源码解析
农夫三拳
10-04 289
启动机制： 1、在dubbo-config包下配置文件（META-INF/spring.handlers）下配置全限定类名： http\://dubbo.apache.org/schema/dubbo=org.apache.dubbo.config.spring.schema.DubboNamespaceHandler 2、spring是如何加载dubbo启动配置文件的？ 基于Spring的Schema和XML的扩展机制实现的，简称spring SPI机制。 spring SPI机制（此图引用
由浅入深Dubbo核心源码剖析SpringBoot整合使用
赵广陆
05-22 694
目录 1 Dubbo与SpringBoot的整合 2 公用RPC接口工程 3. 服务端工程 4. 消费端工程 5. 工程调用验证
springboot项目中dubbo启动的源码分析
lz710117239的博客
08-13 1650
现在本人开始使用起来了微服务，spring boot是微服务必备的框架，那么今天就说下，springboot中是怎么整合dubbo的（源码层面） 我们直接从AbstractApplicationContext类的refresh方法开始说起，首先springboot项目的Application上面的注解是配置扫描的路径的，如下： @SpringBootApplication @MapperSc...
Spring Boot 中使用 Dubbo 详解
2401_84048290的博客
05-06 847
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
springboot-dubbo-demo.rar
04-15
《SpringBoot与Dubbo整合详解》 在现代的微服务架构中，SpringBoot和Dubbo是两个非常重要的组件。SpringBoot以其便捷的初始化配置和快速的应用开发能力，深受开发者喜爱；而Dubbo作为阿里巴巴开源的分布式服务框架...
springboot+dubbo+zookeeper整合
12-18
【SpringBoot + Dubbo + ZooKeeper 整合详解】 在现代企业级开发中，SpringBoot以其简洁的配置和快速的启动特性，成为了构建微服务的首选框架。而Dubbo作为阿里巴巴开源的分布式服务框架，专注于服务治理，为大型...
Dubbo 服务注册与启动源码解析
小菜的博客
11-24 827
Dubbo 服务注册与启动源码解析：通过画图的方式，更直观，清晰
springboot2.0.x+dubbo-spring-boot-starter
06-24
dubbo官方最新springboot2.0.x集成dubbo2.6.例子（springboot+com.alibaba.boot）
dubbo源码深度解析_SpringBoot源码深度解析
weixin_39834984的博客
11-25 190
Spring开源框架，解决企业级开发的复杂性的问题，简化开发AOP， IOCSpring 配置越来多，配置不方便管理！Javaweb---Servlet+tomcat + Struct2 SpringMVC SPRINGboot.....所有的技术框架：从一个复杂的场景慢慢的衍生出来一种规范！简单的配置！==SpringBoot ：自动配置！==Springboot怎么自动配置，核心...
dubbo服务端启动源码分析（基于Dubbo 3）
LeoHan
09-06 990
本文基于Dubbo 3.0.2来进行源码研究。 在基于springboot的开发中，dubbot的spring-boot-starter中，DubboAutoConfiguration自动配置是一个关键类，这个类向spring容器注入了如下关键类： ServiceAnnotationPostProcessor DubboBootstrapApplicationListener 其中ServiceAnnotationPostProcessor主要是用来加载被DubbotService注解修饰的类，而Dub
Dubbo源码分析
Lucifer ZHAO
11-10 630
dubbo运用双亲委派模型搭建作用域范围模型结构，扩展点
dubbo服务启动流程源码分析
qq_35670001的博客
11-07 513
dubbo服务启动流程源码分析 搭建一个简单的springboot-dubbo项目 先搭建一个简单的springboot dubbo项目，需要引入相关依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>dubbo</artifactId> <v...
Dubbo核心源码分析（二）
边博磊的博客
01-05 371
1.Dubbo的SPI源码分析 2.Dubbo的warapper 3.Dubbo的注入 4.Dubbo的自适应扩展
springboot启动过程源码
IT从业者
02-09 501
springboot启动过程
springboot整合dubbo-start
bossaiaboy的专栏
07-12 4639
Springboot整合dubbo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值