SpringBoot2动态@Value的实现方法

这篇文章主要介绍“SpringBoot2动态@Value的实现方法”，在日常操作中，相信很多人在SpringBoot2动态@Value的实现方法问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”SpringBoot2动态@Value的实现方法”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

前言

前面文章有详细描述过各个不同阶段对于bean的扩展接口

所以今天就基于BeanPostProcessor实现Spring中的@Value注解值动态变化

基于上面也可以实现一个配置中心，比如说Apollo

具体的实现步骤分为如下几步

通过BeanPostProcessor取得有使用@Value注解的bean,并存储到map中

动态修改map中的bean字段的值

获取bean

首先写一个类实现BeanPostProcessor接口，只需要使用其中的一个函数就可以。前后都可以用来实现，并不影响最终的使用，因为咱们只是需要bean的实例。

接下来看一下具体实现代码

package com.allen.apollo;import org.springframework.beans.BeansException;import org.springframework.beans.factory.annotation.Value;import org.springframework.beans.factory.config.BeanPostProcessor;import org.springframework.context.annotation.Configuration;import org.springframework.util.ReflectionUtils;import java.lang.reflect.Field;import java.util.LinkedList;import java.util.List;import java.util.Set;@Configurationpublic class SpringValueProcessor implements BeanPostProcessor {    private final PlaceholderHelper placeholderHelper = new PlaceholderHelper();    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        if (beanName.equals("springValueController")) {            Class obj = bean.getClass();            List<Field> fields = findAllField(obj);            for (Field field : fields) {                Value value = field.getAnnotation(Value.class);                if (value != null) {                    Set<String> keys = placeholderHelper.extractPlaceholderKeys(value.value());                    for (String key : keys) {                        SpringValue springValue = new SpringValue(key, value.value(), bean, beanName, field, false);                        SpringValueCacheMap.map.put(key, springValue);                    }                }            }        }        return bean;    }    private List<Field> findAllField(Class clazz) {        final List<Field> res = new LinkedList<>();        ReflectionUtils.doWithFields(clazz, new ReflectionUtils.FieldCallback() {            @Override            public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {                res.add(field);            }        });        return res;    }}

上面的代码咱们就已经拿到了SpringValueController这个实例bean并存储到了map当中，下面看一下测试代码

  package com.allen.apollo;import com.google.common.collect.LinkedListMultimap;import com.google.common.collect.Multimap;public class SpringValueCacheMap {    public static final Multimap<String, SpringValue> map = LinkedListMultimap.create();}

 package com.allen.apollo;import java.lang.ref.WeakReference;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.Type;import org.springframework.core.MethodParameter;public class SpringValue {    private MethodParameter methodParameter;    private Field field;    private WeakReference<Object> beanRef;    private String beanName;    private String key;    private String placeholder;    private Class<?> targetType;    private Type genericType;    private boolean isJson;    public SpringValue(String key, String placeholder, Object bean, String beanName, Field field, boolean isJson) {        this.beanRef = new WeakReference<>(bean);        this.beanName = beanName;        this.field = field;        this.key = key;        this.placeholder = placeholder;        this.targetType = field.getType();        this.isJson = isJson;        if (isJson) {            this.genericType = field.getGenericType();        }    }    public SpringValue(String key, String placeholder, Object bean, String beanName, Method method, boolean isJson) {        this.beanRef = new WeakReference<>(bean);        this.beanName = beanName;        this.methodParameter = new MethodParameter(method, 0);        this.key = key;        this.placeholder = placeholder;        Class<?>[] paramTps = method.getParameterTypes();        this.targetType = paramTps[0];        this.isJson = isJson;        if (isJson) {            this.genericType = method.getGenericParameterTypes()[0];        }    }    public void update(Object newVal) throws IllegalAccessException, InvocationTargetException {        if (isField()) {            injectField(newVal);        } else {            injectMethod(newVal);        }    }    private void injectField(Object newVal) throws IllegalAccessException {        Object bean = beanRef.get();        if (bean == null) {            return;        }        boolean accessible = field.isAccessible();        field.setAccessible(true);        field.set(bean, newVal);        field.setAccessible(accessible);    }    private void injectMethod(Object newVal)            throws InvocationTargetException, IllegalAccessException {        Object bean = beanRef.get();        if (bean == null) {            return;        }        methodParameter.getMethod().invoke(bean, newVal);    }    public String getBeanName() {        return beanName;    }    public Class<?> getTargetType() {        return targetType;    }    public String getPlaceholder() {        return this.placeholder;    }    public MethodParameter getMethodParameter() {        return methodParameter;    }    public boolean isField() {        return this.field != null;    }    public Field getField() {        return field;    }    public Type getGenericType() {        return genericType;    }    public boolean isJson() {        return isJson;    }    boolean isTargetBeanValid() {        return beanRef.get() != null;    }    @Override    public String toString() {        Object bean = beanRef.get();        if (bean == null) {            return "";        }        if (isField()) {            return String                    .format("key: %s, beanName: %s, field: %s.%s", key, beanName, bean.getClass().getName(), field.getName());        }        return String.format("key: %s, beanName: %s, method: %s.%s", key, beanName, bean.getClass().getName(),                methodParameter.getMethod().getName());    }}

