背景

前面我们描述了spring profile和maven profile的异同maven profile VS spring profile

通常意义上我们说的配置一般都是properties文件，但是spring支持yml【结构程度更好】

EnableConfigurationProperties

原先我们在使用Spring时更多的是使用value注解进行注入，但是对于比较多的属性的情况下

也只能一味的进行复制拷贝

Spring支持了EnableConfigurationProperties 

/**  * Enable support for {@link ConfigurationProperties} annotated beans.  * {@link ConfigurationProperties} beans can be registered in the standard way (for  * example using {@link Bean @Bean} methods) or, for convenience, can be specified  * directly on this annotation.  *  * @author Dave Syer  */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(EnableConfigurationPropertiesImportSelector.class) public @interface EnableConfigurationProperties {      /**     * Convenient way to quickly register {@link ConfigurationProperties} annotated beans     * with Spring. Standard Spring Beans will also be scanned regardless of this value.     * @return {@link ConfigurationProperties} annotated beans to register     */    Class<?>[] value() default {};   }

对于EnableConfigurationProperties import  EnableConfigurationPropertiesImportSelector

该selector做了如下操作

class EnableConfigurationPropertiesImportSelector implements ImportSelector {      @Override    public String[] selectImports(AnnotationMetadata metadata) {       MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(             EnableConfigurationProperties.class.getName(), false);       Object[] type = attributes == null ? null             : (Object[]) attributes.getFirst("value");       if (type == null || type.length == 0) {          return new String[] {                ConfigurationPropertiesBindingPostProcessorRegistrar.class                      .getName() };       }       return new String[] { ConfigurationPropertiesBeanRegistrar.class.getName(),             ConfigurationPropertiesBindingPostProcessorRegistrar.class.getName() };    }      /**     * {@link ImportBeanDefinitionRegistrar} for configuration properties support.     */    public static class ConfigurationPropertiesBeanRegistrar          implements ImportBeanDefinitionRegistrar {         @Override       public void registerBeanDefinitions(AnnotationMetadata metadata,             BeanDefinitionRegistry registry) {          MultiValueMap<String, Object> attributes = metadata                .getAllAnnotationAttributes(                      EnableConfigurationProperties.class.getName(), false);          List<Class<?>> types = collectClasses(attributes.get("value"));          for (Class<?> type : types) {             String prefix = extractPrefix(type);             String name = (StringUtils.hasText(prefix) ? prefix + "-" + type.getName()                   : type.getName());             if (!registry.containsBeanDefinition(name)) {                registerBeanDefinition(registry, type, name);             }          }       }         private String extractPrefix(Class<?> type) {          ConfigurationProperties annotation = AnnotationUtils.findAnnotation(type,                ConfigurationProperties.class);          if (annotation != null) {             return annotation.prefix();          }          return "";       }         private List<Class<?>> collectClasses(List<Object> list) {          ArrayList<Class<?>> result = new ArrayList<Class<?>>();          for (Object object : list) {             for (Object value : (Object[]) object) {                if (value instanceof Class && value != void.class) {                   result.add((Class<?>) value);                }             }          }          return result;       }         private void registerBeanDefinition(BeanDefinitionRegistry registry,             Class<?> type, String name) {          BeanDefinitionBuilder builder = BeanDefinitionBuilder                .genericBeanDefinition(type);          AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();          registry.registerBeanDefinition(name, beanDefinition);            ConfigurationProperties properties = AnnotationUtils.findAnnotation(type,                ConfigurationProperties.class);          Assert.notNull(properties,                "No " + ConfigurationProperties.class.getSimpleName()                      + " annotation found on  '" + type.getName() + "'.");       }      }   } 而事实上的处理位置在  @SuppressWarnings("deprecation") private void postProcessBeforeInitialization(Object bean, String beanName,       ConfigurationProperties annotation) {    Object target = bean;    PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(          target);    factory.setPropertySources(this.propertySources);    factory.setValidator(determineValidator(bean));    // If no explicit conversion service is provided we add one so that (at least)    // comma-separated arrays of convertibles can be bound automatically    factory.setConversionService(this.conversionService == null          ? getDefaultConversionService() : this.conversionService);    if (annotation != null) {       factory.setIgnoreInvalidFields(annotation.ignoreInvalidFields());       factory.setIgnoreUnknownFields(annotation.ignoreUnknownFields());       factory.setExceptionIfInvalid(annotation.exceptionIfInvalid());       factory.setIgnoreNestedProperties(annotation.ignoreNestedProperties());       if (StringUtils.hasLength(annotation.prefix())) {          factory.setTargetName(annotation.prefix());       }    }    try {       factory.bindPropertiesToTarget();    }    catch (Exception ex) {       String targetClass = ClassUtils.getShortName(target.getClass());       throw new BeanCreationException(beanName, "Could not bind properties to "             + targetClass + " (" + getAnnotationDetails(annotation) + ")", ex);    } }

可以看到prefix会被设置到targetname中 而targetname将会被包装秤Releaxedname

private Iterable<String> getRelaxedTargetNames() {    return (this.target != null && StringUtils.hasLength(this.targetName)          ? new RelaxedNames(this.targetName) : null); }

而relaxedname如下

/**  * Create a new {@link RelaxedNames} instance.  * @param name the source name. For the maximum number of variations specify the name  * using dashed notation (e.g. {@literal my-property-name}  */ public RelaxedNames(String name) {    this.name = (name == null ? "" : name);    initialize(RelaxedNames.this.name, this.values); }   @Override public Iterator<String> iterator() {    return this.values.iterator(); }   private void initialize(String name, Set<String> values) {    if (values.contains(name)) {       return;    }    for (Variation variation : Variation.values()) {       for (Manipulation manipulation : Manipulation.values()) {          String result = name;          result = manipulation.apply(result);          result = variation.apply(result);          values.add(result);          initialize(result, values);       }    } }

将会包装成多个【大小写 驼峰等等】望文生义

总之通过各种异形的名称来在属性文件中获取到设置的值

下面和以前Spring3一样通过setPropertyValue来设置对应的值。

PropertySource

其中有一个random特别引起了开发者的欢迎。

比如可以如下定义

my:   secret:     password: ${random.value}     intValue: ${random.int}     intValueRange: ${random.int[1,99]}     longValue: ${random.long}     longValueRange: ${random.long[111111111111,999999999999]}     uuid: ${random.uuid}

来查看

/**  * {@link PropertySource} that returns a random value for any property that starts with  * {@literal "random."}. Where the "unqualified property name" is the portion of the  * requested property name beyond the "random." prefix, this {@link PropertySource}  * returns:  * <ul>  * <li>When {@literal "int"}, a random {@link Integer} value, restricted by an optionally  * specified range.</li>  * <li>When {@literal "long"}, a random {@link Long} value, restricted by an optionally  * specified range.</li>  * <li>Otherwise, a {@code byte[]}.</li>  * </ul>  * The {@literal "random.int"} and {@literal "random.long"} properties supports a range  * suffix whose syntax is:  * <p>  * {@code OPEN value (,max) CLOSE} where the {@code OPEN,CLOSE} are any character and  * {@code value,max} are integers. If {@code max} is provided then {@code value} is the  * minimum value and {@code max} is the maximum (exclusive).  *  * @author Dave Syer  * @author Matt Benson  */ public class RandomValuePropertySource extends PropertySource<Random> {      /**     * Name of the random {@link PropertySource}.     */    public static final String RANDOM_PROPERTY_SOURCE_NAME = "random";      private static final String PREFIX = "random.";      private static final Log logger = LogFactory.getLog(RandomValuePropertySource.class);      public RandomValuePropertySource(String name) {       super(name, new Random());    }      public RandomValuePropertySource() {       this(RANDOM_PROPERTY_SOURCE_NAME);    }      @Override    public Object getProperty(String name) {       if (!name.startsWith(PREFIX)) {          return null;       }       if (logger.isTraceEnabled()) {          logger.trace("Generating random property for '" + name + "'");       }       return getRandomValue(name.substring(PREFIX.length()));    }      private Object getRandomValue(String type) {       if (type.equals("int")) {          return getSource().nextInt();       }       if (type.equals("long")) {          return getSource().nextLong();       }       String range = getRange(type, "int");       if (range != null) {          return getNextIntInRange(range);       }       range = getRange(type, "long");       if (range != null) {          return getNextLongInRange(range);       }       if (type.equals("uuid")) {          return UUID.randomUUID().toString();       }       return getRandomBytes();    }      private String getRange(String type, String prefix) {       if (type.startsWith(prefix)) {          int startIndex = prefix.length() + 1;          if (type.length() > startIndex) {             return type.substring(startIndex, type.length() - 1);          }       }       return null;    }      private int getNextIntInRange(String range) {       String[] tokens = StringUtils.commaDelimitedListToStringArray(range);       int start = Integer.parseInt(tokens[0]);       if (tokens.length == 1) {          return getSource().nextInt(start);       }       return start + getSource().nextInt(Integer.parseInt(tokens[1]) - start);    }      private long getNextLongInRange(String range) {       String[] tokens = StringUtils.commaDelimitedListToStringArray(range);       if (tokens.length == 1) {          return Math.abs(getSource().nextLong() % Long.parseLong(tokens[0]));       }       long lowerBound = Long.parseLong(tokens[0]);       long upperBound = Long.parseLong(tokens[1]) - lowerBound;       return lowerBound + Math.abs(getSource().nextLong() % upperBound);    }      private Object getRandomBytes() {       byte[] bytes = new byte[32];       getSource().nextBytes(bytes);       return DigestUtils.md5DigestAsHex(bytes);    }      public static void addToEnvironment(ConfigurableEnvironment environment) {       environment.getPropertySources().addAfter(             StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,             new RandomValuePropertySource(RANDOM_PROPERTY_SOURCE_NAME));       logger.trace("RandomValuePropertySource add to Environment");    }   }

非常有意思

properties 加载顺序

至于实现profile的关键 

spring 解析对应properties通过 PropertySourcesPropertyResolver

protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {    if (this.propertySources != null) {       for (PropertySource<?> propertySource : this.propertySources) {          if (logger.isTraceEnabled()) {             logger.trace("Searching for key '" + key + "' in PropertySource '" +                   propertySource.getName() + "'");          }          Object value = propertySource.getProperty(key);          if (value != null) {             if (resolveNestedPlaceholders && value instanceof String) {                value = resolveNestedPlaceholders((String) value);             }             logKeyFound(key, propertySource, value);             return convertValueIfNecessary(value, targetValueType);          }       }    }    if (logger.isDebugEnabled()) {       logger.debug("Could not find key '" + key + "' in any property source");    }    return null; }

可以看出propertySources的顺序非常影响对应注入的参数【当查找到第一个符合条件的结果后就返回了】

那么我们最经常用的在Jvm参数中 -Dspring.active.profile=dev 

关于JVM参数中-D

-D<name>=<value> set a system property  设置系统属性。

这样相当于在environment中设置了spring.active.profile

因此部分小伙伴碰到在properties定义属性为

user.name发现无法生效【这是因为在系统中已经存在比properties优先级更高的系统环境变量】

如何确认propertySource的优先级顺序呢？

SpringBoot在启动时或默认配置如下

/**  * Add, remove or re-order any {@link PropertySource}s in this application's  * environment.  * @param environment this application's environment  * @param args arguments passed to the {@code run} method  * @see #configureEnvironment(ConfigurableEnvironment, String[])  */ protected void configurePropertySources(ConfigurableEnvironment environment,       String[] args) {    MutablePropertySources sources = environment.getPropertySources();    if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {       sources.addLast(             new MapPropertySource("defaultProperties", this.defaultProperties));    }    if (this.addCommandLineProperties && args.length > 0) {       String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;       if (sources.contains(name)) {          PropertySource<?> source = sources.get(name);          CompositePropertySource composite = new CompositePropertySource(name);          composite.addPropertySource(new SimpleCommandLinePropertySource(                name + "-" + args.hashCode(), args));          composite.addPropertySource(source);          sources.replace(name, composite);       }       else {          sources.addFirst(new SimpleCommandLinePropertySource(args));       }    } }

可以看到我们可以设置默认defaultProperties 如果存在将会设置到最后

但是对于java调用参数【如果存在】来说默认会将其放入第一位

对于标准环境来说Spring默认也会调用如下方法

/**  * Create a new {@code Environment} instance, calling back to  * {@link #customizePropertySources(MutablePropertySources)} during construction to  * allow subclasses to contribute or manipulate {@link PropertySource} instances as  * appropriate.  * @see #customizePropertySources(MutablePropertySources)  */ public AbstractEnvironment() {    customizePropertySources(this.propertySources);    if (logger.isDebugEnabled()) {       logger.debug("Initialized " + getClass().getSimpleName() + " with PropertySources " + this.propertySources);    } } /**  * Customize the set of property sources with those appropriate for any standard  * Java environment:  * <ul>  * <li>{@value #SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME}  * <li>{@value #SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME}  * </ul>  * <p>Properties present in {@value #SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME} will  * take precedence over those in {@value #SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME}.  * @see AbstractEnvironment#customizePropertySources(MutablePropertySources)  * @see #getSystemProperties()  * @see #getSystemEnvironment()  */ @Override protected void customizePropertySources(MutablePropertySources propertySources) {    propertySources.addLast(new MapPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));    propertySources.addLast(new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment())); }

