SpringBoot bean的注册

我是小趴菜
133 阅读4分钟

1:在Spring中，bean算是一等公民了，我们很有必要了解bean是如何被发现和注册的

还是进入到run方法，run方法中有一个this.refreshContext(context);方法，
然后一直进入到AbstractApplicationContext的refresh()方法中

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		......
		try {
			
			// 我们进入到这个方法
			invokeBeanFactoryPostProcessors(beanFactory);
            ....
		}

2:进入到invokeBeanFactoryPostProcessors()

//这个方法是实例化并调用所有BeanFactoryPostProcesser的bean
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
       //所以我们重点研究这个方法
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
}

3:进入invokeBeanFactoryPostProcessors()方法之后，就来到了PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors()方法，下面我只是截取了其中的一部分代码

for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		

                //从名字来看应该是调用后置处理器去注册BeanDefinition,在Spring中，bean在容器中是以BeanDefinition的形式存在的，
                //所以这个方法跟我们注册bean有很大关系
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

4:进入方法，这里应该就是调用给定的BeanDefinitionRegistryPostProcessor，其中就有一个ConfigurationClassPostProcessor

private static void invokeBeanDefinitionRegistryPostProcessors(
            Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

        for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
    }

5:这个方法就是从配置类中去注册beanDefinition

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

6:跟进这个方法之后会发现这个方法好长好长，不过暂时我们只关心重点，解析配置

  do {
            //找到这个parse方法，然后进入
            parser.parse(candidates);
            parser.validate();

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

7:进入parse()方法

public void parse(Set<BeanDefinitionHolder> configCandidates) {
      for (BeanDefinitionHolder holder : configCandidates) {
          BeanDefinition bd = holder.getBeanDefinition();
          try {
              //因为我们一般使用的是注解，所以会进入这个if中的parse方法
              if (bd instanceof AnnotatedBeanDefinition) {
                  parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
              }
              else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                  parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
              }
              else {
                  parse(bd.getBeanClassName(), holder.getBeanName());
              }
          }
          catch (BeanDefinitionStoreException ex) {
              throw ex;
          }
          catch (Throwable ex) {
              throw new BeanDefinitionStoreException(
                      "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
          }
      }

      this.deferredImportSelectorHandler.process();
  }

8:再次进入parse()方法

  //首先进入processConfigurationClass()方法
  protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
        processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
    }
    
    
    //进入这个方法之后，继续进入sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
    //这个方法
    protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
	......
	SourceClass sourceClass = asSourceClass(configClass, filter);
	do {
		sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
	}
	while (sourceClass != null);

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

9:最后会进入到ConfigurationClassParser类的doProcessConfigurationClass()方法，到了这个方法，我们暂时只分析bean的注册，所以只关注解析@Component注解和@ComponentScans注解二种

protected final SourceClass doProcessConfigurationClass(
            ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
            throws IOException {

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

        // 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), filter, 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;
    }

10:解析@Component注解

 //其实这个方法只是看下启动类是否有内部类，如果没有就不做任何事情了，
 //如果有的话，那么就会看下这个类上是否有@Component，@Import等等的一些注解
 //如果没有也就不做任何操作
 //如果有这些注解，而且这个内部类不是接口，如果是接口也不会做任何处理
 //就好比瞎下面这样，再启动类内部又定义了一个类，而且有相关注解
   @SpringBootApplication
   public class DemoApplication {

        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }

            @Component
            class People{}
   }
 //如果这个内部类有相关注解，而且不是接口，那么就会递归调用第9步的方法进行解析，如果还有内部类就依次执行
 if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            // Recursively process any member (nested) classes first
            processMemberClasses(configClass, sourceClass, filter);
 }

11:解析@ComponentScans注解

 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) {
                // 这里就已经返回了BeanDefinition，所以我们进入到这个parse()方法
                Set<BeanDefinitionHolder> scannedBeanDefinitions =
                        this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                
               ........
            }
        }

12:进入parse()方法

    进入这个方法之后直接看最后一行，
    return scanner.doScan(StringUtils.toStringArray(basePackages));
    debug可以发现basePackages的值就是我们启动类的包路径，Spring会去扫描这个包下面的所有的bean，这也是为什么我们写的bean都要在启动类包下面的原因了

13:进入doScan()方法，这个目的很明确了，就是找到启动类包下的所有的.class文件，然后利用反射看下类上是否有相关注解，比如@Service,@Component,@Configuration等注解，如果有就会将这个对象注册到容器中去

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
        for (String basePackage : basePackages) {
            //核心方法
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            for (BeanDefinition candidate : candidates) {
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                if (candidate instanceof AbstractBeanDefinition) {
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                if (candidate instanceof AnnotatedBeanDefinition) {
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                if (checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    //注册beanDefinition
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }

14:注册beanDefinition也就是调用了DefaultListableBeanFactory中的一个Map的put方法，将bean的信息保存起来

avatar
文章
阅读
粉丝