Merge pull request #142 from mercyblitz/dev-1.x

Enhance configuration properties handling and update README

Author: mercyblitz

README.md

@@ -110,8 +110,8 @@ Choose the version that matches your Spring Boot generation:
 
 | Branch | Spring Boot Compatibility | Latest Version |
 |--------|---------------------------|----------------|
-| `main` | 3.0.x – 3.5.x, 4.1.x      | `0.2.24`       |
-| `1.x`  | 2.0.x – 2.7.x             | `0.1.24`       |
+| `main` | 3.0.x – 3.5.x, 4.1.x      | `0.2.26`       |
+| `1.x`  | 2.0.x – 2.7.x             | `0.1.26`       |
 
 ### Add Module Dependencies
 

microsphere-spring-boot-compatible/src/main/java/org/springframework/boot/context/properties/ConstructorBinding.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2012-2021 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.springframework.boot.context.properties;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation that can be used to indicate that configuration properties should be bound
+ * using constructor arguments rather than by calling setters. Can be added at the type
+ * level (if there is an unambiguous constructor) or on the actual constructor to use.
+ * <p>
+ * Note: To use constructor binding the class must be enabled using
+ * {@link EnableConfigurationProperties @EnableConfigurationProperties} or configuration
+ * property scanning. Constructor binding cannot be used with beans that are created by
+ * the regular Spring mechanisms (e.g.
+ * {@link org.springframework.stereotype.Component @Component} beans, beans created via
+ * {@link org.springframework.context.annotation.Bean @Bean} methods or beans loaded using
+ * {@link org.springframework.context.annotation.Import @Import}).
+ *
+ * @author Phillip Webb
+ * @since 2.2.0
+ * @see ConfigurationProperties
+ */
+@Target({ ElementType.TYPE, ElementType.CONSTRUCTOR })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface ConstructorBinding {
+
+}

microsphere-spring-boot-core/src/main/java/io/microsphere/spring/boot/context/properties/bind/ConfigurationPropertiesBeanContext.java

