Enhancement and Bugfix in 2.7.1

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/beans/factory/annotation/AnnotationBeanNameBuilder.java

@@ -0,0 +1,142 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.dubbo.config.spring.beans.factory.annotation;
+
+import static org.apache.dubbo.common.Constants.CONSUMERS_CATEGORY;
+import static org.apache.dubbo.common.Constants.DEFAULT_PROTOCOL;
+import static org.apache.dubbo.common.Constants.PROVIDERS_CATEGORY;
+import static org.apache.dubbo.config.spring.util.AnnotationUtils.resolveInterfaceName;
+import static org.springframework.util.StringUtils.arrayToCommaDelimitedString;
+import static org.springframework.util.StringUtils.hasText;
+
+import org.apache.dubbo.common.Constants;
+import org.apache.dubbo.config.annotation.Reference;
+import org.apache.dubbo.config.annotation.Service;
+import org.apache.dubbo.registry.Registry;
+
+import org.springframework.core.env.Environment;
+
+/**
+ * The Bean Name Builder for the annotations {@link Service} and {@link Reference}
+ * <p>
+ * The naming rule is consistent with the the implementation {@link Registry} that is based on the service-name aware
+ * infrastructure, e.g Spring Cloud, Cloud Native and so on.
+ * <p>
+ * The pattern of bean name : ${category}:${protocol}:${serviceInterface}:${version}:${group}.
+ * <p>
+ * ${version} and ${group} are optional.
+ *
+ * @since 2.6.6
+ */
+class AnnotationBeanNameBuilder {
+
+    private static final String SEPARATOR = ":";
+
+    // Required properties
+
+    private final String category;
+
+    private final String protocol;
+
+    private final String interfaceClassName;
+
+    // Optional properties
+
+    private String version;
+
+    private String group;
+
+    private Environment environment;
+
+    private AnnotationBeanNameBuilder(String category, String protocol, String interfaceClassName) {
+        this.category = category;
+        this.protocol = protocol;
+        this.interfaceClassName = interfaceClassName;
+    }
+
+    private AnnotationBeanNameBuilder(Service service, Class<?> interfaceClass) {
+        this(PROVIDERS_CATEGORY, resolveProtocol(service.protocol()), resolveInterfaceName(service, interfaceClass));
+        this.group(service.group());
+        this.version(service.version());
+    }
+
+    private AnnotationBeanNameBuilder(Reference reference, Class<?> interfaceClass) {
+        this(CONSUMERS_CATEGORY, resolveProtocol(reference.protocol()), resolveInterfaceName(reference, interfaceClass));
+        this.group(reference.group());
+        this.version(reference.version());
+    }
+
+    public static AnnotationBeanNameBuilder create(Service service, Class<?> interfaceClass) {
+        return new AnnotationBeanNameBuilder(service, interfaceClass);
+    }
+
+    public static AnnotationBeanNameBuilder create(Reference reference, Class<?> interfaceClass) {
+        return new AnnotationBeanNameBuilder(reference, interfaceClass);
+    }
+
+    private static void append(StringBuilder builder, String value) {
+        if (hasText(value)) {
+            builder.append(SEPARATOR).append(value);
+        }
+    }
+
+    public AnnotationBeanNameBuilder group(String group) {
+        this.group = group;
+        return this;
+    }
+
+    public AnnotationBeanNameBuilder version(String version) {
+        this.version = version;
+        return this;
+    }
+
+    public AnnotationBeanNameBuilder environment(Environment environment) {
+        this.environment = environment;
+        return this;
+    }
+
+    /**
+     * Resolve the protocol
+     *
+     * @param protocols one or more protocols
+     * @return if <code>protocols</code> == <code>null</code>, it will return
+     * {@link Constants#DEFAULT_PROTOCOL "dubbo"} as the default protocol
+     * @see Constants#DEFAULT_PROTOCOL
+     */
+    private static String resolveProtocol(String... protocols) {
+        String protocol = arrayToCommaDelimitedString(protocols);
+        return hasText(protocol) ? protocol : DEFAULT_PROTOCOL;
+    }
+
+    /**
+     * Build bean name while resolve the placeholders if possible.
+     *
+     * @return pattern : ${category}:${protocol}:${serviceInterface}:${version}:${group}
+     */
+    public String build() {
+        // Append the required properties
+        StringBuilder beanNameBuilder = new StringBuilder(category);
+        append(beanNameBuilder, protocol);
+        append(beanNameBuilder, interfaceClassName);
+        // Append the optional properties
+        append(beanNameBuilder, version);
+        append(beanNameBuilder, group);
+        String beanName = beanNameBuilder.toString();
+        // Resolve placeholders
+        return environment != null ? environment.resolvePlaceholders(beanName) : beanName;
+    }
+}

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/beans/factory/annotation/DubboConfigBindingBeanPostProcessor.java

