Dubbo学习记录(七) -- Spring整合Dubbo原理中@Service解析流程；

最新推荐文章于 2024-07-15 09:40:00 发布
最新推荐文章于 2024-07-15 09:40:00 发布
阅读量1.1k 收藏 3
点赞数 2
分类专栏： dubbo Spring 文章标签： 学习 java dubbo spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoyaochengxian/article/details/123293680
版权

Spring

看完了Spring整合Dubbo中， Dubbo配置文件的加载流程；
对@Service, @Reference的加载原理好奇， 挖根刨地，虽然看不懂每处细节，但是我至少想要了解整个流程是怎么走的。

package org.apache.dubbo.demo.provider;
public class Application {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class);
        context.start();

        System.in.read();
    }
    @Configuration
    @EnableDubbo(scanBasePackages = "org.apache.dubbo.demo.provider")
    @PropertySource("classpath:/spring/dubbo-provider.properties")
    static class ProviderConfiguration {

    }
}
//@EnabeDubbo注解

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

	//该属性的值也是DubboComponentScan属性basePackages的值；
    @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;

}
  • @EnableDubboConfig是用来加载配置文件的，并将properties文件里面的配置项转换为绑定的DubboConfig配置类与DubboConfigBingdingBeanPostProcessor后置处理器类，在前置处理过程， 使用Spring的DataBinder技术，给每个DubboConfig配置类绑定值；
  • @DubboComponentScan： 用来扫描@Service 和@Reference注解修饰的类；

@DubboComponentScan

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {

    /**
     * basePackages属性的别名。
     * 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 {};

    /**
     * 扫描@Service注解类的基本包路径， value属性是这个属性的别名
     * 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 {};=
	//...
    Class<?>[] basePackageClasses() default {};

}
  • @DubboComponentScan 使用 Import注解 导入类DubboComponentScanRegistrar.class， 通过这个类完成@Service 和@Reference注解的扫描工作；

DubboComponentScanRegistrar

工作：

  1. 获得@DubboComponentToScan注解 定义的基础包路径，扫描基础包路径下的类。
  2. 注册一个ServiceAnnotationBeanPostProcessor处理器类，作用是完成处理被@Service修饰的类；
  3. 注册一个ReferenceAnnotationBeanPostProcessor处理器类， 作用是完成处理被@Reference注解修饰的类；
public class DubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        System.out.println("执行DubboComponentScanRegistrar");

        // 拿到DubboComponentScan注解所定义的包路径，扫描该package下的类，识别这些类上
        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);

        // 注册ServiceAnnotationBeanPostProcessor一个Bean
        // 实现了BeanDefinitionRegistryPostProcessor接口，所以在Spring启动时会调用postProcessBeanDefinitionRegistry方法
        // 该方法会进行扫描，扫描@Service注解了的类，然后生成BeanDefinition（会生成两个，一个普通的bean，一个ServiceBean），后续的Spring周期中会生成Bean
        // 在ServiceBean中会监听ContextRefreshedEvent事件，一旦Spring启动完后，就会进行服务导出
        registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);

        // 注册ReferenceAnnotationBeanPostProcessor
        // 实现了AnnotationInjectedBeanPostProcessor接口，继而实现了InstantiationAwareBeanPostProcessorAdapter接口
        // 所以Spring在启动时，在对属性进行注入时会调用AnnotationInjectedBeanPostProcessor接口中的postProcessPropertyValues方法
        // 在这个过程中会按照@Refrence注解的信息去生成一个RefrenceBean对象
        registerReferenceAnnotationBeanPostProcessor(registry);

    }
}

getPackagesToScan(importingClassMetadata)

工作：

  1. 获取DubboComponentScan注解类的所有属性；
  2. 获取DubboComponentScan的basePackages属性值；
  3. 获取DubboComponentScan的basePackageClasses属性值；
  4. 获取DubboComponentScan的value属性值；
  5. 创建一个Set集合存储存储value, basePackages路径；
  6. 获取basePackageClass的包名路径，放入Set集合；
  7. 如果Set集合最后还是为空， 先获取注解所修饰的类的路径包名；
  • 开头@EnableDubbo(scanBasePackages = “org.apache.dubbo.demo.provider”)，我们指定了扫描的基本路径
  • 如果没有配置这个路径， 就会使用 @EnabbleDubbo 所修饰的类的路径包名 作为扫描路径 即“org.apache.dubbo.demo.provider”
    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;
    }

registerServiceAnnotationBeanPostProcessor(packagesToScan, registry)

工作：

  1. 创建一个代表ServiceAnnotationBeanPostProcessor的BeanDefinitionBuilder构造器；
  2. 设置构造器属性 ， 参数为扫描的路径集合；
  3. 设置Role属性， 默认为2；
  4. 获取代表ServiceAnnotationBeanPostProcessor的BeanDefinition;
  5. 注入容器；
    /**
     * 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) {
        // 生成一个RootBeanDefinition，对应的beanClass为ServiceAnnotationBeanPostProcessor.class
        BeanDefinitionBuilder builder = rootBeanDefinition(ServiceAnnotationBeanPostProcessor.class);
        // 将包路径作为在构造ServiceAnnotationBeanPostProcessor时调用构造方法时的传入参数
        builder.addConstructorArgValue(packagesToScan);
        builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);
    }
ServiceAnnotationBeanPostProcessor
  • 这个类名很奇怪， 第一次还以为是后置处理器， 结果发现这个类是没有实现BeanPostProcessor接口，因此，这个不是一个后置处理器；
  • 该类实现BeanDefinitionRegistryPostProcessor接口， 这个接口是Bean定义注册处理器， 就是用来注册BeanDefinition的；
  • 在Spring启动时， 会调用这个类的postProcessBeanDefinitionRegistry方法，扫描@Service注解所修饰的类，并作为一个Dubbo服务；
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}
public class ServiceAnnotationBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware,
        ResourceLoaderAware, BeanClassLoaderAware {
     //1. 处理包名， 路径中如果有空格，就去掉；
     //2.  扫描包，进行Bean注册
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);
        if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
            // 扫描包，进行Bean注册
            registerServiceBeans(resolvedPackagesToScan, registry);
        } else {
            if (logger.isWarnEnabled()) {
                logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
            }
        }

    }
    private Set<String> resolvePackagesToScan(Set<String> packagesToScan) {
        Set<String> resolvedPackagesToScan = new LinkedHashSet<String>(packagesToScan.size());
        for (String packageToScan : packagesToScan) {
            if (StringUtils.hasText(packageToScan)) {
                String resolvedPackageToScan = environment.resolvePlaceholders(packageToScan.trim());
                resolvedPackagesToScan.add(resolvedPackageToScan);
            }
        }
        return resolvedPackagesToScan;
    }
}
registerServiceBeans(resolvedPackagesToScan, registry)

工作：

  1. 创建一个DubboClassPathBeanDefinitionScanner实例， dubbo的路径扫描器；
  2. 创建一个Bean名称生成器；
  3. 扫描器设置要扫描的注解， 指定为Service.class,和com.alibaba.dubbo.config.annotation.Service.class， 后者为了兼容处理；
  4. 遍历扫描包路径集合；
    4.1 scanner.scan(packageToScan) 扫描Dubbo自定义的@Service注解， 并将扫描到的Dubbo服务转换为BeanDefinition实例注入容器；
    4.2 findServiceBeanDefinitionHolders查找路径下所有被@Service注解所修饰的类的BeanDefinition；
    4.3 遍历BeanDefinition
    4.4 生成一个ServiceBean实例，并注入容器；
	
    private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {

        DubboClassPathBeanDefinitionScanner scanner =
                new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);

        BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);

        scanner.setBeanNameGenerator(beanNameGenerator);

        // 扫描被Service注解标注的类
        scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
        scanner.addIncludeFilter(new AnnotationTypeFilter(com.alibaba.dubbo.config.annotation.Service.class));

        for (String packageToScan : packagesToScan) {

            // Registers @Service Bean first
            scanner.scan(packageToScan);

            // 查找被@Service注解的类的BeanDefinition（无论这个类有没有被@ComponentScan注解标注了）
            // Finds all BeanDefinitionHolders of @Service whether @ComponentScan scans or not.
            Set<BeanDefinitionHolder> beanDefinitionHolders =
                    findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);

            if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {

                // 扫描到BeanDefinition开始处理它
                for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                    registerServiceBean(beanDefinitionHolder, registry, scanner);
                }
              	//...日志

            } else {
            //....日志
            }

        }

    }
ClassPathBeanDefinitionScanner#doScan

这个内容是Spring的扫描注解的内容， 我大概知道其作用，内部源码和我想象的不一样；
工作：

  1. 创建返回结果beanDefinitions的Set集合
  2. 遍历包路径
  3. findCandidateComponents扫描候选的组件，返回一个BeanDefinition集合；
  4. 遍历返回的BeanDefinition集合；
  5. 将BeanDefinition转换为BeanDefinitionHolder实例， 然后registerBeanDefinition方法注入容器；
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
		for (String basePackage : basePackages) {
			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);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}
findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator)

工作：

  1. 使用扫描器对包路径下的服务进行扫描，扫描到的Dubbo服务类都会转换为一个Bean Definition类 （是否重复了这个过程，上面就已经执行了一次,有点疑问）
  2. 创建一个Set集合存储结果
  3. 遍历 扫描的BeanDefinition类
  4. 转换为BeanDefinitionHolder类， 加入Set集合结果；
  5. 返回；
    private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(
            ClassPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry,
            BeanNameGenerator beanNameGenerator) {

        Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);

        Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<>(beanDefinitions.size());

        for (BeanDefinition beanDefinition : beanDefinitions) {

            String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
            BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
            beanDefinitionHolders.add(beanDefinitionHolder);

        }

        return beanDefinitionHolders;

    }
registerServiceBean(beanDefinitionHolder, registry, scanner)

工作：

  1. 获取BeanDefinitionHolder代表的Dubbo服务实现类；
  2. 获取@Service注解对象实例； （@Service(protocol , version …) 注解里面可以指定多个属性）
  3. 获取@Service注解对象实例的所有的属性值；
  4. 获取实现类实现的接口；
  5. 获取服务实现类的Bean名称；DemoServiceImpl类的bean名称为demoServiceImpl…
  6. 创建一个代表serviceBean的BeanDefinition实例；
  7. 获取一个ServiceBean的Bean名称， （以类名+组名+版本号为名称）
  8. 判断容器中是否已经存在，不存在就注入容器；

    private void registerServiceBean(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry,
                                     DubboClassPathBeanDefinitionScanner scanner) {
        // 处理扫描到的每一个BeanDefinition
        // 1. 得到@Service注解上所配置的参数
        // 2. 根据每一个BeanDefinition会再额外的生成一个ServiceBean
        // 3. 对于每一个被@Service注解的类（服务的实现类），会生成两个Bean，一个服务实现类对应的Bean（普通Bean，和@Component一样），一个ServiceBean（Dubbo中要用到的Bean，因为在ServiceBean中包括了很的Config）

        // 具体的服务实现类
        Class<?> beanClass = resolveClass(beanDefinitionHolder);
        // @Service可以对服务进行各种配置
        Annotation service = findServiceAnnotation(beanClass);

        /**
         * The {@link AnnotationAttributes} of @Service annotation
         */
        AnnotationAttributes serviceAnnotationAttributes = getAnnotationAttributes(service, false, false);

        // 服务实现类对应的接口
        Class<?> interfaceClass = resolveServiceInterfaceClass(serviceAnnotationAttributes, beanClass);
        // 服务实现类对应的bean的名字，比如：demoServiceImpl
        String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();

        // 生成一个ServiceBean
        AbstractBeanDefinition serviceBeanDefinition =
                buildServiceBeanDefinition(service, serviceAnnotationAttributes, interfaceClass, annotatedServiceBeanName);

        // ServiceBean Bean name   ServiceBean表示服务，我们要使用一个服务应该拿ServiceBean
        String beanName = generateServiceBeanName(serviceAnnotationAttributes, interfaceClass);

        if (scanner.checkCandidate(beanName, serviceBeanDefinition)) { // check duplicated candidate bean

            // 把ServiceBean注册进去，对应的beanName为ServiceBean:org.apache.dubbo.demo.DemoService
            registry.registerBeanDefinition(beanName, serviceBeanDefinition);
      		//...日志

        } else {
          //...日志
        }

    }
