@Import({ abc.class , abd.class... })
public class Config {
}

public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {

	private static final String ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME =
			"org.springframework.scheduling.aspectj.AspectJAsyncConfiguration";
			
	@Override
	@Nullable
	public String[] selectImports(AdviceMode adviceMode) {
		switch (adviceMode) {
			case PROXY:
				return new String[] {ProxyAsyncConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};
			default:
				return null;
		}
	}

}

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}

public ConfigurableApplicationContext run(String... args) {
 	
 	......
 	
 	try {
 		ApplicationArguments applicationArguments = new DefaultApplicationArguments(
 				args);
 		ConfigurableEnvironment environment = prepareEnvironment(listeners,
 				applicationArguments);
 		configureIgnoreBeanInfo(environment);
 		Banner printedBanner = printBanner(environment);
 		context = createApplicationContext();
 		exceptionReporters = getSpringFactoriesInstances(
 				SpringBootExceptionReporter.class,
 				new Class[] { ConfigurableApplicationContext.class }, context);
 		prepareContext(context, environment, listeners, applicationArguments,
 				printedBanner);
 		refreshContext(context);
 		afterRefresh(context, applicationArguments);
 		stopWatch.stop();
 		
 	......
 	
 	return context;
 }

protected void load(ApplicationContext context, Object[] sources) {
 	if (logger.isDebugEnabled()) {
 		logger.debug(
 				"Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
 	}
 	BeanDefinitionLoader loader = createBeanDefinitionLoader(
 			getBeanDefinitionRegistry(context), sources);
 	if (this.beanNameGenerator != null) {
 		loader.setBeanNameGenerator(this.beanNameGenerator);
 	}
 	if (this.resourceLoader != null) {
 		loader.setResourceLoader(this.resourceLoader);
 	}
 	if (this.environment != null) {
 		loader.setEnvironment(this.environment);
 	}
 	loader.load();
 }

protected BeanDefinitionLoader createBeanDefinitionLoader(
		BeanDefinitionRegistry registry, Object[] sources) {
	return new BeanDefinitionLoader(registry, sources);
}

BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
 	Assert.notNull(registry, "Registry must not be null");
 	Assert.notEmpty(sources, "Sources must not be empty");
 	this.sources = sources;
 	this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
 	this.xmlReader = new XmlBeanDefinitionReader(registry);
 	if (isGroovyPresent()) {
 		this.groovyReader = new GroovyBeanDefinitionReader(registry);
 	}
 	this.scanner = new ClassPathBeanDefinitionScanner(registry);
 	this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));
 }

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
 	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
 	Assert.notNull(environment, "Environment must not be null");
 	this.registry = registry;
 	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
 	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
 }

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
 		BeanDefinitionRegistry registry, @Nullable Object source) {
    ......

 	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

 	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
 		def.setSource(source);
 		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
 	}
    ......

 	return beanDefs;
 }

public void refresh() throws BeansException, IllegalStateException {
 	synchronized (this.startupShutdownMonitor) {
 		// Prepare this context for refreshing.
 		prepareRefresh();

 		// Tell the subclass to refresh the internal bean factory.
 		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

 		// Prepare the bean factory for use in this context.
 		prepareBeanFactory(beanFactory);

 		try {
 			// Allows post-processing of the bean factory in context subclasses.
 			postProcessBeanFactory(beanFactory);

 			// Invoke factory processors registered as beans in the context.
 			invokeBeanFactoryPostProcessors(beanFactory);

 			// Register bean processors that intercept bean creation.
 			registerBeanPostProcessors(beanFactory);

 			// Initialize message source for this context.
 			initMessageSource();

 			// Initialize event multicaster for this context.
 			initApplicationEventMulticaster();

 			// Initialize other special beans in specific context subclasses.
 			onRefresh();

 			// Check for listener beans and register them.
 			registerListeners();

 			// Instantiate all remaining (non-lazy-init) singletons.
 			finishBeanFactoryInitialization(beanFactory);

 			// Last step: publish corresponding event.
 			finishRefresh();
 		}

 		......
 	}
 }

