13518219792
网站建设资讯

NEWS

网站建设资讯

SpringBoot2动态@Value怎么实现

本篇内容介绍了“SpringBoot2动态@Value怎么实现”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：空间域名、虚拟主机、营销软件、网站建设、射阳网站维护、网站推广。

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

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

2.动态修改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;
@Configuration
public 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 fields = findAllField(obj);
            for (Field field : fields) {
                Value value = field.getAnnotation(Value.class);
                if (value != null) {
                    Set 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 findAllField(Class clazz) {
        final List 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当中，下面看一下测试代码

  /**
   * cache  field,存储bean 字段
   */
package com.allen.apollo;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Multimap;
public class SpringValueCacheMap {
    public static final Multimap 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 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;
/**
 * Placeholder helper functions.
 */
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 = "}";
  /**
   * Resolve placeholder property values, e.g.
   * 
   * 
   * "${somePropertyValue}" -> "the actual property value"
   */
  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));
  }
  /**
   * Extract keys from placeholder, e.g.
   * 
    
   * 
  • ${some.key} => "some.key"
    • 
   * 
  • ${some.key:${some.other.key:100}} => "some.key", "some.other.key"
    • 
   * 
  • ${${some.key}} => "some.key"
    • 
   * 
  • ${${some.key:other.key}} => "some.key"
    • 
   * 
  • ${${some.key}:${another.key}} => "some.key", "another.key"
    • 
   * 
  • #{new java.text.SimpleDateFormat("${some.key}").parse("${another.key}")} => "some.key", "another.key"
    • 
   * 

   */
  public Set extractPlaceholderKeys(String propertyString) {
    Set placeholderKeys = Sets.newHashSet();
    if (!isNormalizedPlaceholder(propertyString) && !isExpressionWithPlaceholder(propertyString)) {
      return placeholderKeys;
    }
    Stack 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
@Slf4j
public 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怎么实现”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！
            
            
                        

            网站题目：SpringBoot2动态@Value怎么实现            

            分享地址：http://cdweb.net/article/jcpejh.html
        
    
    

        
其他资讯