SpringBoot注解@Import原理之关于ConfigurationClassPostProcessor源码解析

@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;
 }