Skip to content

S
spring-boot
Commit 1d83e87b authored by Phillip Webb's avatar Phillip Webb
Browse files
Options

Validate @ConfigurationProperties on @Bean methods 

Refactor `ConfigurationPropertiesBindingPostProcessor` to allow JSR-303
validation on `@ConfigurationProperties` defined at the `@Bean` method
level.

JSR-303 validation is now applied when a JSR-303 implementation is
available and `@Validated` is present on either the configuration
properties class itself or the `@Bean` method that creates it.

Standard Spring validation is also supported using a validator bean
named `configurationPropertiesValidator`, or by having the configuration
properties implement `Validator`.

The commit also consolidates tests into a single location.

Fixes gh-10803
parent 9e75680e
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 2126 additions and 2403 deletions
spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc
View file @ 1d83e87b
...@@ -1213,9 +1213,13 @@ to your fields, as shown in the following example: ...@@ -1213,9 +1213,13 @@ to your fields, as shown in the following example:
} }
---- ----
In order to validate the values of nested properties, you must annotate the associated TIP: You can also trigger validation by annotating the `@Bean` method that creates the
field as `@Valid` to trigger its validation. The following example builds on the configuration properties with `@Validated`.
preceding `AcmeProperties` example:
Although nested properties will also be validated when bound, it's good practice to
also annotate the associated field as `@Valid`. This ensure that validation is triggered
even if no nested properties are found. The following example builds on the preceding
`AcmeProperties` example:
[source,java,indent=0] [source,java,indent=0]
---- ----
......
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationBeanFactoryMetadata.java
View file @ 1d83e87b
...@@ -39,6 +39,12 @@ import org.springframework.util.ReflectionUtils; ...@@ -39,6 +39,12 @@ import org.springframework.util.ReflectionUtils;
*/ */
public class ConfigurationBeanFactoryMetadata implements BeanFactoryPostProcessor { public class ConfigurationBeanFactoryMetadata implements BeanFactoryPostProcessor {
/**
* The bean name that this class is registered with.
*/
public static final String BEAN_NAME = ConfigurationBeanFactoryMetadata.class
.getName();
private ConfigurableListableBeanFactory beanFactory; private ConfigurableListableBeanFactory beanFactory;
private final Map<String, FactoryMetadata> beansFactoryMetadata = new HashMap<>(); private final Map<String, FactoryMetadata> beansFactoryMetadata = new HashMap<>();
......
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesBindingException.java → spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesBindException.java
View file @ 1d83e87b
/* /*
* Copyright 2012-2017 the original author or authors. * Copyright 2012-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
...@@ -16,26 +16,54 @@ ...@@ -16,26 +16,54 @@
package org.springframework.boot.context.properties; package org.springframework.boot.context.properties;
import org.springframework.core.NestedExceptionUtils; import org.springframework.beans.factory.BeanCreationException;
import org.springframework.util.ClassUtils;
/** /**
* Exception thrown when a {@code @ConfigurationProperties} annotated object failed to be * Exception thrown when {@link ConfigurationProperties @ConfigurationProperties} binding
* bound. * fails.
* *
* @author Phillip Webb
* @author Stephane Nicoll * @author Stephane Nicoll
* @since 2.0.0
*/ */
class ConfigurationPropertiesBindingException extends RuntimeException { public class ConfigurationPropertiesBindException extends BeanCreationException {
ConfigurationPropertiesBindingException(String message, Throwable cause) { private final Class<?> beanType;
super(message, cause);
private final ConfigurationProperties annotation;
ConfigurationPropertiesBindException(String beanName, Object bean,
ConfigurationProperties annotation, Exception cause) {
super(beanName, getMessage(bean, annotation), cause);
this.beanType = bean.getClass();
this.annotation = annotation;
}
/**
* Return the bean type that was being bound.
* @return the bean type
*/
public Class<?> getBeanType() {
return this.beanType;
} }
/** /**
* Retrieve the innermost cause of this exception, if any. * Return the configuration properties annotation that triggered the binding.
* @return the innermost exception, or {@code null} if none * @return the configuration properties annotation
*/ */
public Throwable getRootCause() { public ConfigurationProperties getAnnotation() {
return NestedExceptionUtils.getRootCause(this); return this.annotation;
}
private static String getMessage(Object bean, ConfigurationProperties annotation) {
StringBuilder message = new StringBuilder();
message.append("Could not bind properties to '"
+ ClassUtils.getShortName(bean.getClass()) + "' : ");
message.append("prefix=").append(annotation.prefix());
message.append(", ignoreInvalidFields=").append(annotation.ignoreInvalidFields());
message.append(", ignoreUnknownFields=").append(annotation.ignoreUnknownFields());
return message.toString();
} }
} }
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesBinder.java
View file @ 1d83e87b
...@@ -16,6 +16,9 @@ ...@@ -16,6 +16,9 @@
package org.springframework.boot.context.properties; package org.springframework.boot.context.properties;
import java.util.ArrayList;
import java.util.List;
import org.springframework.boot.context.properties.bind.BindHandler; import org.springframework.boot.context.properties.bind.BindHandler;
import org.springframework.boot.context.properties.bind.Bindable; import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder; import org.springframework.boot.context.properties.bind.Binder;
...@@ -23,86 +26,78 @@ import org.springframework.boot.context.properties.bind.PropertySourcesPlacehold ...@@ -23,86 +26,78 @@ import org.springframework.boot.context.properties.bind.PropertySourcesPlacehold
import org.springframework.boot.context.properties.bind.handler.IgnoreErrorsBindHandler; import org.springframework.boot.context.properties.bind.handler.IgnoreErrorsBindHandler;
import org.springframework.boot.context.properties.bind.handler.NoUnboundElementsBindHandler; import org.springframework.boot.context.properties.bind.handler.NoUnboundElementsBindHandler;
import org.springframework.boot.context.properties.bind.validation.ValidationBindHandler; import org.springframework.boot.context.properties.bind.validation.ValidationBindHandler;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.ConfigurationPropertySources; import org.springframework.boot.context.properties.source.ConfigurationPropertySources;
import org.springframework.boot.context.properties.source.UnboundElementsSourceFilter; import org.springframework.boot.context.properties.source.UnboundElementsSourceFilter;
import org.springframework.core.ResolvableType; import org.springframework.context.ApplicationContext;
import org.springframework.core.convert.ConversionService; import org.springframework.core.env.PropertySources;
import org.springframework.core.env.PropertySource;
import org.springframework.util.Assert; import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator; import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
/** /**
* Bind {@link ConfigurationProperties} annotated object from a configurable list of * Internal class by the {@link ConfigurationPropertiesBindingPostProcessor} to handle the
* {@link PropertySource}. * actual {@link ConfigurationProperties} binding.
* *
* @author Stephane Nicoll * @author Stephane Nicoll
* @author Phillip Webb
*/ */
class ConfigurationPropertiesBinder { class ConfigurationPropertiesBinder {
private final Iterable<PropertySource<?>> propertySources; private final ApplicationContext applicationContext;
private final ConversionService conversionService; private final PropertySources propertySources;
private final Validator validator; private final Validator configurationPropertiesValidator;
private Iterable<ConfigurationPropertySource> configurationSources; private final Validator jsr303Validator;
private final Binder binder; private volatile Binder binder;
ConfigurationPropertiesBinder(Iterable<PropertySource<?>> propertySources, ConfigurationPropertiesBinder(ApplicationContext applicationContext,
ConversionService conversionService, Validator validator) { String validatorBeanName) {
Assert.notNull(propertySources, "PropertySources must not be null"); this.applicationContext = applicationContext;
this.propertySources = propertySources; this.propertySources = new PropertySourcesDeducer(applicationContext)
this.conversionService = conversionService; .getPropertySources();
this.validator = validator; this.configurationPropertiesValidator = getConfigurationPropertiesValidator(
this.configurationSources = ConfigurationPropertySources.from(propertySources); applicationContext, validatorBeanName);
this.binder = new Binder(this.configurationSources, this.jsr303Validator = ConfigurationPropertiesJsr303Validator
new PropertySourcesPlaceholdersResolver(this.propertySources), .getIfJsr303Present(applicationContext);
this.conversionService); }
public void bind(Bindable<?> target) {
ConfigurationProperties annotation = target
.getAnnotation(ConfigurationProperties.class);
Assert.state(annotation != null, "Missing @ConfigurationProperties on " + target);
List<Validator> validators = getValidators(target);
BindHandler bindHandler = getBindHandler(annotation, validators);
getBinder().bind(annotation.prefix(), target, bindHandler);
} }
/** private Validator getConfigurationPropertiesValidator(
* Bind the specified {@code target} object using the configuration defined by the ApplicationContext applicationContext, String validatorBeanName) {
* specified {@code annotation}. if (applicationContext.containsBean(validatorBeanName)) {
* @param target the target to bind the configuration property sources to return applicationContext.getBean(validatorBeanName, Validator.class);
* @param annotation the binding configuration
* @param targetType the resolvable type for the target
* @throws ConfigurationPropertiesBindingException if the binding failed
*/
void bind(Object target, ConfigurationProperties annotation,
ResolvableType targetType) {
Validator validator = determineValidator(target);
BindHandler handler = getBindHandler(annotation, validator);
Bindable<?> bindable = Bindable.of(targetType).withExistingValue(target);
try {
this.binder.bind(annotation.prefix(), bindable, handler);
}
catch (Exception ex) {
String message = "Could not bind properties to '"
+ ClassUtils.getShortName(target.getClass()) + "': "
+ getAnnotationDetails(annotation);
throw new ConfigurationPropertiesBindingException(message, ex);
} }
return null;
} }
private Validator determineValidator(Object bean) { private List<Validator> getValidators(Bindable<?> target) {
boolean supportsBean = (this.validator != null List<Validator> validators = new ArrayList<>(3);
&& this.validator.supports(bean.getClass())); if (this.configurationPropertiesValidator != null) {
if (ClassUtils.isAssignable(Validator.class, bean.getClass())) { validators.add(this.configurationPropertiesValidator);
if (supportsBean) { }
return new ChainingValidator(this.validator, (Validator) bean); if (this.jsr303Validator != null
} && target.getAnnotation(Validated.class) != null) {
return (Validator) bean; validators.add(this.jsr303Validator);
} }
return (supportsBean ? this.validator : null); if (target.getValue() != null && target.getValue().get() instanceof Validator) {
validators.add((Validator) target.getValue().get());
}
return validators;
} }
private BindHandler getBindHandler(ConfigurationProperties annotation, private BindHandler getBindHandler(ConfigurationProperties annotation,
Validator validator) { List<Validator> validators) {
BindHandler handler = BindHandler.DEFAULT; BindHandler handler = BindHandler.DEFAULT;
if (annotation.ignoreInvalidFields()) { if (annotation.ignoreInvalidFields()) {
handler = new IgnoreErrorsBindHandler(handler); handler = new IgnoreErrorsBindHandler(handler);
...@@ -111,55 +106,22 @@ class ConfigurationPropertiesBinder { ...@@ -111,55 +106,22 @@ class ConfigurationPropertiesBinder {
UnboundElementsSourceFilter filter = new UnboundElementsSourceFilter(); UnboundElementsSourceFilter filter = new UnboundElementsSourceFilter();
handler = new NoUnboundElementsBindHandler(handler, filter); handler = new NoUnboundElementsBindHandler(handler, filter);
} }
if (validator != null) { if (!validators.isEmpty()) {
handler = new ValidationBindHandler(handler, validator); handler = new ValidationBindHandler(handler,
validators.toArray(new Validator[validators.size()]));
} }
return handler; return handler;
} }
private String getAnnotationDetails(ConfigurationProperties annotation) { private Binder getBinder() {
if (annotation == null) { if (this.binder == null) {
return ""; this.binder = new Binder(
ConfigurationPropertySources.from(this.propertySources),
new PropertySourcesPlaceholdersResolver(this.propertySources),
new ConversionServiceDeducer(this.applicationContext)
.getConversionService());
} }
StringBuilder details = new StringBuilder(); return this.binder;
details.append("prefix=").append(annotation.prefix());
details.append(", ignoreInvalidFields=").append(annotation.ignoreInvalidFields());
details.append(", ignoreUnknownFields=").append(annotation.ignoreUnknownFields());
return details.toString();
}
/**
* {@link Validator} implementation that wraps {@link Validator} instances and chains
* their execution.
*/
private static class ChainingValidator implements Validator {
private final Validator[] validators;
ChainingValidator(Validator... validators) {
Assert.notNull(validators, "Validators must not be null");
this.validators = validators;
}
@Override
public boolean supports(Class<?> clazz) {
for (Validator validator : this.validators) {
if (validator.supports(clazz)) {
return true;
}
}
return false;
}
@Override
public void validate(Object target, Errors errors) {
for (Validator validator : this.validators) {
if (validator.supports(target.getClass())) {
validator.validate(target, errors);
}
}
}
} }
} }
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesBindingPostProcessor.java
View file @ 1d83e87b
...@@ -16,32 +16,21 @@ ...@@ -16,32 +16,21 @@
package org.springframework.boot.context.properties; package org.springframework.boot.context.properties;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException; import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware; import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.Ordered; import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered; import org.springframework.core.PriorityOrdered;
import org.springframework.core.ResolvableType; import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotationUtils; import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.env.PropertySources; import org.springframework.core.env.PropertySources;
import org.springframework.core.env.StandardEnvironment; import org.springframework.validation.annotation.Validated;
/** /**
* {@link BeanPostProcessor} to bind {@link PropertySources} to beans annotated with * {@link BeanPostProcessor} to bind {@link PropertySources} to beans annotated with
...@@ -53,156 +42,90 @@ import org.springframework.core.env.StandardEnvironment; ...@@ -53,156 +42,90 @@ import org.springframework.core.env.StandardEnvironment;
* @author Stephane Nicoll * @author Stephane Nicoll
* @author Madhura Bhave * @author Madhura Bhave
*/ */
public class ConfigurationPropertiesBindingPostProcessor public class ConfigurationPropertiesBindingPostProcessor implements BeanPostProcessor,
implements BeanPostProcessor, BeanFactoryAware, EnvironmentAware, PriorityOrdered, ApplicationContextAware, InitializingBean {
ApplicationContextAware, InitializingBean, PriorityOrdered {
/**
* The bean name that this post-processor is registered with.
*/
public static final String BEAN_NAME = ConfigurationPropertiesBindingPostProcessor.class
.getName();
/** /**
* The bean name of the configuration properties validator. * The bean name of the configuration properties validator.
*/ */
public static final String VALIDATOR_BEAN_NAME = "configurationPropertiesValidator"; public static final String VALIDATOR_BEAN_NAME = "configurationPropertiesValidator";
private static final Log logger = LogFactory private ConfigurationBeanFactoryMetadata beanFactoryMetadata;
.getLog(ConfigurationPropertiesBindingPostProcessor.class);
private ConfigurationBeanFactoryMetadata beans = new ConfigurationBeanFactoryMetadata();
private BeanFactory beanFactory;
private Environment environment = new StandardEnvironment();
private ApplicationContext applicationContext; private ApplicationContext applicationContext;
private ConfigurationPropertiesBinder configurationPropertiesBinder; private ConfigurationPropertiesBinder configurationPropertiesBinder;
private PropertySources propertySources;
/**
* Return the order of the bean.
* @return the order
*/
@Override
public int getOrder() {
return Ordered.HIGHEST_PRECEDENCE + 1;
}
/**
* Set the bean meta-data store.
* @param beans the bean meta data store
*/
public void setBeanMetadataStore(ConfigurationBeanFactoryMetadata beans) {
this.beans = beans;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
@Override
public void setEnvironment(Environment environment) {
this.environment = environment;
}
@Override @Override
public void setApplicationContext(ApplicationContext applicationContext) { public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext = applicationContext; this.applicationContext = applicationContext;
} }
@Override @Override
public void afterPropertiesSet() throws Exception { public void afterPropertiesSet() throws Exception {
this.propertySources = deducePropertySources(); // We can't use constructor injection of the application context because
} // it causes eager factory bean initialization
this.beanFactoryMetadata = this.applicationContext.getBean(
private PropertySources deducePropertySources() { ConfigurationBeanFactoryMetadata.BEAN_NAME,
MutablePropertySources environmentPropertySources = extractEnvironmentPropertySources(); ConfigurationBeanFactoryMetadata.class);
PropertySourcesPlaceholderConfigurer configurer = getSinglePropertySourcesPlaceholderConfigurer(); this.configurationPropertiesBinder = new ConfigurationPropertiesBinder(
if (configurer == null) { this.applicationContext, VALIDATOR_BEAN_NAME);
if (environmentPropertySources != null) {
return environmentPropertySources;
}
throw new IllegalStateException("Unable to obtain PropertySources from "
+ "PropertySourcesPlaceholderConfigurer or Environment");
}
PropertySources appliedPropertySources = configurer.getAppliedPropertySources();
if (environmentPropertySources == null) {
return appliedPropertySources;
}
return new CompositePropertySources(new FilteredPropertySources(
appliedPropertySources,
PropertySourcesPlaceholderConfigurer.ENVIRONMENT_PROPERTIES_PROPERTY_SOURCE_NAME),
environmentPropertySources);
} }
private MutablePropertySources extractEnvironmentPropertySources() { @Override
if (this.environment instanceof ConfigurableEnvironment) { public int getOrder() {
return ((ConfigurableEnvironment) this.environment).getPropertySources(); return Ordered.HIGHEST_PRECEDENCE + 1;
}
return null;
}
private PropertySourcesPlaceholderConfigurer getSinglePropertySourcesPlaceholderConfigurer() {
// Take care not to cause early instantiation of all FactoryBeans
if (this.beanFactory instanceof ListableBeanFactory) {
ListableBeanFactory listableBeanFactory = (ListableBeanFactory) this.beanFactory;
Map<String, PropertySourcesPlaceholderConfigurer> beans = listableBeanFactory
.getBeansOfType(PropertySourcesPlaceholderConfigurer.class, false,
false);
if (beans.size() == 1) {
return beans.values().iterator().next();
}
if (beans.size() > 1 && logger.isWarnEnabled()) {
logger.warn("Multiple PropertySourcesPlaceholderConfigurer "
+ "beans registered " + beans.keySet()
+ ", falling back to Environment");
}
}
return null;
} }
@Override @Override
public Object postProcessBeforeInitialization(Object bean, String beanName) public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException { throws BeansException {
ConfigurationProperties annotation = getAnnotation(bean, beanName); ConfigurationProperties annotation = getAnnotation(bean, beanName,
ConfigurationProperties.class);
if (annotation != null) { if (annotation != null) {
try { bind(bean, beanName, annotation);
ResolvableType type = ResolvableType.forClass(bean.getClass());
Method factoryMethod = this.beans.findFactoryMethod(beanName);
if (factoryMethod != null) {
type = ResolvableType.forMethodReturnType(factoryMethod);
}
getBinder().bind(bean, annotation, type);
}
catch (ConfigurationPropertiesBindingException ex) {
throw new BeanCreationException(beanName, ex.getMessage(), ex.getCause());
}
} }
return bean; return bean;
} }
@Override private void bind(Object bean, String beanName, ConfigurationProperties annotation) {
public Object postProcessAfterInitialization(Object bean, String beanName) ResolvableType type = getBeanType(bean, beanName);
throws BeansException { Validated validated = getAnnotation(bean, beanName, Validated.class);
return bean; Annotation[] annotations = (validated == null ? new Annotation[] { annotation }
: new Annotation[] { annotation, validated });
Bindable<?> target = Bindable.of(type).withExistingValue(bean)
.withAnnotations(annotations);
try {
this.configurationPropertiesBinder.bind(target);
}
catch (Exception ex) {
throw new ConfigurationPropertiesBindException(beanName, bean, annotation,
ex);
}
} }
private ConfigurationProperties getAnnotation(Object bean, String beanName) { private ResolvableType getBeanType(Object bean, String beanName) {
ConfigurationProperties annotation = this.beans.findFactoryAnnotation(beanName, Method factoryMethod = this.beanFactoryMetadata.findFactoryMethod(beanName);
ConfigurationProperties.class); if (factoryMethod != null) {
if (annotation == null) { return ResolvableType.forMethodReturnType(factoryMethod);
annotation = AnnotationUtils.findAnnotation(bean.getClass(),
ConfigurationProperties.class);
} }
return annotation; return ResolvableType.forClass(bean.getClass());
} }
private ConfigurationPropertiesBinder getBinder() { private <A extends Annotation> A getAnnotation(Object bean, String beanName,
if (this.configurationPropertiesBinder == null) { Class<A> type) {
this.configurationPropertiesBinder = new ConfigurationPropertiesBinderBuilder( A annotation = this.beanFactoryMetadata.findFactoryAnnotation(beanName, type);
this.applicationContext).withPropertySources(this.propertySources) if (annotation == null) {
.build(); annotation = AnnotationUtils.findAnnotation(bean.getClass(), type);
} }
return this.configurationPropertiesBinder; return annotation;
} }
} }
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesBindingPostProcessorRegistrar.java
View file @ 1d83e87b
...@@ -16,8 +16,9 @@ ...@@ -16,8 +16,9 @@
package org.springframework.boot.context.properties; package org.springframework.boot.context.properties;
import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar; import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata; import org.springframework.core.type.AnnotationMetadata;
...@@ -31,26 +32,33 @@ import org.springframework.core.type.AnnotationMetadata; ...@@ -31,26 +32,33 @@ import org.springframework.core.type.AnnotationMetadata;
public class ConfigurationPropertiesBindingPostProcessorRegistrar public class ConfigurationPropertiesBindingPostProcessorRegistrar
implements ImportBeanDefinitionRegistrar { implements ImportBeanDefinitionRegistrar {
/**
* The bean name of the {@link ConfigurationPropertiesBindingPostProcessor}.
*/
public static final String BINDER_BEAN_NAME = ConfigurationPropertiesBindingPostProcessor.class
.getName();
private static final String METADATA_BEAN_NAME = BINDER_BEAN_NAME + ".store";
@Override @Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
BeanDefinitionRegistry registry) { BeanDefinitionRegistry registry) {
if (!registry.containsBeanDefinition(BINDER_BEAN_NAME)) { if (!registry.containsBeanDefinition(
BeanDefinitionBuilder meta = BeanDefinitionBuilder ConfigurationPropertiesBindingPostProcessor.BEAN_NAME)) {
.genericBeanDefinition(ConfigurationBeanFactoryMetadata.class); registerConfigurationPropertiesBindingPostProcessor(registry);
BeanDefinitionBuilder bean = BeanDefinitionBuilder.genericBeanDefinition( registerConfigurationBeanFactoryMetadata(registry);
ConfigurationPropertiesBindingPostProcessor.class);
bean.addPropertyReference("beanMetadataStore", METADATA_BEAN_NAME);
registry.registerBeanDefinition(BINDER_BEAN_NAME, bean.getBeanDefinition());
registry.registerBeanDefinition(METADATA_BEAN_NAME, meta.getBeanDefinition());
} }
} }
private void registerConfigurationPropertiesBindingPostProcessor(
BeanDefinitionRegistry registry) {
GenericBeanDefinition definition = new GenericBeanDefinition();
definition.setBeanClass(ConfigurationPropertiesBindingPostProcessor.class);
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(
ConfigurationPropertiesBindingPostProcessor.BEAN_NAME, definition);
}
private void registerConfigurationBeanFactoryMetadata(
BeanDefinitionRegistry registry) {
GenericBeanDefinition definition = new GenericBeanDefinition();
definition.setBeanClass(ConfigurationBeanFactoryMetadata.class);
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(ConfigurationBeanFactoryMetadata.BEAN_NAME,
definition);
}
} }
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/Jsr303ConfigurationPropertiesValidator.java → spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesJsr303Validator.java
View file @ 1d83e87b
...@@ -18,7 +18,7 @@ package org.springframework.boot.context.properties; ...@@ -18,7 +18,7 @@ package org.springframework.boot.context.properties;
import org.springframework.boot.validation.MessageInterpolatorFactory; import org.springframework.boot.validation.MessageInterpolatorFactory;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import org.springframework.core.annotation.AnnotatedElementUtils; import org.springframework.util.ClassUtils;
import org.springframework.validation.Errors; import org.springframework.validation.Errors;
import org.springframework.validation.Validator; import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
...@@ -30,18 +30,22 @@ import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean; ...@@ -30,18 +30,22 @@ import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
* *
* @author Phillip Webb * @author Phillip Webb
*/ */
class Jsr303ConfigurationPropertiesValidator implements Validator { final class ConfigurationPropertiesJsr303Validator implements Validator {
private static final String[] VALIDATOR_CLASSES = { "javax.validation.Validator",
"javax.validation.ValidatorFactory",
"javax.validation.bootstrap.GenericBootstrap" };
private final Delegate delegate; private final Delegate delegate;
Jsr303ConfigurationPropertiesValidator(ApplicationContext applicationContext) { private ConfigurationPropertiesJsr303Validator(
ApplicationContext applicationContext) {
this.delegate = new Delegate(applicationContext); this.delegate = new Delegate(applicationContext);
} }
@Override @Override
public boolean supports(Class<?> type) { public boolean supports(Class<?> type) {
return AnnotatedElementUtils.hasAnnotation(type, Validated.class) return this.delegate.supports(type);
&& this.delegate.supports(type);
} }
@Override @Override
...@@ -49,6 +53,17 @@ class Jsr303ConfigurationPropertiesValidator implements Validator { ...@@ -49,6 +53,17 @@ class Jsr303ConfigurationPropertiesValidator implements Validator {
this.delegate.validate(target, errors); this.delegate.validate(target, errors);
} }
public static ConfigurationPropertiesJsr303Validator getIfJsr303Present(
ApplicationContext applicationContext) {
ClassLoader classLoader = applicationContext.getClassLoader();
for (String validatorClass : VALIDATOR_CLASSES) {
if (!ClassUtils.isPresent(validatorClass, classLoader)) {
return null;
}
}
return new ConfigurationPropertiesJsr303Validator(applicationContext);
}
private static class Delegate extends LocalValidatorFactoryBean { private static class Delegate extends LocalValidatorFactoryBean {
Delegate(ApplicationContext applicationContext) { Delegate(ApplicationContext applicationContext) {
......
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesBinderBuilder.java → spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConversionServiceDeducer.java
View file @ 1d83e87b
...@@ -27,125 +27,34 @@ import org.springframework.core.convert.ConversionService; ...@@ -27,125 +27,34 @@ import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.converter.Converter; import org.springframework.core.convert.converter.Converter;
import org.springframework.core.convert.converter.GenericConverter; import org.springframework.core.convert.converter.GenericConverter;
import org.springframework.core.convert.support.DefaultConversionService; import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.env.PropertySource;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.validation.Validator;
/** /**
* Builder for creating {@link ConfigurationPropertiesBinder} based on the state of the * Utility to deduce the {@link ConversionService} to use for configuration properties
* {@link ApplicationContext}. * binding.
* *
* @author Stephane Nicoll * @author Phillip Webb
*/ */
class ConfigurationPropertiesBinderBuilder { class ConversionServiceDeducer {
/**
* The bean name of the configuration properties validator.
*/
static final String VALIDATOR_BEAN_NAME = ConfigurationPropertiesBindingPostProcessor.VALIDATOR_BEAN_NAME;
/**
* The bean name of the configuration properties conversion service.
*/
static final String CONVERSION_SERVICE_BEAN_NAME = ConfigurableApplicationContext.CONVERSION_SERVICE_BEAN_NAME;
private static final String[] VALIDATOR_CLASSES = { "javax.validation.Validator",
"javax.validation.ValidatorFactory",
"javax.validation.bootstrap.GenericBootstrap" };
private final ApplicationContext applicationContext; private final ApplicationContext applicationContext;
private ConversionService conversionService; ConversionServiceDeducer(ApplicationContext applicationContext) {
private Validator validator;
private Iterable<PropertySource<?>> propertySources;
/**
* Creates an instance with the {@link ApplicationContext} to use.
* @param applicationContext the application context
*/
ConfigurationPropertiesBinderBuilder(ApplicationContext applicationContext) {
Assert.notNull(applicationContext, "ApplicationContext must not be null");
this.applicationContext = applicationContext; this.applicationContext = applicationContext;
} }
/** public ConversionService getConversionService() {
* Specify the {@link PropertySource property sources} to use.
* @param propertySources the configuration the binder should use
* @return this instance
*/
ConfigurationPropertiesBinderBuilder withPropertySources(
Iterable<PropertySource<?>> propertySources) {
this.propertySources = propertySources;
return this;
}
/**
* Build a {@link ConfigurationPropertiesBinder} based on the state of the builder,
* discovering the {@link ConversionService} and {@link Validator} if necessary.
* @return a {@link ConfigurationPropertiesBinder}
*/
ConfigurationPropertiesBinder build() {
return new ConfigurationPropertiesBinder(this.propertySources,
determineConversionService(), determineValidator());
}
private Validator determineValidator() {
if (this.validator != null) {
return this.validator;
}
Validator defaultValidator = getOptionalBean(VALIDATOR_BEAN_NAME,
Validator.class);
if (defaultValidator != null) {
return defaultValidator;
}
if (isJsr303Present()) {
return new Jsr303ConfigurationPropertiesValidator(this.applicationContext);
}
return null;
}
private ConversionService determineConversionService() {
if (this.conversionService != null) {
return this.conversionService;
}
ConversionService conversionServiceByName = getOptionalBean(
CONVERSION_SERVICE_BEAN_NAME, ConversionService.class);
if (conversionServiceByName != null) {
return conversionServiceByName;
}
return createDefaultConversionService();
}
private ConversionService createDefaultConversionService() {
ConversionServiceFactory conversionServiceFactory = this.applicationContext
.getAutowireCapableBeanFactory()
.createBean(ConversionServiceFactory.class);
return conversionServiceFactory.createConversionService();
}
private boolean isJsr303Present() {
for (String validatorClass : VALIDATOR_CLASSES) {
if (!ClassUtils.isPresent(validatorClass,
this.applicationContext.getClassLoader())) {
return false;
}
}
return true;
}
private <T> T getOptionalBean(String name, Class<T> type) {
try { try {
return this.applicationContext.getBean(name, type); return this.applicationContext.getBean(
ConfigurableApplicationContext.CONVERSION_SERVICE_BEAN_NAME,
ConversionService.class);
} }
catch (NoSuchBeanDefinitionException ex) { catch (NoSuchBeanDefinitionException ex) {
return null; return this.applicationContext.getAutowireCapableBeanFactory()
.createBean(Factory.class).create();
} }
} }
private static class ConversionServiceFactory { private static class Factory {
private List<Converter<?, ?>> converters = Collections.emptyList(); private List<Converter<?, ?>> converters = Collections.emptyList();
...@@ -173,7 +82,7 @@ class ConfigurationPropertiesBinderBuilder { ...@@ -173,7 +82,7 @@ class ConfigurationPropertiesBinderBuilder {
this.genericConverters = converters; this.genericConverters = converters;
} }
public ConversionService createConversionService() { public ConversionService create() {
DefaultConversionService conversionService = new DefaultConversionService(); DefaultConversionService conversionService = new DefaultConversionService();
for (Converter<?, ?> converter : this.converters) { for (Converter<?, ?> converter : this.converters) {
conversionService.addConverter(converter); conversionService.addConverter(converter);
......
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/EnableConfigurationPropertiesImportSelector.java
View file @ 1d83e87b
/* /*
* Copyright 2012-2017 the original author or authors. * Copyright 2012-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
...@@ -16,13 +16,15 @@ ...@@ -16,13 +16,15 @@
package org.springframework.boot.context.properties; package org.springframework.boot.context.properties;
import java.util.ArrayList; import java.util.Arrays;
import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar; import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.context.annotation.ImportSelector; import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.annotation.AnnotationUtils; import org.springframework.core.annotation.AnnotationUtils;
...@@ -47,19 +49,13 @@ import org.springframework.util.StringUtils; ...@@ -47,19 +49,13 @@ import org.springframework.util.StringUtils;
*/ */
class EnableConfigurationPropertiesImportSelector implements ImportSelector { class EnableConfigurationPropertiesImportSelector implements ImportSelector {
private static final String[] IMPORTS = {
ConfigurationPropertiesBeanRegistrar.class.getName(),
ConfigurationPropertiesBindingPostProcessorRegistrar.class.getName() };
@Override @Override
public String[] selectImports(AnnotationMetadata metadata) { public String[] selectImports(AnnotationMetadata metadata) {
MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes( return IMPORTS;
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() };
} }
/** /**
...@@ -71,73 +67,68 @@ class EnableConfigurationPropertiesImportSelector implements ImportSelector { ...@@ -71,73 +67,68 @@ class EnableConfigurationPropertiesImportSelector implements ImportSelector {
@Override @Override
public void registerBeanDefinitions(AnnotationMetadata metadata, public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) { BeanDefinitionRegistry registry) {
getTypes(metadata).forEach((type) -> register(registry,
(ConfigurableListableBeanFactory) registry, type));
}
private List<Class<?>> getTypes(AnnotationMetadata metadata) {
MultiValueMap<String, Object> attributes = metadata MultiValueMap<String, Object> attributes = metadata
.getAllAnnotationAttributes( .getAllAnnotationAttributes(
EnableConfigurationProperties.class.getName(), false); EnableConfigurationProperties.class.getName(), false);
List<Class<?>> types = collectClasses(attributes.get("value")); return collectClasses(attributes == null ? Collections.emptyList()
for (Class<?> type : types) { : attributes.get("value"));
String prefix = extractPrefix(type);
String name = (StringUtils.hasText(prefix) ? prefix + "-" + type.getName()
: type.getName());
if (!containsBeanDefinition((ConfigurableListableBeanFactory) registry,
name)) {
registerBeanDefinition(registry, type, name);
}
}
} }
private String extractPrefix(Class<?> type) { private List<Class<?>> collectClasses(List<?> values) {
ConfigurationProperties annotation = AnnotationUtils.findAnnotation(type, return values.stream().flatMap((value) -> Arrays.stream((Object[]) value))
ConfigurationProperties.class); .map((o) -> (Class<?>) o).filter((type) -> void.class != type)
if (annotation != null) { .collect(Collectors.toList());
return annotation.prefix();
}
return "";
} }
private List<Class<?>> collectClasses(List<Object> list) { private void register(BeanDefinitionRegistry registry,
ArrayList<Class<?>> result = new ArrayList<>(); ConfigurableListableBeanFactory beanFactory, Class<?> type) {
for (Object object : list) { String name = getName(type);
for (Object value : (Object[]) object) { if (!containsBeanDefinition(beanFactory, name)) {
if (value instanceof Class && value != void.class) { registerBeanDefinition(registry, name, type);
result.add((Class<?>) value);
}
}
} }
return result;
} }
private void registerBeanDefinition(BeanDefinitionRegistry registry, private String getName(Class<?> type) {
Class<?> type, String name) { ConfigurationProperties annotation = AnnotationUtils.findAnnotation(type,
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.genericBeanDefinition(type);
AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
registry.registerBeanDefinition(name, beanDefinition);
ConfigurationProperties properties = AnnotationUtils.findAnnotation(type,
ConfigurationProperties.class); ConfigurationProperties.class);
Assert.notNull(properties, String prefix = (annotation != null ? annotation.prefix() : "");
"No " + ConfigurationProperties.class.getSimpleName() return (StringUtils.hasText(prefix) ? prefix + "-" + type.getName()
+ " annotation found on '" + type.getName() + "'."); : type.getName());
} }
private boolean containsBeanDefinition( private boolean containsBeanDefinition(
ConfigurableListableBeanFactory beanFactory, String name) { ConfigurableListableBeanFactory beanFactory, String name) {
if (beanFactory.containsBeanDefinition(name)) {
boolean result = beanFactory.containsBeanDefinition(name);
if (result) {
return true; return true;
} }
if (beanFactory BeanFactory parent = beanFactory.getParentBeanFactory();
.getParentBeanFactory() instanceof ConfigurableListableBeanFactory) { if (parent instanceof ConfigurableListableBeanFactory) {
return containsBeanDefinition( return containsBeanDefinition((ConfigurableListableBeanFactory) parent,
(ConfigurableListableBeanFactory) beanFactory
.getParentBeanFactory(),
name); name);
} }
return false; return false;
} }
private void registerBeanDefinition(BeanDefinitionRegistry registry, String name,
Class<?> type) {
assertHasAnnotation(type);
GenericBeanDefinition definition = new GenericBeanDefinition();
definition.setBeanClass(type);
registry.registerBeanDefinition(name, definition);
}
private void assertHasAnnotation(Class<?> type) {
Assert.notNull(
AnnotationUtils.findAnnotation(type, ConfigurationProperties.class),
"No " + ConfigurationProperties.class.getSimpleName()
+ " annotation found on '" + type.getName() + "'.");
}
} }
} }
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/PropertySourcesDeducer.java 0 → 100644
View file @ 1d83e87b
/*
* Copyright 2012-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.context.properties;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.env.PropertySources;
import org.springframework.util.Assert;
/**
* Utility to deduce the {@link PropertySources} to use for configuration binding.
*
* @author Phillip Webb
*/
class PropertySourcesDeducer {
private static final Log logger = LogFactory.getLog(PropertySourcesDeducer.class);
private final ApplicationContext applicationContext;
PropertySourcesDeducer(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
public PropertySources getPropertySources() {
MutablePropertySources environmentPropertySources = extractEnvironmentPropertySources();
PropertySourcesPlaceholderConfigurer placeholderConfigurer = getSinglePropertySourcesPlaceholderConfigurer();
if (placeholderConfigurer == null) {
Assert.state(environmentPropertySources != null,
"Unable to obtain PropertySources from "
+ "PropertySourcesPlaceholderConfigurer or Environment");
return environmentPropertySources;
}
PropertySources appliedPropertySources = placeholderConfigurer
.getAppliedPropertySources();
if (environmentPropertySources == null) {
return appliedPropertySources;
}
return merge(environmentPropertySources, appliedPropertySources);
}
private MutablePropertySources extractEnvironmentPropertySources() {
Environment environment = this.applicationContext.getEnvironment();
if (environment instanceof ConfigurableEnvironment) {
return ((ConfigurableEnvironment) environment).getPropertySources();
}
return null;
}
private PropertySourcesPlaceholderConfigurer getSinglePropertySourcesPlaceholderConfigurer() {
// Take care not to cause early instantiation of all FactoryBeans
Map<String, PropertySourcesPlaceholderConfigurer> beans = this.applicationContext
.getBeansOfType(PropertySourcesPlaceholderConfigurer.class, false, false);
if (beans.size() == 1) {
return beans.values().iterator().next();
}
if (beans.size() > 1 && logger.isWarnEnabled()) {
logger.warn(
"Multiple PropertySourcesPlaceholderConfigurer " + "beans registered "
+ beans.keySet() + ", falling back to Environment");
}
return null;
}
private PropertySources merge(PropertySources environmentPropertySources,
PropertySources appliedPropertySources) {
FilteredPropertySources filtered = new FilteredPropertySources(
appliedPropertySources,
PropertySourcesPlaceholderConfigurer.ENVIRONMENT_PROPERTIES_PROPERTY_SOURCE_NAME);
return new CompositePropertySources(filtered, environmentPropertySources);
}
}
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/bind/Bindable.java
View file @ 1d83e87b
/* /*
* Copyright 2012-2017 the original author or authors. * Copyright 2012-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
...@@ -86,6 +86,22 @@ public final class Bindable<T> { ...@@ -86,6 +86,22 @@ public final class Bindable<T> {
return this.annotations; return this.annotations;
} }
/**
* Return a single associated annotations that could affect binding.
* @param <A> the annotation type
* @param type annotation type
* @return the associated annotation or {@code null}
*/
@SuppressWarnings("unchecked")
public <A extends Annotation> A getAnnotation(Class<A> type) {
for (Annotation annotation : this.annotations) {
if (type.isInstance(annotation)) {
return (A) annotation;
}
}
return null;
}
@Override @Override
public String toString() { public String toString() {
ToStringCreator creator = new ToStringCreator(this); ToStringCreator creator = new ToStringCreator(this);
......
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/bind/validation/BindValidationException.java
View file @ 1d83e87b
...@@ -32,6 +32,7 @@ public class BindValidationException extends RuntimeException { ...@@ -32,6 +32,7 @@ public class BindValidationException extends RuntimeException {
private final ValidationErrors validationErrors; private final ValidationErrors validationErrors;
BindValidationException(ValidationErrors validationErrors) { BindValidationException(ValidationErrors validationErrors) {
super(getMessage(validationErrors));
Assert.notNull(validationErrors, "ValidationErrors must not be null"); Assert.notNull(validationErrors, "ValidationErrors must not be null");
this.validationErrors = validationErrors; this.validationErrors = validationErrors;
} }
...@@ -44,4 +45,14 @@ public class BindValidationException extends RuntimeException { ...@@ -44,4 +45,14 @@ public class BindValidationException extends RuntimeException {
return this.validationErrors; return this.validationErrors;
} }
private static String getMessage(ValidationErrors errors) {
StringBuilder message = new StringBuilder("Binding validation errors");
if (errors != null) {
message.append(" on " + errors.getName());
errors.getAllErrors().forEach(
(error) -> message.append(String.format("%n - %s", error)));
}
return message.toString();
}
} }
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/bind/validation/ValidationBindHandler.java
View file @ 1d83e87b
/* /*
* Copyright 2012-2017 the original author or authors. * Copyright 2012-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
...@@ -17,7 +17,9 @@ ...@@ -17,7 +17,9 @@
package org.springframework.boot.context.properties.bind.validation; package org.springframework.boot.context.properties.bind.validation;
import java.util.Arrays; import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedHashSet; import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Set; import java.util.Set;
import java.util.stream.Collectors; import java.util.stream.Collectors;
...@@ -27,11 +29,9 @@ import org.springframework.boot.context.properties.bind.BindHandler; ...@@ -27,11 +29,9 @@ import org.springframework.boot.context.properties.bind.BindHandler;
import org.springframework.boot.context.properties.bind.Bindable; import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.source.ConfigurationProperty; import org.springframework.boot.context.properties.source.ConfigurationProperty;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName; import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.validation.BeanPropertyBindingResult; import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.validation.BindingResult; import org.springframework.validation.BindingResult;
import org.springframework.validation.Validator; import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
/** /**
* {@link BindHandler} to apply {@link Validator Validators} to bound results. * {@link BindHandler} to apply {@link Validator Validators} to bound results.
...@@ -44,10 +44,10 @@ public class ValidationBindHandler extends AbstractBindHandler { ...@@ -44,10 +44,10 @@ public class ValidationBindHandler extends AbstractBindHandler {
private final Validator[] validators; private final Validator[] validators;
private boolean validate;
private final Set<ConfigurationProperty> boundProperties = new LinkedHashSet<>(); private final Set<ConfigurationProperty> boundProperties = new LinkedHashSet<>();
private final Deque<BindValidationException> exceptions = new LinkedList<>();
public ValidationBindHandler(Validator... validators) { public ValidationBindHandler(Validator... validators) {
this.validators = validators; this.validators = validators;
} }
...@@ -57,21 +57,6 @@ public class ValidationBindHandler extends AbstractBindHandler { ...@@ -57,21 +57,6 @@ public class ValidationBindHandler extends AbstractBindHandler {
this.validators = validators; this.validators = validators;
} }
@Override
public boolean onStart(ConfigurationPropertyName name, Bindable<?> target,
BindContext context) {
if (context.getDepth() == 0) {
this.validate = shouldValidate(target);
}
return super.onStart(name, target, context);
}
private boolean shouldValidate(Bindable<?> target) {
Validated annotation = AnnotationUtils
.findAnnotation(target.getBoxedType().resolve(), Validated.class);
return (annotation != null);
}
@Override @Override
public Object onSuccess(ConfigurationPropertyName name, Bindable<?> target, public Object onSuccess(ConfigurationPropertyName name, Bindable<?> target,
BindContext context, Object result) { BindContext context, Object result) {
...@@ -84,8 +69,9 @@ public class ValidationBindHandler extends AbstractBindHandler { ...@@ -84,8 +69,9 @@ public class ValidationBindHandler extends AbstractBindHandler {
@Override @Override
public void onFinish(ConfigurationPropertyName name, Bindable<?> target, public void onFinish(ConfigurationPropertyName name, Bindable<?> target,
BindContext context, Object result) throws Exception { BindContext context, Object result) throws Exception {
if (this.validate) { validate(name, target, result);
validate(name, target, result); if (context.getDepth() == 0 && !this.exceptions.isEmpty()) {
throw this.exceptions.pop();
} }
super.onFinish(name, target, context, result); super.onFinish(name, target, context, result);
} }
...@@ -110,22 +96,22 @@ public class ValidationBindHandler extends AbstractBindHandler { ...@@ -110,22 +96,22 @@ public class ValidationBindHandler extends AbstractBindHandler {
private void validate(ConfigurationPropertyName name, Object target, Class<?> type) { private void validate(ConfigurationPropertyName name, Object target, Class<?> type) {
if (target != null) { if (target != null) {
BindingResult errors = new BeanPropertyBindingResult(target, name.toString()); BindingResult errors = new BeanPropertyBindingResult(target, name.toString());
Arrays.stream(this.validators).filter((v) -> v.supports(type)) Arrays.stream(this.validators).filter((validator) -> validator.supports(type))
.forEach((v) -> v.validate(target, errors)); .forEach((validator) -> validator.validate(target, errors));
if (errors.hasErrors()) { if (errors.hasErrors()) {
throwBindValidationException(name, errors); this.exceptions.push(getBindValidationException(name, errors));
} }
} }
} }
private void throwBindValidationException(ConfigurationPropertyName name, private BindValidationException getBindValidationException(
BindingResult errors) { ConfigurationPropertyName name, BindingResult errors) {
Set<ConfigurationProperty> boundProperties = this.boundProperties.stream() Set<ConfigurationProperty> boundProperties = this.boundProperties.stream()
.filter((property) -> name.isAncestorOf(property.getName())) .filter((property) -> name.isAncestorOf(property.getName()))
.collect(Collectors.toCollection(LinkedHashSet::new)); .collect(Collectors.toCollection(LinkedHashSet::new));
ValidationErrors validationErrors = new ValidationErrors(name, boundProperties, ValidationErrors validationErrors = new ValidationErrors(name, boundProperties,
errors.getAllErrors()); errors.getAllErrors());
throw new BindValidationException(validationErrors); return new BindValidationException(validationErrors);
} }
} }
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/bind/validation/ValidationErrors.java
View file @ 1d83e87b
...@@ -22,11 +22,11 @@ import java.util.Iterator; ...@@ -22,11 +22,11 @@ import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.context.properties.source.ConfigurationProperty; import org.springframework.boot.context.properties.source.ConfigurationProperty;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName; import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName.Form; import org.springframework.boot.context.properties.source.ConfigurationPropertyName.Form;
import org.springframework.boot.origin.Origin; import org.springframework.boot.origin.Origin;
import org.springframework.boot.origin.OriginProvider;
import org.springframework.util.Assert; import org.springframework.util.Assert;
import org.springframework.validation.FieldError; import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError; import org.springframework.validation.ObjectError;
...@@ -76,7 +76,7 @@ public class ValidationErrors implements Iterable<ObjectError> { ...@@ -76,7 +76,7 @@ public class ValidationErrors implements Iterable<ObjectError> {
private FieldError convertFieldError(ConfigurationPropertyName name, private FieldError convertFieldError(ConfigurationPropertyName name,
Set<ConfigurationProperty> boundProperties, FieldError error) { Set<ConfigurationProperty> boundProperties, FieldError error) {
if (error instanceof ObjectProvider<?>) { if (error instanceof OriginProvider) {
return error; return error;
} }
return OriginTrackedFieldError.of(error, return OriginTrackedFieldError.of(error,
......
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/context/properties/ConfigurationPropertiesBinderBuilderTests.java deleted 100644 → 0
View file @ 9e75680e
/*
* Copyright 2012-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.context.properties;
import java.time.Duration;
import javax.validation.constraints.NotNull;
import org.junit.Test;
import org.springframework.boot.context.properties.bind.validation.BindValidationException;
import org.springframework.boot.context.properties.bind.validation.ValidationErrors;
import org.springframework.context.support.StaticApplicationContext;
import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.mock.env.MockEnvironment;
import org.springframework.test.context.support.TestPropertySourceUtils;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ConfigurationPropertiesBinderBuilder}.
*
* @author Stephane Nicoll
*/
public class ConfigurationPropertiesBinderBuilderTests {
private final StaticApplicationContext applicationContext = new StaticApplicationContext();
private final ConfigurationPropertiesBinderBuilder builder = new ConfigurationPropertiesBinderBuilder(
this.applicationContext);
private final MockEnvironment environment = new MockEnvironment();
@Test
public void detectDefaultConversionService() {
this.applicationContext.registerSingleton("conversionService",
DefaultConversionService.class);
ConfigurationPropertiesBinder binder = builderWithSources().build();
assertThat(ReflectionTestUtils.getField(binder, "conversionService"))
.isSameAs(this.applicationContext.getBean("conversionService"));
}
@Test
public void bindToJavaTimeDuration() {
TestPropertySourceUtils.addInlinedPropertiesToEnvironment(this.environment,
"test.duration=PT1M");
ConfigurationPropertiesBinder binder = builderWithSources().build();
PropertyWithDuration target = new PropertyWithDuration();
bind(binder, target);
assertThat(target.getDuration().getSeconds()).isEqualTo(60);
}
@Test
public void detectDefaultValidator() {
this.applicationContext.registerSingleton(
ConfigurationPropertiesBindingPostProcessor.VALIDATOR_BEAN_NAME,
LocalValidatorFactoryBean.class);
ConfigurationPropertiesBinder binder = builderWithSources().build();
assertThat(ReflectionTestUtils.getField(binder, "validator"))
.isSameAs(this.applicationContext.getBean(
ConfigurationPropertiesBindingPostProcessor.VALIDATOR_BEAN_NAME));
}
@Test
public void validationWithoutJsr303() {
ConfigurationPropertiesBinder binder = builderWithSources().build();
assertThat(bindWithValidationErrors(binder, new PropertyWithoutJSR303())
.getAllErrors()).hasSize(1);
}
@Test
public void validationWithJsr303() {
ConfigurationPropertiesBinder binder = builderWithSources().build();
assertThat(
bindWithValidationErrors(binder, new PropertyWithJSR303()).getAllErrors())
.hasSize(2);
}
private ConfigurationPropertiesBinderBuilder builderWithSources() {
return this.builder.withPropertySources(this.environment.getPropertySources());
}
@Test
public void validationWithJsr303AndValidInput() {
TestPropertySourceUtils.addInlinedPropertiesToEnvironment(this.environment,
"test.foo=123456", "test.bar=654321");
ConfigurationPropertiesBinder binder = new ConfigurationPropertiesBinder(
this.environment.getPropertySources(), null, null);
PropertyWithJSR303 target = new PropertyWithJSR303();
bind(binder, target);
assertThat(target.getFoo()).isEqualTo("123456");
assertThat(target.getBar()).isEqualTo("654321");
}
private ValidationErrors bindWithValidationErrors(
ConfigurationPropertiesBinder binder, Object target) {
try {
bind(binder, target);
throw new AssertionError("Should have failed to bind " + target);
}
catch (ConfigurationPropertiesBindingException ex) {
Throwable rootCause = ex.getRootCause();
assertThat(rootCause).isInstanceOf(BindValidationException.class);
return ((BindValidationException) rootCause).getValidationErrors();
}
}
private void bind(ConfigurationPropertiesBinder binder, Object target) {
binder.bind(target,
AnnotationUtils.findAnnotation(target.getClass(),
ConfigurationProperties.class),
ResolvableType.forType(target.getClass()));
}
@ConfigurationProperties(prefix = "test")
public static class PropertyWithDuration {
private Duration duration;
public Duration getDuration() {
return this.duration;
}
public void setDuration(Duration duration) {
this.duration = duration;
}
}
@ConfigurationProperties(prefix = "test")
@Validated
public static class PropertyWithoutJSR303 implements Validator {
private String foo;
@Override
public boolean supports(Class<?> clazz) {
return clazz.isAssignableFrom(getClass());
}
@Override
public void validate(Object target, Errors errors) {
ValidationUtils.rejectIfEmpty(errors, "foo", "TEST1");
}
public String getFoo() {
return this.foo;
}
public void setFoo(String foo) {
this.foo = foo;
}
}
@ConfigurationProperties(prefix = "test")
@Validated
public static class PropertyWithJSR303 extends PropertyWithoutJSR303 {
@NotNull
private String bar;
public void setBar(String bar) {
this.bar = bar;
}
public String getBar() {
return this.bar;
}
}
}
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/context/properties/bind/BindableTests.java
View file @ 1d83e87b
/* /*
* Copyright 2012-2017 the original author or authors. * Copyright 2012-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
...@@ -24,6 +24,7 @@ import org.junit.Rule; ...@@ -24,6 +24,7 @@ import org.junit.Rule;
import org.junit.Test; import org.junit.Test;
import org.junit.rules.ExpectedException; import org.junit.rules.ExpectedException;
import org.springframework.context.annotation.Bean;
import org.springframework.core.ResolvableType; import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotationUtils; import org.springframework.core.annotation.AnnotationUtils;
...@@ -140,6 +141,20 @@ public class BindableTests { ...@@ -140,6 +141,20 @@ public class BindableTests {
.containsExactly(annotation); .containsExactly(annotation);
} }
@Test
public void getAnnotationWhenMatchShouldReuturnAnnotation() {
Test annotation = AnnotationUtils.synthesizeAnnotation(Test.class);
assertThat(Bindable.of(String.class).withAnnotations(annotation)
.getAnnotation(Test.class)).isSameAs(annotation);
}
@Test
public void getAnnotationWhenNoMatchShouldReturnNull() {
Test annotation = AnnotationUtils.synthesizeAnnotation(Test.class);
assertThat(Bindable.of(String.class).withAnnotations(annotation)
.getAnnotation(Bean.class)).isNull();
}
@Test @Test
public void toStringShouldShowDetails() { public void toStringShouldShowDetails() {
Annotation annotation = AnnotationUtils Annotation annotation = AnnotationUtils
......
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/context/properties/bind/validation/ValidationBindHandlerTests.java
View file @ 1d83e87b
/* /*
* Copyright 2012-2017 the original author or authors. * Copyright 2012-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
...@@ -127,8 +127,8 @@ public class ValidationBindHandlerTests { ...@@ -127,8 +127,8 @@ public class ValidationBindHandlerTests {
BindValidationException cause = bindAndExpectValidationError( BindValidationException cause = bindAndExpectValidationError(
() -> this.binder.bind(ConfigurationPropertyName.of("foo"), () -> this.binder.bind(ConfigurationPropertyName.of("foo"),
Bindable.of(ExampleValidatedWithNestedBean.class), this.handler)); Bindable.of(ExampleValidatedWithNestedBean.class), this.handler));
assertThat(cause.getValidationErrors().getName().toString()) assertThat(cause.getValidationErrors().getName().toString()).isEqualTo("foo");
.isEqualTo("foo.nested"); assertThat(cause.getMessage()).contains("nested.age");
} }
@Test @Test
...@@ -144,11 +144,13 @@ public class ValidationBindHandlerTests { ...@@ -144,11 +144,13 @@ public class ValidationBindHandlerTests {
} }
@Test @Test
public void bindShouldNotValidateWithoutAnnotation() { public void bindShouldValidateWithoutAnnotation() {
ExampleNonValidatedBean existingValue = new ExampleNonValidatedBean(); ExampleNonValidatedBean existingValue = new ExampleNonValidatedBean();
this.binder.bind(ConfigurationPropertyName.of("foo"), Bindable bindAndExpectValidationError(
.of(ExampleNonValidatedBean.class).withExistingValue(existingValue), () -> this.binder.bind(ConfigurationPropertyName.of("foo"),
this.handler); Bindable.of(ExampleNonValidatedBean.class)
.withExistingValue(existingValue),
this.handler));
} }
private BindValidationException bindAndExpectValidationError(Runnable action) { private BindValidationException bindAndExpectValidationError(Runnable action) {
...@@ -156,8 +158,6 @@ public class ValidationBindHandlerTests { ...@@ -156,8 +158,6 @@ public class ValidationBindHandlerTests {
action.run(); action.run();
} }
catch (BindException ex) { catch (BindException ex) {
ex.printStackTrace();
BindValidationException cause = (BindValidationException) ex.getCause(); BindValidationException cause = (BindValidationException) ex.getCause();
return cause; return cause;
} }
......
spring-boot-project/spring-boot/src/test/resources/org/springframework/boot/context/properties/testProperties.xml
View file @ 1d83e87b
...@@ -4,8 +4,8 @@ ...@@ -4,8 +4,8 @@
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean <bean
id="org.springframework.boot.context.properties.EnableConfigurationPropertiesTests$TestProperties" id="org.springframework.boot.context.properties.ConfigurationPropertiesTests$BasicProperties"
class="org.springframework.boot.context.properties.EnableConfigurationPropertiesTests$TestProperties"> class="org.springframework.boot.context.properties.ConfigurationPropertiesTests$BasicProperties">
<property name="name" value="bar"/> <property name="name" value="bar"/>
</bean> </bean>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment