public class RequiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware
BeanPostProcessorimplementation that enforces required JavaBean properties to have been configured. Required bean properties are detected through a Java 5 annotation: by default, Spring's
The motivation for the existence of this BeanPostProcessor is to allow developers to annotate the setter properties of their own classes with an arbitrary JDK 1.5 annotation to indicate that the container must check for the configuration of a dependency injected value. This neatly pushes responsibility for such checking onto the container (where it arguably belongs), and obviates the need (in part) for a developer to code a method that simply checks that all required properties have actually been set.
Please note that an 'init' method may still need to implemented (and may
still be desirable), because all that this class does is enforce that a
'required' property has actually been configured with a value. It does
not check anything else... In particular, it does not check that a
configured value is not
Note: A default RequiredAnnotationBeanPostProcessor will be registered by the "context:annotation-config" and "context:component-scan" XML tags. Remove or turn off the default annotation configuration there if you intend to specify a custom RequiredAnnotationBeanPostProcessor bean definition.
setRequiredAnnotationType(java.lang.Class<? extends java.lang.annotation.Annotation>),
|Modifier and Type||Field and Description|
Bean definition attribute that may indicate whether a given bean is supposed to be skipped when performing this post-processor's required property check.
|Constructor and Description|
|Modifier and Type||Method and Description|
Return the order value of this object, with a higher value meaning greater in terms of sorting.
Return the 'required' annotation type.
Is the supplied property required to have a value (that is, to be dependency-injected)?
Post-process the given merged bean definition for the specified bean.
Post-process the given property values before the factory applies them to the given bean.
Callback that supplies the owning factory to a bean instance.
Set the 'required' annotation type, to be used on bean property setter methods.
Check whether the given bean definition is not subject to the annotation-based required property check as performed by this post-processor.
determineCandidateConstructors, getEarlyBeanReference, postProcessAfterInitialization, postProcessAfterInstantiation, postProcessBeforeInitialization, postProcessBeforeInstantiation, predictBeanType
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
public static final String SKIP_REQUIRED_CHECK_ATTRIBUTE
public void setRequiredAnnotationType(Class<? extends Annotation> requiredAnnotationType)
The default required annotation type is the Spring-provided
This setter property exists so that developers can provide their own (non-Spring-specific) annotation type to indicate that a property value is required.
protected Class<? extends Annotation> getRequiredAnnotationType()
public void setBeanFactory(BeanFactory beanFactory)
Invoked after the population of normal bean properties
but before an initialization callback such as
InitializingBean.afterPropertiesSet() or a custom init-method.
beanFactory- owning BeanFactory (never
null). The bean can immediately call methods on the factory.
public void setOrder(int order)
public int getOrder()
Normally starting with 0, with
indicating the greatest value. Same order values will result
in arbitrary positions for the affected objects.
Higher values can be interpreted as lower priority. As a consequence, the object with the lowest value has highest priority (somewhat analogous to Servlet "load-on-startup" values).
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)
beanDefinition- the merged bean definition for the bean
beanType- the actual type of the managed bean instance
beanName- the name of the bean
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor pds, Object bean, String beanName) throws BeansException
Also allows for replacing the property values to apply, typically through creating a new MutablePropertyValues instance based on the original PropertyValues, adding or removing specific values.
pvs- the property values that the factory is about to apply (never
pds- the relevant property descriptors for the target bean (with ignored dependency types - which the factory handles specifically - already filtered out)
bean- the bean instance created, but whose properties have not yet been set
beanName- the name of the bean
nullto skip property population
BeansException- in case of errors
protected boolean shouldSkip(ConfigurableListableBeanFactory beanFactory, String beanName)
The default implementations check for the presence of the
SKIP_REQUIRED_CHECK_ATTRIBUTE attribute in the bean definition, if any.
It also suggests skipping in case of a bean definition with a "factory-bean"
reference set, assuming that instance-based factories pre-populate the bean.
beanFactory- the BeanFactory to check against
beanName- the name of the bean to check against
trueto skip the bean;
falseto process it
protected boolean isRequiredProperty(PropertyDescriptor propertyDescriptor)
This implementation looks for the existence of a
on the supplied
propertyDescriptor- the target PropertyDescriptor (never
trueif the supplied property has been marked as being required;
falseif not, or if the supplied property does not have a setter method