将Spring的environment的配置动态绑定到配置类

在Spring中，我们有很多配置，如果一个个设置的话比较繁琐，参考Spring Boot的

@ConfigurationProperties(prefix = "spring.nbp")的方式类动态将spring.nbp前缀的配置全部绑定到我们的配置类就比较方便了。

好了，我们先上个实际使用示例,假设我们需要将spring.nbp前缀的配置绑定到DispatchProperty：

DispatchProperty property = BinderUtils.relaxedDataBinderBind(this.environment, DispatchProperty.PREFIX, DispatchProperty.class);

一行代码就搞定，那么这个类是如何帮我们来实现配置动态绑定的呢？我们抽丝剥茧来看一下关键类:

BinderUtils

package com.xxx.arch.mw.nbp.client.spring.bind;

import org.springframework.core.env.ConfigurableEnvironment;

import java.lang.reflect.Constructor;

/**
 * @created 2022-11-24 12:38 AM
 * @description:
 */
public class BinderUtils {

    public static  T relaxedDataBinderBind(ConfigurableEnvironment environment, String prefix, Class type) {
        T instance;
        try {
            Constructor constructor = type.getDeclaredConstructor();
            instance = constructor.newInstance();
        } catch (Throwable e) {
            throw new IllegalArgumentException(e);
        }
        if (environment != null) {
            new RelaxedDataBinder(instance, prefix)
                    .bind(new PropertySourcesPropertyValues(environment.getPropertySources()));
        }
        return instance;
    }
}

RelaxedDataBinder

package com.xxx.arch.mw.nbp.client.spring.bind;


import com.xxx.commons.data.constant.CommonConstants;
import org.springframework.beans.*;
import org.springframework.beans.propertyeditors.FileEditor;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.validation.DataBinder;

import java.beans.PropertyEditor;
import java.util.*;

/**
 * Binder implementation that allows caller to bind to maps and also allows property names
 * to match a bit loosely (if underscores or dashes are removed and replaced with camel
 * case for example).
 *
 * @author Dave Syer
 * @author Phillip Webb
 * @author Stephane Nicoll
 * @author Andy Wilkinson
 * @see RelaxedNames
 */
public class RelaxedDataBinder extends DataBinder {

    private static final Set> EXCLUDED_EDITORS;
    private static final Object BLANK = new Object();
    private static final String REGEX = "[_\\-\\.]";
    private static final String EMPTY = "";

    static {
        Set> excluded = new HashSet>();
        excluded.add(FileEditor.class);
        EXCLUDED_EDITORS = Collections.unmodifiableSet(excluded);
    }

    private String namePrefix;

    private boolean ignoreNestedProperties;

    private MultiValueMap nameAliases = new LinkedMultiValueMap();

    /**
     * Create a new {@link RelaxedDataBinder} instance.
     *
     * @param target the target into which properties are bound
     */
    public RelaxedDataBinder(Object target) {
        super(wrapTarget(target));
    }

    /**
     * Create a new {@link RelaxedDataBinder} instance.
     *
     * @param target     the target into which properties are bound
     * @param namePrefix An optional prefix to be used when reading properties
     */
    public RelaxedDataBinder(Object target, String namePrefix) {
        super(wrapTarget(target), (StringUtils.hasLength(namePrefix) ? namePrefix : DEFAULT_OBJECT_NAME));
        this.namePrefix = cleanNamePrefix(namePrefix);
    }

    private static Object wrapTarget(Object target) {
        if (target instanceof Map) {
            @SuppressWarnings("unchecked") Map map = (Map) target;
            target = new MapHolder(map);
        }
        return target;
    }

    private String cleanNamePrefix(String namePrefix) {
        if (!StringUtils.hasLength(namePrefix)) {
            return null;
        }
        return (namePrefix.endsWith(CommonConstants.DOT) ? namePrefix : namePrefix + CommonConstants.DOT);
    }

    /**
     * Flag to disable binding of nested properties (i.e. those with period separators in
     * their paths). Can be useful to disable this if the name prefix is empty and you
     * don't want to ignore unknown fields.
     *
     * @param ignoreNestedProperties the flag to set (default false)
     */
    public void setIgnoreNestedProperties(boolean ignoreNestedProperties) {
        this.ignoreNestedProperties = ignoreNestedProperties;
    }

