Dubbo学习之PostProcessor

原创 已于 2022-05-07 18:55:31 修改 · 1.6k 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#dubbo
于 2022-04-29 18:16:26 首次发布
本文详细解析了Dubbo在SpringBoot环境中的自动配置过程，包括ServiceAnnotationPostProcessor、ReferenceAnnotationBeanPostProcessor等处理器的作用。这些处理器在BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor阶段处理Dubbo的Service和Reference注解，实现服务的注册和引用。内容涵盖了扫描、注册BeanDefinition、处理注解等关键步骤，深入理解Dubbo与Spring的集成机制。

相关阅读

简介

本文基于Spring Boot 2.6.6，dubbo-spring-boot-starter 3.0.6环境。

Dubbo中使用的BeanDefinitionRegistryPostProcessor如下：

  1. ServiceAnnotationPostProcessor，在DubboAutoConfiguration中以BeanMethod方式注册；
  2. DubboConfigAliasPostProcessor，在DubboBeanUtils.registerCommonBeans方法中注册RootBeanDefinition；
  3. DubboInfraBeanRegisterPostProcessor，在DubboBeanUtils.registerCommonBeans方法中注册RootBeanDefinition；

这三者都未实现PriorityOrdered、Ordered接口，由ConfigurationClassPostProcessor（实现了PriorityOrdered）解析注册到容器中；

Dubbo中使用的BeanFactoryPostProcessor如下：

  1. ReferenceAnnotationBeanPostProcessor，间接实现了Ordered接口；

Dubbo中使用的BeanPostProcessor如下：

  1. DubboConfigDefaultPropertyValueBeanPostProcessor实现了PriorityOrdered接口，在DubboBeanUtils.registerCommonBeans方法中注册RootBeanDefinition；
  2. ReferenceAnnotationBeanPostProcessor实现了Ordered接口，在DubboBeanUtils.registerCommonBeans方法中注册RootBeanDefinition；
  3. DubboConfigAliasPostProcessor，在DubboBeanUtils.registerCommonBeans方法中注册RootBeanDefinition；

DubboConfigDefaultPropertyValueBeanPostProcessor和DubboConfigAliasPostProcessor的实例化是发生在AbstractApplicationContext。registerBeanPostProcessors方法中；
ReferenceAnnotationBeanPostProcessor的实例化是发生在DubboInfraBeanRegisterPostProcessor.postProcessBeanFactory方法中，且在ReferenceAnnotationBeanPostProcessor.postProcessBeanFactory方法中会移除自身的RootBeanDefinition，以避免在AbstractApplicationContext。registerBeanPostProcessors方法中再次实例化；

BeanFactoryPostProcessor

ServiceAnnotationPostProcessor

在postProcessBeanDefinitionRegistry方法中处理Dubbo Service注解标注的类，如：

@DubboService
public class DemoServiceImpl implements DemoService {
}

在postProcessBeanFactory方法中处理Dubbo Service注解标注的Bean（标注在BeanMethod），如：

@Bean
@DubboService
public MethodServiceImpl methodService() {
    return new MethodServiceImpl();
}

同时，ServiceAnnotationPostProcessor也作为<dubbo:annotation package="" />标签的解析器，配置如下：

// DubboNamespaceHandler.java
registerBeanDefinitionParser("annotation", new AnnotationBeanDefinitionParser());


// AnnotationBeanDefinitionParser.java
protected Class<?> getBeanClass(Element element) {
    return ServiceAnnotationPostProcessor.class;
}

postProcessBeanDefinitionRegistry

