Make moduleFeaturesMap local; use BeanFactory helper

Refactor ConfigurationPropertyHasFeaturesAutoConfiguration to keep moduleFeaturesMap as a local variable instead of a long-lived field and pass it into helper methods. Use BeanFactoryUtils.asDefaultListableBeanFactory(...) when setting the beanFactory for safer conversion. Clear the local map after registering HasFeatures beans. Update tests to expect WebClient as an abstract feature for the "web" module and adjust assertions accordingly.

Author: mercyblitz

microsphere-spring-cloud-commons/src/main/java/io/microsphere/spring/cloud/client/actuator/ConfigurationPropertyHasFeaturesAutoConfiguration.java

@@ -41,6 +41,7 @@
 import static io.microsphere.collection.MapUtils.newLinkedHashMap;
 import static io.microsphere.logging.LoggerFactory.getLogger;
 import static io.microsphere.spring.beans.BeanUtils.isBeanPresent;
+import static io.microsphere.spring.beans.factory.BeanFactoryUtils.asDefaultListableBeanFactory;
 import static io.microsphere.spring.cloud.client.actuator.FeaturesUtils.getAbstractFeaturePropertyName;
 import static io.microsphere.spring.cloud.client.actuator.FeaturesUtils.getHasFeaturesBeanName;
 import static io.microsphere.spring.cloud.client.actuator.FeaturesUtils.getNamedFeaturePropertyName;
@@ -93,8 +94,6 @@ public class ConfigurationPropertyHasFeaturesAutoConfiguration implements BeanFa
 
     private DefaultListableBeanFactory beanFactory;
 
-    private final Map<String, ModuleFeatures> moduleFeaturesMap = newLinkedHashMap();
-
     @Autowired
     private FeaturesProperties featuresProperties;
 
@@ -105,17 +104,18 @@ public void setBeanClassLoader(ClassLoader classLoader) {
 
     @Override
     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
-        this.beanFactory = (DefaultListableBeanFactory) beanFactory;
+        this.beanFactory = asDefaultListableBeanFactory(beanFactory);
     }
 
     @Override
     public void afterPropertiesSet() {
         FeaturesProperties featuresProperties = this.featuresProperties;
 
+        Map<String, ModuleFeatures> moduleFeaturesMap = newLinkedHashMap();
         Map<String, List<String>> abstractProperties = featuresProperties.getAbstract();
 
         abstractProperties.forEach((moduleName, featureClassNames) -> {
-            addAbstractFeatureClassNames(moduleName, featureClassNames);
+            addAbstractFeatureClassNames(moduleName, featureClassNames, moduleFeaturesMap);
         });
 
         Map<String, Map<String, String>> namedProperties = featuresProperties.getNamed();
@@ -124,14 +124,15 @@ public void afterPropertiesSet() {
             for (Entry<String, String> entry : namedFeatures.entrySet()) {
                 String featureName = entry.getKey();
                 String featureClassName = entry.getValue();
-                addNamedFeatureClassName(moduleName, featureName, featureClassName);
+                addNamedFeatureClassName(moduleName, featureName, featureClassName, moduleFeaturesMap);
             }
         });
 
-        registerHasFeaturesBeans();
+        registerHasFeaturesBeans(moduleFeaturesMap);
+        moduleFeaturesMap.clear();
     }
 