    /**
     * Set name aliases.
     *
     * @param aliases a map of property name to aliases
     */
    public void setNameAliases(Map> aliases) {
        this.nameAliases = new LinkedMultiValueMap(aliases);
    }

    /**
     * Add aliases to the {@link org.springframework.validation.DataBinder}.
     *
     * @param name  the property name to alias
     * @param alias aliases for the property names
     * @return this instance
     */
    public RelaxedDataBinder withAlias(String name, String... alias) {
        for (String value : alias) {
            this.nameAliases.add(name, value);
        }
        return this;
    }

    @Override
    protected void doBind(MutablePropertyValues propertyValues) {
        super.doBind(modifyProperties(propertyValues, getTarget()));
    }

    /**
     * Modify the property values so that period separated property paths are valid for
     * map keys. Also creates new maps for properties of map type that are null (assuming
     * all maps are potentially nested). The standard bracket {@code[...]} dereferencing
     * is also accepted.
     *
     * @param propertyValues the property values
     * @param target         the target object
     * @return modified property values
     */
    private MutablePropertyValues modifyProperties(MutablePropertyValues propertyValues, Object target) {
        propertyValues = getPropertyValuesForNamePrefix(propertyValues);
        if (target instanceof MapHolder) {
            propertyValues = addMapPrefix(propertyValues);
        }
        BeanWrapper wrapper = new BeanWrapperImpl(target);
        wrapper.setAutoGrowNestedPaths(true);
        List sortedValues = new ArrayList();
        Set modifiedNames = new HashSet();
        List sortedNames = getSortedPropertyNames(propertyValues);
        for (String name : sortedNames) {
            PropertyValue propertyValue = propertyValues.getPropertyValue(name);
            PropertyValue modifiedProperty = modifyProperty(wrapper, propertyValue);
            if (modifiedNames.add(modifiedProperty.getName())) {
                sortedValues.add(modifiedProperty);
            }
        }
        return new MutablePropertyValues(sortedValues);
    }

    private List getSortedPropertyNames(MutablePropertyValues propertyValues) {
        List names = new LinkedList();
        for (PropertyValue propertyValue : propertyValues.getPropertyValueList()) {
            names.add(propertyValue.getName());
        }
        sortPropertyNames(names);
        return names;
    }

    /**
     * Sort by name so that parent properties get processed first (e.g. 'foo.bar' before
     * 'foo.bar.spam'). Don't use Collections.sort() because the order might be
     * significant for other property names (it shouldn't be but who knows what people
     * might be relying on, e.g. HSQL has a JDBCXADataSource where "databaseName" is a
     * synonym for "url").
     *
     * @param names the names to sort
     */
    private void sortPropertyNames(List names) {
        for (String name : new ArrayList(names)) {
            int propertyIndex = names.indexOf(name);
            BeanPath path = new BeanPath(name);
            for (String prefix : path.prefixes()) {
                int prefixIndex = names.indexOf(prefix);
                if (prefixIndex >= propertyIndex) {
                    // The child property has a parent in the list in the wrong order
                    names.remove(name);
                    names.add(prefixIndex, name);
                }
            }
        }
    }

    private MutablePropertyValues addMapPrefix(MutablePropertyValues propertyValues) {
        MutablePropertyValues rtn = new MutablePropertyValues();
        for (PropertyValue pv : propertyValues.getPropertyValues()) {
            rtn.add("map." + pv.getName(), pv.getValue());
        }
        return rtn;
    }

    private MutablePropertyValues getPropertyValuesForNamePrefix(MutablePropertyValues propertyValues) {
        if (!StringUtils.hasText(this.namePrefix) && !this.ignoreNestedProperties) {
            return propertyValues;
        }
        MutablePropertyValues rtn = new MutablePropertyValues();
        for (PropertyValue value : propertyValues.getPropertyValues()) {
            String name = value.getName();
            for (String prefix : new RelaxedNames(stripLastDot(this.namePrefix))) {
                for (String separator : new String[]{
                        CommonConstants.DOT,
                        CommonConstants.UNDERLINE_SEPARATOR
                }) {
                    String candidate = (StringUtils.hasLength(prefix) ? prefix + separator : prefix);
                    if (name.startsWith(candidate)) {
                        name = name.substring(candidate.length());
                        if (!(this.ignoreNestedProperties && name.contains(CommonConstants.DOT))) {
                            rtn.addPropertyValue(new PropertyValue(name, value.getValue()));
                        }
                    }
                }
            }
        }
        return rtn;
    }