findServiceAnnotation(beanClass)

工作 ：获取服务实现类Class上的@Service注解信息；

    private Annotation findServiceAnnotation(Class<?> beanClass) {
        Annotation service = findMergedAnnotation(beanClass, Service.class);
        if (service == null) {
            service = findMergedAnnotation(beanClass, com.alibaba.dubbo.config.annotation.Service.class);
        }
        return service;
    }
    public static <A extends Annotation> A findMergedAnnotation(AnnotatedElement element, Class<A> annotationType) {
        if (!(element instanceof Class)) {
        	//关键： 获取Class的注解@Service
            A annotation = element.getAnnotation(annotationType);
            if (annotation != null) {
            	//返回
                return AnnotationUtils.synthesizeAnnotation(annotation, element);
            }
        }

        AnnotationAttributes attributes = findMergedAnnotationAttributes(element, annotationType, false, false);
        return AnnotationUtils.synthesizeAnnotation(attributes, annotationType, element);
    }
buildServiceBeanDefinition(service, serviceAnnotationAttributes, interfaceClass, annotatedServiceBeanName)

作用： 创建代表ServiceBean的BeanDefinition对象；
工作：

  1. 生成一个ServiceBean对应的BeanDefinition
  2. 获取ServiceBean的普通属性MutablePropertyValues （像String,Long…)
  3. 从@Service注解的配置值 赋值给ServiceBean的属性；
  4. 设置ref属性， ref属性 引用 Dubbo服务实现类实例；
    4.1 Spring的内容： Spring根据传入的Bean名称，从容器中拿到Bean，拿不到就进行创建， 然后返回， 然后ServiceBean的ref属性引用Bean实例；
  5. ServiceBean的属性"provider", “monitor”, “application”, “module”, “registry”, “protocol”，“interface”, “interfaceName”, "parameters"赋值，
    这些属性都不是普通属性， 而是类对象， 例如application对应得DubboApplicationConfig, protocol对应得ProtocolConfig依次类推，Spring中使用addPropertyValue进行赋值；
  6. 最终返回代表ServiceBean得BeanDefinition对象

    private AbstractBeanDefinition buildServiceBeanDefinition(Annotation serviceAnnotation,
                                                              AnnotationAttributes serviceAnnotationAttributes,
                                                              Class<?> interfaceClass,
                                                              String annotatedServiceBeanName) {
        // 生成一个ServiceBean对应的BeanDefinition
        BeanDefinitionBuilder builder = rootBeanDefinition(ServiceBean.class);

        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();

        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();

        String[] ignoreAttributeNames = of("provider", "monitor", "application", "module", "registry", "protocol",
                "interface", "interfaceName", "parameters");

        // 把serviceAnnotation中的参数值赋值给ServiceBean的属性
        propertyValues.addPropertyValues(new AnnotationPropertyValuesAdapter(serviceAnnotation, environment, ignoreAttributeNames));

        // References "ref" property to annotated-@Service Bean
        // ref属性赋值为另外一个bean, 对应的就是被@Service注解的服务实现类对应的bean
        addPropertyReference(builder, "ref", annotatedServiceBeanName);
        // Set interface
        builder.addPropertyValue("interface", interfaceClass.getName());
        // Convert parameters into map
        builder.addPropertyValue("parameters", convertParameters(serviceAnnotationAttributes.getStringArray("parameters")));

        // 配置了methods属性，则给ServiceBean对应的methods属性赋值
        // Add methods parameters
        List<MethodConfig> methodConfigs = convertMethodConfigs(serviceAnnotationAttributes.get("methods"));
        if (!methodConfigs.isEmpty()) {
            builder.addPropertyValue("methods", methodConfigs);
        }

        /**
         * Add {@link org.apache.dubbo.config.ProviderConfig} Bean reference
         */
        String providerConfigBeanName = serviceAnnotationAttributes.getString("provider");
        if (StringUtils.hasText(providerConfigBeanName)) {
            addPropertyReference(builder, "provider", providerConfigBeanName);
        }

        /**
         * Add {@link org.apache.dubbo.config.MonitorConfig} Bean reference
         */
        String monitorConfigBeanName = serviceAnnotationAttributes.getString("monitor");
        if (StringUtils.hasText(monitorConfigBeanName)) {
            addPropertyReference(builder, "monitor", monitorConfigBeanName);
        }

        /**
         * Add {@link org.apache.dubbo.config.ApplicationConfig} Bean reference
         */
        String applicationConfigBeanName = serviceAnnotationAttributes.getString("application");
        if (StringUtils.hasText(applicationConfigBeanName)) {
            addPropertyReference(builder, "application", applicationConfigBeanName);
        }

        /**
         * Add {@link org.apache.dubbo.config.ModuleConfig} Bean reference
         */
        String moduleConfigBeanName = serviceAnnotationAttributes.getString("module");
        if (StringUtils.hasText(moduleConfigBeanName)) {
            addPropertyReference(builder, "module", moduleConfigBeanName);
        }


        /**
         * Add {@link org.apache.dubbo.config.RegistryConfig} Bean reference
         * 获取注解上配置的注册中心的beanName
         */
        String[] registryConfigBeanNames = serviceAnnotationAttributes.getStringArray("registry");

        List<RuntimeBeanReference> registryRuntimeBeanReferences = toRuntimeBeanReferences(registryConfigBeanNames);

        if (!registryRuntimeBeanReferences.isEmpty()) {
            builder.addPropertyValue("registries", registryRuntimeBeanReferences);
        }

        /**
         * Add {@link org.apache.dubbo.config.ProtocolConfig} Bean reference
         */
        String[] protocolConfigBeanNames = serviceAnnotationAttributes.getStringArray("protocol");

        List<RuntimeBeanReference> protocolRuntimeBeanReferences = toRuntimeBeanReferences(protocolConfigBeanNames);

        if (!protocolRuntimeBeanReferences.isEmpty()) {
            builder.addPropertyValue("protocols", protocolRuntimeBeanReferences);
        }

        return builder.getBeanDefinition();

    }