代码如下：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    this.registry = registry;
    scanServiceBeans(resolvedPackagesToScan, registry);
}

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

    // 设置扫描标识，避免重复扫描
    scaned = true;
    if (CollectionUtils.isEmpty(packagesToScan)) {
        // 无路径需要扫描，则直接退出
        if (logger.isWarnEnabled()) {
            logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
        }
        return;
    }

    // 配置DubboClassPathBeanDefinitionScanner
    DubboClassPathBeanDefinitionScanner scanner =
            new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);

    BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
    scanner.setBeanNameGenerator(beanNameGenerator);
    for (Class<? extends Annotation> annotationType : serviceAnnotationTypes) {
        scanner.addIncludeFilter(new AnnotationTypeFilter(annotationType));
    }

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

    // 扫描各个包路径
    for (String packageToScan : packagesToScan) {

        // 如果已经扫描过则跳过
        if (servicePackagesHolder.isPackageScanned(packageToScan)) {
            if (logger.isInfoEnabled()) {
                logger.info("Ignore package who has already bean scanned: " + packageToScan);
            }
            continue;
        }

        // 扫描包路径下被Dubbo Service注解标注的类，并生成BeanDefinition
        scanner.scan(packageToScan);

        // 查找Dubbo Service的BeanDefinitionHolder
        // 结果会在scan中缓存，故此次直接从缓存中得到
        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, registry, scanner);
                // 缓存已扫描过的类
                servicePackagesHolder.addScannedClass(beanDefinitionHolder.getBeanDefinition().getBeanClassName());
            }
        } else {
            if (logger.isWarnEnabled()) {
                logger.warn("No class annotated by Dubbo @Service was found under package ["
                        + packageToScan + "], ignore re-scanned classes: " + scanExcludeFilter.getExcludedCount());
            }
        }

        // 缓存已扫描过的包路径
        servicePackagesHolder.addScannedPackage(packageToScan);
    }
}

主要逻辑为：

  1. 生成标注为Dubbo Service 的Class的BeanDefinition并注册到容器；
  2. 将生成的BeanDefinition，再次注册为Dubbo Service BeanDefinition；
生成标注为Dubbo Service的BeanDefinition

ClassPathBeanDefinitionScanner.scan(packageToScan)内部使用doScan实现，其代码如下：

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    for (String basePackage : basePackages) {
        // 查找满足要求的候选组件Dubbo Service Class
        // 对basePackage路径下所有类经过isCandidateComponent筛选
        //     先经过excludeFilters（优先），再经过includeFilters
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        for (BeanDefinition candidate : candidates) {
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
            if (candidate instanceof AbstractBeanDefinition) {
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            }
            if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            // 校验当前容器是否已存在该BeanDefinition
            // 1. 若不存在则校验通过
            // 2. 若存在，但兼容，则校验不通过
            // 3. 若存在，且不兼容，则抛出异常
            if (checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                definitionHolder =
                        AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                // 注册BeanDefinition，此时beanName根据原始类名生成
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    return beanDefinitions;
}
注册Dubbo Service BeanDefinition

processScannedBeanDefinition代码如下：

private void processScannedBeanDefinition(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry,
                                          DubboClassPathBeanDefinitionScanner scanner) {

    Class<?> beanClass = resolveClass(beanDefinitionHolder);

    // 获取类上标注的Dubbo Service注解
    Annotation service = findServiceAnnotation(beanClass);

    // 获取注解的属性
    Map<String, Object> serviceAnnotationAttributes = AnnotationUtils.getAttributes(service, true);

    String serviceInterface = resolveInterfaceName(serviceAnnotationAttributes, beanClass);

    String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();

    // 构造Dubbo Service BeanName
    // ServiceBean:interfaceName
    String beanName = generateServiceBeanName(serviceAnnotationAttributes, serviceInterface);

    // 构造Dubbo Service BeanDefinition
    AbstractBeanDefinition serviceBeanDefinition =
            buildServiceBeanDefinition(serviceAnnotationAttributes, serviceInterface, annotatedServiceBeanName);

    // 注册Dubbo Service BeanDefinition
    // 此时beanName为ServiceBean:interfaceName
    registerServiceBeanDefinition(beanName, serviceBeanDefinition, serviceInterface);

}

postProcessBeanFactory

代码如下：

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    if (this.registry == null) {
        // 未在postProcessBeanDefinitionRegistry中设置，则此时设置
        this.registry = (BeanDefinitionRegistry) beanFactory;
    }

    // 处理由标注了Dubbo Service注解的BeanMethod得到的BeanDefinition
    String[] beanNames = beanFactory.getBeanDefinitionNames();
    for (String beanName : beanNames) {
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
        Map<String, Object> annotationAttributes = getServiceAnnotationAttributes(beanDefinition);
        // 存在则说明BeanMethod上存在Dubbo Service注解
        if (annotationAttributes != null) {
            // 注册为Dubbo Service BeanDefinition
            processAnnotatedBeanDefinition(beanName, (AnnotatedBeanDefinition) beanDefinition, annotationAttributes);
        }
    }

    if (!scaned) {
        // 还未扫描过，则扫描
        scanServiceBeans(resolvedPackagesToScan, registry);
    }
}

DubboConfigAliasPostProcessor

DubboConfigAliasPostProcessor核心功能是给AbstractConfig添加Alias，如果其id存在的话，该动作是在BeanPostProcessor.postProcessAfterInitialization方法中实现的，本文关注其接口BeanFactoryPostProcessor的实现，代码如下：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    this.registry = registry;
}

