我们在用context获取bean的时候，其实底层都是操作的DefaultListableBeanFactory这个类。这个类中主要分为两块:

1. 注册bean:解析class,封装为beanDefinition对象；
2. 从beanDefinition中实例化对象。

先看下是如何保存数据的。

beanDefinition对象

DefaultListableBeanFactory中的属性：

	// key：bean的名称// value：BeanDefinition对象private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);//通过类型保存key:类型，value:bean的名称private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);// 这里只保存了单例的private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);// 所有bean的名称private volatile List<String> beanDefinitionNames = new ArrayList<>(256);// 手动添加的bean的名称// 为什么有手动添加的呢？因为我们可以操作context,添加自己的BeanDefinition,这就是手动添加的，会加入到这个set中。private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

实例对象

从DefaultListableBeanFactory一直找父类，会找到DefaultSingletonBeanRegistry

	//bean名称  bean实例private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);//保存的是ObjectFactory的类private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);//早期暴露的bean，用于解决循环依赖private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);// 实例的名称。private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

知道了在哪里保存数据，那么就开始看从哪里开始解析类，并封装为beandefinitions类。由于spring支持配置文件和注解。所以分别看下是如何注册bean的。

ClassPathXmlApplicationContext 解析配置文件注册bean

我们在使用的时候通常都是这样创建的：

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