ServiceBean

public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean,
        ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, BeanNameAware,
        ApplicationEventPublisherAware {
	//...省略部分代码

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 当前服务没有被导出并且没有卸载，才导出服务
        if (!isExported() && !isUnexported()) {
            if (logger.isInfoEnabled()) {
                logger.info("The service ready on spring started. service: " + getInterface());
            }
            // 服务导出（服务注册）
            export();
        }
    }
}
public class ServiceConfig<T> extends AbstractServiceConfig {

    private static final long serialVersionUID = 3033787999037024738L;
    private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
    private static final ProxyFactory PROXY_FACTORY = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();
    private static final Map<String, Integer> RANDOM_PORT_MAP = new HashMap<String, Integer>();
    private static final ScheduledExecutorService DELAY_EXPORT_EXECUTOR = Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("DubboServiceDelayExporter", true));
    private final List<URL> urls = new ArrayList<URL>();
    private final List<Exporter<?>> exporters = new ArrayList<Exporter<?>>();

    private String interfaceName;
    private Class<?> interfaceClass;
    private T ref;
    private String path;
    private List<MethodConfig> methods;
    private ProviderConfig provider;
    private String providerIds;
}
public abstract class AbstractServiceConfig extends AbstractInterfaceConfig {

    private static final long serialVersionUID = 1L;