DubboInfraBeanRegisterPostProcessor

DubboInfraBeanRegisterPostProcessor用于实例化基础Bean，如：ReferenceAnnotationBeanPostProcessor；
核心代码如下：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    this.registry = registry;
}

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    if (registry != null) {
        // 实例化ReferenceAnnotationBeanPostProcessor，用于处理ReferenceBean
        ReferenceAnnotationBeanPostProcessor referenceAnnotationBeanPostProcessor = beanFactory.getBean(
            ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class);
        beanFactory.addBeanPostProcessor(referenceAnnotationBeanPostProcessor);

        // 注册PropertySourcesPlaceholderConfigurer如果容器还不存在的话
        DubboBeanUtils.registerPlaceholderConfigurerBeanIfNotExists(beanFactory, registry);
    }

    ApplicationModel applicationModel = DubboBeanUtils.getApplicationModel(beanFactory);
    ModuleModel moduleModel = DubboBeanUtils.getModuleModel(beanFactory);

    // 设置applicationContext
    SpringExtensionInjector.get(applicationModel).init(applicationContext);
    SpringExtensionInjector.get(moduleModel).init(applicationContext);
    DubboBeanUtils.getInitializationContext(beanFactory).setApplicationContext(applicationContext);

    // 设置Dubbo配置参数
    ConfigurableEnvironment environment = (ConfigurableEnvironment) applicationContext.getEnvironment();
    SortedMap<String, String> dubboProperties = EnvironmentUtils.filterDubboProperties(environment);
    applicationModel.getModelEnvironment().setAppConfigMap(dubboProperties);

    // 注册ConfigManager单例
    beanFactory.registerSingleton(ConfigManager.BEAN_NAME, applicationModel.getApplicationConfigManager());
}

BeanFactoryPostProcessor

ReferenceAnnotationBeanPostProcessor

