1：写在前面
在这篇文章 中我们分析了通过xml配置方式配置解析的过程，本文一起来看下基于注解配置方式，即Java config方式配置的解析过程。另外关于dubbo注解配置使用可以参考如下的文章列表：
dubbo之入门 。
dubbo之外部化配置 。
如下是服务提供者端一个可能的配置：
@Configuration
@EnableDubbo(scanBasePackages = "dongshi.daddy.service.annotation")
public class DubboConfiguration {
@Bean // #1 服务提供者信息配置
public ProviderConfig providerConfig() {
ProviderConfig providerConfig = new ProviderConfig();
providerConfig.setTimeout(1000);
return providerConfig;
}
@Bean // #2 分布式应用信息配置，相当于xml配置：<dubbo:application name="dongshidaddy-provider" owner="dongshidaddy">
public ApplicationConfig applicationConfig() {
ApplicationConfig applicationConfig = new ApplicationConfig();
applicationConfig.setName("dubbo-annotation-provider");
return applicationConfig;
}
@Bean // #3 注册中心信息配置，相当于xml配置：<dubbo:registry address="zookeeper://192.168.10.119:2181" />
public RegistryConfig registryConfig() {
RegistryConfig registryConfig = new RegistryConfig();
registryConfig.setProtocol("zookeeper");
registryConfig.setAddress("192.168.10.119");
registryConfig.setPort(2181);
return registryConfig;
}
@Bean // #4 使用协议配置，这里使用 dubbo，相当于xml配置：<dubbo:protocol name="dubbo" port="20823"/>
public ProtocolConfig protocolConfig() {
ProtocolConfig protocolConfig = new ProtocolConfig();
protocolConfig.setName("dubbo");
protocolConfig.setPort(20885);
return protocolConfig;
}
}启动类：
public class ProviderAnnotationMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DubboConfiguration.class);
context.start();
new Thread(() -> {
while (true) {
try {
Thread.sleep(900000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}服务消费者端配置：
@Configuration
@EnableDubbo(scanBasePackages = "dongshi.daddy.service.annotation")
@ComponentScan(value = {"dongshi.daddy.service.annotation"})
public class ConsumerConfiguration {
@Bean // 应用配置
public ApplicationConfig applicationConfig() {
ApplicationConfig applicationConfig = new ApplicationConfig();
applicationConfig.setName("dubbo-annotation-consumer");
Map<String, String> stringStringMap = new HashMap<String, String>();
stringStringMap.put("qos.enable","true");
stringStringMap.put("qos.accept.foreign.ip","false");
stringStringMap.put("qos.port","33333");
applicationConfig.setParameters(stringStringMap);
return applicationConfig;
}
@Bean // 服务消费者配置
public ConsumerConfig consumerConfig() {
ConsumerConfig consumerConfig = new ConsumerConfig();
consumerConfig.setTimeout(3000);
return consumerConfig;
}
@Bean // 配置注册中心
public RegistryConfig registryConfig() {
RegistryConfig registryConfig = new RegistryConfig();
registryConfig.setProtocol("zookeeper");
registryConfig.setAddress("192.168.10.119");
registryConfig.setPort(2181);
return registryConfig;
}
}启动类：
public class ConsumerAnnotationMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerConfiguration.class);
context.start(); // 启动
ConsumerAnnotationService consumerAnnotationService = context.getBean(ConsumerAnnotationService.class);
String hello = consumerAnnotationService.doSayHello("annotation"); // 调用方法
System.out.println("result: " + hello); // 输出结果
}
}2. @EnableDubbo
类全限定名称是com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo，源码如下：
@Target({ElementType.TYPE}) // 用在类上
@Retention(RetentionPolicy.RUNTIME) // 保留到运行时
@Inherited // 可以被继承
@Documented
@EnableDubboConfig
@DubboComponentScan // 启用dubbo组件的扫描，即扫描@Service注解的服务提供者类，@Reference注解的服务消费者类
public @interface EnableDubbo {
// 扫描使用了@Service，@Reference注解的类的基础包，是相当于使用DubboComponentScan.class注解的basePackages
@AliasFor(annotation = DubboComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
// 同scanBasePackages直接以字符串的方式来指定要扫描的包的集合，该值指定一组class后，会以class所在的包路径来扫描@Service和@Reference注解的类
@AliasFor(annotation = DubboComponentScan.class, attribute = "basePackageClasses")
Class<?>[] scanBasePackageClasses() default {};
// 暂时不知道干啥用的
@AliasFor(annotation = EnableDubboConfig.class, attribute = "multiple")
boolean multipleConfig() default true;
}可以看到该注解组合了注解@EnableDubboConfig和注解DubboComponentScan,接下来我们先来看下@EnableDubboConfig注解。
3. @EnableDubboConfig
源码如下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Import(DubboConfigConfigurationRegistrar.class)
public @interface EnableDubboConfig {
// 是否允许dubbo多配置bean绑定，2.5.8版本引入默认为false，2.5.9版本开始修改为默认true
boolean multiple() default true;
}可以看到源码中通过@Import(DubboConfigConfigurationRegistrar.class)引入了bean定义，因此，接下来我们看下DubboConfigConfigurationRegistrar到底做了什么操作。
3.1：DubboConfigConfigurationRegistrar
源码如下：
public class DubboConfigConfigurationRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 获取@EnableDubboConfig配置的属性信息
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
importingClassMetadata.getAnnotationAttributes(EnableDubboConfig.class.getName()));
// 获取multiple属性的值
boolean multiple = attributes.getBoolean("multiple");
// 2021-12-27 13:30:24
registerBeans(registry, DubboConfigConfiguration.Single.class);
// 2021-12-27 13:30:45
if (multiple) { // Since 2.6.6 https://github.com/apache/incubator-dubbo/issues/3193
registerBeans(registry, DubboConfigConfiguration.Multiple.class);
}
}
}2021-12-27 13:30:24处是默认注册一个DubboConfigConfiguration.Single的内部类的bean，2021-12-27 13:30:45处是如果是开启了多dubbo配置bean绑定则注册DubboConfigConfiguration.Multiple内部类，可以看到都是DubboConfigConfiguration的内部类，源码如下：
public class DubboConfigConfiguration {
// 单dubbo配置bean绑定
@EnableDubboConfigBindings({
@EnableDubboConfigBinding(prefix = "dubbo.application", type = ApplicationConfig.class),
@EnableDubboConfigBinding(prefix = "dubbo.module", type = ModuleConfig.class),
@EnableDubboConfigBinding(prefix = "dubbo.registry", type = RegistryConfig.class),
@EnableDubboConfigBinding(prefix = "dubbo.protocol", type = ProtocolConfig.class),
@EnableDubboConfigBinding(prefix = "dubbo.monitor", type = MonitorConfig.class),
@EnableDubboConfigBinding(prefix = "dubbo.provider", type = ProviderConfig.class),
@EnableDubboConfigBinding(prefix = "dubbo.consumer", type = ConsumerConfig.class)
})
public static class Single {
}
// 多dubbo配置bean绑定，注意都设置了"multiple = true"
@EnableDubboConfigBindings({
@EnableDubboConfigBinding(prefix = "dubbo.applications", type = ApplicationConfig.class, multiple = true),
@EnableDubboConfigBinding(prefix = "dubbo.modules", type = ModuleConfig.class, multiple = true),
@EnableDubboConfigBinding(prefix = "dubbo.registries", type = RegistryConfig.class, multiple = true),
@EnableDubboConfigBinding(prefix = "dubbo.protocols", type = ProtocolConfig.class, multiple = true),
@EnableDubboConfigBinding(prefix = "dubbo.monitors", type = MonitorConfig.class, multiple = true),
@EnableDubboConfigBinding(prefix = "dubbo.providers", type = ProviderConfig.class, multiple = true),
@EnableDubboConfigBinding(prefix = "dubbo.consumers", type = ConsumerConfig.class, multiple = true)
})
public static class Multiple {
}
}可以看到都是用了@EnableDubboConfigBindings和@EnableDubboConfigBinding注解，这两个注解是用来设置指定外部配置文件属性前缀绑定到AbstractConfig的子类的，下面来一起看下都完成了哪些工作。@EnableDubboConfigBindings参考3.2：@EnableDubboConfigBindings,@EnableDubboConfigBinding参考3.3：@EnableDubboConfigBinding。
3.2：@EnableDubboConfigBindings
源码如下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboConfigBindingsRegistrar.class)
public @interface EnableDubboConfigBindings {
EnableDubboConfigBinding[] value();
}可以看到使用了@Import(DubboConfigBindingsRegistrar.class)来引入bean定义。
3.2.1：DubboConfigBindingsRegistrar
源码如下：
public class DubboConfigBindingsRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {
// 环境
private ConfigurableEnvironment environment;
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 获得类上标注的@EnableDubboConfigBindings属性信息
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
importingClassMetadata.getAnnotationAttributes(EnableDubboConfigBindings.class.getName()));
// 获取value值，即使用@EnableDubboConfigBinding注解配置的属性前缀和AbstractConfig子类的对应关系
AnnotationAttributes[] annotationAttributes = attributes.getAnnotationArray("value");
// 创建DubboConfigBindingRegistrar并使用其完成dubbo注册
DubboConfigBindingRegistrar registrar = new DubboConfigBindingRegistrar();
registrar.setEnvironment(environment);
for (AnnotationAttributes element : annotationAttributes) {
// 2021-12-28 13:31:38
registrar.registerBeanDefinitions(element, registry);
}
}
@Override
public void setEnvironment(Environment environment) {
Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
this.environment = (ConfigurableEnvironment) environment;
}
}2021-12-28 13:31:38处是注册单个映射关系的bean定义，具体参考3.3.1：DubboConfigBindingRegistrar。
3.3：@EnableDubboConfigBinding
源码如下：
// 启用外部化配置，从@PropertySource注解指定的配置文件中读取相关配置映射绑定到AbstractConfig对应的子类中，前缀比如"dubbo.application.",`dubbo.application`
@Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboConfigBindingRegistrar.class)
public @interface EnableDubboConfigBinding {
// 能够绑定到AbstractConfig子类的属性前缀
String prefix();
// 要绑定的AbstractConfig子类
Class<? extends AbstractConfig> type();
// 是否支持绑定到多个spring bean
boolean multiple() default false;
}通过@Import(DubboConfigBindingRegistrar.class)引入相关的spring bean,具体参考3.3.1：DubboConfigBindingRegistrar。
3.3.1：DubboConfigBindingRegistrar
源码如下：
public class DubboConfigBindingRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {
private final Log log = LogFactory.getLog(getClass());
private ConfigurableEnvironment environment;
protected void registerBeanDefinitions(AnnotationAttributes attributes, BeanDefinitionRegistry registry) {
// 获取在@EnableDubboConfigBinding注解中配置的prefix值，如dubbo.application
String prefix = environment.resolvePlaceholders(attributes.getString("prefix"));
// 获取在@EnableDubboConfigBinding注解中type的值，即设置的要绑定的AbtractConfig子类
Class<? extends AbstractConfig> configClass = attributes.getClass("type");
// 获取multiple属性的值，即是否支持dubbo多配置bean绑定
boolean multiple = attributes.getBoolean("multiple");
registerDubboConfigBeans(prefix, configClass, multiple, registry);
}
private void registerDubboConfigBeans(String prefix,
Class<? extends AbstractConfig> configClass,
boolean multiple,
BeanDefinitionRegistry registry) {
// 获取配置文件中以prefix开头的配置信息，如获取dubbo.application开头的，如下配置：
/*
dubbo.application.name=dongshidaddy-provider
dubbo.application.owner=dongshidaddy
*/
// 则这里获取的结果就是：
/*
"owner" -> "dongshidaddy"
"name" -> "dongshidaddy-provider"
*/
Map<String, Object> properties = getSubProperties(environment.getPropertySources(), prefix);
// 没有对应的外部配置属性，不报错，只是给出日志，就return
if (CollectionUtils.isEmpty(properties)) {
if (log.isDebugEnabled()) {
log.debug("There is no property for binding to dubbo config class [" + configClass.getName()
+ "] within prefix [" + prefix + "]");
}
return;
}
// 2021-12-29 14:15:46
// 获取绑定的AbstractConfig的bean名称集合
Set<String> beanNames = multiple ? resolveMultipleBeanNames(properties) :
Collections.singleton(resolveSingleBeanName(properties, configClass, registry));
for (String beanName : beanNames) {
// 将bean定义注册到BeanDefinitionRegistry registry中
registerDubboConfigBean(beanName, configClass, registry);
// 2021-12-29 16:24:02
// 注册DubboConfigBindingBeanPostProcessor后置bean处理器，关于BeanPostProcessort可以参考:
//
//
registerDubboConfigBindingBeanPostProcessor(prefix, beanName, multiple, registry);
}
}
}2021-12-29 14:15:46处是注册bean名称，multiple=false时resolveSingleBeanName，源码如下：
class FakeCls {
private String resolveSingleBeanName(Map<String, Object> properties, Class<? extends AbstractConfig> configClass,
BeanDefinitionRegistry registry) {
// 获取id属性，如dubbo.application.id=myApplicationConfigBean，则使用myApplicationConfigBean
String beanName = (String) properties.get("id");
// 没有配置id属性，则使用“类全限定名称+#序号”方式生成结果，如com.alibaba.dubbo.config.ApplicationConfig
// 则结果可能是com.alibaba.dubbo.config.ApplicationConfig#0
if (!StringUtils.hasText(beanName)) {
BeanDefinitionBuilder builder = rootBeanDefinition(configClass);
beanName = BeanDefinitionReaderUtils.generateBeanName(builder.getRawBeanDefinition(), registry);
}
// 返回bean名称
return beanName;
}
}multiple=true时resolveMultipleBeanNames源码如下：
class FakeCls {
private Set<String> resolveMultipleBeanNames(Map<String, Object> properties) {
// 以dubbo.application为例多配置bean格式为dubbo.applications.${bean名称}.${属性名称} = 属性值,比如配置如下：
/*
dubbo.applications.applicationBean.name = dubbo-demo-application
dubbo.applications.applicationBean2.name = dubbo-demo-application2
dubbo.applications.applicationBean3.name = dubbo-demo-application3
*/
// 则properties结果就是:
/*
"applicationBean.name" -> "dubbo-demo-application"
"applicationBean2.name" -> "dubbo-demo-application2"
"applicationBean3.name" -> "dubbo-demo-application3"
*/
// 其中的applicationBean，applicationBean2，applicationBean3就是就是我们需要的bean名称
Set<String> beanNames = new LinkedHashSet<String>();
for (String propertyName : properties.keySet()) {
int index = propertyName.indexOf(".");
if (index > 0) {
String beanName = propertyName.substring(0, index);
beanNames.add(beanName);
}
}
return beanNames;
}
}2021-12-29 16:24:02处是添加后置bean处理器，具体参考3.4：DubboConfigBindingBeanPostProcessor，主要是完成的工作是填充配置bean的相关属性，从前面的分析我们看到只是创建了配置bean的bean定义并没有填充属性，解析来再来看下这个属性填充的过程。
3.4：DubboConfigBindingBeanPostProcessor
这是一个后置bean处理器的实现类，关于后置bean处理器可以参考这篇文章 。
3.4.1：构造方法
class FakeCls {
public DubboConfigBindingBeanPostProcessor(String prefix, String beanName) {
Assert.notNull(prefix, "The prefix of Configuration Properties must not be null");
Assert.notNull(beanName, "The name of bean must not be null");
// 外部化配置属性前缀，如dubbo.application
this.prefix = prefix;
// 外部化配置对应的AbstractConfig子类的bean名称
this.beanName = beanName;
}
}3.4.2：afterPropertiesSet
因为实现了InitializingBean接口所以会在DubboConfigBindingBeanPostProcessor bean创建完毕并设置属性完毕后调用afterPropertiesSet方法，主要是设置config bean的后置处理时需要的相关对象，如用来设置config bean属性的DataBinder等，源码如下：
class FakeCls {
public void afterPropertiesSet() throws Exception {
// 2021-12-30 19:29:47
initDubboConfigBinder();
// 2021-12-30 19:29:53
initConfigBeanCustomizers();
}
}2021-12-30 19:29:47处是设置DataBinder （spring提供的用于进行属性绑定的API）`，具体源码如下：
class FakeCls {
private void initDubboConfigBinder() {
if (dubboConfigBinder == null) {
try {
dubboConfigBinder = applicationContext.getBean(DubboConfigBinder.class);
} catch (BeansException ignored) {
if (log.isDebugEnabled()) {
log.debug("DubboConfigBinder Bean can't be found in ApplicationContext.");
}
/*
protected DubboConfigBinder createDubboConfigBinder(Environment environment) {
DefaultDubboConfigBinder defaultDubboConfigBinder = new DefaultDubboConfigBinder();
defaultDubboConfigBinder.setEnvironment(environment);
return defaultDubboConfigBinder;
}
*/
dubboConfigBinder = createDubboConfigBinder(applicationContext.getEnvironment());
}
}
// 忽略未知字段
dubboConfigBinder.setIgnoreUnknownFields(ignoreUnknownFields);
// 忽略无效字段
dubboConfigBinder.setIgnoreInvalidFields(ignoreInvalidFields);
}
}DubboConfigBinder是直接使用的DataBinder来绑定外部配置文件属性信息到AbstractConfig子类的属性中，源码如下：
public class DefaultDubboConfigBinder extends AbstractDubboConfigBinder {
@Override
public <C extends AbstractConfig> void bind(String prefix, C dubboConfig) {
DataBinder dataBinder = new DataBinder(dubboConfig);
// 设置忽略无效属性
dataBinder.setIgnoreInvalidFields(isIgnoreInvalidFields());
// 设置忽略未知属性
dataBinder.setIgnoreUnknownFields(isIgnoreUnknownFields());
// 从@PropertySource注解指定的配置文件中获取指定前缀的属性
Map<String, Object> properties = getSubProperties(getPropertySources(), prefix);
// 转换Map为MutablePropertyValues
MutablePropertyValues propertyValues = new MutablePropertyValues(properties);
// 调用DataBinder的API完成绑定，即设置AbstractConfig子类的属性的值
dataBinder.bind(propertyValues);
}
}可以看到上面的代码就完成的外部属性设置到AbtractConfig子类的bean中的工作，那么是什么时候调用的呢，具体参考3.4.4：postProcessBeforeInitialization。2021-12-30 19:29:53处是获取并设置针对config spring bean进行定义的对象，是一个扩展的口，如下：
class FakeCls {
private void initConfigBeanCustomizers() {
// 从容器中获取类型为DubboConfigBeanCustomizer的所有spring bean
Collection<DubboConfigBeanCustomizer> configBeanCustomizers =
beansOfTypeIncludingAncestors(applicationContext, DubboConfigBeanCustomizer.class).values();
// 赋值到全局属性中，供后续使用
this.configBeanCustomizers = new ArrayList<DubboConfigBeanCustomizer>(configBeanCustomizers);
// 排序
AnnotationAwareOrderComparator.sort(this.configBeanCustomizers);
}
}3.4.4：postProcessBeforeInitialization
通过后置bena处理器的postProcessBeforeInitialization方法，即初始化spring bean之前设置对象属性，源码如下：
class FakeCls {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (beanName.equals(this.beanName) && bean instanceof AbstractConfig) {
AbstractConfig dubboConfig = (AbstractConfig) bean;
// 2021-12-31 13:45:09
bind(prefix, dubboConfig);
customize(beanName, dubboConfig);
}
return bean;
}
}2021-12-31 13:45:09处是绑定属性，源码如下：
class FakeCls {
private void bind(String prefix, AbstractConfig dubboConfig) {
// 调用的就是DefaultDubboConfigBinder#bind方法，在"3.4.2：afterPropertiesSet"已经进行了讲解
dubboConfigBinder.bind(prefix, dubboConfig);
if (log.isInfoEnabled()) {
log.info("The properties of bean [name : " + beanName + "] have been binding by prefix of " +
"configuration properties : " + prefix);
}
}
}到这里config bean就创建完毕并且属性也填充完毕了。dubbo配置相关的spring bean是如何创建的已经分析完了，接下来在看下第二部分重要的spring bean，即使用了@Service注解和@Reference注解的spring bean，dubbo定义了@DubboComponentScan注解来定义扫描哪些目录加载使用了相关注解的类为spring bean，接着就来一起看下这部分的内容。
4：@DubboComponentScan
该注解用来扫描指定包路径下使用了@Service和@Reference注解的类，从而创建对应的spring bean对象，源码如下：
// 从classpath下扫描使用了@Service，@Reference注解的类自动注册为spring beans
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {
// 设置要扫描的基础包路径
String[] value() default {};
// 设置要要扫描的包路径
String[] basePackages() default {};
// 通过设置Class来指定要扫描的基础包路径，即Class所在的包
Class<?>[] basePackageClasses() default {};
}从@Import(DubboComponentScanRegistrar.class)注解可以看出是通过DubboComponentScanRegistrar类来完成扫描和注册spring bean的。
4.1：DubboComponentScanRegistrar
该类处理@DubboComponentScan注解，注册@Service注解对应的ServiceAnnotationBeanPostProcessor和@Reference注解对应的ReferenceAnnotationBeanPostProcessor后置bean处理器到spring 容器中，以便对@Service和@Reference对应的spring bean进行后置处理。源码如下：
class FakeCls {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 2021-12-31 15:02:34
// 获取要扫描的包路径集合，配置@DubboComponentScan(basePackages = { "dongshi.daddy.service.multipleexternalconfig" })，这里的结果就是：
// 0 = dongshi.daddy.service.multipleexternalconfig
Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
// 2021-12-31 14:42:55
registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
// 2021-12-31 14:43:08
registerReferenceAnnotationBeanPostProcessor(registry);
}
}2021-12-31 14:42:55处是设置@Service注解对应的ServiceAnnotationBeanPostProcessor，具体参考4.1.1：registerServiceAnnotationBeanPostProcessor，2021-12-31 14:43:08,ServiceAnnotationBeanPostProcessor具体参考4.2：ServiceAnnotationBeanPostProcessor。处是设置@Reference注解对应的ReferenceAnnotationBeanPostProcessor，ReferenceAnnotationBeanPostProcessor具体参考4.3：ReferenceAnnotationBeanPostProcessor。2021-12-31 15:02:34处源码如下：
class FakeCls {
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
// 获取@DubboComponentScan配置的属性值
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
metadata.getAnnotationAttributes(DubboComponentScan.class.getName()));
// 获取basePackages,basePackageClasses,value数组，三者都是用来配置要扫描的包路径的
String[] basePackages = attributes.getStringArray("basePackages");
Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
String[] value = attributes.getStringArray("value");
// 转通过value配置的包路径为set集合
Set<String> packagesToScan = new LinkedHashSet<String>(Arrays.asList(value));
// 添加通过basePackage属性配置的包路径到要扫描的包路径集合中，此时value和basePackages会做一个并集
packagesToScan.addAll(Arrays.asList(basePackages));
// 添加通过basePackageClasses配置的包路径扫到要扫描的包路径集合中，此时value，basePackages，basePakcageClasess三者做了并集
for (Class<?> basePackageClass : basePackageClasses) {
packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
}
// 如果是没有要扫描的包路径，则使用当前Java config类所在包路径作为要扫描的基础包路径
// 如public class MyMultipleExternalConfigConfiguration {},所在包为package dongshi.daddy.service.multipleexternalconfig;
// 则这里的结果就是dongshi.daddy.service.multipleexternalconfig
if (packagesToScan.isEmpty()) {
return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName()));
}
return packagesToScan;
}
}4.1.1：registerServiceAnnotationBeanPostProcessor
源码如下：
class FakeCls {
private void registerServiceAnnotationBeanPostProcessor(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
// 构造器设计模式，创建用于构造BeanDefinition的构造器，源码如下：
/*
public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass, String factoryMethodName) {
BeanDefinitionBuilder builder = new BeanDefinitionBuilder();
builder.beanDefinition = new RootBeanDefinition();
builder.beanDefinition.setBeanClass(beanClass);
builder.beanDefinition.setFactoryMethodName(factoryMethodName);
return builder;
}
*/
BeanDefinitionBuilder builder = rootBeanDefinition(ServiceAnnotationBeanPostProcessor.class);
// 添加构造函数参数，这里添加的是要扫描的包路径
builder.addConstructorArgValue(packagesToScan);
// 设置角色，这里设置该bean定义为纯粹内部使用，和外部用户没有任何关系，正常可以忽略该属性
builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
// 从构造器中获取创建的RootBeanDefinition
AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
// 注册bean定义到bean定义注册器中
BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);
}
}4.1.2：registerReferenceAnnotationBeanPostProcessor
源码如下：
class FakeCls {
private void registerReferenceAnnotationBeanPostProcessor(BeanDefinitionRegistry registry) {
// 获取bean名称为public static final String BEAN_NAME = "referenceAnnotationBeanPostProcessor";的bean，默认为需要的ReferenceAnnotaionBeanPostProcessor的bean，源码如下：
/*
public static void registerInfrastructureBean(BeanDefinitionRegistry beanDefinitionRegistry,
String beanName,
Class<?> beanType) {
// 不包含则重新创建并添加到bean定义注册器中
if (!beanDefinitionRegistry.containsBeanDefinition(beanName)) {
RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
beanDefinitionRegistry.registerBeanDefinition(beanName, beanDefinition);
}
}
*/
BeanRegistrar.registerInfrastructureBean(registry,
ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class);
}
}4.2：ServiceAnnotationBeanPostProcessor
4.2.1：构造方法
class FakeCls {
public ServiceAnnotationBeanPostProcessor(String... packagesToScan) {
this(Arrays.asList(packagesToScan));
}
public ServiceAnnotationBeanPostProcessor(Collection<String> packagesToScan) {
this(new LinkedHashSet<String>(packagesToScan));
}
public ServiceAnnotationBeanPostProcessor(Set<String> packagesToScan) {
this.packagesToScan = packagesToScan;
}
}4.2.2：postProcessBeanDefinitionRegistry
因为实现了接口BeanDefinitionRegistryPostProcessor所以会在将bean定义全部注册到BeanDefinitionRegistry之后调用postProcessBeanDefinitionRegistry方法来对bean定义注册器进行修改，
为什么要实现BeanDefinitionRegistryPostProcessor接口：因为此时spring所有能够识别的（如使用了@Component，@Bean等spring提供的注解）类都已经生成bean definition并注册到BeanDefinitionRegistry中了，但是dubbo提供的@Service注解和@Reference注解，spring的默认机制是不识别的，所以在这个节点来做，就是最合适的了。
源码如下：
class FakeCls {
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
// 因为可能存在占位符，所以有此步骤的占位符替换，源码如下:
/*
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;
}
*/
Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);
if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
// 2021-12-31 16:14:05
registerServiceBeans(resolvedPackagesToScan, registry);
} else {
if (logger.isWarnEnabled()) {
logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
}
}
}
}2021-12-31 16:14:05处是扫描指定的包路径集合并将有@Service注解的类生成对应的bean definition，具体参考4.2.2.1：registerServiceBeans。
4.2.2.1：registerServiceBeans
源码如下：
class FakeCls {
private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
// 创建用于从classpath的指定包中扫描类的DubboClassPathBeanDefinitionScanner
DubboClassPathBeanDefinitionScanner scanner =
new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
// 解析获取的bean名称生成器，源码如下:
/*
private BeanNameGenerator resolveBeanNameGenerator(BeanDefinitionRegistry registry) {
BeanNameGenerator beanNameGenerator = null;
if (registry instanceof SingletonBeanRegistry) {
SingletonBeanRegistry singletonBeanRegistry = SingletonBeanRegistry.class.cast(registry);
beanNameGenerator = (BeanNameGenerator) singletonBeanRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
}
if (beanNameGenerator == null) {
// ...
beanNameGenerator = new AnnotationBeanNameGenerator();
}
return beanNameGenerator;
}
*/
BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
scanner.setBeanNameGenerator(beanNameGenerator);
// 只过滤标注了@com.alibaba.dubbo.config.annotation.Service注解的类
scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
// 一个包一个包的开始扫描生成bean definition
for (String packageToScan : packagesToScan) {
// 扫描注解了@com.alibaba.dubbo.config.annotation.Service注解的类的类
scanner.scan(packageToScan);
// 2021-12-31 16:52:08
Set<BeanDefinitionHolder> beanDefinitionHolders =
findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
// 有beanDefinitionHolder，即再扫描的包路径下有标注了dubbo的@Service注解的类
if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
// 循环注册到bean定义注册器中
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
// 2022-01-01 17:04:21
registerServiceBean(beanDefinitionHolder, registry, scanner);
}
if (logger.isInfoEnabled()) {
logger.info(beanDefinitionHolders.size() + " annotated Dubbo's @Service Components { " +
beanDefinitionHolders +
" } were scanned under package[" + packageToScan + "]");
}
} else {
if (logger.isWarnEnabled()) {
logger.warn("No Spring Bean annotating Dubbo's @Service was found under package["
+ packageToScan + "]");
}
}
}
}
}2021-12-31 16:52:08处是封装当前包路径解析到的bean definition为BeanDefinitionHolder集合，一个bean definition对应一个BeanDefinitionHolder集合，源码如下：
class FakeCls {
private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(
ClassPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry,
BeanNameGenerator beanNameGenerator) {
// 获取扫描到的BeanDefinition集合
Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
for (BeanDefinition beanDefinition : beanDefinitions) {
// 生成bean名称
String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
beanDefinitionHolders.add(beanDefinitionHolder);
}
return beanDefinitionHolders;
}
}2022-01-01 17:04:21处是注册bean定义到bean定义注册器中，具体参考4.2.2.1：registerServiceBean。
4.2.2.1：registerServiceBean
源码如下：
class FakeCls {
private void registerServiceBean(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry,
DubboClassPathBeanDefinitionScanner scanner) {
// 从beanDefinitionHolder中获取使用了com.alibaba.dubbo.config.annotation.Service注解的服务提供者类的Class对象
Class<?> beanClass = resolveClass(beanDefinitionHolder);
// 获取Service注解对象
Service service = findAnnotation(beanClass, Service.class);
// 获取服务提供接口类型
// 2022-01-01 17:25:37
Class<?> interfaceClass = resolveServiceInterfaceClass(beanClass, service);
// 获取bean名称
String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();
// 创建服务提供类对应的beandefinition对象
// 2022-01-01 20:28:22
AbstractBeanDefinition serviceBeanDefinition =
buildServiceBeanDefinition(service, interfaceClass, annotatedServiceBeanName);
// 重新生成bean名称，更具有业务含义
// ServiceBean Bean name，如ServiceBean:dubbo:dongshi.daddy.service.annotation.ProviderServiceAnnotation
String beanName = generateServiceBeanName(service, interfaceClass, annotatedServiceBeanName);
// 校验重复，不存在则中注册bean定义到bean定义注册器中
if (scanner.checkCandidate(beanName, serviceBeanDefinition)) {
// 注册
registry.registerBeanDefinition(beanName, serviceBeanDefinition);
if (logger.isInfoEnabled()) {
logger.info("The BeanDefinition[" + serviceBeanDefinition +
"] of ServiceBean has been registered with name : " + beanName);
}
} else {
if (logger.isWarnEnabled()) {
logger.warn("The Duplicated BeanDefinition[" + serviceBeanDefinition +
"] of ServiceBean[ bean name : " + beanName +
"] was be found , Did @DubboComponentScan scan to same package in many times?");
}
}
}
}2022-01-01 17:25:37处是获取服务提供者接口类型，源码如下：
class FakeCls {
private Class<?> resolveServiceInterfaceClass(Class<?> annotatedServiceBeanClass, Service service) {
// 首先获取在Service注解上设置的Class<?> interfaceClass() default void.class;，一般我们不设置所以是默认值void.class
Class<?> interfaceClass = service.interfaceClass();
// 如果是void.class，即获取的是默认值
if (void.class.equals(interfaceClass)) {
interfaceClass = null;
// 获取Service注解上配置的String interfaceName() default "";，默认是空串
String interfaceClassName = service.interfaceName();
// 如果是在Service注解上配置了String interfaceName() default "";
if (StringUtils.hasText(interfaceClassName)) {
// 有该类，则解析为Class对象
if (ClassUtils.isPresent(interfaceClassName, classLoader)) {
interfaceClass = resolveClassName(interfaceClassName, classLoader);
}
}
}
// 如果是执行到这里说明在Service注解上即没有设置interfaceClass也没有设置interfaceName
if (interfaceClass == null) {
// 获取所有的父接口集合，然后取第一个作为目标接口类型，此处在之前版本因为代码是Class<?>[] allInterfaces = annotatedServiceBeanClass.getInterfaces();
// 这种方式只会获取直接实现的接口，而不会递归获取父类实现的接口，因此如果不直接实现接口的话就问题了，关于该问题可以查看
// issue：https://github.com/apache/incubator-dubbo/issues/3251
Class<?>[] allInterfaces = ClassUtils.getAllInterfacesForClass(annotatedServiceBeanClass);
if (allInterfaces.length > 0) {
// 取第一个，作为结果
interfaceClass = allInterfaces[0];
}
}
// 断言获取到了class对象
Assert.notNull(interfaceClass,
"@Service interfaceClass() or interfaceName() or interface class must be present!");
// 断言获取到的class对象是接口类型
Assert.isTrue(interfaceClass.isInterface(),
"The typfe that was annotated @Service is not an interace!");
return interfaceClass;
}
}2022-01-01 20:28:22处是构造bean定义，具体参考4.2.2.2：buildServiceBeanDefinition。
4.2.2.2：buildServiceBeanDefinition
源码如下：
class FakeCls {
private AbstractBeanDefinition buildServiceBeanDefinition(Service service, Class<?> interfaceClass,
String annotatedServiceBeanName) {
// ServiceBean是服务提供者service对应的配置类ServiceConfig的子类，用于进一步封装信息，这里返回的是其对应的BeanDefinition的构造器类
// 即使用的是构造器设计模式，使用构造器设计模式的原因是方便灵活设置属性信息，摆脱构造函数的束缚
BeanDefinitionBuilder builder = rootBeanDefinition(ServiceBean.class);
// 获取内部封装的ServiceBean对应的BeanDefinition
AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
// 获取内部的MutablePropertyValues，方便修改属性
MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
String[] ignoreAttributeNames = of("provider", "monitor", "application", "module", "registry", "protocol",
"interface", "interfaceName");
// 使用AnnotationPropertyValuesAdapter，获取dubbo @Service注解中的属性，并最终通过addPropertyValues添加到MutablePropertyValues propertyValues
// ，最终添加到ServiceBean对应的beandefinition中,如设置@Service(timeout = 5000, version = "2.3.4")，则会将timeout和version添加
propertyValues.addPropertyValues(new AnnotationPropertyValuesAdapter(service, environment, ignoreAttributeNames));
// 将ServiceBean内部实际的服务提供者类的bean名称设置ref属性，个人理解是方便后续查找使用
// 也可以这样理解，是设置了ServiceBean实际引用的服务提供者类的spring bean是哪个
addPropertyReference(builder, "ref", annotatedServiceBeanName);
// 设置服务提供者类的全限定接口名称
builder.addPropertyValue("interface", interfaceClass.getName());
// 设置使用的provider的bean，如果是xml的话对应的标签就是<dubbo:provider>
String providerConfigBeanName = service.provider();
if (StringUtils.hasText(providerConfigBeanName)) {
addPropertyReference(builder, "provider", providerConfigBeanName);
}
// 获取和设置使用的monitor，对应的xml标签是<dubbo:monitor>
String monitorConfigBeanName = service.monitor();
if (StringUtils.hasText(monitorConfigBeanName)) {
addPropertyReference(builder, "monitor", monitorConfigBeanName);
}
// 获取和设置使用的application，对应的xml标签是<dubbo:application>
String applicationConfigBeanName = service.application();
if (StringUtils.hasText(applicationConfigBeanName)) {
addPropertyReference(builder, "application", applicationConfigBeanName);
}
// 获取和设置使用的module，对应的xml标签是<dubbo:module>
String moduleConfigBeanName = service.module();
if (StringUtils.hasText(moduleConfigBeanName)) {
addPropertyReference(builder, "module", moduleConfigBeanName);
}
// 获取和设置使用的registries，对应的xml标签是<dubbo:registry>
String[] registryConfigBeanNames = service.registry();
// 可能有多个，所以是List
List<RuntimeBeanReference> registryRuntimeBeanReferences = toRuntimeBeanReferences(registryConfigBeanNames);
if (!registryRuntimeBeanReferences.isEmpty()) {
builder.addPropertyValue("registries", registryRuntimeBeanReferences);
}
// 获取和设置使用的protocols，对应的xml标签是<dubbo:protocol>
String[] protocolConfigBeanNames = service.protocol();
// 可能有多个，所以是List
List<RuntimeBeanReference> protocolRuntimeBeanReferences = toRuntimeBeanReferences(protocolConfigBeanNames);
if (!protocolRuntimeBeanReferences.isEmpty()) {
builder.addPropertyValue("protocols", protocolRuntimeBeanReferences);
}
// 设置方法配置，如下可能配置：
/*
@Service(methods = {
@Method(name = "SayHelloAnnotation", timeout = 2000)
})
*/
Method[] methods = service.methods();
List<MethodConfig> methodConfigs = MethodConfig.constructMethodConfig(methods);
if(!methodConfigs.isEmpty()){
builder.addPropertyValue("methods", methodConfigs);
}
// 获取bean定义并返回
return builder.getBeanDefinition();
}
}4.3：ReferenceAnnotationBeanPostProcessor
该后置bean处理器用于处理标注了dubbo @Reference注解的属性，实现其属性的注入，如下可能的代码:
@Component("annotatedConsumer")
public class ConsumerAnnotationService {
@Reference
private ProviderServiceAnnotation providerServiceAnnotation;
public String doSayHello(String name) {
return providerServiceAnnotation.SayHelloAnnotation(name);
}
}所要作的事情就是为private ProviderServiceAnnotation providerServiceAnnotation属性注入属性值。因为是属性注入，所以ReferenceAnnotationBeanPostProcessor是通过加入spring 提供的inject相关的方法完整自定义的属性注入的，最终会执行到方法doGetInjectedBean,我们就从这个方法开始吧！
4.3.1：doGetInjectedBean
源码如下：
class FakeCls {
@Override
protected Object doGetInjectedBean(Reference reference, Object bean, String beanName, Class<?> injectedType,
InjectionMetadata.InjectedElement injectedElement) throws Exception {
// 2022-01-02 19:17:27
String referencedBeanName = buildReferencedBeanName(reference, injectedType);
// 2022-01-02 20:42:39
ReferenceBean referenceBean = buildReferenceBeanIfAbsent(referencedBeanName, reference, injectedType, getClassLoader());
// 添加到缓存，根据是基于属性注入还是方法注入，加入不同的缓存中，源码如下：
/*
private void cacheInjectedReferenceBean(ReferenceBean referenceBean,
InjectionMetadata.InjectedElement injectedElement) {
if (injectedElement.getMember() instanceof Field) {
// private final ConcurrentMap<InjectionMetadata.InjectedElement, ReferenceBean<?>> injectedFieldReferenceBeanCache = new ConcurrentHashMap<InjectionMetadata.InjectedElement, ReferenceBean<?>>(CACHE_SIZE);
injectedFieldReferenceBeanCache.put(injectedElement, referenceBean);
} else if (injectedElement.getMember() instanceof Method) {
// private final ConcurrentMap<InjectionMetadata.InjectedElement, ReferenceBean<?>> injectedMethodReferenceBeanCache = new ConcurrentHashMap<InjectionMetadata.InjectedElement, ReferenceBean<?>>(CACHE_SIZE);
injectedMethodReferenceBeanCache.put(injectedElement, referenceBean);
}
}
*/
cacheInjectedReferenceBean(referenceBean, injectedElement);
// 2022-01-03 10:35:17
Object proxy = buildProxy(referencedBeanName, referenceBean, injectedType);
return proxy;
}
}2022-01-02 19:17:27处是要生成将要引用对象的bean名称（其实就是通过netty调用远端服务提供者的代理对象），reference是@Reference注解本身，injectedType是要注入的类型，一般是接口，因为我们都是通过接口来注入对象的，具体参考4.3.1.1：buildReferencedBeanName，2022-01-02 20:42:39创建ReferenceBean对象，和ServiceBean对应，具体参考4.3.1.2：buildReferenceBeanIfAbsent,2022-01-03 10:35:17处是构建代理类，具体参考4.3.1.3：buildProxy。
4.3.1.1：buildReferencedBeanName
源码如下：
class FakeCls {
private String buildReferencedBeanName(Reference reference, Class<?> injectedType) {
// 生成bean名称构造器对象，内容可能如下：
/*
category = "consumers"
protocol = "dubbo"
interfaceClassName = "dongshi.daddy.service.annotation.ProviderServiceAnnotation"
version = ""
group = ""
environment = null
*/
AnnotationBeanNameBuilder builder = AnnotationBeanNameBuilder.create(reference, injectedType);
// 设置环境，用于替换可能存在的占位符
builder.environment(getEnvironment());
// 替换占位符并返回结果,build方法如下：
/*
// 格式：${category}:${protocol}:${serviceInterface}:${version}:${group}
public String build() {
// 追加必须的属性信息，category：{provider|consumer}
StringBuilder beanNameBuilder = new StringBuilder(category);
// 追加协议，如dubbo，zookeeper
append(beanNameBuilder, protocol);
append(beanNameBuilder, interfaceClassName);
// 替换可选属性
append(beanNameBuilder, version);
append(beanNameBuilder, group);
String beanName = beanNameBuilder.toString();
// 替换占位符
return environment != null ? environment.resolvePlaceholders(beanName) : beanName;
}
*/
// 从build方法的源码中可以看到其实已经执行过替换占位符的操作，不知道为何这里又重复执行替换占位符操作
return getEnvironment().resolvePlaceholders(builder.build());
}
}4.3.1.2：buildReferenceBeanIfAbsent
源码如下：
class FakeCls {
private ReferenceBean buildReferenceBeanIfAbsent(String referencedBeanName, Reference reference,
Class<?> referencedType, ClassLoader classLoader)
throws Exception {
// 先从缓存中获取，为什么要使用缓存，为了复用
ReferenceBean<?> referenceBean = referenceBeanCache.get(referencedBeanName);
// 缓存中没有
if (referenceBean == null) {
// 使用ReferenceBeanBuilder构造器类来构造ReferenceBean（又是构造器设计模式）
// 2022-01-02 20:51:45
ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder
.create(reference, classLoader, applicationContext)
.interfaceClass(referencedType);
// 构造
referenceBean = beanBuilder.build();
// 放到缓存中
referenceBeanCache.put(referencedBeanName, referenceBean);
}
// 返回
return referenceBean;
}
}2022-01-02 20:51:45处是使用ReferenceBeanBuilder类来构造ReferenceBean，关于ReferenceBeanBuilder类参考4.3.2：ReferenceBeanBuilder。
4.3.1.3：buildProxy
源码如下：
class FakeCls {
private Object buildProxy(String referencedBeanName, ReferenceBean referenceBean, Class<?> injectedType) {
// 2022-01-03 19:03:53
// 生成jdk动态代理中的java.lang.reflect.InvocationHandler
InvocationHandler handler = buildInvocationHandler(referencedBeanName, referenceBean);
// 使用java.lang.reflect.Proxy#newProxyInstance方法生成jdk的动态代理类
Object proxy = Proxy.newProxyInstance(getClassLoader(), new Class[]{injectedType}, handler);
return proxy;
}
}2022-01-03 19:03:53处就是动态代理的核心逻辑了，提供了java.lang.reflect.InvocationHandler实现类，执行具体的代理执行逻辑，具体参考``。
4.3.2：ReferenceBeanBuilder
4.3.3：buildInvocationHandler
源码如下：
class FakeCls {
private InvocationHandler buildInvocationHandler(String referencedBeanName, ReferenceBean referenceBean) {
// 先从缓存中获取，private final ConcurrentHashMap<String, ReferenceBeanInvocationHandler> localReferenceBeanInvocationHandlerCache = new ConcurrentHashMap<String, ReferenceBeanInvocationHandler>(CACHE_SIZE);
ReferenceBeanInvocationHandler handler = localReferenceBeanInvocationHandlerCache.get(referencedBeanName);
// 没有，new一个ReferenceBeanInvocationHandler，这是InvocationHandler的子类
// private static class ReferenceBeanInvocationHandler implements InvocationHandler {}
if (handler == null) {
// referenceBean参数：封装了服务接口的ReferenceBean对象
handler = new ReferenceBeanInvocationHandler(referenceBean);
}
if (applicationContext.containsBean(referencedBeanName)) { // Is local @Service Bean or not ?
// ReferenceBeanInvocationHandler's initialization has to wait for current local @Service Bean has been exported.
localReferenceBeanInvocationHandlerCache.put(referencedBeanName, handler);
} else {
// Remote Reference Bean should initialize immediately
handler.init();
}
return handler;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