因此将会放入对应的propertySource【在做Environment的构造函数时】因此在创建完成时 

SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME

SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME

分别出现在properties前两位【直到放入commandArgument】

对于servlet容器

/**  * Customize the set of property sources with those contributed by superclasses as  * well as those appropriate for standard servlet-based environments:  * <ul>  * <li>{@value #SERVLET_CONFIG_PROPERTY_SOURCE_NAME}  * <li>{@value #SERVLET_CONTEXT_PROPERTY_SOURCE_NAME}  * <li>{@value #JNDI_PROPERTY_SOURCE_NAME}  * </ul>  * <p>Properties present in {@value #SERVLET_CONFIG_PROPERTY_SOURCE_NAME} will  * take precedence over those in {@value #SERVLET_CONTEXT_PROPERTY_SOURCE_NAME}, and  * properties found in either of the above take precedence over those found in  * {@value #JNDI_PROPERTY_SOURCE_NAME}.  * <p>Properties in any of the above will take precedence over system properties and  * environment variables contributed by the {@link StandardEnvironment} superclass.  * <p>The {@code Servlet}-related property sources are added as  * {@link StubPropertySource stubs} at this stage, and will be  * {@linkplain #initPropertySources(ServletContext, ServletConfig) fully initialized}  * once the actual {@link ServletContext} object becomes available.  * @see StandardEnvironment#customizePropertySources  * @see org.springframework.core.env.AbstractEnvironment#customizePropertySources  * @see ServletConfigPropertySource  * @see ServletContextPropertySource  * @see org.springframework.jndi.JndiPropertySource  * @see org.springframework.context.support.AbstractApplicationContext#initPropertySources  * @see #initPropertySources(ServletContext, ServletConfig)  */ @Override protected void customizePropertySources(MutablePropertySources propertySources) {    propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));    propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));    if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {       propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));    }    super.customizePropertySources(propertySources); }

SERVLET_CONTEXT_PROPERTY_SOURCE_NAME 也会出现在properties的前列【即web.xml中配置选项】

因此可以得出结论

commandLineArgs>servletContextInitParams>servletContextInitParams>jndiProperties>systemProperties>systemEnvironment>properties>defaultProperties

至于小伙伴认为为啥会defaultProperties排在最后

private void addConfigurationProperties(       ConfigurationPropertySources configurationSources) {    MutablePropertySources existingSources = this.environment          .getPropertySources();    if (existingSources.contains(DEFAULT_PROPERTIES)) {       existingSources.addBefore(DEFAULT_PROPERTIES, configurationSources);    }    else {       existingSources.addLast(configurationSources);    } }