@@ -20,6 +20,7 @@
 import org.apache.dubbo.config.AbstractConfig;
 import org.apache.dubbo.config.spring.context.annotation.DubboConfigBindingRegistrar;
 import org.apache.dubbo.config.spring.context.annotation.EnableDubboConfigBinding;
+import org.apache.dubbo.config.spring.context.config.DubboConfigBeanCustomizer;
 import org.apache.dubbo.config.spring.context.properties.DefaultDubboConfigBinder;
 import org.apache.dubbo.config.spring.context.properties.DubboConfigBinder;
 
@@ -30,8 +31,16 @@
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
+import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 import org.springframework.core.env.Environment;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import static org.springframework.beans.factory.BeanFactoryUtils.beansOfTypeIncludingAncestors;
+
 /**
  * Dubbo Config Binding {@link BeanPostProcessor}
  *
@@ -62,6 +71,8 @@ public class DubboConfigBindingBeanPostProcessor implements BeanPostProcessor, A
 
     private boolean ignoreInvalidFields = true;
 
+    private List<DubboConfigBeanCustomizer> configBeanCustomizers = Collections.emptyList();
+
     /**
      * @param prefix   the prefix of Configuration Properties
      * @param beanName the binding Bean Name
@@ -80,18 +91,34 @@ public Object postProcessBeforeInitialization(Object bean, String beanName) thro
 
             AbstractConfig dubboConfig = (AbstractConfig) bean;
 
-            dubboConfigBinder.bind(prefix, dubboConfig);
+            bind(prefix, dubboConfig);
+
+            customize(beanName, dubboConfig);
 
-            if (log.isInfoEnabled()) {
-                log.info("The properties of bean [name : " + beanName + "] have been binding by prefix of " +
-                        "configuration properties : " + prefix);
-            }
         }
 
         return bean;
 
     }
 
+    private void bind(String prefix, AbstractConfig dubboConfig) {
+
+        dubboConfigBinder.bind(prefix, dubboConfig);
+
+        if (log.isInfoEnabled()) {
+            log.info("The properties of bean [name : " + beanName + "] have been binding by prefix of " +
+                    "configuration properties : " + prefix);
+        }
+    }
+
+    private void customize(String beanName, AbstractConfig dubboConfig) {
+
+        for (DubboConfigBeanCustomizer customizer : configBeanCustomizers) {
+            customizer.customize(beanName, dubboConfig);
+        }
+
+    }
+
     public boolean isIgnoreUnknownFields() {
         return ignoreUnknownFields;
     }
@@ -129,6 +156,14 @@ public void setApplicationContext(ApplicationContext applicationContext) throws
     @Override
     public void afterPropertiesSet() throws Exception {
 
+        initDubboConfigBinder();
+
+        initConfigBeanCustomizers();
+
+    }
+
+    private void initDubboConfigBinder() {
+
         if (dubboConfigBinder == null) {
             try {
                 dubboConfigBinder = applicationContext.getBean(DubboConfigBinder.class);
@@ -146,6 +181,16 @@ public void afterPropertiesSet() throws Exception {
 
     }
 
+    private void initConfigBeanCustomizers() {
+
+        Collection<DubboConfigBeanCustomizer> configBeanCustomizers =
+                beansOfTypeIncludingAncestors(applicationContext, DubboConfigBeanCustomizer.class).values();
+
+        this.configBeanCustomizers = new ArrayList<DubboConfigBeanCustomizer>(configBeanCustomizers);
+
+        AnnotationAwareOrderComparator.sort(this.configBeanCustomizers);
+    }
+
     /**
      * Create {@link DubboConfigBinder} instance.
      *

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/beans/factory/annotation/ReferenceAnnotationBeanPostProcessor.java

@@ -16,6 +16,17 @@
  */
 package org.apache.dubbo.config.spring.beans.factory.annotation;
 
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
 import org.apache.dubbo.config.annotation.Reference;
 import org.apache.dubbo.config.spring.ReferenceBean;
 import org.apache.dubbo.config.spring.ServiceBean;