    protected String version;

    protected String group;

    protected Boolean deprecated = false;

    protected Integer delay;

    protected Boolean export;

    protected Integer weight;

    protected String document;

    protected Boolean dynamic = true;

    protected String token;

    protected String accesslog;

    protected List<ProtocolConfig> protocols;

    protected String protocolIds;

    private Integer executes;

    private Boolean register;

    private Integer warmup;

    private String serialization;
  }
  • 重要配置属性：
    ServiceBean表示一个Dubbo服务，它有一些参数，比如：
  1. ref，表示服务的具体实现类
  2. interface，表示服务的接口
  3. parameters，表示服务的参数（@Service注解中所配置的信息）
  4. application，表示服务所属的应用
  5. protocols，表示服务所使用的协议
  6. registries，表示服务所要注册的注册中心
  • ServiceBean本身实现了ApplicationListener监听器接口， 当Spring应用启动完后，Bean全部加载完毕， Dubbo的所有服务都会进行导出，例如注册到注册中心等操作；

结果

  1. Dubbo整合Spring过程中， 扫描@Service注解和所修饰的类时， 会生成代表服务实现类的BeanDefinition,并注入容器；
  2. 对于Dubbo来说此时得到的Bean是一个服务， 因此Dubbo需要解析@Service注解所包含的信息， 解析@Service注解后，会另外生成一个代表ServiceBean的BeanDefinition， 并注入容器；
