Java tutorial
/* * Copyright 2002-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 * * https://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.beans.factory.annotation; import java.beans.PropertyDescriptor; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.springframework.beans.PropertyValues; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.beans.factory.BeanInitializationException; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter; import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor; import org.springframework.beans.factory.support.RootBeanDefinition; import org.springframework.core.Conventions; import org.springframework.core.Ordered; import org.springframework.core.PriorityOrdered; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.lang.Nullable; import org.springframework.util.Assert; /** * {@link org.springframework.beans.factory.config.BeanPostProcessor} implementation * that enforces required JavaBean properties to have been configured. * Required bean properties are detected through a Java 5 annotation: * by default, Spring's {@link Required} annotation. * * <p>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 (<b>in part</b>) for a developer to code a method that * simply checks that all required properties have actually been set. * * <p>Please note that an 'init' method may still need to be implemented (and may * still be desirable), because all that this class does is enforcing that a * 'required' property has actually been configured with a value. It does * <b>not</b> check anything else... In particular, it does not check that a * configured value is not {@code null}. * * <p>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. * * @author Rob Harrop * @author Juergen Hoeller * @since 2.0 * @see #setRequiredAnnotationType * @see Required * @deprecated as of 5.1, in favor of using constructor injection for required settings * (or a custom {@link org.springframework.beans.factory.InitializingBean} implementation) */ @Deprecated public class RequiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware { /** * Bean definition attribute that may indicate whether a given bean is supposed * to be skipped when performing this post-processor's required property check. * @see #shouldSkip */ public static final String SKIP_REQUIRED_CHECK_ATTRIBUTE = Conventions .getQualifiedAttributeName(RequiredAnnotationBeanPostProcessor.class, "skipRequiredCheck"); private Class<? extends Annotation> requiredAnnotationType = Required.class; private int order = Ordered.LOWEST_PRECEDENCE - 1; @Nullable private ConfigurableListableBeanFactory beanFactory; /** * Cache for validated bean names, skipping re-validation for the same bean. */ private final Set<String> validatedBeanNames = Collections.newSetFromMap(new ConcurrentHashMap<>(64)); /** * Set the 'required' annotation type, to be used on bean property * setter methods. * <p>The default required annotation type is the Spring-provided * {@link Required} annotation. * <p>This setter property exists so that developers can provide their own * (non-Spring-specific) annotation type to indicate that a property value * is required. */ public void setRequiredAnnotationType(Class<? extends Annotation> requiredAnnotationType) { Assert.notNull(requiredAnnotationType, "'requiredAnnotationType' must not be null"); this.requiredAnnotationType = requiredAnnotationType; } /** * Return the 'required' annotation type. */ protected Class<? extends Annotation> getRequiredAnnotationType() { return this.requiredAnnotationType; } @Override public void setBeanFactory(BeanFactory beanFactory) { if (beanFactory instanceof ConfigurableListableBeanFactory) { this.beanFactory = (ConfigurableListableBeanFactory) beanFactory; } } public void setOrder(int order) { this.order = order; } @Override public int getOrder() { return this.order; } @Override public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { } @Override public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) { if (!this.validatedBeanNames.contains(beanName)) { if (!shouldSkip(this.beanFactory, beanName)) { List<String> invalidProperties = new ArrayList<>(); for (PropertyDescriptor pd : pds) { if (isRequiredProperty(pd) && !pvs.contains(pd.getName())) { invalidProperties.add(pd.getName()); } } if (!invalidProperties.isEmpty()) { throw new BeanInitializationException(buildExceptionMessage(invalidProperties, beanName)); } } this.validatedBeanNames.add(beanName); } return pvs; } /** * Check whether the given bean definition is not subject to the annotation-based * required property check as performed by this post-processor. * <p>The default implementations check for the presence of the * {@link #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. * @param beanFactory the BeanFactory to check against * @param beanName the name of the bean to check against * @return {@code true} to skip the bean; {@code false} to process it */ protected boolean shouldSkip(@Nullable ConfigurableListableBeanFactory beanFactory, String beanName) { if (beanFactory == null || !beanFactory.containsBeanDefinition(beanName)) { return false; } BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); if (beanDefinition.getFactoryBeanName() != null) { return true; } Object value = beanDefinition.getAttribute(SKIP_REQUIRED_CHECK_ATTRIBUTE); return (value != null && (Boolean.TRUE.equals(value) || Boolean.parseBoolean(value.toString()))); } /** * Is the supplied property required to have a value (that is, to be dependency-injected)? * <p>This implementation looks for the existence of a * {@link #setRequiredAnnotationType "required" annotation} * on the supplied {@link PropertyDescriptor property}. * @param propertyDescriptor the target PropertyDescriptor (never {@code null}) * @return {@code true} if the supplied property has been marked as being required; * {@code false} if not, or if the supplied property does not have a setter method */ protected boolean isRequiredProperty(PropertyDescriptor propertyDescriptor) { Method setter = propertyDescriptor.getWriteMethod(); return (setter != null && AnnotationUtils.getAnnotation(setter, getRequiredAnnotationType()) != null); } /** * Build an exception message for the given list of invalid properties. * @param invalidProperties the list of names of invalid properties * @param beanName the name of the bean * @return the exception message */ private String buildExceptionMessage(List<String> invalidProperties, String beanName) { int size = invalidProperties.size(); StringBuilder sb = new StringBuilder(); sb.append(size == 1 ? "Property" : "Properties"); for (int i = 0; i < size; i++) { String propertyName = invalidProperties.get(i); if (i > 0) { if (i == (size - 1)) { sb.append(" and"); } else { sb.append(","); } } sb.append(" '").append(propertyName).append("'"); } sb.append(size == 1 ? " is" : " are"); sb.append(" required for bean '").append(beanName).append("'"); return sb.toString(); } }