@@ -30,16 +41,6 @@
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.ContextRefreshedEvent;
 
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
 /**
  * {@link org.springframework.beans.factory.config.BeanPostProcessor} implementation
  * that Consumer service {@link Reference} annotated fields
@@ -155,7 +156,18 @@ private ReferenceBeanInvocationHandler(ReferenceBean referenceBean) {
 
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-            return method.invoke(bean, args);
+            Object result = null;
+            try {
+                if (bean == null) { // If the bean is not initialized, invoke init()
+                    // issue: https://github.com/apache/incubator-dubbo/issues/3429
+                    init();
+                }
+                result = method.invoke(bean, args);
+            } catch (InvocationTargetException e) {
+                // re-throws the actual Exception.
+                throw e.getTargetException();
+            }
+            return result;
         }
 
         private void init() {
@@ -176,7 +188,9 @@ protected String buildInjectedObjectCacheKey(Reference reference, Object bean, S
 
     private String buildReferencedBeanName(Reference reference, Class<?> injectedType) {
 
-        ServiceBeanNameBuilder builder = ServiceBeanNameBuilder.create(reference, injectedType, getEnvironment());
+        AnnotationBeanNameBuilder builder = AnnotationBeanNameBuilder.create(reference, injectedType);
+
+        builder.environment(getEnvironment());
 
         return getEnvironment().resolvePlaceholders(builder.build());
     }

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/beans/factory/annotation/ServiceAnnotationBeanPostProcessor.java

@@ -16,6 +16,18 @@
  */
 package org.apache.dubbo.config.spring.beans.factory.annotation;
 
+import static org.apache.dubbo.config.spring.util.ObjectUtils.of;
+import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
+import static org.springframework.context.annotation.AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR;
+import static org.springframework.core.annotation.AnnotationUtils.findAnnotation;
+import static org.springframework.util.ClassUtils.resolveClassName;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
 import org.apache.dubbo.common.logger.Logger;
 import org.apache.dubbo.common.logger.LoggerFactory;
 import org.apache.dubbo.config.MethodConfig;
@@ -52,18 +64,6 @@
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.apache.dubbo.config.spring.util.ObjectUtils.of;
-import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
-import static org.springframework.context.annotation.AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR;
-import static org.springframework.core.annotation.AnnotationUtils.findAnnotation;
-import static org.springframework.util.ClassUtils.resolveClassName;
-
 /**
  * {@link Service} Annotation
  * {@link BeanDefinitionRegistryPostProcessor Bean Definition Registry Post Processor}
@@ -290,8 +290,9 @@ private void registerServiceBean(BeanDefinitionHolder beanDefinitionHolder, Bean
      */
     private String generateServiceBeanName(Service service, Class<?> interfaceClass, String annotatedServiceBeanName) {
 
-        ServiceBeanNameBuilder builder = ServiceBeanNameBuilder.create(service, interfaceClass, environment);
+        AnnotationBeanNameBuilder builder = AnnotationBeanNameBuilder.create(service, interfaceClass);
 
+        builder.environment(environment);
 
         return builder.build();
 
@@ -316,8 +317,9 @@ private Class<?> resolveServiceInterfaceClass(Class<?> annotatedServiceBeanClass
         }
 
         if (interfaceClass == null) {
-
-            Class<?>[] allInterfaces = annotatedServiceBeanClass.getInterfaces();
+            // Find all interfaces from the annotated class
+            // To resolve an issue : https://github.com/apache/incubator-dubbo/issues/3251
+            Class<?>[] allInterfaces = ClassUtils.getAllInterfacesForClass(annotatedServiceBeanClass);
 
             if (allInterfaces.length > 0) {
                 interfaceClass = allInterfaces[0];