问道玄霄
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
web service接口_Dubbo配置参考手册之dubbo:service
weixin_39854440的博客
11-19 1222
概述dubbo:service配置项用于在服务提供者端定义真实服务信息，一共有31个属性可供配置。所有配置最终都将转换为URL表示，然后注册到注册中心并传递给消费方。大部分的属性都会有一个URL的参数与之对应。属性详情interface服务接口名，类型是class即接口完整类名，属于dubbo:service标签的必填属性(后续的属性说明中，没有专门指明是必填属性的，均为可选属性)，其作用是用于服...
SpringBoot整合dubbo详解(阿里官方dubbo-spring-boot-starter)
热门推荐
u011788183的博客
08-12 2万+
Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服务模型的角度来看，Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。 Dubbo 的RPC 调用流程主要涉及到4个模块...
Dubbo源码分析（三）：Dubbo之服务端（Service）
xiaomin1991222的专栏
10-30 145
      如上图所示的Dubbo的暴露服务的过程，不难看出它也和消费者端很像，也需要一个像reference的对象来维护service关联的所有对象及其属性，这里的reference就是provider。由于ServiceBean实现了   InitializingBean接口，所有在Spring实例化这个bean后会调用接口方法afterPropertiesSet： [j...
探索Dubbo的注解配置
最新发布
FireFox1997
07-15 857
通过注解配置Dubbo，不仅简化了配置流程，还增强了代码的可读性和可维护性。@Service、@Reference和@DubboComponentScan这三个注解，分别负责标注服务提供者、注入服务消费者以及扫描Dubbo组件，是Dubbo注解配置的核心。希望这篇文章能够帮助你更好地理解和使用Dubbo的注解配置，让你的微服务开发更加高效和便捷。如果你有任何问题或需要进一步的探讨，欢迎随时与我交流。
dubbo service注解用法_基于注解的Dubbo服务配置方法(实例讲解)
weixin_29213655的博客
01-17 1934
基于注解的Dubbo服务配置可以大大减少dubbo xml配置文件中的Service配置量，主要步骤如下：一、服务提供方1. Dubbo配置文件中增加Dubbo注解扫描2.Service实现类上添加Dubbo Service注解import com.alibaba.dubbo.config.annotation.Service;@Servicepublic class DubboServiceIm...
Dubbo注册Service
HanJuly9569的博客
10-22 376
Dubbo注册Service 1 与Spring的结合 首先spring注册实例让IOC容器管理实例的方式有注解方式，xml的方式。Dubbo中使用另一种方式。BeanDefinitionRegistryPostProcessor提供了让我们对BeanDefinition进行自定义注册的方法，如果Spring中的默认配置方式不能满足你的要求，就可以通过实现BeanDefinitionRegistr...
Dubbo学习之DubboService
我家有猫已长成的博客
05-11 9730
Dubbo学习之DubboService 的简介。
Spring整合Dubbo框架过程及原理解析
08-25
Spring整合Dubbo框架过程及原理解析 一、Dubbo框架架构 Dubbo是一个RPC框架，主要提供了服务注册、服务发现、服务调用等功能。Dubbo架构主要分为四个节点角色：Provider、Consumer、Registry、Monitor。 * ...
深入理解Spring与Dubbo整合原理与源码分析：从启动类配置到注解解析.rar
03-18
在源码层面，当我们使用@DubboService或@DubboReference注解时，Spring的AOP机制会动态地生成代理对象，使得在业务代码中可以透明地调用远程服务。Dubbo的注解解析过程是关键，它会读取注解信息，生成并注册相应的...
深入理解Spring与Dubbo整合原理与源码分析：从启动类配置到注解解析
01-16
《深入理解Spring与Dubbo整合原理与源码分析：从启动类配置到注解解析》 Spring与Dubbo的整合是现代微服务架构中的常见实践，这篇文章旨在剖析这一过程的内在机制，帮助开发者深入理解其工作原理。文章首先从应用的...
Dubbo源码分析-Spring与Dubbo整合原理与源码分析（二）
qq_22685435的博客
03-14 2893
Spring与Dubbo整合的整体流程（基于apache-dubbo-2.7.15） 因为dubbo有较多的兼容以前的代码比如@DubboReference 以前就有两个版本@Reference 和@com.alibaba.dubbo.config.annotation.Reference ，为了方便文章如果提到@DubboReference其实可能还包括的其他两个注解，其他情况也类似。 Spring启动时先根据properties配置生成9个Config对象，如应用配置，注册中心配置等。 Spirng
dubbo-service 实现
07-15
微服务分布式架构实践，dubbo-service 服务器端，下载即运行[4.3]
dubbo学习篇2 注解之 @Service 原理解析
w18637468680的专栏
09-30 3162
一.使用注解 在dubbo springboot 使用时，在需要调用的服务接口上使用@Service 即可将接口实现作为服务暴露 即可给消费者调用 @Service(version = "1.0.0", application = "${dubbo.application.id}", protocol = "${dubbo.protocol.id}", ...
dubbo:service
BLOG域名:programb.blog.csdn.net
04-28 506
The configuration of the service provider. The corresponding class is org.apache.dubbo.config.ServiceConfig. Attribute Corresponding URL parameter Type Required Default Value Function Descriptio...
Dubbo - @Service
chengtouque9610的博客
08-11 712
xx 转载于:https://my.oschina.net/u/2552286/blog/3086453
Dubbo-service--服务启动
Niulx
08-18 2142
通过注解方式（service）进行暴漏服务 1. AnnotationBean通过调用postProcessAfterInitialization方法,得到(service)注解上的内容，创建一个ServiceBean。 2. 为ServiceBean 注入application，module，registries，provider，monitor，protocol等，初始化信息，在此过程...
dubbo源码-Service注解
LiuRenyou的博客
12-27 2718
dubbo源码-Service注解前言源码分析总结 前言 上一篇已经详细分析了dubbo的配置解析，本小节我们聊聊@Service注解。 当你使用@Service注解时有没有疑惑，这不是spring自带的注解，dubbo是如何扫描到该注解的，扫描到后又做了什么处理。 源码分析 @EnableDubbo @EnableDubbo(scanBasePackages = “org.apache.dubbo.demo.provider”) @DubboComponentScan public @interface
dubbo 注解版 @Service @Reference 常用配置 超时，重试,多版本，分组，权重，负载均衡等
小哇
12-31 1580
1 多版本（灰色发布），将服务提供者的实现类，再重新写一个，注解中添加参数即可 当出现系统版本升级时,新版本有可能不够稳定,这时候可以通过设置version来进行平滑的过渡,下面是dubbo官网的版本迁移步骤： 在低压力时间段，先升级一半提供者为新版本，再将所有消费者升级为新版本，然后将剩下的一半提供者升级为新版 而新旧版本我们可以通过version来定义,假设老版本...
5分钟Spring-boot快速集成Dubbo，构建分布式服务
本文将引导读者通过一个实战项目，了解如何在Spring Boot环境中整合Dubbo，并展示服务注册、消费和监控的全过程，以便快速理解和部署分布式服务。如果想深入了解，可以参考源码或访问提供的Github项目地址获取更多...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值