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.wiring; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.BeanCreationException; import org.springframework.beans.factory.BeanCurrentlyInCreationException; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.lang.Nullable; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; /** * Convenient base class for bean configurers that can perform Dependency Injection * on objects (however they may be created). Typically subclassed by AspectJ aspects. * * <p>Subclasses may also need a custom metadata resolution strategy, in the * {@link BeanWiringInfoResolver} interface. The default implementation looks for * a bean with the same name as the fully-qualified class name. (This is the default * name of the bean in a Spring XML file if the '{@code id}' attribute is not used.) * @author Rob Harrop * @author Rod Johnson * @author Juergen Hoeller * @author Adrian Colyer * @since 2.0 * @see #setBeanWiringInfoResolver * @see ClassNameBeanWiringInfoResolver */ public class BeanConfigurerSupport implements BeanFactoryAware, InitializingBean, DisposableBean { /** Logger available to subclasses. */ protected final Log logger = LogFactory.getLog(getClass()); @Nullable private volatile BeanWiringInfoResolver beanWiringInfoResolver; @Nullable private volatile ConfigurableListableBeanFactory beanFactory; /** * Set the {@link BeanWiringInfoResolver} to use. * <p>The default behavior is to look for a bean with the same name as the class. * As an alternative, consider using annotation-driven bean wiring. * @see ClassNameBeanWiringInfoResolver * @see org.springframework.beans.factory.annotation.AnnotationBeanWiringInfoResolver */ public void setBeanWiringInfoResolver(BeanWiringInfoResolver beanWiringInfoResolver) { Assert.notNull(beanWiringInfoResolver, "BeanWiringInfoResolver must not be null"); this.beanWiringInfoResolver = beanWiringInfoResolver; } /** * Set the {@link BeanFactory} in which this aspect must configure beans. */ @Override public void setBeanFactory(BeanFactory beanFactory) { if (!(beanFactory instanceof ConfigurableListableBeanFactory)) { throw new IllegalArgumentException( "Bean configurer aspect needs to run in a ConfigurableListableBeanFactory: " + beanFactory); } this.beanFactory = (ConfigurableListableBeanFactory) beanFactory; if (this.beanWiringInfoResolver == null) { this.beanWiringInfoResolver = createDefaultBeanWiringInfoResolver(); } } /** * Create the default BeanWiringInfoResolver to be used if none was * specified explicitly. * <p>The default implementation builds a {@link ClassNameBeanWiringInfoResolver}. * @return the default BeanWiringInfoResolver (never {@code null}) */ @Nullable protected BeanWiringInfoResolver createDefaultBeanWiringInfoResolver() { return new ClassNameBeanWiringInfoResolver(); } /** * Check that a {@link BeanFactory} has been set. */ @Override public void afterPropertiesSet() { Assert.notNull(this.beanFactory, "BeanFactory must be set"); } /** * Release references to the {@link BeanFactory} and * {@link BeanWiringInfoResolver} when the container is destroyed. */ @Override public void destroy() { this.beanFactory = null; this.beanWiringInfoResolver = null; } /** * Configure the bean instance. * <p>Subclasses can override this to provide custom configuration logic. * Typically called by an aspect, for all bean instances matched by a pointcut. * @param beanInstance the bean instance to configure (must <b>not</b> be {@code null}) */ public void configureBean(Object beanInstance) { if (this.beanFactory == null) { if (logger.isDebugEnabled()) { logger.debug("BeanFactory has not been set on " + ClassUtils.getShortName(getClass()) + ": " + "Make sure this configurer runs in a Spring container. Unable to configure bean of type [" + ClassUtils.getDescriptiveType(beanInstance) + "]. Proceeding without injection."); } return; } BeanWiringInfoResolver bwiResolver = this.beanWiringInfoResolver; Assert.state(bwiResolver != null, "No BeanWiringInfoResolver available"); BeanWiringInfo bwi = bwiResolver.resolveWiringInfo(beanInstance); if (bwi == null) { // Skip the bean if no wiring info given. return; } ConfigurableListableBeanFactory beanFactory = this.beanFactory; Assert.state(beanFactory != null, "No BeanFactory available"); try { String beanName = bwi.getBeanName(); if (bwi.indicatesAutowiring() || (bwi.isDefaultBeanName() && beanName != null && !beanFactory.containsBean(beanName))) { // Perform autowiring (also applying standard factory / post-processor callbacks). beanFactory.autowireBeanProperties(beanInstance, bwi.getAutowireMode(), bwi.getDependencyCheck()); beanFactory.initializeBean(beanInstance, (beanName != null ? beanName : "")); } else { // Perform explicit wiring based on the specified bean definition. beanFactory.configureBean(beanInstance, (beanName != null ? beanName : "")); } } catch (BeanCreationException ex) { Throwable rootCause = ex.getMostSpecificCause(); if (rootCause instanceof BeanCurrentlyInCreationException) { BeanCreationException bce = (BeanCreationException) rootCause; String bceBeanName = bce.getBeanName(); if (bceBeanName != null && beanFactory.isCurrentlyInCreation(bceBeanName)) { if (logger.isDebugEnabled()) { logger.debug("Failed to create target bean '" + bce.getBeanName() + "' while configuring object of type [" + beanInstance.getClass().getName() + "] - probably due to a circular reference. This is a common startup situation " + "and usually not fatal. Proceeding without injection. Original exception: " + ex); } return; } } throw ex; } } }