Spring源码
public AnnotationConfigApplicationContext(String... basePackages) { this(); scan(basePackages); refresh(); }
1）this()方法
AnnotationConfigApplicationContext继承父类GenericApplicationContext，会执行父类的构造方法去创建一个DefaultListableBeanFactory容器
public AnnotationConfigApplicationContext() { //初始化读取注解的Bean定义读取器，并注册注解配置的的处理器 this.reader = new AnnotatedBeanDefinitionReader(this); //初始化一个ClassPath类型的Bean的扫描器 this.scanner = new ClassPathBeanDefinitionScanner(this); }
在构造AnnotatedBeanDefinitionReader时Spring会添加内置的后置处理器；
//注册内置处理器 AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); //五个内置处理器 ConfigurationClassPostProcessor = "org.springframework.context.annotation.internalConfigurationAnnotationProcessor" implements BeanDefinitionRegistryPostProcessor,PriorityOrdered AutowiredAnnotationBeanPostProcessor = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor" implements BeanPostProcessor,PriorityOrdered CommonAnnotationBeanPostProcessor = "org.springframework.context.annotation.internalCommonAnnotationProcessor" implements BeanPostProcessor EventListenerMethodProcessor = "org.springframework.context.event.internalEventListenerProcessor" implements BeanFactoryPostProcessor DefaultEventListenerFactory = "org.springframework.context.event.internalEventListenerFactory"
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) { DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); if (beanFactory != null) { if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); } if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); } } Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(8); RootBeanDefinition def; //用来解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import等注解。 if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) { def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor")); } //用来解析@Autowired和@Value、@Inject注解 if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")) { def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalAutowiredAnnotationProcessor")); } //用来处理@PostConstruct、@PreDestroy和@Resource注解 if (jsr250Present && !registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")) { def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalCommonAnnotationProcessor")); } if (jpaPresent && !registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")) { def = new RootBeanDefinition(); try { def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader())); } catch (ClassNotFoundException var6) { throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6); } def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalPersistenceAnnotationProcessor")); } //用来处理@EventListener事件监听注解 if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")) { def = new RootBeanDefinition(EventListenerMethodProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerProcessor")); } //注册事件监听器工厂 if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")) { def = new RootBeanDefinition(DefaultEventListenerFactory.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerFactory")); } return beanDefs; }
2）scan(basePackages)方法
public int scan(String... basePackages) { // 计数容器中加载的Bean int beanCountAtScanStart = this.registry.getBeanDefinitionCount(); // 开始进行包扫描 doScan(basePackages); // 注册注释配置处理器，如果有需要（再次执行，将自定义的处理器也注册进容器） if (this.includeAnnotationConfig) { AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); } // 返回计数结果 return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart); }
protected Set<BeanDefinitionHolder> doScan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); //创建一个set集合，存储所有扫描的类的源信息 Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>(); for (String basePackage : basePackages) { //扫描对应包下的@Component注解资源，把扫描到的class解析成Resource，最后包装成BeanDefinition 配置信息放到BeanDefinitions集合里 Set<BeanDefinition> candidates = findCandidateComponents(basePackage); for (BeanDefinition candidate : candidates) { //解析bean的scope作用域 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate); candidate.setScope(scopeMetadata.getScopeName()); //生成Bean的名称 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); if (candidate instanceof AbstractBeanDefinition) { //设置bean的一些默认属性，lazy,init,destory方法等 postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } //通过解析类设置bean的一些属性，lazy,Primary,DependsOn等 if (candidate instanceof AnnotatedBeanDefinition) { AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } if (checkCandidate(beanName, candidate)) { BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); //scope 是否需要设置代理 解决@Scope(value = WebApplicationContext.SCOPE_SESSION,proxyMode =ScopedProxyMode.INTERFACES) definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); beanDefinitions.add(definitionHolder); //注册bean的配置信息到Bean定义集合中 registerBeanDefinition(definitionHolder, this.registry); } } } //返回Set，set中存储的是扫描出的类信息，比如 Bean名称、是否是单例的、是否是懒加载、是否是抽象类等 return beanDefinitions; }
findCandidateComponents(basePackage)里最终调用的scanCandidateComponents()来扫描
private Set<BeanDefinition> scanCandidateComponents(String basePackage) { LinkedHashSet candidates = new LinkedHashSet(); try { // 组装扫描包路径信息 String packageSearchPath = "classpath*:" + this.resolveBasePackage(basePackage) + '/' + this.resourcePattern; // 获取该路径下所有class资源 Resource[] resources = this.getResourcePatternResolver().getResources(packageSearchPath); boolean traceEnabled = this.logger.isTraceEnabled(); boolean debugEnabled = this.logger.isDebugEnabled(); Resource[] var7 = resources; int var8 = resources.length; //遍历所有class资源 for(int var9 = 0; var9 < var8; ++var9) { Resource resource = var7[var9]; if (traceEnabled) { this.logger.trace("Scanning " + resource); } //资源是否可读 if (resource.isReadable()) { try { //通过ASM获取class元数据，并封装在MetadataReader元数据读取器中 MetadataReader metadataReader = this.getMetadataReaderFactory().getMetadataReader(resource); //判断是否带有@Component注解，是否符合@CompoentScan的过滤规则 if (this.isCandidateComponent(metadataReader)) { //把元数据转化为 BeanDefinition ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setResource(resource); sbd.setSource(resource); //是否是独立的类、具体的类 if (this.isCandidateComponent((AnnotatedBeanDefinition)sbd)) { if (debugEnabled) { this.logger.debug("Identified candidate component class: " + resource); } candidates.add(sbd); } else if (debugEnabled) { this.logger.debug("Ignored because not a concrete top-level class: " + resource); } } else if (traceEnabled) { this.logger.trace("Ignored because not matching any filter: " + resource); } ...省略
//返回BeanDefinition集合 return candidates; } catch (IOException var14) { throw new BeanDefinitionStoreException("I/O failure during classpath scanning", var14); } }
3）refresh()方法
public void refresh() throws BeansException, IllegalStateException { synchronized(this.startupShutdownMonitor) { //准备工作，记录容器的启动时间、标记“已启动”状态、检查环境变量等 this.prepareRefresh(); //创建一个默认的BeanFactory: DefaultListableBeanFactory，并加载BeanDefinition ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); /*对Bean工厂进行属性填充： 1.设置类加载器，bean表达式解释器，忽略给定接口的自动装配功能 2.添加了ApplicationContextAwareProcessor（获取 applicationContext上下文，资源，系统参数等） ApplicationListenerDetector后置处理器(检测容器中的ApplicationLisenter，将其注册到上下文中)*/ this.prepareBeanFactory(beanFactory); try { //目前没有任何实现 this.postProcessBeanFactory(beanFactory); /* 拿到所有自定义和内置的BeanDefinitionRegistryPostProcessor后置处理器,循环调用postProcessBeanDefinitionRegistry; 其中最重要的是ConfigurationClassPostProcessor处理器的执行：遍历BeanDefinition找到带有@Configuration注解的BeanDefinition, 解析处理配置类中的@Import，@PropertySources，@ComponentScans(如果存在注解，则会扫描对应路径的类转换成BeanDefinition，存入BeanDefinitionMap)，@Bean(同样)注解等 */ this.invokeBeanFactoryPostProcessors(beanFactory); //注册BeanPostProcessor后置处理器 this.registerBeanPostProcessors(beanFactory); //初始化消息资源解析器 this.initMessageSource(); //初始化注册一个单列ApplicationContext事件监听器applicationEventMulticaster this.initApplicationEventMulticaster(); //容器初始化扩展方法，交给子类实现 this.onRefresh(); //注册事件监听器,派发容器初始化的事件：监听器需要实现ApplicationListener接口 this.registerListeners(); //实例所有的单例Bean，创建单例非懒加载的bean this.finishBeanFactoryInitialization(beanFactory); //容器初始化完成 this.finishRefresh(); } catch (BeansException var9) { if (this.logger.isWarnEnabled()) { this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9); } this.destroyBeans(); this.cancelRefresh(var9); throw var9; } finally { this.resetCommonCaches(); } } }
prepareBeanFactory()方法
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 设置类加载器,bean表达式解释器，属性编辑注册器 beanFactory.setBeanClassLoader(this.getClassLoader()); beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment())); // 很重要，添加BeanPostProcessor，完成Bean的applicationContext上下文，资源，系统参数等注入工作!!! beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); // 忽略给定的自动装配依赖接口 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); ... // 注册可以解析的自动装配 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); ... // 注册ApplicationListenerDetector后置处理器，把实现了ApplicationListener接口的单例对象注册到容器的事件集合中去 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); // 如果当前BeanFactory包含loadTimeWeaver Bean，说明存在类加载期织入AspectJ， // 则把当前BeanFactory交给类加载期BeanPostProcessor实现类LoadTimeWeaverAwareProcessor来处理，从而实现类加载期织入AspectJ的目的。 if (beanFactory.containsBean("loadTimeWeaver")) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } // 向当前容器注册环境environment组件Bean,统配置systemProperties组件Bean,系统环境systemEnvironment组件Bean if (!beanFactory.containsLocalBean("environment")) { beanFactory.registerSingleton("environment", this.getEnvironment()); } if (!beanFactory.containsLocalBean("systemProperties")) { beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean("systemEnvironment")) { beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment()); } }
invokeBeanFactoryPostProcessors()方法
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { // 获取容器中的Bean工厂后置处理器(注意这里Bean工厂后置处理器还没有初始化) // getBeanFactoryPostProcessors()方法一般是获取不到值的，除非我们手动调用addBeanFactoryPostProcessor方法或注解@Component来注入BeanFactoryPostProcessors对象 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors()); }
PostProcessorRegistrationDelegate代理invokeBeanFactoryPostProcessors()方法
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { Set<String> processedBeans = new HashSet<>();
//开始处理BeanDefinitionRegistryPostProcessor // 判断beanFactory是否为BeanDefinitionRegistry，beanFactory为DefaultListableBeanFactory,而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此为true if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; // 用于存放普通的BeanFactoryPostProcessor List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); // 用于存放BeanDefinitionRegistryPostProcessor List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); // 首先处理入参中的beanFactoryPostProcessors,遍历区分BeanDefinitionRegistryPostProcessor和普通BeanFactoryPostProcessor for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; // 执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法 registryProcessor.postProcessBeanDefinitionRegistry(registry); // 添加到registryProcessors(用于最后执行postProcessBeanFactory方法) registryProcessors.add(registryProcessor); }else { // 添加到regularPostProcessors(用于最后执行postProcessBeanFactory方法) regularPostProcessors.add(postProcessor); } } // 首先，调用实现PriorityOrdered的BeanDefinitionRegistryPostProcessors // 用于保存本次要执行的BeanDefinitionRegistryPostProcessor。 List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>(); // 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 校验是否实现了PriorityOrdered接口 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } // 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序) sortPostProcessors(currentRegistryProcessors, beanFactory); // 合并 registryProcessors.addAll(currentRegistryProcessors); // 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); // 清空currentRegistryProcessors currentRegistryProcessors.clear(); // 然后调用实现Ordered的BeanDefinitionRegistryPostProcessors。 // 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 校验是否实现了Ordered接口，并且还未执行过 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } //同上，排序,合并，执行，清空 sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); // 最后，调用所有其他BeanDefinitionRegistryPostProcessor，直到没有其他的出现。 boolean reiterate = true; while (reiterate) { reiterate = false; // 找出所有实现BeanDefinitionRegistryPostProcessor接口的类 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 跳过已经执行过的 if (!processedBeans.contains(ppName)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); reiterate = true; } } //同上，排序,合并，执行，清空 sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); } // 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor) invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); // 调用所有普通BeanFactoryPostProcessor的postProcessBeanFactory方法 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); }else { // 调用在上下文实例中注册的工厂处理器。 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } // 到这里,容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕. // 下面开始处理容器中的所有BeanFactoryPostProcessor // 不要在这里初始化FactoryBeans，我们需要保留所有未初始化的常规bean，以使BeanFactoryPostProcessor对其应用！ String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); // 将实现PriorityOrdered，Ordered的BeanFactoryPostProcessor与其他的分开. // 用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor // 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName // 用于存放普通BeanFactoryPostProcessor的beanName List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); List<String> orderedPostProcessorNames = new ArrayList<>(); List<String> nonOrderedPostProcessorNames = new ArrayList<>(); for (String ppName : postProcessorNames) { //跳过已处理的 if (processedBeans.contains(ppName)) {} else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); }else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { // 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName orderedPostProcessorNames.add(ppName); }else { // 添加剩下的普通BeanFactoryPostProcessor的beanName nonOrderedPostProcessorNames.add(ppName); } } // 排序，调用实现PriorityOrdered的BeanFactoryPostProcessors sortPostProcessors(priorityOrderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); // 排序，调用实现Ordered的BeanFactoryPostProcessors List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); for (String postProcessorName : orderedPostProcessorNames) { orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } sortPostProcessors(orderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); // 调用普通的BeanFactoryPostProcessor List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); for (String postProcessorName : nonOrderedPostProcessorNames) { nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); // 清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType） // 因为后处理器可能已经修改了原始元数据，例如， 替换值中的占位符... beanFactory.clearMetadataCache(); }
在上面BeanDefinitionRegistryPostProcessor的invokeBeanDefinitionRegistryPostProcessors处理中，有一个很重要的内置处理器：ConfigurationClassPostProcessor
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { List<BeanDefinitionHolder> configCandidates = new ArrayList<>(); // 获取Spring容器中目前所有BeanDefinition的名称 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); } } // 判断是否是配置类 else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) { configCandidates.add(new BeanDefinitionHolder(beanDef, beanName)); } } // 如果未找到@Configuration类，则立即返回 if (configCandidates.isEmpty()) { return; } // 按@Order值排序 configCandidates.sort((bd1, bd2) -> { int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition()); int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition()); return Integer.compare(i1, i2); }); // 创建@CompentScan、@Import导入进来的bean名称的生成器 SingletonBeanRegistry 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); // 创建一个集合用于保存我们的配置类BeanDefinitionHolder集合默认长度是配置类集合的长度 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()); } // 在此之前仅仅只是解析完成，并未注册到Spring容器中，然后将解析出来的配置类转换成BeanDefinition并注册到Spring 容器中 this.reader.loadBeanDefinitions(configClasses); alreadyParsed.addAll(configClasses); candidates.clear(); //判断 Spring 容器中Bean的定义数量是否 > 候选原始的bean定义的个数 if (registry.getBeanDefinitionCount() > candidateNames.length) { // 获取所有的bean定义 String[] newCandidateNames = registry.getBeanDefinitionNames(); // 原始的bean定义 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()); // 将ImportRegistry注册为Bean，以支持ImportAware @Configuration类 if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) { sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry()); } // 清除缓存 if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) { ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache(); } }
parse()方法
public void parse(Set<BeanDefinitionHolder> configCandidates) { for (BeanDefinitionHolder holder : configCandidates) { BeanDefinition bd = holder.getBeanDefinition(); try { if (bd instanceof AnnotatedBeanDefinition) { // 如果bean实现自 AnnotatedBeanDefinition 接口,则进行注解bean定义的解析 parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName()); } else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) { // 如果bean实现自 AbstractBeanDefinition 接口,则进行抽象bean定义的解析 parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName()); } else { // 常规配置类进行解析 parse(bd.getBeanClassName(), holder.getBeanName()); } } ... } //这里会加载解析spring.properties中的配置类 this.deferredImportSelectorHandler.process(); }
protected final SourceClass doProcessConfigurationClass( ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException { if (configClass.getMetadata().isAnnotated(Component.class.getName())) { // 首先递归处理任何成员（嵌套）类，递归执行当前方法 processMemberClasses(configClass, sourceClass, filter); } // 处理@PropertySource注解，解析添加到环境中的propertySourcesList中 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注解 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) { // 如果找到@ComponentScan注解->立即执行扫描 // 将扫描出来的class转成BeanDefinition的集合，最终调用doScan()方法注册到Spring 容器中 Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()); // 检查扫描的BeanDefinition集合是否有其他配置类，有的话递归解析 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()); } } } } // 处理@Import注解： processImports(configClass, sourceClass, getImports(sourceClass), filter, true); // 处理@ImportResource注解 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); } } // 处理单个@Bean注解 Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass); for (MethodMetadata methodMetadata : beanMethods) { configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass)); } // 处理接口上的默认方法 processInterfaces(configClass, sourceClass); // 如果有父类的话，处理 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(); } } // 解析完成 return null; }
finishBeanFactoryInitialization()方法
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // 为上下文初始化转换服务。 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } // 注册默认的嵌入式值解析器 if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // 尽早初始化LoadTimeWeaverAware Bean，以便尽早注册其转换器。 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // 停止使用临时的ClassLoader进行类型匹配。 beanFactory.setTempClassLoader(null); // 允许缓存所有bean定义元数据，而不期望进一步的更改。 beanFactory.freezeConfiguration(); // 实例化所有剩余的（非延迟初始化）单例。 beanFactory.preInstantiateSingletons(); }
preInstantiateSingletons()方法
public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // 遍历缓存中所有的beanDefinitionName来创建实例 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); for (String beanName : beanNames) { // 父子BeanDefinition合并 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 如果不是抽象的，单例的，非懒加载的就实例化 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); }else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { getBean(beanName); } } } // 触发所有适用bean的初始化后回调... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }
getBean()方法中实际是调用doGetBean()方法
protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { // 返回实际的bean名称，删除工厂的取消引用:& String beanName = transformedBeanName(name); Object bean; // 检查单例缓存是否有手动注册的单例。先从缓存中取Bean Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } // 直接获取Bean的实例对象 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // 如果scope 是Prototype的，校验是否有出现循环依赖，如果有则直接报错 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // 对IOC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否能在当前的BeanFactory中获取的所需要的Bean， // 如果不能则委托当前容器的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // 找不到 -> 检查父级 String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // 委派父级容器根据指定名称和显式的参数查找 return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // 委派父级容器根据指定名称和类型查找 return parentBeanFactory.getBean(nameToLookup, requiredType); } else { // 委派父级容器根据指定名称和类型查找 return (T) parentBeanFactory.getBean(nameToLookup); } } // 创建的Bean是否需要进行类型验证，一般不需要 if (!typeCheckOnly) { // 向容器标记指定的Bean已经被创建 markBeanAsCreated(beanName); } try { // 父子BeanDefinition合并 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 检验是不是抽象类，是直接抛出异常 checkMergedBeanDefinition(mbd, beanName, args); // 确保当前bean依赖的bean的初始化。 // 获取当前Bean所有依赖Bean的名称。 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { // 递归实例化依赖的bean 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); } } } // 创建单例模式Bean的实例对象 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { // 创建Bean实例对象，并且注册给所依赖的对象 return createBean(beanName, mbd, args); } catch (BeansException ex) { // 显式地从容器单例模式Bean缓存中清除实例对象 destroySingleton(beanName); throw ex; } }); // 获取给定Bean的实例对象 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // 如果是scope 是 Prototype,每次创建一个新实例对象 Object prototypeInstance = null; try { // 回调beforePrototypeCreation方法，默认的功能是注册当前创建的原型对象 beforePrototypeCreation(beanName); // 创建指定Bean对象实例 prototypeInstance = createBean(beanName, mbd, args); } finally { // 回调afterPrototypeCreation方法，默认的功能告诉IOC容器指定Bean的原型对象不再创建 afterPrototypeCreation(beanName); } // 获取给定Bean的实例对象 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } // 要创建的Bean既不是单例模式，也不是原型模式，则根据Bean定义资源中 else { String scopeName = mbd.getScope(); // Bean定义资源中没有配置生命周期范围，则Bean定义不合法 if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'"); } 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的实例对象 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; } } // 对创建的Bean实例对象进行类型检查 if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isTraceEnabled()) { logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }
createBean()方法
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; // 解析bean对应的Class Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // 验证methodOverride对应的方法是否存在？是否有重载？ try { mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { // 给BeanPostProcessor一个机会来返回代理bean。 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 { // 创建bean Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); } }
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { // 实例化Bean instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // 应用MergedBeanDefinitionPostProcessor 后处理器，合并bean的定义信息 // Autowire等注解信息就是在这一步完成预解析，并且将注解需要的信息放入缓存 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } // 提前暴露bean，循环依赖处理 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"); } // 为了避免循环依赖，在bean初始化完成前，就将创建bean实例的ObjectFactory放入工厂缓存（singletonFactories） addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // 初始化bean实例. Object exposedObject = bean; try { //属性填充，自动注入，InstantiationAwareBeanPostProcessors处理 populateBean(beanName, mbd, instanceWrapper); //调用初始化方法，比如init-method、注入Aware对象、应用后处理器等 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); //只有检测到循环依赖的情况下，earlySingletonReference才不会为null 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); } } //因为bean创建后，其依赖的bean一定也是已经创建的 //如果actualDependentBeans不为空，则表示依赖的bean并没有被创建完，即存在循环依赖 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 " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } // 根据scope注册bean try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // 解析class Class<?> beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); } // 如果工厂方法不为空则使用工厂方法 Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); } if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } // Shortcut when re-creating the same bean... boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { //当一个类有多个构造函数，根据不同参数锁定不同的构造函数 if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } if (resolved) { if (autowireNecessary) { // 构造函数自动注入 return autowireConstructor(beanName, mbd, null, null); } else { // 默认构造函数构造 return instantiateBean(beanName, mbd); } } // 自动装配的候选构造函数 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); } // 默认构造的首选构造函数 ctors = mbd.getPreferredConstructors(); if (ctors != null) { // 构造函数自动注入 return autowireConstructor(beanName, mbd, ctors, null); } // 默认无参构造函数构造 return instantiateBean(beanName, mbd); }
构造方法的优先级: 工厂方法 > 带参数构造方法 > (无参)默认构造方法
getObjectForBeanInstance()方法获取bean实例
protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { // 如果是工厂引用(即name以&开头)，但该实例又不是FactoryBean类型，则抛出异常 if (BeanFactoryUtils.isFactoryDereference(name)) { if (beanInstance instanceof NullBean) { return beanInstance; } if (!(beanInstance instanceof FactoryBean)) { throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass()); } if (mbd != null) { mbd.isFactoryBean = true; } return beanInstance; } // 如果该实例不是FactoryBean类型，直接返回该实例 if (!(beanInstance instanceof FactoryBean)) { return beanInstance; } Object object = null; if (mbd != null) { mbd.isFactoryBean = true; } else { // 尝试从缓存中加载bean object = getCachedObjectForFactoryBean(beanName); } if (object == null) { // 把初始bean实例强转为FactoryBean FactoryBean<?> factory = (FactoryBean<?>) beanInstance; if (mbd == null && containsBeanDefinition(beanName)) { mbd = getMergedLocalBeanDefinition(beanName); } boolean synthetic = (mbd != null && mbd.isSynthetic()); //从缓存中获取实例 object = getObjectFromFactoryBean(factory, beanName, !synthetic); } return object; } protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { // 判断是否是单例，如果是单例，就不必重复创建 if (factory.isSingleton() && containsSingleton(beanName)) { synchronized (getSingletonMutex()) { // 尝试从缓存获取 Object object = this.factoryBeanObjectCache.get(beanName); if (object == null) { // 缓存没有，尝试从factory中获取 object = doGetObjectFromFactoryBean(factory, beanName); // 再次从缓存中获取，看有没有其他线程创建好的，如果有值，可以直接返回 Object alreadyThere = this.factoryBeanObjectCache.get(beanName); if (alreadyThere != null) { object = alreadyThere; } else { if (shouldPostProcess) { if (isSingletonCurrentlyInCreation(beanName)) { // Temporarily return non-post-processed object, not storing it yet.. return object; } beforeSingletonCreation(beanName); try { // 调用bean的后置处理器 object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", ex); } finally { afterSingletonCreation(beanName); } } //缓存 if (containsSingleton(beanName)) { this.factoryBeanObjectCache.put(beanName, object); } } } return object; } } else { // 原型模式，获取bean Object object = doGetObjectFromFactoryBean(factory, beanName); if (shouldPostProcess) { try { // 调用bean的后置处理器 object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex); } } return object; } } private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException { Object object; try { if (System.getSecurityManager() != null) { AccessControlContext acc = getAccessControlContext(); try { object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc); } catch (PrivilegedActionException pae) { throw pae.getException(); } } else { // 真正的获取bean实例对象的代码FactoryBean.getObject() // 里面使用动态代理Proxy.newProxyInstance来进行bean实例对象的获取 object = factory.getObject(); } } catch (FactoryBeanNotInitializedException ex) { throw new BeanCurrentlyInCreationException(beanName, ex.toString()); } catch (Throwable ex) { throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex); } // Do not accept a null value for a FactoryBean that's not fully // initialized yet: Many FactoryBeans just return null then. if (object == null) { if (isSingletonCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException( beanName, "FactoryBean which is currently in creation returned null from getObject"); } object = new NullBean(); } return object; }
浙公网安备 33010602011771号