传入spring的配置文件，通过解析里面的配置，注册到容器中。

	public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException {super(parent);// 设置配置文件的路径setConfigLocations(configLocations);if (refresh) {// 调用刷新方法。refresh();}}

刷新方法在org.springframework.context.support.AbstractApplicationContext#refresh()，这里面有众多的方法。xml的解析在obtainFreshBeanFactory方法中

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {// 刷新工厂，并将工厂返回refreshBeanFactory();return getBeanFactory();}

org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory

	protected final void refreshBeanFactory() throws BeansException {// 如果已经有了，就销毁，重新创建。if (hasBeanFactory()) {destroyBeans();closeBeanFactory();}try {// 实例化工厂，就是创建DefaultListableBeanFactory对象DefaultListableBeanFactory beanFactory = createBeanFactory();beanFactory.setSerializationId(getId());customizeBeanFactory(beanFactory);// 将配置文件中的配置，注册到beanFactory中。loadBeanDefinitions(beanFactory);synchronized (this.beanFactoryMonitor) {this.beanFactory = beanFactory;}}catch (IOException ex) {throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);}}

---

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)

	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {Resource[] configResources = getConfigResources();if (configResources != null) {reader.loadBeanDefinitions(configResources);}String[] configLocations = getConfigLocations();if (configLocations != null) {reader.loadBeanDefinitions(configLocations);}}

XmlBeanDefinitionReader实例化的时候已经将beanFactory放进入了，现在传入配置文件的路径。

继续深入，找到方法：

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions

	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {if (delegate.isDefaultNamespace(root)) {NodeList nl = root.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (node instanceof Element) {Element ele = (Element) node;if (delegate.isDefaultNamespace(ele)) {parseDefaultElement(ele, delegate);}else {delegate.parseCustomElement(ele);}}}}else {delegate.parseCustomElement(root);}}

通过命名空间，解析标签。就行，，在不同的命名空间下
先看本命名空间下的：

	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {// import标签，导入其他的配置文件。if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {importBeanDefinitionResource(ele);}// 别名标签else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {processAliasRegistration(ele);}// bean标签else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {processBeanDefinition(ele, delegate);}//beans标签else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {// recursedoRegisterBeanDefinitions(ele);}}

importBeanDefinitionResource：用来解析import标签的。import标签就是用来引入其他的配置文件的；内部逻辑是得到location数据，接续用XmlBeanDefinitionReader解析这个路径。其实就是解析配置问价的逻辑

processAliasRegistration：解析alias标签，将别名解析出来，key：bean名称，value是别名，放入到别名的map中。

processBeanDefinition：解析bean标签。bean标签中的数据会直接对应beandenition中的属性。property标签会解析为PropertyValue，添加到bf的属性集合中。构造函数也是类似的逻辑。

doRegisterBeanDefinitions：解析beans标签，就是递归了，还是调用同样的逻辑，现在解析的就是beans标签内的内容。

---

看下其他命名空间的解析：

解析对应的标签。
org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse

	public BeanDefinition parse(Element element, ParserContext parserContext) {BeanDefinitionParser parser = findParserForElement(element, parserContext);return (parser != null ? parser.parse(element, parserContext) : null);}

这里开始不同的命名空间，使用不同的解析器了

看名字就知道对应那些标签了：

AnnotationConfigBeanDefinitionParser

代码就补贴了，直接说做了那些事情。注册了一些bean，这些bean是做什么的呢？
ConfigurationClassPostProcessor：用来解析配置类（@configuration）的

AutowiredAnnotationBeanPostProcessor: @Autowired依赖注入的处理器

CommonAnnotationBeanPostProcessor：@resource依赖注入的处理器

EventListenerMethodProcessor
DefaultEventListenerFactory
后面这两也给注入了，我还没看。

AnnotationDrivenBeanDefinitionParser

也是注册了2个bean:这两个好分析，就是创建一个代理，将代理的的方法放在一个线程中执行。

AsyncAnnotationBeanPostProcessor
ScheduledAnnotationBeanPostProcessor

AnnotationDrivenCacheBeanDefinitionParser

看名字是spring的Cache有关，依旧是注册的和其相关的处理器类。
有两个方式，一种是切面，一种是代理。切面的没了解过，代理是注册了InfrastructureAdvisorAutoProxyCreator类，他是专门解析spring内部的切面的，啥是spring内部的呢？Role() == BeanDefinition.ROLE_INFRASTRUCTURE

AspectJAutoProxyBeanDefinitionParser

一看就是和aop相关的，注册是处理器是AnnotationAwareAspectJAutoProxyCreator

ComponentScanBeanDefinitionParser

扫描包的处理器：

	public BeanDefinition parse(Element element, ParserContext parserContext) {String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);// 解析包名的处理器ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);registerComponents(parserContext.getReaderContext(), beanDefinitions, element);return null;}

注意：ClassPathBeanDefinitionScanner 的doScan方法就已经经扫描到的bean注册了。registerComponents方法包含了上面AnnotationConfigBeanDefinitionParser的功能。

还有一些其他的解析器。就自行分析吧。

---

ClassPathXmlApplicationContext 的注册bean就已经分析完了：除了bean标签是真正的注册bean,其他的标签都是注册的功能的处理器。

下面看下注解的容器是如何注册bean的，思考下：ClassPathXmlApplicationContext 是通过解析标签是注册处理器，那么在AnnotationConfigApplicationContext中一定是用注解来实现注册处理器。

那普通bean怎么注册呢？猜测一下，应该是扫描的注解。

ClassPathXmlApplicationContext 是给一个配置文件。解析文件。
AnnotationConfigApplicationContext：给一个有配置注解的类。解析类中的注解。

AnnotationConfigApplicationContext解析配置类

ClassPathXmlApplicationContext 的参数是配置文件路径；可以传多个路径，或者在一个总的文件问价中import标签引入其他的配置文件；

AnnotationConfigApplicationContext则需要传进配置类；同样可以传进来多个；但通常只会传主的配置类。之后主配置类中注解：@compoentscan；扫描bean和配置类。再进行解析。

	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {// 调用自身的构造器this();// 将主配置类注册register(componentClasses);// 刷新方法refresh();}//无参构造器创建了两个对象。public AnnotationConfigApplicationContext() {// 读取注解的处理器this.reader = new AnnotatedBeanDefinitionReader(this);// 用来扫描bean的处理器this.scanner = new ClassPathBeanDefinitionScanner(this);}

创建AnnotatedBeanDefinitionReader对象时，注册了几个bean,是AnnotationConfigBeanDefinitionParser功能中注册的那几bean;注意：ConfigurationClassPostProcessor这个bean就是用来解析配置类的。

创建ClassPathBeanDefinitionScanner时，只是配置了扫描的条件。

再了解注解类型的容器是如何解析类并封装为beanDefinition的，先看下这篇文章：
【Spring-IOC】通过BeanFactoryPostProcessor实现BeanFactory的定制化

上面的基础上，看下这个类：ConfigurationClassPostProcessor，没有就是AnnotatedBeanDefinitionReader给注册的。

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware

实现了BeanDefinitionRegistryPostProcessor，有实现了PriorityOrdered。知道哪里调用这个类了吧。

直接看postProcessBeanDefinitionRegistry方法。

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {int registryId = System.identityHashCode(registry);if (this.registriesPostProcessed.contains(registryId)) {throw new IllegalStateException("postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);}if (this.factoriesPostProcessed.contains(registryId)) {throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + registry);}// 避免重复解析this.registriesPostProcessed.add(registryId);processConfigBeanDefinitions(registry);}

	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {List<BeanDefinitionHolder> configCandidates = new ArrayList<>();// 找出所有注册的bean名称String[] candidateNames = registry.getBeanDefinitionNames();for (String beanName : candidateNames) {BeanDefinition beanDef = registry.getBeanDefinition(beanName);if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {if (logger.isDebugEnabled()) {logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);}}// 如果是用@configuration注解注释的，添加集合else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));}}// Return immediately if no @Configuration classes were foundif (configCandidates.isEmpty()) {return;}// Sort by previously determined @Order value, if applicableconfigCandidates.sort((bd1, bd2) -> {int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());return Integer.compare(i1, i2);});// Detect any custom bean name generation strategy supplied through the enclosing application contextSingletonBeanRegistry sbr = null;if (registry instanceof SingletonBeanRegistry) {sbr = (SingletonBeanRegistry) registry;if (!this.localBeanNameGeneratorSet) {BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);if (generator != null) {this.componentScanBeanNameGenerator = generator;this.importBeanNameGenerator = generator;}}}if (this.environment == null) {this.environment = new StandardEnvironment();}// 创建@Configuration类解析器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();// 剩下的代码：先分析parser.parse(candidates);。。。。}

跳过了一些方法，直接看这个：

	protected final void parse(@Nullable String className, String beanName) throws IOException {Assert.notNull(className, "No bean class name for configuration class bean definition");MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);processConfigurationClass(new ConfigurationClass(reader, beanName));}

每个配置类对应一个ConfigurationClass；

---

真正的解析配置类：

	protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)throws IOException {// 配置类，必然是Component注解标注的。// 这个方法是解析内部类的，如果内部类用@configuration注解标注了，会先解析内部类的。if (configClass.getMetadata().isAnnotated(Component.class.getName())) {processMemberClasses(configClass, sourceClass);}// @PropertySource 解析这个注解的逻辑也很简单，就是将property文件解析出来，键值对放入到环境中。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");}}// 解析@ComponentScan注解// 根据报名，扫描包，直接注入bean,返回beanDefinition集合。// 从中筛选。如果是配置类的，还要解析这个配置类。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 immediatelySet<BeanDefinitionHolder> scannedBeanDefinitions =this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());// Check the set of scanned definitions for any further config classes and parse recursively if neededfor (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());}}}}// @Import 导入配置类。对标的是xml中的import标签。// getImports(sourceClass)是得到import注解设置的类。processImports(configClass, sourceClass, getImports(sourceClass), true);// Process any @ImportResource annotationsAnnotationAttributes 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);}}// 解析@Bean注解：找到所有方法，添加到configClass属性中。Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);for (MethodMetadata methodMetadata : beanMethods) {configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));}// Process default methods on interfacesprocessInterfaces(configClass, sourceClass);// Process superclass, if anyif (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 recursereturn sourceClass.getSuperClass();}}// No superclass -> processing is completereturn null;}

注意，这里只是将解析，之后添加到configClass的属性中，并没有封装为bd.

解析内部类

	private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {// 得到内部类集合Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();if (!memberClasses.isEmpty()) {List<SourceClass> candidates = new ArrayList<>(memberClasses.size());for (SourceClass memberClass : memberClasses) {// 如果内部类使用@configuration注解标注，添加到集合。if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&!memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {candidates.add(memberClass);}}OrderComparator.sort(candidates);// 遍历集合。解析内部配置类：for (SourceClass candidate : candidates) {if (this.importStack.contains(configClass)) {this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));}else {this.importStack.push(configClass);try {// 这里传进来的是内部类的classprocessConfigurationClass(candidate.asConfigClass(configClass));}finally {this.importStack.pop();}}}}}

解析import注解

先给出基础只是：
import是导入的配置配置类；
如果import注解中标注的类是ImportSelector类型，该类的selectImports方法返回的才是导入的配置类，而并非该类。

如果标注的类是ImportBeanDefinitionRegistrar，那么会给传入注册中心。自己注册。

如果是普通类型的，那么该类才是真正的配置类。

	private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,Collection<SourceClass> importCandidates, boolean checkForCircularImports) {// Collection<SourceClass> importCandidates是import注解中标注的类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) {// 如果是ImportSelector类型，if (candidate.isAssignable(ImportSelector.class)) {// Candidate class is an ImportSelector -> delegate to it to determine importsClass<?> candidateClass = candidate.loadClass();ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,this.environment, this.resourceLoader, this.registry);if (selector instanceof DeferredImportSelector) {this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);}else {// 这里看到了吗？得到selectImports方法的返回值，再次调用来的本方法processImports，进行解析，知道找到普通的类或者ImportBeanDefinitionRegistrar类。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 ->// ImportBeanDefinitionRegistrar类型的会实例化，之后添加到configClass的属性中。Class<?> candidateClass = candidate.loadClass();ImportBeanDefinitionRegistrar registrar =ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,this.environment, this.resourceLoader, this.registry);configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());}else {// 如果是普通的bean,那么它是以得配置类。放入configClass的属性中，通知再次解析配置类。调用processConfigurationClass方法。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();}}}

import注解是十分复杂的，还需要反复思考：
可以这样理解：ImportSelector是批量导入的类的。ImportBeanDefinitionRegistrar是手动添加beanDefinition的，普通的才是真正的配置类。

梳理下解析有哪块生成了新的ConfigurationClass。

1. 内部类的
2. 包扫描的，如果是配置类，会生成新的。
3. import注解，普通的，会生成新的。

注意生成新的就是要对该类进行再一步的解析。所以的ConfigurationClass都缓存到了ConfigurationClassParser 中。

下面看下processConfigBeanDefinitions剩下的方法：

		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 contentif (this.reader == null) {this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment,this.importBeanNameGenerator, parser.getImportRegistry());}// 将配置类封装为bdthis.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());

之所以使用while循环。是判断是否有新的配置类生成，有点话就要再次解析。

---

封装为beanDefinition

	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;}// 就是import的普通类。// 解析了几个注解：@lazy,@dependon,@primary等if (configClass.isImported()) {registerBeanDefinitionForImportedConfigurationClass(configClass);}// bean方法，主要是@bean注解中属性的封装为bd中的属性。// 该方法设置为工厂方法for (BeanMethod beanMethod : configClass.getBeanMethods()) {loadBeanDefinitionsForBeanMethod(beanMethod);}// 引入配置文件，xmlBeanDefinitionreader解析这个配置文件loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());//这个是import中是importBeanDefinitionRegistrar类型。调用方法。手动注册。loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());}

到此位置，bean的解析已经完成。。