/* * Copyright 2002-2011 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.beans.factory.config; import java.beans.PropertyDescriptor; import org.springframework.beans.BeansException; import org.springframework.beans.PropertyValues; /** * Subinterface of {@link BeanPostProcessor} that adds a before-instantiation callback, * and a callback after instantiation but before explicit properties are set or * autowiring occurs. * *
Typically used to suppress default instantiation for specific target beans, * for example to create proxies with special TargetSources (pooling targets, * lazily initializing targets, etc), or to implement additional injection strategies * such as field injection. * *
NOTE: This interface is a special purpose interface, mainly for * internal use within the framework. It is recommended to implement the plain * {@link BeanPostProcessor} interface as far as possible, or to derive from * {@link InstantiationAwareBeanPostProcessorAdapter} in order to be shielded * from extensions to this interface. * * @author Juergen Hoeller * @author Rod Johnson * @since 1.2 * @see org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#setCustomTargetSourceCreators * @see org.springframework.aop.framework.autoproxy.target.LazyInitTargetSourceCreator */ public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor { /** * Apply this BeanPostProcessor before the target bean gets instantiated. * The returned bean object may be a proxy to use instead of the target bean, * effectively suppressing default instantiation of the target bean. *
If a non-null object is returned by this method, the bean creation process * will be short-circuited. The only further processing applied is the * {@link #postProcessAfterInitialization} callback from the configured * {@link BeanPostProcessor BeanPostProcessors}. *
This callback will only be applied to bean definitions with a bean class. * In particular, it will not be applied to beans with a "factory-method". *
Post-processors may implement the extended
* {@link SmartInstantiationAwareBeanPostProcessor} interface in order
* to predict the type of the bean object that they are going to return here.
* @param beanClass the class of the bean to be instantiated
* @param beanName the name of the bean
* @return the bean object to expose instead of a default instance of the target bean,
* or null
to proceed with default instantiation
* @throws org.springframework.beans.BeansException in case of errors
* @see org.springframework.beans.factory.support.AbstractBeanDefinition#hasBeanClass
* @see org.springframework.beans.factory.support.AbstractBeanDefinition#getFactoryMethodName
*/
Object postProcessBeforeInstantiation(Class> beanClass, String beanName) throws BeansException;
/**
* Perform operations after the bean has been instantiated, via a constructor or factory method,
* but before Spring property population (from explicit properties or autowiring) occurs.
*
This is the ideal callback for performing field injection on the given bean instance.
* See Spring's own {@link org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor}
* for a typical example.
* @param bean the bean instance created, with properties not having been set yet
* @param beanName the name of the bean
* @return true
if properties should be set on the bean; false
* if property population should be skipped. Normal implementations should return true
.
* Returning false
will also prevent any subsequent InstantiationAwareBeanPostProcessor
* instances being invoked on this bean instance.
* @throws org.springframework.beans.BeansException in case of errors
*/
boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
/**
* Post-process the given property values before the factory applies them
* to the given bean. Allows for checking whether all dependencies have been
* satisfied, for example based on a "Required" annotation on bean property setters.
*
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.
* @param pvs the property values that the factory is about to apply (never null
)
* @param pds the relevant property descriptors for the target bean (with ignored
* dependency types - which the factory handles specifically - already filtered out)
* @param bean the bean instance created, but whose properties have not yet been set
* @param beanName the name of the bean
* @return the actual property values to apply to to the given bean
* (can be the passed-in PropertyValues instance), or null
* to skip property population
* @throws org.springframework.beans.BeansException in case of errors
* @see org.springframework.beans.MutablePropertyValues
*/
PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException;
}