public static void invokeBeanFactoryPostProcessors(
 		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
     
     ......
 	
 	// Do not initialize FactoryBeans here: We need to leave all regular beans
 	// uninitialized to let the bean factory post-processors apply to them!
 	String[] postProcessorNames =
 			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

 	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
 	// Ordered, and the rest.
 	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
 	List<String> orderedPostProcessorNames = new ArrayList<>();
 	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
 	for (String ppName : postProcessorNames) {
 		if (processedBeans.contains(ppName)) {
 			// skip - already processed in first phase above
 		}
 		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
 		}
 		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
 			orderedPostProcessorNames.add(ppName);
 		}
 		else {
 			nonOrderedPostProcessorNames.add(ppName);
 		}
 	}

 	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
 	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

 	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
 	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
 	for (String postProcessorName : orderedPostProcessorNames) {
 		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 	}
 	sortPostProcessors(orderedPostProcessors, beanFactory);
 	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

 	// Finally, invoke all other BeanFactoryPostProcessors.
 	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
 	for (String postProcessorName : nonOrderedPostProcessorNames) {
 		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 	}
 	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

 	// Clear cached merged bean definitions since the post-processors might have
 	// modified the original metadata, e.g. replacing placeholders in values...
 	beanFactory.clearMetadataCache();
 }

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 	int factoryId = System.identityHashCode(beanFactory);
 	if (this.factoriesPostProcessed.contains(factoryId)) {
 		throw new IllegalStateException(
 				"postProcessBeanFactory already called on this post-processor against " + beanFactory);
 	}
 	this.factoriesPostProcessed.add(factoryId);
 	if (!this.registriesPostProcessed.contains(factoryId)) {
 		// BeanDefinitionRegistryPostProcessor hook apparently not supported...
 		// Simply call processConfigurationClasses lazily at this point then.
 		processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
 	}

 	enhanceConfigurationClasses(beanFactory);
 	beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
 }

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {

 	......
 	
 	// Parse each @Configuration class
 	ConfigurationClassParser parser = new ConfigurationClassParser(
 			this.metadataReaderFactory, this.problemReporter, this.environment,
 			this.resourceLoader, this.componentScanBeanNameGenerator, registry);

 	Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
 	Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
 	do {
 		parser.parse(candidates);
 		parser.validate();

 		Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
 		configClasses.removeAll(alreadyParsed);

 		// Read the model and create bean definitions based on its content
 		if (this.reader == null) {
 			this.reader = new ConfigurationClassBeanDefinitionReader(
 					registry, this.sourceExtractor, this.resourceLoader, this.environment,
 					this.importBeanNameGenerator, parser.getImportRegistry());
 		}
 		this.reader.loadBeanDefinitions(configClasses);
 		alreadyParsed.addAll(configClasses);

 		candidates.clear();
 		if (registry.getBeanDefinitionCount() > candidateNames.length) {
 			String[] newCandidateNames = registry.getBeanDefinitionNames();
 			Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
 			Set<String> alreadyParsedClasses = new HashSet<>();
 			for (ConfigurationClass configurationClass : alreadyParsed) {
 				alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
 			}
 			for (String candidateName : newCandidateNames) {
 				if (!oldCandidateNames.contains(candidateName)) {
 					BeanDefinition bd = registry.getBeanDefinition(candidateName);
 					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
 							!alreadyParsedClasses.contains(bd.getBeanClassName())) {
 						candidates.add(new BeanDefinitionHolder(bd, candidateName));
 					}
 				}
 			}
 			candidateNames = newCandidateNames;
 		}
 	}
 	while (!candidates.isEmpty());

 	// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
 	if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
 		sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
 	}

 	if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
 		// Clear cache in externally provided MetadataReaderFactory; this is a no-op
 		// for a shared cache since it'll be cleared by the ApplicationContext.
 		((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
 	}
 }

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
 	if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
 		return;
 	}

 	ConfigurationClass existingClass = this.configurationClasses.get(configClass);
 	if (existingClass != null) {
 		if (configClass.isImported()) {
 			if (existingClass.isImported()) {
 				existingClass.mergeImportedBy(configClass);
 			}
 			// Otherwise ignore new imported config class; existing non-imported class overrides it.
 			return;
 		}
 		else {
 			// Explicit bean definition found, probably replacing an import.
 			// Let's remove the old one and go with the new one.
 			this.configurationClasses.remove(configClass);
 			this.knownSuperclasses.values().removeIf(configClass::equals);
 		}
 	}

 	// Recursively process the configuration class and its superclass hierarchy.
 	SourceClass sourceClass = asSourceClass(configClass);
 	do {
 		sourceClass = doProcessConfigurationClass(configClass, sourceClass);
 	}
 	while (sourceClass != null);

 	this.configurationClasses.put(configClass, configClass);
 }

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
 		throws IOException {

 	if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
 		// Recursively process any member (nested) classes first
 		processMemberClasses(configClass, sourceClass);
 	}

 	// Process any @PropertySource annotations
 	for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
 			sourceClass.getMetadata(), PropertySources.class,
 			org.springframework.context.annotation.PropertySource.class)) {
 		if (this.environment instanceof ConfigurableEnvironment) {
 			processPropertySource(propertySource);
 		}
 		else {
 			logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
 					"]. Reason: Environment must implement ConfigurableEnvironment");
 		}
 	}

 	// Process any @ComponentScan annotations
 	Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
 			sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
 	if (!componentScans.isEmpty() &&
 			!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
 		for (AnnotationAttributes componentScan : componentScans) {
 			// The config class is annotated with @ComponentScan -> perform the scan immediately
 			Set<BeanDefinitionHolder> scannedBeanDefinitions =
 					this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
 			// Check the set of scanned definitions for any further config classes and parse recursively if needed
 			for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
 				BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
 				if (bdCand == null) {
 					bdCand = holder.getBeanDefinition();
 				}
 				if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
 					parse(bdCand.getBeanClassName(), holder.getBeanName());
 				}
 			}
 		}
 	}

 	// Process any @Import annotations
 	processImports(configClass, sourceClass, getImports(sourceClass), true);

 	// Process any @ImportResource annotations
 	AnnotationAttributes importResource =
 			AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
 	if (importResource != null) {
 		String[] resources = importResource.getStringArray("locations");
 		Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
 		for (String resource : resources) {
 			String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
 			configClass.addImportedResource(resolvedResource, readerClass);
 		}
 	}

 	// Process individual @Bean methods
 	Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
 	for (MethodMetadata methodMetadata : beanMethods) {
 		configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
 	}

 	// Process default methods on interfaces
 	processInterfaces(configClass, sourceClass);

 	// Process superclass, if any
 	if (sourceClass.getMetadata().hasSuperClass()) {
 		String superclass = sourceClass.getMetadata().getSuperClassName();
 		if (superclass != null && !superclass.startsWith("java") &&
 				!this.knownSuperclasses.containsKey(superclass)) {
 			this.knownSuperclasses.put(superclass, configClass);
 			// Superclass found, return its annotation metadata and recurse
 			return sourceClass.getSuperClass();
 		}
 	}

 	// No superclass -> processing is complete
 	return null;
 }

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
 		Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

 	if (importCandidates.isEmpty()) {
 		return;
 	}

 	if (checkForCircularImports && isChainedImportOnStack(configClass)) {
 		this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
 	}
 	else {
 		this.importStack.push(configClass);
 		try {
 			for (SourceClass candidate : importCandidates) {
 				if (candidate.isAssignable(ImportSelector.class)) {
 					// Candidate class is an ImportSelector -> delegate to it to determine imports
 					Class<?> candidateClass = candidate.loadClass();
 					ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
 					ParserStrategyUtils.invokeAwareMethods(
 							selector, this.environment, this.resourceLoader, this.registry);
 					if (selector instanceof DeferredImportSelector) {
 						this.deferredImportSelectorHandler.handle(
 								configClass, (DeferredImportSelector) selector);
 					}
 					else {
 						String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
 						Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
 						processImports(configClass, currentSourceClass, importSourceClasses, false);
 					}
 				}
 				else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
 					// Candidate class is an ImportBeanDefinitionRegistrar ->
 					// delegate to it to register additional bean definitions
 					Class<?> candidateClass = candidate.loadClass();
 					ImportBeanDefinitionRegistrar registrar =
 							BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
 					ParserStrategyUtils.invokeAwareMethods(
 							registrar, this.environment, this.resourceLoader, this.registry);
 					configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
 				}
 				else {
 					// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
 					// process it as an @Configuration class
 					this.importStack.registerImport(
 							currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
 					processConfigurationClass(candidate.asConfigClass(configClass));
 				}
 			}
 		}
 		catch (BeanDefinitionStoreException ex) {
 			throw ex;
 		}
 		catch (Throwable ex) {
 			throw new BeanDefinitionStoreException(
 					"Failed to process import candidates for configuration class [" +
 					configClass.getMetadata().getClassName() + "]", ex);
 		}
 		finally {
 			this.importStack.pop();
 		}
 	}
 }

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
 	TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
 	for (ConfigurationClass configClass : configurationModel) {
 		loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
 	}
 }

 private void loadBeanDefinitionsForConfigurationClass(
 		ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

 	if (trackedConditionEvaluator.shouldSkip(configClass)) {
 		String beanName = configClass.getBeanName();
 		if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
 			this.registry.removeBeanDefinition(beanName);
 		}
 		this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
 		return;
 	}

 	if (configClass.isImported()) {
 		registerBeanDefinitionForImportedConfigurationClass(configClass);
 	}
 	for (BeanMethod beanMethod : configClass.getBeanMethods()) {
 		loadBeanDefinitionsForBeanMethod(beanMethod);
 	}

 	loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
 	loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
 }