ReferenceAnnotationBeanPostProcessor用于处理DubboReference注解，继承自AbstractAnnotationBeanPostProcessor，从而支持将ReferenceBean注入DubboReference注解标注的字段或者setter方法；同时实现了BeanFactoryPostProcessor接口，便于早期处理容器中已注册的Bean信息；
核心方法如下：

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    String[] beanNames = beanFactory.getBeanDefinitionNames();
    for (String beanName : beanNames) {
        Class<?> beanType;
        if (beanFactory.isFactoryBean(beanName)){
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            if (isReferenceBean(beanDefinition)) {
                continue;
            }
            if (isAnnotatedReferenceBean(beanDefinition)) {
                // 处理BeanMethod上的DubboReference注解
                processReferenceAnnotatedBeanDefinition(beanName, (AnnotatedBeanDefinition) beanDefinition);
                continue;
            }

            String beanClassName = beanDefinition.getBeanClassName();
//                if (beanDefinition instanceof AnnotatedBeanDefinition) {
//                    AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition) beanDefinition;
//                    beanClassName = annotatedBeanDefinition.getFactoryMethodMetadata().getDeclaringClassName();
//                }
            beanType = ClassUtils.resolveClass(beanClassName, getClassLoader());
        } else {
            beanType = beanFactory.getType(beanName);
        }
        if (beanType != null) {
            AnnotatedInjectionMetadata metadata = findInjectionMetadata(beanName, beanType, null);
            try {
                // 注入Dubbo Reference如果需要的话
                prepareInjection(metadata);
            } catch (BeansException e) {
                throw e;
            } catch (Exception e) {
                throw new IllegalStateException("Prepare dubbo reference injection element failed", e);
            }
        }
    }

    if (beanFactory instanceof AbstractBeanFactory) {
        List<BeanPostProcessor> beanPostProcessors = ((AbstractBeanFactory) beanFactory).getBeanPostProcessors();
        for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
            if (beanPostProcessor == this) {
                // 本BeanPostProcessor在DubboInfraBeanRegisterPostProcessor实例化，并注册为BeanPostProcessor
                // 不需要在PostProcessorRegistrationDelegate.registerBeanPostProcessors方法中再次注册
                // 那么会导致BeanPostProcessorChecker统计出错
                // 故此时移除BeanDefinition，这样在PostProcessorRegistrationDelegate.registerBeanPostProcessors方法中就不会被再注册
                beanDefinitionRegistry.removeBeanDefinition(BEAN_NAME);
                break;
            }
        }
    }

    try {
        // 发布DubboConfigInitEvent事件，开始Dubbo初始化
        applicationContext.publishEvent(new DubboConfigInitEvent(applicationContext));
    } catch (Exception e) {
        logger.warn("publish early application event failed, please upgrade spring version to 4.2.x or later: " + e);
    }
}

BeanPostProcessor

DubboConfigDefaultPropertyValueBeanPostProcessor

DubboConfigDefaultPropertyValueBeanPostProcessor继承自GenericBeanPostProcessorAdapter<AbstractConfig>，故只会处理AbstractConfig Bean，主要是给AbstractConfig Bean设置id字段如果该字段还未赋值的话；
核心代码如下：

protected void processBeforeInitialization(AbstractConfig dubboConfigBean, String beanName) throws BeansException {
    if (!beanName.contains("#")) {
        // 设置id字段如果不存在的话
        setPropertyIfAbsent(dubboConfigBean, Constants.ID, beanName);

        // beanName should not be used as config name, fix https://github.com/apache/dubbo/pull/7624
        //setPropertyIfAbsent(dubboConfigBean, "name", beanName);
    }
}

protected void setPropertyIfAbsent(Object bean, String propertyName, String beanName) {

    Class<?> beanClass = getTargetClass(bean);

    PropertyDescriptor propertyDescriptor = getPropertyDescriptor(beanClass, propertyName);

    if (propertyDescriptor != null) {
        Method getterMethod = propertyDescriptor.getReadMethod();

        if (getterMethod == null) {
            return;
        }

        Object propertyValue = invokeMethod(getterMethod, bean);

        if (propertyValue != null) {
            // 字段值存在则无需操作
            return;
        }

        Method setterMethod = propertyDescriptor.getWriteMethod();
        if (setterMethod != null) {
            if (Arrays.equals(of(String.class), setterMethod.getParameterTypes())) {
                // 使用beanName作为该字段值
                invokeMethod(setterMethod, bean, beanName);
            }
        }
    }
}

ReferenceAnnotationBeanPostProcessor

对于BeanPostProcessor接口的方法，ReferenceAnnotationBeanPostProcessor没有特殊实现，ReferenceAnnotationBeanPostProcessor继承自AbstractAnnotationBeanPostProcessor是为了实现注入ReferenceBean功能；

DubboConfigAliasPostProcessor