-    private void addAbstractFeatureClassNames(String moduleName, List<String> featureClassNames) {
+    private void addAbstractFeatureClassNames(String moduleName, List<String> featureClassNames, Map<String, ModuleFeatures> moduleFeaturesMap) {
         for (String featureClassName : featureClassNames) {
             Class<?> featureClass = loadClass(featureClassName);
             if (featureClass == null) {
@@ -140,18 +141,18 @@ private void addAbstractFeatureClassNames(String moduleName, List<String> featur
                         featureClassName, propertyName);
                 continue;
             }
-            addAbstractFeatureClass(moduleName, featureClass);
+            addAbstractFeatureClass(moduleName, featureClass, moduleFeaturesMap);
         }
     }
 
-    private void addAbstractFeatureClass(String moduleName, Class<?> featureClass) {
-        ModuleFeatures moduleFeatures = getModuleFeatures(moduleName);
+    private void addAbstractFeatureClass(String moduleName, Class<?> featureClass, Map<String, ModuleFeatures> moduleFeaturesMap) {
+        ModuleFeatures moduleFeatures = getModuleFeatures(moduleFeaturesMap, moduleName);
         logger.trace("The AbstractFeature[moduel: '{}' , class : '{}'] will be added in the HasFeatures.", moduleName,
                 featureClass.getName());
         moduleFeatures.abstractFeatures.add(featureClass);
     }
 
-    private void addNamedFeatureClassName(String moduleName, String featureName, String featureClassName) {
+    private void addNamedFeatureClassName(String moduleName, String featureName, String featureClassName, Map<String, ModuleFeatures> moduleFeaturesMap) {
         String name = getQualifierFeatureName(moduleName, featureName);
         Class<?> featureClass = loadClass(featureClassName);
         String propertyName = getNamedFeaturePropertyName(moduleName, featureName);
@@ -165,25 +166,25 @@ private void addNamedFeatureClassName(String moduleName, String featureName, Str
             logger.trace("The NamedFeature[name : '{}' , class : '{}' , configuration property : '{}'] will be added in the HasFeatures.",
                     name, featureClassName, propertyName);
             NamedFeature namedFeature = new NamedFeature(name, featureClass);
-            ModuleFeatures moduleFeatures = getModuleFeatures(moduleName);
+            ModuleFeatures moduleFeatures = getModuleFeatures(moduleFeaturesMap, moduleName);
             moduleFeatures.namedFeatures.add(namedFeature);
         } else {
             logger.warn("No bean of named feature[name : '{}' , class : '{}'] is present in the BeanFactory, so it will be fallback as an abstract feature, please check the configuration property : '{}'",
                     name, featureClassName, propertyName);
-            addAbstractFeatureClass(moduleName, featureClass);
+            addAbstractFeatureClass(moduleName, featureClass, moduleFeaturesMap);
         }
     }
 
     private Class<?> loadClass(String className) {
         return resolveClass(className, this.classLoader);
     }
 
-    private ModuleFeatures getModuleFeatures(String moduleName) {
-        return this.moduleFeaturesMap.computeIfAbsent(moduleName, ModuleFeatures::new);
+    private ModuleFeatures getModuleFeatures(Map<String, ModuleFeatures> moduleFeaturesMap, String moduleName) {
+        return moduleFeaturesMap.computeIfAbsent(moduleName, ModuleFeatures::new);
     }
 
-    private void registerHasFeaturesBeans() {
-        for (Entry<String, ModuleFeatures> entry : this.moduleFeaturesMap.entrySet()) {
+    private void registerHasFeaturesBeans(Map<String, ModuleFeatures> moduleFeaturesMap) {
+        for (Entry<String, ModuleFeatures> entry : moduleFeaturesMap.entrySet()) {
             String moduleName = entry.getKey();
             ModuleFeatures moduleFeatures = entry.getValue();
             HasFeatures hasFeatures = moduleFeatures.toHasFeatures();

microsphere-spring-cloud-commons/src/test/java/io/microsphere/spring/cloud/client/actuator/ConfigurationPropertyHasFeaturesAutoConfigurationTest.java

@@ -26,6 +26,7 @@
 import org.springframework.cloud.client.actuator.NamedFeature;
 import org.springframework.web.client.RestOperations;
 import org.springframework.web.client.RestTemplate;
+import org.springframework.web.reactive.function.client.WebClient;
 
 import java.util.List;
 import java.util.Map;
@@ -74,12 +75,15 @@ void test() {
         assertNull(hasFeatures);
 
         hasFeatures = this.hasFeaturesBeansMap.get(getHasFeaturesBeanName("web"));
-        assertNull(hasFeatures);
+        assertNotNull(hasFeatures);
+        List<Class<?>> abstractFeatures = hasFeatures.getAbstractFeatures();
+        assertEquals(1, abstractFeatures.size());
+        assertEquals(WebClient.class, abstractFeatures.get(0));
 
         hasFeatures = this.hasFeaturesBeansMap.get(getHasFeaturesBeanName("rest"));
         assertNotNull(hasFeatures);
 
-        List<Class<?>> abstractFeatures = hasFeatures.getAbstractFeatures();
+        abstractFeatures = hasFeatures.getAbstractFeatures();
         assertEquals(1, abstractFeatures.size());
         assertEquals(RestOperations.class, abstractFeatures.get(0));