public static void registerBeanPostProcessors(
 		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

 	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
     
     ......
 	
 	// Now, register all regular BeanPostProcessors.
 	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
 	for (String ppName : nonOrderedPostProcessorNames) {
 		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
 		nonOrderedPostProcessors.add(pp);
 		if (pp instanceof MergedBeanDefinitionPostProcessor) {
 			internalPostProcessors.add(pp);
 		}
 	}
 	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

 	// Finally, re-register all internal BeanPostProcessors.
 	sortPostProcessors(internalPostProcessors, beanFactory);
 	registerBeanPostProcessors(beanFactory, internalPostProcessors);

 	// Re-register post-processor for detecting inner beans as ApplicationListeners,
 	// moving it to the end of the processor chain (for picking up proxies etc).
 	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
 }

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
 		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        
        ......
 		
 		// Check if bean definition exists in this factory.
 		BeanFactory parentBeanFactory = getParentBeanFactory();
 		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
 			// Not found -> check parent.
 			String nameToLookup = originalBeanName(name);
 			if (parentBeanFactory instanceof AbstractBeanFactory) {
 				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
 						nameToLookup, requiredType, args, typeCheckOnly);
 			}
 			else if (args != null) {
 				// Delegation to parent with explicit args.
 				return (T) parentBeanFactory.getBean(nameToLookup, args);
 			}
 			else if (requiredType != null) {
 				// No args -> delegate to standard getBean method.
 				return parentBeanFactory.getBean(nameToLookup, requiredType);
 			}
 			else {
 				return (T) parentBeanFactory.getBean(nameToLookup);
 			}
 		}

 		if (!typeCheckOnly) {
 			markBeanAsCreated(beanName);
 		}

 		try {
 			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 			checkMergedBeanDefinition(mbd, beanName, args);

 			// Guarantee initialization of beans that the current bean depends on.
 			String[] dependsOn = mbd.getDependsOn();
 			if (dependsOn != null) {
 				for (String dep : dependsOn) {
 					if (isDependent(beanName, dep)) {
 						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
 					}
 					registerDependentBean(dep, beanName);
 					try {
 						getBean(dep);
 					}
 					catch (NoSuchBeanDefinitionException ex) {
 						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
 					}
 				}
 			}

 			// Create bean instance.
 			if (mbd.isSingleton()) {
 				sharedInstance = getSingleton(beanName, () -> {
 					try {
 						return createBean(beanName, mbd, args);
 					}
 					catch (BeansException ex) {
 						// Explicitly remove instance from singleton cache: It might have been put there
 						// eagerly by the creation process, to allow for circular reference resolution.
 						// Also remove any beans that received a temporary reference to the bean.
 						destroySingleton(beanName);
 						throw ex;
 					}
 				});
 				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 			}

 			else if (mbd.isPrototype()) {
 				// It's a prototype -> create a new instance.
 				Object prototypeInstance = null;
 				try {
 					beforePrototypeCreation(beanName);
 					prototypeInstance = createBean(beanName, mbd, args);
 				}
 				finally {
 					afterPrototypeCreation(beanName);
 				}
 				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
 			}

 			else {
 				String scopeName = mbd.getScope();
 				final Scope scope = this.scopes.get(scopeName);
 				if (scope == null) {
 					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
 				}
 				try {
 					Object scopedInstance = scope.get(beanName, () -> {
 						beforePrototypeCreation(beanName);
 						try {
 							return createBean(beanName, mbd, args);
 						}
 						finally {
 							afterPrototypeCreation(beanName);
 						}
 					});
 					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
 				}
 				catch (IllegalStateException ex) {
 					throw new BeanCreationException(beanName,
 							"Scope '" + scopeName + "' is not active for the current thread; consider " +
 							"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
 							ex);
 				}
 			}
 		}
 		catch (BeansException ex) {
 			cleanupAfterBeanCreationFailure(beanName);
 			throw ex;
 		}
 	}

 	......
 	
 	return (T) bean;
 }

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
 		throws BeanCreationException {

 	if (logger.isTraceEnabled()) {
 		logger.trace("Creating instance of bean '" + beanName + "'");
 	}
 	RootBeanDefinition mbdToUse = mbd;

 	// Make sure bean class is actually resolved at this point, and
 	// clone the bean definition in case of a dynamically resolved Class
 	// which cannot be stored in the shared merged bean definition.
 	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
 	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
 		mbdToUse = new RootBeanDefinition(mbd);
 		mbdToUse.setBeanClass(resolvedClass);
 	}

 	// Prepare method overrides.
 	try {
 		mbdToUse.prepareMethodOverrides();
 	}
 	catch (BeanDefinitionValidationException ex) {
 		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
 				beanName, "Validation of method overrides failed", ex);
 	}

 	try {
 		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
 		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
 		if (bean != null) {
 			return bean;
 		}
 	}
 	catch (Throwable ex) {
 		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
 				"BeanPostProcessor before instantiation of bean failed", ex);
 	}

 	try {
 		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
 		if (logger.isTraceEnabled()) {
 			logger.trace("Finished creating instance of bean '" + beanName + "'");
 		}
 		return beanInstance;
 	}
 	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
 		// A previously detected exception with proper bean creation context already,
 		// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
 		throw ex;
 	}
 	catch (Throwable ex) {
 		throw new BeanCreationException(
 				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
 	}
 }

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	......

	// Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		if (logger.isTraceEnabled()) {
			logger.trace("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		populateBean(beanName, mbd, instanceWrapper);
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
			throw (BeanCreationException) ex;
		}
		else {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
		}
	}

	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException(beanName,
							"Bean with name '" + beanName + "' has been injected into other beans [" +
							StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
							"] in its raw version as part of a circular reference, but has eventually been " +
							"wrapped. This means that said other beans do not use the final version of the " +
							"bean. This is often the result of over-eager type matching - consider using " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}

	// Register bean as disposable.
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

private void invokeAwareMethods(final String beanName, final Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

 public void setBeanFactory(BeanFactory beanFactory) {
 	super.setBeanFactory(beanFactory);

 	AsyncAnnotationAdvisor advisor = new AsyncAnnotationAdvisor(this.executor, this.exceptionHandler);
 	if (this.asyncAnnotationType != null) {
 		advisor.setAsyncAnnotationType(this.asyncAnnotationType);
 	}
 	advisor.setBeanFactory(beanFactory);
 	this.advisor = advisor;
 }