DubboConfigAliasPostProcessor核心功能是给AbstractConfig Bean添加值为id字段的Alias，如果其id字段值存在的话；
核心代码如下：

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof AbstractConfig) {
        String id = ((AbstractConfig) bean).getId();
        if (hasText(id)
                && !nullSafeEquals(id, beanName)
                && !hasAlias(registry, beanName, id)) {
            // 注册别名：ID
            registry.registerAlias(beanName, id);
        }
    }
    return bean;
}
Dubbo架构篇 - 服务引用
The Secret
01-11 587
本文基于Dubbo2.7.6版本，并且使用Nacos为注册中心，展开服务引用的过程解析。
Dubbo2.7.3版本源码学习系列二: Dubbo服务提供者@EnableDubbo注解ServiceAnnotationBeanPostProcessor原理
avengerEug的博客
04-05 2259
前言 上篇博客Dubbo2.7.3版本源码学习系列一: 初始Dubbo利用SPI机制实现AOP和IOC的源码分析我们详细了解了Dubbo的一些SPI扩展机制。接下来我们学习一下Dubbo注解版本的@EnableDubbo注解实现原理(此注解结合了spring的相关知识点，需要有spring基础的才能看懂。本人总结过spring相关一些常用知识点。传送门) 准备工作: 需要拉取Dubbo 2.7....
ServiceAnnotationBeanPostProcessor源码分析
qwerty的博客
07-28 617
ServiceAnnotationBeanPostProcessor实现了BeanDefinitionRegistryPostProcessor接口 public class ServiceAnnotationBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware,ResourceLoaderAware, BeanClassLoaderAware { private final Logge
dubbo服务端启动源码分析（基于Dubbo 3）
LeoHan
09-06 1246
本文基于Dubbo 3.0.2来进行源码研究。 在基于springboot的开发中，dubbot的spring-boot-starter中，DubboAutoConfiguration自动配置是一个关键类，这个类向spring容器注入了如下关键类： ServiceAnnotationPostProcessor DubboBootstrapApplicationListener 其中ServiceAnnotationPostProcessor主要是用来加载被DubbotService注解修饰的类，而Dub
dubbo源码解析:config-spring——ServiceClassPostProcessor
megggggg的博客
03-14 643
ServiceClassPostProcessor ServiceClassPostProcessor postProcessBeanDefinitionRegistry ServiceClassPostProcessor implements BeanDefinitionRegistryPostProcessor，实现该接口的两个方法，postProcessBeanFactory方法空实现，关键看postProcessBeanDefinitionRegistry，这个方法的作用是注册更多的bean到spr
Dubbo源码学习(八)ScopeBeanFactory对比Spring 的BeanFactory
Dream_it_possible！的博客
10-31 877
ScopeBeanFactory在Dubbo里的职责是充当着管理Dubbo里的bean, 类似于Spring 的BeanFactory注册管理Bean， 不同的是Spring BeanFactory是一个接口，主要实现是DefaultListableBeanFactory。
7_invokeBeanFactoryPostProcessors方法讲解前的一些描述
hu619016140的博客
08-22 368
invokeBeanFactoryPostProcessors方法是一个很好的扩展点。在需要进行统一组件扫描的情境下，通过实现BeanDefinitionRegistryPostProcessor该接口，复写其中的postProcessBeanDefinitionRegistry方法，可以很方便的去做响应的逻辑处理，如dubbo的service扫描。以及mybatis的Mapper 扫描。dubb...
json解析错误_springboot源码架构解析postProcessor
weixin_35720035的博客
01-18 395
说在前面前期回顾sharding-jdbc源码解析更新完毕spring源码解析 更新完毕spring-mvc源码解析 更新完毕spring-tx源码解析 更新完毕spring-boot源码解析 更新完毕rocketmq源码解析 更新完毕dubbbo源码解析 更新完毕netty源码解析 更新完毕spring源码架构更新完毕spring-mvc源码架构更新完毕springboot源码架构更...
面试官：说说 Spring Bean 的实例化过程？面试必问的！
weixin_44421461的博客
02-25 202
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细...
No Spring Bean annotating Dubbo‘s @Service was found under package
学习小窝
09-14 4020
问题描述： No Spring Bean annotating Dubbo’s @Service was found under package 原因分析： 在dubbo服务启动的时候一直无法扫描到Service注解，通过控制台的ServiceAnnotationBeanPostProcessor类查找133行 //注册指定包路径下的贴有Service的Bean scanner.scan(packageToScan); //查找@Service的所有BeanDefinitionHolders，无论@Comp
SpringBoot整合Dubbo：注册失败问题 No Spring Bean annotating Dubbo's @Service was found under package
metamoss
12-24 6048
启动zookeeper，启动provider，启动consumer之后，访问报错。 There was an unexpected error (type=Internal Server Error, status=500). No provider available from registry 127.0.0.1:2181 for service com.example.interfa...
03.Dubbo 应用之扩展机制
masteryourself
12-29 203
1. Java SPI 1.1 配置文件 1. META-INF/services/pers.masteryourself.study.java.spi.Car pers.masteryourself.study.java.spi.BlackCar pers.masteryourself.study.java.spi.RedCar 1.2 代码 1. Car public interface C...
Java SPI机制简介，及dubbo SPI
潘建南的博客
02-03 3004
转自：https://www.jianshu.com/p/46aa69643c97 SPI 简介 SPI 全称为 (Service Provider Interface) ，是JDK内置的一种服务提供发现机制。 目前有不少框架用它来做服务的扩展发现， 简单来说，它就是一种动态替换发现的机制， 举个例子来说， 有个接口，想运行时动态的给它添加实现，你只需要添加一个实现， 而后，把新加的实现，描...
并不简单的代理，Dubbo是如何做服务引用的
战斧的博客
07-14 7845
我们在Dubbo与SpringCloud对比的那一期就说过，Dubbo并不满足于作为RPC框架，除了RPC所需要的内容，还提供了如服务治理等额外的支持。但是无奈，很多人对Dubbo的印象就是RPC框架，因为其核心还是围绕RPC进行的。上一篇我们讲了服务暴露，今天来学习RPC桥梁的另一端：消费者，也就是服务的引用。
Dubbo（四）：Spring 整合 Dubbo 源码分析
Men-DD
08-19 582
在 Java 中，一切皆对象。在 JDK 中使用 java.lang.Class 来描述类这个对象。在 Spring 中，bean 对象是操作核心。那么 Spring 也需要一个东西来描述 bean 这个对象，它就是 BeanDefinition。spring 的基础流程，其整体类图如下:最后的 spring 动作 applicationContext.registerBeanDefinition 会在 IOC 容器内创建描述的 bean 对象。
Springboot 集成dubbo 解决@Reference 注解为空问题汇总
nandao158的博客
01-05 4399
Springboot 集成dubbo，是目前主流的微服务架构之一，两者在集成过程中经常遇到生产者提供的服务类，在消费者服务里依赖注入时启动报错或者注入为空的情况，今天我分享几种情况产生的原因： 首先在查看问题汇总之前需要先了解Springboot 集成dubbo的各种配置和依赖：参考 一、dubbo的注册中心ZK地址配错，导致启动后依赖注入的对象为空： 1、 错误配置：忘记前缀或者后面的端口号，导致启动时就报错 spring: dubbo: application: nam
spring注解方式整合Dubbo源码解析
ZXMSH的博客
02-19 2783
ConfigureBean的前置操作然后设置注册中心配置，监控中心配置，应用配置，模块配置等ConfigureBean的后置操作这里设置配置的逻辑一致，都是从@Reference注解中获取对应的配置名，然后从spring容器中找到对应的配置Bean，然后设置到属性中。
【五】dubbo源码分析之服务调用方启动
Sid小杰的博客
11-02 533
1
Dubbo源码解析（三）
最新发布
qq_40228720的博客
11-14 1240
Dubbo的使用可以不依赖Spring，但是生产环境中Dubbo都是整合到Spring中一起使用，所以本章就解析Dubbo整合Spring的启动流程。
DUBBO bug ServiceAnnotationBeanPostProcessor:No Spring Bean annotating Dubbo‘s @Service
ATM的博客
11-08 623
是同名的两个@Service注解，使用时要注意。使用dubbo提供的注解才能实现rpc调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值