package com.allen.apollo;import com.google.common.base.Strings;import com.google.common.collect.Sets;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.beans.factory.config.BeanExpressionContext;import org.springframework.beans.factory.config.ConfigurableBeanFactory;import org.springframework.beans.factory.config.Scope;import org.springframework.util.StringUtils;import java.util.Set;import java.util.Stack;public class PlaceholderHelper {  private static final String PLACEHOLDER_PREFIX = "${";  private static final String PLACEHOLDER_SUFFIX = "}";  private static final String VALUE_SEPARATOR = ":";  private static final String SIMPLE_PLACEHOLDER_PREFIX = "{";  private static final String EXPRESSION_PREFIX = "#{";  private static final String EXPRESSION_SUFFIX = "}";    public Object resolvePropertyValue(ConfigurableBeanFactory beanFactory, String beanName, String placeholder) {    // resolve string value    String strVal = beanFactory.resolveEmbeddedValue(placeholder);    BeanDefinition bd = (beanFactory.containsBean(beanName) ? beanFactory        .getMergedBeanDefinition(beanName) : null);    // resolve expressions like "#{systemProperties.myProp}"    return evaluateBeanDefinitionString(beanFactory, strVal, bd);  }  private Object evaluateBeanDefinitionString(ConfigurableBeanFactory beanFactory, String value,                                              BeanDefinition beanDefinition) {    if (beanFactory.getBeanExpressionResolver() == null) {      return value;    }    Scope scope = (beanDefinition != null ? beanFactory        .getRegisteredScope(beanDefinition.getScope()) : null);    return beanFactory.getBeanExpressionResolver()        .evaluate(value, new BeanExpressionContext(beanFactory, scope));  }    public Set<String> extractPlaceholderKeys(String propertyString) {    Set<String> placeholderKeys = Sets.newHashSet();    if (!isNormalizedPlaceholder(propertyString) && !isExpressionWithPlaceholder(propertyString)) {      return placeholderKeys;    }    Stack<String> stack = new Stack<>();    stack.push(propertyString);    while (!stack.isEmpty()) {      String strVal = stack.pop();      int startIndex = strVal.indexOf(PLACEHOLDER_PREFIX);      if (startIndex == -1) {        placeholderKeys.add(strVal);        continue;      }      int endIndex = findPlaceholderEndIndex(strVal, startIndex);      if (endIndex == -1) {        // invalid placeholder?        continue;      }      String placeholderCandidate = strVal.substring(startIndex + PLACEHOLDER_PREFIX.length(), endIndex);      // ${some.key:other.key}      if (placeholderCandidate.startsWith(PLACEHOLDER_PREFIX)) {        stack.push(placeholderCandidate);      } else {        // some.key:${some.other.key:100}        int separatorIndex = placeholderCandidate.indexOf(VALUE_SEPARATOR);        if (separatorIndex == -1) {          stack.push(placeholderCandidate);        } else {          stack.push(placeholderCandidate.substring(0, separatorIndex));          String defaultValuePart =              normalizeToPlaceholder(placeholderCandidate.substring(separatorIndex + VALUE_SEPARATOR.length()));          if (!Strings.isNullOrEmpty(defaultValuePart)) {            stack.push(defaultValuePart);          }        }      }      // has remaining part, e.g. ${a}.${b}      if (endIndex + PLACEHOLDER_SUFFIX.length() < strVal.length() - 1) {        String remainingPart = normalizeToPlaceholder(strVal.substring(endIndex + PLACEHOLDER_SUFFIX.length()));        if (!Strings.isNullOrEmpty(remainingPart)) {          stack.push(remainingPart);        }      }    }    return placeholderKeys;  }  private boolean isNormalizedPlaceholder(String propertyString) {    return propertyString.startsWith(PLACEHOLDER_PREFIX) && propertyString.endsWith(PLACEHOLDER_SUFFIX);  }  private boolean isExpressionWithPlaceholder(String propertyString) {    return propertyString.startsWith(EXPRESSION_PREFIX) && propertyString.endsWith(EXPRESSION_SUFFIX)        && propertyString.contains(PLACEHOLDER_PREFIX);  }  private String normalizeToPlaceholder(String strVal) {    int startIndex = strVal.indexOf(PLACEHOLDER_PREFIX);    if (startIndex == -1) {      return null;    }    int endIndex = strVal.lastIndexOf(PLACEHOLDER_SUFFIX);    if (endIndex == -1) {      return null;    }    return strVal.substring(startIndex, endIndex + PLACEHOLDER_SUFFIX.length());  }  private int findPlaceholderEndIndex(CharSequence buf, int startIndex) {    int index = startIndex + PLACEHOLDER_PREFIX.length();    int withinNestedPlaceholder = 0;    while (index < buf.length()) {      if (StringUtils.substringMatch(buf, index, PLACEHOLDER_SUFFIX)) {        if (withinNestedPlaceholder > 0) {          withinNestedPlaceholder--;          index = index + PLACEHOLDER_SUFFIX.length();        } else {          return index;        }      } else if (StringUtils.substringMatch(buf, index, SIMPLE_PLACEHOLDER_PREFIX)) {        withinNestedPlaceholder++;        index = index + SIMPLE_PLACEHOLDER_PREFIX.length();      } else {        index++;      }    }    return -1;  }}

package com.allen.apollo;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Value;import org.springframework.util.StringUtils;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import java.lang.reflect.InvocationTargetException;@RestController@Slf4jpublic class SpringValueController {    @Value("${test:123}")    public String zax;    @Value("${test:123}")    public String test;    @Value(("${zed:zed}"))    public String zed;    @GetMapping("/test")    public String test(String a, String b) {        if (!StringUtils.isEmpty(a)) {            try {                for (SpringValue springValue : SpringValueCacheMap.map.get("test")) {                    springValue.update(a);                }                for (SpringValue springValue : SpringValueCacheMap.map.get("zed")) {                    springValue.update(b);                }            } catch (IllegalAccessException | InvocationTargetException e) {                e.printStackTrace();            }        }        return String.format("test: %s, zax: %s, zed: %s", test, zax, zed);    }}

到此，关于“SpringBoot2动态@Value的实现方法”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程网网站，小编会继续努力为大家带来更多实用的文章！