    private String stripLastDot(String string) {
        if (StringUtils.hasLength(string) && string.endsWith(CommonConstants.DOT)) {
            string = string.substring(0, string.length() - 1);
        }
        return string;
    }

    private PropertyValue modifyProperty(BeanWrapper target, PropertyValue propertyValue) {
        String name = propertyValue.getName();
        String normalizedName = normalizePath(target, name);
        if (!normalizedName.equals(name)) {
            return new PropertyValue(normalizedName, propertyValue.getValue());
        }
        return propertyValue;
    }

    /**
     * Normalize a bean property path to a format understood by a BeanWrapper. This is
     * used so that
     * 

     * 
Fuzzy matching can be employed for bean property names
     * 
Period separators can be used instead of indexing ([...]) for map keys
     * 
     *
     * @param wrapper a bean wrapper for the object to bind
     * @param path    the bean path to bind
     * @return a transformed path with correct bean wrapper syntax
     */
    protected String normalizePath(BeanWrapper wrapper, String path) {
        return initializePath(wrapper, new BeanPath(path), 0);
    }

    private String initializePath(BeanWrapper wrapper, BeanPath path, int index) {
        String prefix = path.prefix(index);
        String key = path.name(index);
        if (path.isProperty(index)) {
            key = getActualPropertyName(wrapper, prefix, key);
            path.rename(index, key);
        }
        if (path.name(++index) == null) {
            return path.toString();
        }
        String name = path.prefix(index);
        TypeDescriptor descriptor = wrapper.getPropertyTypeDescriptor(name);
        if (descriptor == null || descriptor.isMap()) {
            if (isMapValueStringType(descriptor) || isBlanked(wrapper, name, path.name(index))) {
                path.collapseKeys(index);
            }
            path.mapIndex(index);
            extendMapIfNecessary(wrapper, path, index);
        } else if (descriptor.isCollection()) {
            extendCollectionIfNecessary(wrapper, path, index);
        } else if (descriptor.getType().equals(Object.class)) {
            if (isBlanked(wrapper, name, path.name(index))) {
                path.collapseKeys(index);
            }
            path.mapIndex(index);
            if (path.isLastNode(index)) {
                wrapper.setPropertyValue(path.toString(), BLANK);
            } else {
                String next = path.prefix(index + 1);
                if (wrapper.getPropertyValue(next) == null) {
                    wrapper.setPropertyValue(next, new LinkedHashMap());
                }
            }
        }
        return initializePath(wrapper, path, index);
    }

    private boolean isMapValueStringType(TypeDescriptor descriptor) {
        if (descriptor == null || descriptor.getMapValueTypeDescriptor() == null) {
            return false;
        }
        if (Properties.class.isAssignableFrom(descriptor.getObjectType())) {
            // Properties is declared as Map but we know it's really
            // Map
            return true;
        }
        Class valueType = descriptor.getMapValueTypeDescriptor().getObjectType();
        return (valueType != null && CharSequence.class.isAssignableFrom(valueType));
    }

    @SuppressWarnings("rawtypes")
    private boolean isBlanked(BeanWrapper wrapper, String propertyName, String key) {
        Object value = (wrapper.isReadableProperty(propertyName) ? wrapper.getPropertyValue(propertyName) : null);
        if (value instanceof Map) {
            if (((Map) value).get(key) == BLANK) {
                return true;
            }
        }
        return false;
    }

    private void extendCollectionIfNecessary(BeanWrapper wrapper, BeanPath path, int index) {
        String name = path.prefix(index);
        TypeDescriptor elementDescriptor = wrapper.getPropertyTypeDescriptor(name).getElementTypeDescriptor();
        if (!elementDescriptor.isMap() && !elementDescriptor.isCollection() && !elementDescriptor.getType()
                .equals(Object.class)) {
            return;
        }
        Object extend = new LinkedHashMap();
        if (!elementDescriptor.isMap() && path.isArrayIndex(index)) {
            extend = new ArrayList