@@ -110,6 +110,13 @@ public Object getValue() {
     }
 
     public String getName() {
+        if (this.name == null) {
+            return resolveName();
+        }
+        return this.name;
+    }
+
+    String resolveName() {
         Field field = this.field;
         if (field != null) {
             return field.getName();
@@ -142,6 +149,6 @@ public ResolvableType getType() {
 
     @Override
     public String toString() {
-        return format("{} {}.{} = {}", getType(), getDeclaringClassType(), getName(), getValue());
+        return format("{} {}.{} = {}", getType(), getDeclaringClassType(), resolveName(), getValue());
     }
 }

microsphere-spring-boot-core/src/main/java/io/microsphere/spring/boot/context/properties/bind/ConfigurationPropertiesBeanProperty.java

@@ -19,9 +19,8 @@
 import io.microsphere.annotation.Nullable;
 import io.microsphere.logging.Logger;
 import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.SmartInitializingSingleton;
-import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
-import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.boot.context.properties.bind.BindContext;
 import org.springframework.boot.context.properties.bind.Bindable;
@@ -30,21 +29,16 @@
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.core.ResolvableType;
-import org.springframework.core.annotation.AnnotationAttributes;
 
 import java.util.Map;
 import java.util.function.Supplier;
 
-import static io.microsphere.collection.MapUtils.newHashMap;
 import static io.microsphere.logging.LoggerFactory.getLogger;
+import static io.microsphere.spring.boot.context.properties.bind.ConfigurationPropertiesBeanContext.buildConfigurationPropertiesBeanContexts;
 import static io.microsphere.spring.boot.context.properties.bind.util.BindUtils.isBoundProperty;
 import static io.microsphere.spring.boot.context.properties.bind.util.BindUtils.isConfigurationPropertiesBean;
 import static io.microsphere.spring.boot.context.properties.source.util.ConfigurationPropertyUtils.getPrefix;
-import static io.microsphere.spring.boot.context.properties.util.ConfigurationPropertiesUtils.CONFIGURATION_PROPERTIES_CLASS;
-import static io.microsphere.spring.boot.context.properties.util.ConfigurationPropertiesUtils.findConfigurationProperties;
-import static io.microsphere.spring.core.annotation.AnnotationUtils.getAnnotationAttributes;
-import static org.springframework.util.Assert.isInstanceOf;
+import static io.microsphere.spring.context.ApplicationContextUtils.asConfigurableApplicationContext;
 
 /**
  * A {@link BindListener} implementation of {@link ConfigurationProperties @ConfigurationProperties} Bean to publish
@@ -56,12 +50,10 @@
  * @see ConfigurationPropertiesBeanPropertyChangedEvent
  * @since 1.0.0
  */
-public class EventPublishingConfigurationPropertiesBeanPropertyChangedListener implements BindListener, BeanFactoryPostProcessor, ApplicationContextAware, SmartInitializingSingleton {
+public class EventPublishingConfigurationPropertiesBeanPropertyChangedListener implements BindListener, ApplicationContextAware, InitializingBean, SmartInitializingSingleton {
 
     private static final Logger logger = getLogger(EventPublishingConfigurationPropertiesBeanPropertyChangedListener.class);
 
-    private static final Class<ConfigurableApplicationContext> CONFIGURABLE_APPLICATION_CONTEXT_CLASS = ConfigurableApplicationContext.class;
-
     private Map<String, ConfigurationPropertiesBeanContext> beanContexts;
 
     private ConfigurableApplicationContext context;
@@ -95,16 +87,14 @@ public <T> void onStart(ConfigurationPropertyName name, Bindable<T> target, Bind
      */
     @Override
     public void onSuccess(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result) {
-        setConfigurationPropertiesBeanProperty(name, target, context, result);
+        if (isBound()) {
+            setConfigurationPropertiesBeanProperty(name, target, context, result);
+        }
     }
 
     void initConfigurationPropertiesBeanContext(ConfigurationPropertyName name, Bindable<?> target, BindContext context) {
         ConfigurationPropertiesBeanContext configurationPropertiesBeanContext = getConfigurationPropertiesBeanContext(name, target, context);
         if (configurationPropertiesBeanContext == null) {
-            if (logger.isWarnEnabled()) {
-                logger.warn("No ConfigurationPropertiesBeanContext was found[name : '{}' , target : {} , depth : {}]",
-                        name, target, context.getDepth());
-            }
             return;
         }
         if (isConfigurationPropertiesBean(context)) {
@@ -116,45 +106,27 @@ void initConfigurationPropertiesBeanContext(ConfigurationPropertyName name, Bind
                             name, target, context.getDepth());
                 }
             } else {
-                configurationPropertiesBeanContext.initialize(bean);
+                configurationPropertiesBeanContext.setBean(bean);
                 if (logger.isTraceEnabled()) {
                     logger.trace("The ConfigurationPropertiesBean binding is finished[name : '{}' , target : {} , depth : {} , bean : '{}']",
                             name, target, context.getDepth(), bean);
                 }
             }
-        } else {
-            configurationPropertiesBeanContext.initProperty(name, target);
         }
     }
 
     @Nullable
     private ConfigurationPropertiesBeanContext getConfigurationPropertiesBeanContext(ConfigurationPropertyName name,
                                                                                      Bindable<?> target, BindContext context) {
         String prefix = getPrefix(name, context);
-        return beanContexts.computeIfAbsent(prefix, p -> newConfigurationPropertiesBeanContext(target, p));
-    }
-
-    ConfigurationPropertiesBeanContext newConfigurationPropertiesBeanContext(Bindable<?> target, String prefix) {
-        ConfigurationProperties annotation = findConfigurationProperties(target);
-        if (annotation == null) {
-            if (logger.isWarnEnabled()) {
-                logger.warn("The ConfigurationPropertiesBeanContext is not created caused by the missing @ConfigurationProperties annotation, target : {}",
-                        target);
-            }
-            return null;
-        }
-        AnnotationAttributes annotationAttributes = getAnnotationAttributes(annotation);
-        String actualPrefix = annotationAttributes.getString("prefix");
-        if (!prefix.equalsIgnoreCase(actualPrefix)) {
+        ConfigurationPropertiesBeanContext configurationPropertiesBeanContext = this.beanContexts.get(prefix);
+        if (configurationPropertiesBeanContext == null) {
             if (logger.isWarnEnabled()) {
-                logger.warn("The ConfigurationPropertiesBeanContext is not created caused by the mismatched prefix[expected : '{}' , actual : '{}'], target : {}",
-                        prefix, actualPrefix, target);
+                logger.warn("No ConfigurationPropertiesBeanContext was found[name : '{}' , target : {} , depth : {}]",
+                        name, target, context.getDepth());
             }
-            return null;
         }
-
-        ResolvableType beanType = target.getType();
-        return new ConfigurationPropertiesBeanContext(beanType, annotationAttributes, prefix, this.context);
+        return configurationPropertiesBeanContext;
     }
 
     /**
@@ -170,88 +142,48 @@ void setConfigurationPropertiesBeanProperty(ConfigurationPropertyName name, Bind
         if (isBoundProperty(context)) {
             ConfigurationProperty property = context.getConfigurationProperty();
             ConfigurationPropertiesBeanContext configurationPropertiesBeanContext = getConfigurationPropertiesBeanContext(name, target, context);
-            configurationPropertiesBeanContext.setProperty(property, result, isBound());
+            if (configurationPropertiesBeanContext == null) {
+                return;
+            }
+            configurationPropertiesBeanContext.setProperty(property, result);
             if (logger.isTraceEnabled()) {
                 logger.trace("binding Bean property is finished , configuration property : '{}' , type : '{}' , depth : {} , result : '{}'", property, target.getType(), context.getDepth(), result);
             }
         }
     }
 
-    /**
-     * Post-processes the bean factory to initialize the internal map of
-     * {@link ConfigurationPropertiesBeanContext} instances for all
-     * {@link ConfigurationProperties @ConfigurationProperties} beans.
-     *
-     * <h3>Example Usage</h3>
-     * <pre>{@code
-     *   EventPublishingConfigurationPropertiesBeanPropertyChangedListener listener =
-     *       new EventPublishingConfigurationPropertiesBeanPropertyChangedListener();
-     *   listener.postProcessBeanFactory(beanFactory);
-     * }</pre>
-     *
-     * @param beanFactory the bean factory to post-process
-     * @throws BeansException if an error occurs
-     */
-    @Override
-    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
-        initConfigurationPropertiesBeanContexts(beanFactory);
-    }
-
-    private void initConfigurationPropertiesBeanContexts(ConfigurableListableBeanFactory beanFactory) {
-        String[] beanNames = beanFactory.getBeanNamesForAnnotation(CONFIGURATION_PROPERTIES_CLASS);
-        int beanCount = beanNames.length;
-        this.beanContexts = newHashMap(beanCount);
-    }
-
     /**
      * Sets the {@link ApplicationContext}, which must be a {@link ConfigurableApplicationContext},
      * for publishing property change events.
      *
-     * <h3>Example Usage</h3>
-     * <pre>{@code
-     *   EventPublishingConfigurationPropertiesBeanPropertyChangedListener listener =
-     *       new EventPublishingConfigurationPropertiesBeanPropertyChangedListener();
-     *   listener.setApplicationContext(applicationContext);
-     * }</pre>
-     *
      * @param context the application context, must be a {@link ConfigurableApplicationContext}
      * @throws BeansException if the context is not a {@link ConfigurableApplicationContext}
      */
     @Override
     public void setApplicationContext(ApplicationContext context) throws BeansException {
-        Class<ConfigurableApplicationContext> expectedType = CONFIGURABLE_APPLICATION_CONTEXT_CLASS;
-        isInstanceOf(expectedType, context, "The 'context' argument is not an instance of " + expectedType.getName());
-        this.context = expectedType.cast(context);
+        this.context = asConfigurableApplicationContext(context);
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        this.beanContexts = buildConfigurationPropertiesBeanContexts(this.context);
     }
 
     /**
      * Called after all singleton beans have been instantiated, marking that initial binding
      * is complete. Subsequent binding operations will detect and publish property changes.
-     *
-     * <h3>Example Usage</h3>
-     * <pre>{@code
-     *   EventPublishingConfigurationPropertiesBeanPropertyChangedListener listener = ...;
-     *   // Called automatically by the Spring container
-     *   listener.afterSingletonsInstantiated();
-     *   assertTrue(listener.isBound());
-     * }</pre>
      */
     @Override
     public void afterSingletonsInstantiated() {
+        for (ConfigurationPropertiesBeanContext beanContext : this.beanContexts.values()) {
+            beanContext.bindPropertyValues();
+        }
         bound = true;
     }
 
     /**
      * Returns whether the initial binding of all singleton beans has been completed.
      *
-     * <h3>Example Usage</h3>
-     * <pre>{@code
-     *   EventPublishingConfigurationPropertiesBeanPropertyChangedListener listener = ...;
-     *   if (listener.isBound()) {
-     *       // Property changes will now be published as events
-     *   }
-     * }</pre>
-     *
      * @return {@code true} if initial binding is complete, {@code false} otherwise
      */
     public boolean isBound() {

microsphere-spring-boot-core/src/main/java/io/microsphere/spring/boot/context/properties/bind/EventPublishingConfigurationPropertiesBeanPropertyChangedListener.java

@@ -17,6 +17,7 @@
 
 package io.microsphere.spring.boot.context.properties;
 
+import org.springframework.boot.autoconfigure.info.ProjectInfoProperties;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 import java.util.List;
@@ -40,6 +41,8 @@ public class TestConfigurationProperties {
 
     private List<Integer> ports;
 
+    private Map<String, List<ProjectInfoProperties>> projects;
+
     public String getName() {
         return name;
     }
@@ -71,4 +74,12 @@ public List<Integer> getPorts() {
     public void setPorts(List<Integer> ports) {
         this.ports = ports;
     }
+
+    public Map<String, List<ProjectInfoProperties>> getProjects() {
+        return projects;
+    }
+
+    public void setProjects(Map<String, List<ProjectInfoProperties>> projects) {
+        this.projects = projects;
+    }
 }

microsphere-spring-boot-core/src/test/java/io/microsphere/spring/boot/context/properties/TestConfigurationProperties.java

@@ -18,6 +18,7 @@
 package io.microsphere.spring.boot.context.properties;
 
 import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.context.properties.ConstructorBinding;
 
 /**
  * {@link ConfigurationProperties @ConfigurationProperties} for testing
@@ -31,12 +32,32 @@
 @ConfigurationProperties("test.constructor.binding")
 public class TestConstructorBindingConfigurationProperties {
 
-    private final String name;
+    private String name;
 
-    private final String value;
+    private String value;
 
+    @ConstructorBinding
     public TestConstructorBindingConfigurationProperties(String name, String value) {
         this.name = name;
         this.value = value;
     }
+
+    public TestConstructorBindingConfigurationProperties() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
 }