碼上歡樂
相關內容    簡體    繁體

【轉】【Spring實戰】Spring注解配置工作原理源碼解析

本文轉載自   查看原文   2017-11-28 20:16   5435    springmvc

一、背景知識

在 【Spring實戰】Spring容器初始化完成后執行初始化數據方法一文中說要分析其實現原理，於是就從源碼中尋找答案，看源碼容易跑偏，因此應當有個主線，或者帶着問題、目標去看，這樣才能最大限度的提升自身代碼水平。由於上文中大部分都基於注解進行設置的（ Spring實戰系列篇demo大部分也都是基於注解實現的），因此就想弄明白Spring中注解是怎么工作的，這個也是分析上文中實現原理的一個基礎。於是索性解析下Spring中注解的工作原理。
 

二、從context:component-scan標簽或@ComponentScan注解說起

如果想要使用Spring注解，那么首先要在配置文件中配置context:component-scan標簽或者在配置類中添加@ComponentScan注解。題外話：現在Spring已經完全可以實現無xml（當然有些還是需要xml配置來實現的）的配置，甚至都不需要web.xml，當然這需要Servlet3.0服務器的支持（如Tomcat7或者更高版本）。Spirng In Action Fourth是針對三種bean的裝配機制（xml進行顯示配置、java中進行顯示配置、隱式的bean發現機制和自動裝配）的使用是這樣建議的：
 
 
如果要使用自動配置機制，就要在配置文件中配置context:component-scan標簽或者在配置類中添加@ComponentScan注解。基於 【Spring實戰】----Spring配置文件的解析
篇文章，本文還是基於xml中的自定義標簽進行解析，當然也可以直接看@ComponentScan注解的解析（ComponentScanAnnotationParser.java，這其中還牽扯到@Configuration以及另外的知識點）。
 

三、context:component-scan標簽解析

以實戰篇系列demo為例進行分析
[java] view plain copy
  1. <context:component-scan base-package="com.mango.jtt"></context:component-scan>  


從 【Spring實戰】----Spring配置文件的解析中可知，標簽的處理器為spring.handlers
[html] view plain copy
  1. http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler  
[java] view plain copy
  1. registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());  

在ComponentScanBeanDefinitionParser.java中進行處理
 
[java] view plain copy
  1. @Override  
  2.     public BeanDefinition parse(Element element, ParserContext parserContext) {  
  3.         String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);  
  4.         basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);  
  5.         String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,  
  6.                 ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);  
  7.   
  8.         // Actually scan for bean definitions and register them.  
  9.         ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);    //得到掃描器  
  10.         Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);             //掃描文件，並轉化為spring bean，並注冊  
  11.         registerComponents(parserContext.getReaderContext(), beanDefinitions, element);       //注冊其他相關組件  
  12.   
  13.         return null;  
  14.     }  

從上述代碼中可知，其作用就是掃描basePackages下的文件，轉化為spring中的bean結構，並將其注冊到容器中；最后是注冊相關組件（主要是注解處理器）。注解需要注解處理器來處理。
 
要知道ComponentScanBeanDefinitionParser掃描文件並轉化成spring bean的原則的，就需要看下其定義的屬性值：
[java] view plain copy
  1. private static final String BASE_PACKAGE_ATTRIBUTE = "base-package";  
  2.   
  3.     private static final String RESOURCE_PATTERN_ATTRIBUTE = "resource-pattern";  
  4.   
  5.     private static final String USE_DEFAULT_FILTERS_ATTRIBUTE = "use-default-filters";  
  6.   
  7.     private static final String ANNOTATION_CONFIG_ATTRIBUTE = "annotation-config";  
  8.   
  9.     private static final String NAME_GENERATOR_ATTRIBUTE = "name-generator";  
  10.   
  11.     private static final String SCOPE_RESOLVER_ATTRIBUTE = "scope-resolver";  
  12.   
  13.     private static final String SCOPED_PROXY_ATTRIBUTE = "scoped-proxy";  
  14.   
  15.     private static final String EXCLUDE_FILTER_ELEMENT = "exclude-filter";  
  16.   
  17.     private static final String INCLUDE_FILTER_ELEMENT = "include-filter";  
  18.   
  19.     private static final String FILTER_TYPE_ATTRIBUTE = "type";  
  20.   
  21.     private static final String FILTER_EXPRESSION_ATTRIBUTE = "expression";  

先簡單解析下上述屬性的作用
 
  • base-package:為必須配置屬性,指定了spring需要掃描的跟目錄名稱,可以使用”,” “;” “\t\n(回車符)”來分割多個包名
  • resource-pattern:配置掃描資源格式.默認”**/*.class”
  • use-default-filters:是否使用默認掃描策略,默認為”true”,會自動掃描指定包下的添加了如下注解的類,@Component, @Repository, @Service,or @Controller

  • annotation-config:是否啟用默認配置,默認為”true”,該配置會在BeanDefinition注冊到容器后自動注冊一些BeanPostProcessors對象到容器中.這些處理器用來處理類中Spring’s @Required and 
    @Autowired, JSR 250’s @PostConstruct, @PreDestroy and @Resource (如果可用), 
    JAX-WS’s @WebServiceRef (如果可用), EJB 3’s @EJB (如果可用), and JPA’s 
    @PersistenceContext and @PersistenceUnit (如果可用),但是該屬性不會處理Spring’s @Transactional 和 EJB 3中的@TransactionAttribute注解對象,這兩個注解是通過<tx:annotation-driven>元素處理過程中對應的BeanPostProcessor來處理的.
  • include-filter:如果有自定義元素可以在該處配置
  • exclude-filter:配置哪些類型的類不需要掃描
  • 注意:</context:component-scan>元素中默認配置了annotation-config,所以不需要再單獨配置</annotation-config>元素. 
這些屬性作用配置都是在configureScanner()函數中進行的。
[java] view plain copy
  1. protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {  
  2.         boolean useDefaultFilters = true;  
  3.         if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {  
  4.             useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));       
  5.         }  
  6.   
  7.         // Delegate bean definition registration to scanner class.  
  8.         ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);   //包含了掃描策略配置  
  9.         scanner.setResourceLoader(parserContext.getReaderContext().getResourceLoader());  
  10.         scanner.setEnvironment(parserContext.getReaderContext().getEnvironment());  
  11.         scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());  
  12.         scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());  
  13.   
  14.         if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {  
  15.             scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));        //配置掃描資源格式  
  16.         }  
  17.   
  18.         try {  
  19.             parseBeanNameGenerator(element, scanner);                                    //配置名稱生成器  
  20.         }  
  21.         catch (Exception ex) {  
  22.             parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());  
  23.         }  
  24.   
  25.         try {  
  26.             parseScope(element, scanner);                                     //配置元數據解析器  
  27.         }  
  28.         catch (Exception ex) {  
  29.             parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());  
  30.         }  
  31.   
  32.         parseTypeFilters(element, scanner, parserContext);                      //配置包含和不包含過濾  
  33.   
  34.         return scanner;  
  35.     }  
 
看一下默認掃描策略的配置
[java] view plain copy
  1. /** 
  2.      * Register the default filter for {@link Component @Component}. 
  3.      * <p>This will implicitly register all annotations that have the 
  4.      * {@link Component @Component} meta-annotation including the 
  5.      * {@link Repository @Repository}, {@link Service @Service}, and 
  6.      * {@link Controller @Controller} stereotype annotations. 
  7.      * <p>Also supports Java EE 6's {@link javax.annotation.ManagedBean} and 
  8.      * JSR-330's {@link javax.inject.Named} annotations, if available. 
  9.      * 
  10.      */  
  11.     @SuppressWarnings("unchecked")  
  12.     protected void registerDefaultFilters() {  
  13.         this.includeFilters.add(new AnnotationTypeFilter(Component.class));  
  14.         ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();  
  15.         try {  
  16.             this.includeFilters.add(new AnnotationTypeFilter(  
  17.                     ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));  
  18.             logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");  
  19.         }  
  20.         catch (ClassNotFoundException ex) {  
  21.             // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.  
  22.         }  
  23.         try {  
  24.             this.includeFilters.add(new AnnotationTypeFilter(  
  25.                     ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));  
  26.             logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");  
  27.         }  
  28.         catch (ClassNotFoundException ex) {  
  29.             // JSR-330 API not available - simply skip.  
  30.         }  
  31.     }  
從注釋中看出除了，@Component、和包含元注解@Component的@Controller、@Service、@Repository，還支持Java EE 6的@link javax.annotation.ManagedBean和jsr - 330的 @link javax.inject.Named,如果可用。
- 默認過濾器主要掃描@Component @Repository @Service @Controller注解的類，同樣可以通過配置類掃描過濾器來掃描自定義注解的類。 
- 當類路徑下有javax.annotation.ManagedBean和javax.inject.Named類庫時支持這2個注解掃描。


其掃描過程如下：
- 首先構造一個ClassPathBeanDefinitionScanner對象，需要傳遞一個BeanDefinitionRegistry對象。 
- 根據配置文件配置屬性設置scanner的掃描屬性，比如”resource-pattern”, “name-generator”, “scope-resolver”等。 
- 調用scanner.doScan(String… basePackages)方法完成候選類的自動掃描。 
 
下面看一下doScan
[java] view plain copy
  1. /** 
  2.      * Perform a scan within the specified base packages, 
  3.      * returning the registered bean definitions. 
  4.      * <p>This method does <i>not</i> register an annotation config processor 
  5.      * but rather leaves this up to the caller. 
  6.      * @param basePackages the packages to check for annotated classes 
  7.      * @return set of beans registered if any for tooling registration purposes (never {@code null}) 
  8.      */  
  9.     protected Set<BeanDefinitionHolder> doScan(String... basePackages) {  
  10.         Assert.notEmpty(basePackages, "At least one base package must be specified");  
  11.         Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();  
  12.         for (String basePackage : basePackages) {  
  13.             Set<BeanDefinition> candidates = findCandidateComponents(basePackage);  
  14.             for (BeanDefinition candidate : candidates) {  
  15.                 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);  
  16.                 candidate.setScope(scopeMetadata.getScopeName());  
  17.                 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);  
  18.                 if (candidate instanceof AbstractBeanDefinition) {  
  19.                     postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);    //配置bena屬性  
  20.                 }  
  21.                 if (candidate instanceof AnnotatedBeanDefinition) {  
  22.                     AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); //配置通過注解設置的便屬性  
  23.                 }  
  24.                 if (checkCandidate(beanName, candidate)) {  
  25.                     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);  
  26.                     definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);  
  27.                     beanDefinitions.add(definitionHolder);  
  28.                     registerBeanDefinition(definitionHolder, this.registry);  
  29.                 }  
  30.             }  
  31.         }  
  32.         return beanDefinitions;  
  33.     }  
 
實際上掃描文件並包裝成BeanDefinition是由findCandidateComponents來做的
[java] view plain copy
  1. /** 
  2.      * Scan the class path for candidate components. 
  3.      * @param basePackage the package to check for annotated classes 
  4.      * @return a corresponding Set of autodetected bean definitions 
  5.      */  
  6.     public Set<BeanDefinition> findCandidateComponents(String basePackage) {  
  7.         Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();  
  8.         try {  
  9.             String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +  
  10.                     resolveBasePackage(basePackage) + "/" + this.resourcePattern;  
  11.             Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);  
  12.             boolean traceEnabled = logger.isTraceEnabled();  
  13.             boolean debugEnabled = logger.isDebugEnabled();  
  14.             for (Resource resource : resources) {  
  15.                 if (traceEnabled) {  
  16.                     logger.trace("Scanning " + resource);  
  17.                 }  
  18.                 if (resource.isReadable()) {  
  19.                     try {  
  20.                         MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);  
  21.                         if (isCandidateComponent(metadataReader)) {  
  22.                             ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);  
  23.                             sbd.setResource(resource);  
  24.                             sbd.setSource(resource);  
  25.                             if (isCandidateComponent(sbd)) {  
  26.                                 if (debugEnabled) {  
  27.                                     logger.debug("Identified candidate component class: " + resource);  
  28.                                 }  
  29.                                 candidates.add(sbd);  
  30.                             }  
  31.                             else {  
  32.                                 if (debugEnabled) {  
  33.                                     logger.debug("Ignored because not a concrete top-level class: " + resource);  
  34.                                 }  
  35.                             }  
  36.                         }  
  37.                         else {  
  38.                             if (traceEnabled) {  
  39.                                 logger.trace("Ignored because not matching any filter: " + resource);  
  40.                             }  
  41.                         }  
  42.                     }  
  43.                     catch (Throwable ex) {  
  44.                         throw new BeanDefinitionStoreException(  
  45.                                 "Failed to read candidate component class: " + resource, ex);  
  46.                     }  
  47.                 }  
  48.                 else {  
  49.                     if (traceEnabled) {  
  50.                         logger.trace("Ignored because not readable: " + resource);  
  51.                     }  
  52.                 }  
  53.             }  
  54.         }  
  55.         catch (IOException ex) {  
  56.             throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);  
  57.         }  
  58.         return candidates;  
  59.     }  

大致的流程如下：

(1)先根據context:component-scan 中屬性的base-package="com.mango.jtt"配置轉換為classpath*:com/mango/jtt/**/*.class（默認格式），並掃描對應下的class和jar文件並獲取類對應的路徑，返回Resources

(2)根據指定的不掃描包，指定的掃描包配置進行過濾不包含的包對應下的class和jar。

（3）封裝成BeanDefinition放到隊列里。

實際上，是把所有包下的class文件都掃描了的，並且利用asm技術讀取java字節碼並轉化為MetadataReader中的AnnotationMetadataReadingVisitor結構
[java] view plain copy
  1. MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);  

[java] view plain copy
  1. SimpleMetadataReader(Resource resource, ClassLoader classLoader) throws IOException {  
  2.         InputStream is = new BufferedInputStream(resource.getInputStream());  
  3.         ClassReader classReader;  
  4.         try {  
  5.             classReader = new ClassReader(is);  
  6.         }  
  7.         catch (IllegalArgumentException ex) {  
  8.             throw new NestedIOException("ASM ClassReader failed to parse class file - " +  
  9.                     "probably due to a new Java class file version that isn't supported yet: " + resource, ex);  
  10.         }  
  11.         finally {  
  12.             is.close();  
  13.         }  
  14.   
  15.         AnnotationMetadataReadingVisitor visitor = new AnnotationMetadataReadingVisitor(classLoader);  
  16.         classReader.accept(visitor, ClassReader.SKIP_DEBUG);  
  17.   
  18.         this.annotationMetadata = visitor;  
  19.         // (since AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisitor)  
  20.         this.classMetadata = visitor;  
  21.         this.resource = resource;  
  22.     }  

此處不深究牛X的asm技術，繼續看其兩個if判斷，只有符合這兩個if的才add到candidates，也就是候選者BeanDefinition，函數名字起得名副其實。

[java] view plain copy
  1. if (isCandidateComponent(metadataReader)) {  
  2.                             ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);  
  3.                             sbd.setResource(resource);  
  4.                             sbd.setSource(resource);  
  5.                             if (isCandidateComponent(sbd)) {  
  6.                                 if (debugEnabled) {  
  7.                                     logger.debug("Identified candidate component class: " + resource);  
  8.                                 }  
  9.                                 candidates.add(sbd);  
  10.                             }  
  11.                             else {  
  12.                                 if (debugEnabled) {  
  13.                                     logger.debug("Ignored because not a concrete top-level class: " + resource);  
  14.                                 }  
  15.                             }  
  16.                         }  

先看第一個判斷
[java] view plain copy
  1. /** 
  2.      * Determine whether the given class does not match any exclude filter 
  3.      * and does match at least one include filter. 
  4.      * @param metadataReader the ASM ClassReader for the class 
  5.      * @return whether the class qualifies as a candidate component 
  6.      */  
  7.     protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {  
  8.         for (TypeFilter tf : this.excludeFilters) {  
  9.             if (tf.match(metadataReader, this.metadataReaderFactory)) {  
  10.                 return false;  
  11.             }  
  12.         }  
  13.         for (TypeFilter tf : this.includeFilters) {  
  14.             if (tf.match(metadataReader, this.metadataReaderFactory)) {  
  15.                 return isConditionMatch(metadataReader);  
  16.             }  
  17.         }  
  18.         return false;  
  19.     }  
這里的判斷就用到了前面說的屬性設置，在本例中excludeFilters是沒有內容的，includeFilters包含有@Component和@Named兩個的AnnotationTypeFilter。因此只有第二個循環起作用，也就是是有符合@Component且元注解為@Component的注解和@Named兩種注解的才可以。
 
第二個if就是判斷類是否是實現類，抽象類好接口類都不不可以
[java] view plain copy
  1. /** 
  2.      * Determine whether the given bean definition qualifies as candidate. 
  3.      * <p>The default implementation checks whether the class is concrete 
  4.      * (i.e. not abstract and not an interface). Can be overridden in subclasses. 
  5.      * @param beanDefinition the bean definition to check 
  6.      * @return whether the bean definition qualifies as a candidate component 
  7.      */  
  8.     protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {  
  9.         return (beanDefinition.getMetadata().isConcrete() && beanDefinition.getMetadata().isIndependent());  
  10.     }  
總結：掃描器采用asm技術掃描java字節碼文件，即.class文件。掃描時是掃描指定包下的全部class文件，轉換成指定的MetadataReader結構后，再去判斷是否符合掃描規則，符合的才加入候選bean中，並注冊到容器中。

至此，注解掃描分析完了，看一下bean注冊，回到doScan中
[java] view plain copy
  1. if (checkCandidate(beanName, candidate)) {  
  2.                     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);  
  3.                     definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);  
  4.                     beanDefinitions.add(definitionHolder);  
  5.                     registerBeanDefinition(definitionHolder, this.registry);  
  6.                 }  
也是只有符合條件的才注冊，主要是容器中沒有的，或者不和容器中有的沖突的。
 
再看下其他組件注冊，回到最初的parse
[java] view plain copy
  1. registerComponents(parserContext.getReaderContext(), beanDefinitions, element);  

[java] view plain copy
  1. protected void registerComponents(  
  2.             XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {  
  3.   
  4.         Object source = readerContext.extractSource(element);  
  5.         CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);  
  6.   
  7.         for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {  
  8.             compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));  
  9.         }  
  10.   
  11.         // Register annotation config processors, if necessary.  
  12.         boolean annotationConfig = true;  
  13.         if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {  //本例中沒有配置annotation-config，默認為true  
  14.             annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));  
  15.         }  
  16.         if (annotationConfig) {  
  17.             Set<BeanDefinitionHolder> processorDefinitions =  
  18.                     AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);  //注冊注解處理器  
  19.             for (BeanDefinitionHolder processorDefinition : processorDefinitions) {  
  20.                 compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));  
  21.             }  
  22.         }  
  23.   
  24.         readerContext.fireComponentRegistered(compositeDef);         //目前沒啥卵用，EmptyReaderEventListener.java中都是空操作，擴展用  
  25.     }  

上述代碼的作用主要是注冊注解處理器，本例中沒有配置annotation-config，默認值為true，這里也就說明了為什么配置了<context:component-scan>標簽就不需要再配置<context:annotation-config>標簽的原因。看下注冊注解處理器：
org.springframework.context.annotation.AnnotationConfigUtils.java
 
[java] view plain copy
  1. /** 
  2.      * Register all relevant annotation post processors in the given registry. 
  3.      * @param registry the registry to operate on 
  4.      * @param source the configuration source element (already extracted) 
  5.      * that this registration was triggered from. May be {@code null}. 
  6.      * @return a Set of BeanDefinitionHolders, containing all bean definitions 
  7.      * that have actually been registered by this call 
  8.      */  
  9.     public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(  
  10.             BeanDefinitionRegistry registry, Object source) {  
  11.   
  12.         DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);  
  13.         if (beanFactory != null) {  
  14.             if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {  
  15.                 beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);      //設置注解比較器，為Spring中的Order提供支持  
  16.             }  
  17.             if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {  
  18.                 beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());   //設置AutowireCandidateResolver，為qualifier注解和lazy注解提供支持  
  19.             }  
  20.         }  
  21.   
  22.         Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);  
  23.   
  24.         if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {  
  25.             RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);  
  26.             def.setSource(source);  
  27.             beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)); //注冊@Configuration處理器  
  28.         }  
  29.   
  30.         if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {  
  31.             RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);  
  32.             def.setSource(source);  
  33.             beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));//注冊@Autowired、@Value、@Inject處理器  
  34.         }  
  35.   
  36.         if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {  
  37.             RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);  
  38.             def.setSource(source);  
  39.             beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));//注冊@Required處理器<span style="white-space:pre">  </span>  
  40.         }  
  41.   
  42.         // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.  
  43.         if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {  
  44.             RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);  
  45.             def.setSource(source);  
  46.             beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));//在支持JSR-250條件下注冊javax.annotation包下注解處理器，包括@PostConstruct、@PreDestroy、@Resource注解等  
  47.         }  
  48.   
  49.         // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.  
  50.         if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {  
  51.             RootBeanDefinition def = new RootBeanDefinition();  
  52.             try {  
  53.                 def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,  
  54.                         AnnotationConfigUtils.class.getClassLoader()));  
  55.             }  
  56.             catch (ClassNotFoundException ex) {  
  57.                 throw new IllegalStateException(  
  58.                         "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);  
  59.             }  
  60.             def.setSource(source);  
  61.             beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));//支持jpa的條件下，注冊org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor處理器，處理jpa相關注解  
  62.         }  
  63.   
  64.         if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {  
  65.             RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);  
  66.             def.setSource(source);  
  67.             beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));//注冊@EventListener處理器  
  68.         }  
  69.         if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {  
  70.             RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);  
  71.             def.setSource(source);  
  72.             beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));//注冊支持@EventListener注解的處理器  
  73.         }  
  74.   
  75.         return beanDefs;  
  76.     }  


真正的注冊是如下函數：
[java] view plain copy
  1. private static BeanDefinitionHolder registerPostProcessor(  
  2.             BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {  
  3.   
  4.         definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);   //角色屬於后台角色，框架內部使用，和最終用戶無關  
  5.         registry.registerBeanDefinition(beanName, definition);    //也是注冊到beanFactory中的beanDefinitionMap中，其實和注冊bean一樣，並且beanName是定義好了的  
  6.         return new BeanDefinitionHolder(definition, beanName);  
  7.     }  

注冊注解處理器的過程也是講處理包裝成RootBeanDefinition，放到beanFactory（這里是DefaultListableBeanFactory）中的beanDefinitionMap中。
 
至此，標簽<context:component-scan>的解析已經分析完了，總結如下：
1）根據配置利用asm技術掃描.class文件，並將包含@Component及元注解為@Component的注解@Controller、@Service、@Repository或者還支持Java EE 6的@link javax.annotation.ManagedBean和jsr - 330的 @link javax.inject.Named，如果可用。的bean注冊到beanFactory中
2）注冊注解后置處理器，主要是處理屬性或方法中的注解，包含：
 注冊@Configuration處理器ConfigurationClassPostProcessor，
注冊@Autowired、@Value、@Inject處理器AutowiredAnnotationBeanPostProcessor，
注冊@Required處理器RequiredAnnotationBeanPostProcessor、
在支持JSR-250條件下注冊javax.annotation包下注解處理器CommonAnnotationBeanPostProcessor，包括@PostConstruct、@PreDestroy、@Resource注解等、
支持jpa的條件下，注冊org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor處理器，處理jpa相關注解
注冊@EventListener處理器EventListenerMethodProcessor
 
使用注解的.class文件也掃描完了，注解處理器也注冊完了，那么注解是什么時候處理的呢？下一節會繼續分析。


四、注解處理器實例化

要想使用注解處理器，必須要實例化注解處理器，那么其實例化是在哪里進行的呢，這里還需要回到org.springframework.context.support.AbstractApplicationContext.java中的refresh()函數
 
[java] view plain copy
  1. @Override  
  2.     public void refresh() throws BeansException, IllegalStateException {  
  3.         synchronized (this.startupShutdownMonitor) {  
  4.             // Prepare this context for refreshing.  
  5.             prepareRefresh();   //初始化前的准備，例如對系統屬性或者環境變量進行准備及驗證  
  6.   
  7.             // Tell the subclass to refresh the internal bean factory.  
  8.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  //初始化BeanFactory，解析xml配置文件，其中標簽<context:component-scan>就是在這里解析的  
  9.   
  10.             // Prepare the bean factory for use in this context.  
  11.             prepareBeanFactory(beanFactory);  //配置工廠的標准上下文特征，例如上下文的類加載器和后處理器。  
  12.   
  13.             try {  
  14.                 // Allows post-processing of the bean factory in context subclasses.  
  15.                 postProcessBeanFactory(beanFactory);     //子類覆蓋方法，做特殊處理，主要是后處理器相關  
  16.   
  17.                 // Invoke factory processors registered as beans in the context.  
  18.                 invokeBeanFactoryPostProcessors(beanFactory);  //激活各種beanFactory處理器，實例化並調用所有注冊的BeanFactoryPostProcessor bean，  
  19. 如果給定的話，尊重顯式的順序。注意這里和掃描時的bean處理器的區別。  
  20.   
  21.                 // Register bean processors that intercept bean creation.  
  22.                 registerBeanPostProcessors(beanFactory); //<span style="color: rgb(46, 48, 51); font-family: Arial, "Microsoft YaHei", 微軟雅黑, 宋體, "Malgun Gothic", Meiryo, sans-serif; line-height: 18px;">實例化並調用所有已注冊的BeanPostProcessor bean，</span><span style="color: rgb(46, 48, 51); font-family: Arial, "Microsoft YaHei", 微軟雅黑, 宋體, "Malgun Gothic", Meiryo, sans-serif; line-height: 18px;">如果給定的話，尊重顯式的順序。</span><br style="box-sizing: border-box; color: rgb(46, 48, 51); font-family: Arial, "Microsoft YaHei", 微軟雅黑, 宋體, "Malgun Gothic", Meiryo, sans-serif; line-height: 18px;"><div class="br-height" style="box-sizing: border-box; margin: 0px; padding: 0px; height: 22px; display: inline-block; color: rgb(46, 48, 51); font-family: Arial, "Microsoft YaHei", 微軟雅黑, 宋體, "Malgun Gothic", Meiryo, sans-serif; line-height: 18px;"></div><span style="color: rgb(46, 48, 51); font-family: Arial, "Microsoft YaHei", 微軟雅黑, 宋體, "Malgun Gothic", Meiryo, sans-serif; line-height: 18px;">必須在應用程序bean的任何實例化之前調用它。這是本節的分析重點。這里就是實例化上面注冊的bean處理器</span>  
  23.   
  24.                 // Initialize message source for this context.  
  25.                 initMessageSource();    //初始化消息資源，國際化等用  
  26.   
  27.                 // Initialize event multicaster for this context.  
  28.                 initApplicationEventMulticaster(); //初始化應用事件廣播  
  29.   
  30.                 // Initialize other special beans in specific context subclasses.  
  31.                 onRefresh();               //子類擴展  
  32.   
  33.                 // Check for listener beans and register them.  
  34.                 registerListeners();   //注冊監聽器  
  35.   
  36.                 // Instantiate all remaining (non-lazy-init) singletons.  
  37.                 finishBeanFactoryInitialization(beanFactory);   //實例化非延遲加載單例，包括所有注冊非延遲加載bean的實例化  
  38.   
  39.                 // Last step: publish corresponding event.  
  40.                 finishRefresh();     //完成刷新過程，通知生命周期處理器lifecycleProcessor刷新過程，同時發出ContextRefreshEvent通知別人  
  41.             }  
  42.   
  43.             catch (BeansException ex) {  
  44.                 if (logger.isWarnEnabled()) {  
  45.                     logger.warn("Exception encountered during context initialization - " +  
  46.                             "cancelling refresh attempt: " + ex);  
  47.                 }  
  48.   
  49.                 // Destroy already created singletons to avoid dangling resources.  
  50.                 destroyBeans();  
  51.   
  52.                 // Reset 'active' flag.  
  53.                 cancelRefresh(ex);  
  54.   
  55.                 // Propagate exception to caller.  
  56.                 throw ex;  
  57.             }  
  58.   
  59.             finally {  
  60.                 // Reset common introspection caches in Spring's core, since we  
  61.                 // might not ever need metadata for singleton beans anymore...  
  62.                 resetCommonCaches();  
  63.             }  
  64.         }  
  65.     }  

從上述代碼看，注解處理器也是在registerBeanPostProcessors(beanFactory);中進行實例化的：
[java] view plain copy
  1. public static void registerBeanPostProcessors(  
  2.             ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {  
  3.                 //獲取所有beanFactory注冊的BeanPostProcessor類型的bean處理器，三中注冊的bean處理器在這里都會獲取到  
  4.         String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);  
  5.   
  6.         // Register BeanPostProcessorChecker that logs an info message when  
  7.         // a bean is created during BeanPostProcessor instantiation, i.e. when  
  8.         // a bean is not eligible for getting processed by all BeanPostProcessors.  
  9.         int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;  
  10.         beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));  
  11.                 //以下是實例化bean處理器，並按照次序或無序添加到BeanFactory的beanPostProcessors列表中  
  12.         // Separate between BeanPostProcessors that implement PriorityOrdered,  
  13.         // Ordered, and the rest.  
  14.         List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();  
  15.         List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();  
  16.         List<String> orderedPostProcessorNames = new ArrayList<String>();  
  17.         List<String> nonOrderedPostProcessorNames = new ArrayList<String>();  
  18.         for (String ppName : postProcessorNames) {  
  19.             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {  
  20.                 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);  
  21.                 priorityOrderedPostProcessors.add(pp);  
  22.                 if (pp instanceof MergedBeanDefinitionPostProcessor) {  
  23.                     internalPostProcessors.add(pp);  
  24.                 }  
  25.             }  
  26.             else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {  
  27.                 orderedPostProcessorNames.add(ppName);  
  28.             }  
  29.             else {  
  30.                 nonOrderedPostProcessorNames.add(ppName);  
  31.             }  
  32.         }  
  33.   
  34.         // First, register the BeanPostProcessors that implement PriorityOrdered.  
  35.         sortPostProcessors(beanFactory, priorityOrderedPostProcessors);  
  36.         registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);  
  37.   
  38.         // Next, register the BeanPostProcessors that implement Ordered.  
  39.         List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();  
  40.         for (String ppName : orderedPostProcessorNames) {  
  41.             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);  
  42.             orderedPostProcessors.add(pp);  
  43.             if (pp instanceof MergedBeanDefinitionPostProcessor) {  
  44.                 internalPostProcessors.add(pp);  
  45.             }  
  46.         }  
  47.         sortPostProcessors(beanFactory, orderedPostProcessors);  
  48.         registerBeanPostProcessors(beanFactory, orderedPostProcessors);  
  49.   
  50.         // Now, register all regular BeanPostProcessors.  
  51.         List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();  
  52.         for (String ppName : nonOrderedPostProcessorNames) {  
  53.             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);  
  54.             nonOrderedPostProcessors.add(pp);  
  55.             if (pp instanceof MergedBeanDefinitionPostProcessor) {  
  56.                 internalPostProcessors.add(pp);  
  57.             }  
  58.         }  
  59.         registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);  
  60.   
  61.         // Finally, re-register all internal BeanPostProcessors.  
  62.         sortPostProcessors(beanFactory, internalPostProcessors);  
  63.         registerBeanPostProcessors(beanFactory, internalPostProcessors);  
  64.   
  65.         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));  
  66.     }  
上述代碼實現了bean處理器實例化和排序工作，最終通過registerBeanPostProcessors添加到BeanFactory的beanPostProcessors列表中。

[java] view plain copy
  1. /** 
  2.      * Register the given BeanPostProcessor beans. 
  3.      */  
  4.     private static void registerBeanPostProcessors(  
  5.             ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {  
  6.   
  7.         for (BeanPostProcessor postProcessor : postProcessors) {  
  8.             beanFactory.addBeanPostProcessor(postProcessor);  
  9.         }  
  10.     }  
AbstractBeanFactory.java
[java] view plain copy
  1. @Override  
  2.     public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {  
  3.         Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");  
  4.         this.beanPostProcessors.remove(beanPostProcessor);  
  5.         this.beanPostProcessors.add(beanPostProcessor);  
  6.         if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {  
  7.             this.hasInstantiationAwareBeanPostProcessors = true;  
  8.         }  
  9.         if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {  
  10.             this.hasDestructionAwareBeanPostProcessors = true;  
  11.         }  
  12.     }  
這里的beanPostProcessors在應用bean實例化的時候會進行調用。bean處理器的實例化這里不細說，也是通過beanFactory.getBean()實現的。


五、注解處理器的調用

以 【Spring實戰】Spring容器初始化完成后執行初始化數據方法中的注解@PostConstruct為例分析其注解處理器的調用。四種分析了處理器的實例化，看一下@postConstruct處理器CommonAnnotationBeanPostProcessor.java，其構造函數如下：
[java] view plain copy
  1. /** 
  2.      * Create a new CommonAnnotationBeanPostProcessor, 
  3.      * with the init and destroy annotation types set to 
  4.      * {@link javax.annotation.PostConstruct} and {@link javax.annotation.PreDestroy}, 
  5.      * respectively. 
  6.      */  
  7.     public CommonAnnotationBeanPostProcessor() {  
  8.         setOrder(Ordered.LOWEST_PRECEDENCE - 3);  
  9.         setInitAnnotationType(PostConstruct.class);  
  10.         setDestroyAnnotationType(PreDestroy.class);  
  11.         ignoreResourceType("javax.xml.ws.WebServiceContext");  
  12.     }  
其中設置了初始化注解類型PostConstruct。下面看下這個注解處理器是在哪調用的，那就是創建bean，初始化bean時。創建bean的大概包括以下幾步（在這里不做代碼分析）：
1）創建bean實例，也就是bean的實例化，其實例化策略並不是簡單的使用反射方法直接反射來構造實例對象的，而是反射方法和動態代理（主要針對aop）相結合的方式。
2）記錄創建bean的objectFactory
3）屬性注入
4）初始化bean
5）注冊disposablebean
附上spring bean的生命周期
 
其中@PostConstruct處理器的調用就是在初始化bean時調用的，而屬性的注解，如@Autowired處理器是在屬性注入的時候調用的。先看下調用棧
 
@PostConstuct的
[java] view plain copy
  1. at com.mango.jtt.init.InitMango.init(InitMango.java:29)  
  2.       at sun.reflect.NativeMethodAccessorImpl.invoke0(NativeMethodAccessorImpl.java:-1)  
  3.       at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)  
  4.       at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)  
  5.       at java.lang.reflect.Method.invoke(Method.java:498)  
  6.       at org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleElement.invoke(InitDestroyAnnotationBeanPostProcessor.java:365)  
  7.       at org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleMetadata.invokeInitMethods(InitDestroyAnnotationBeanPostProcessor.java:310)  
  8.       at org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor.postProcessBeforeInitialization(InitDestroyAnnotationBeanPostProcessor.java:133)  
  9.       at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(AbstractAutowireCapableBeanFactory.java:408)  
  10.       at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1570)  
  11.       at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:545)  
  12.       at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482)  
  13.       at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306)  
  14.       at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)  
  15.       - locked <0xe68> (a java.util.concurrent.ConcurrentHashMap)  
  16.       at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302)  
  17.       at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)  
  18.       at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:776)  
  19.       at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:861)  
  20.       at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:541)  
  21.       - locked <0x19af> (a java.lang.Object)  
  22.       at org.springframework.web.context.ContextLoader.configureAndRefreshWebApplicationContext(ContextLoader.java:444)  
  23.       at org.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java:326)  
  24.       at org.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:107)  

@Autowired處理器的調用棧
[java] view plain copy
  1. at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:347)  
  2.       at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1214)  
  3.       at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:543)  
  4.       at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482)  
  5.       at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306)  
  6.       at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)  
  7.       - locked <0xe4f> (a java.util.concurrent.ConcurrentHashMap)  
  8.       at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302)  
  9.       at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)  
  10.       at org.springframework.context.support.PostProcessorRegistrationDelegate.registerBeanPostProcessors(PostProcessorRegistrationDelegate.java:228)  
  11.       at org.springframework.context.support.AbstractApplicationContext.registerBeanPostProcessors(AbstractApplicationContext.java:697)  
  12.       at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:526)  
  13.       - locked <0xe50> (a java.lang.Object)  
  14.       at org.springframework.web.context.ContextLoader.configureAndRefreshWebApplicationContext(ContextLoader.java:444)  
  15.       at org.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java:326)  
  16.       at org.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:107)  
 
具體分析下@PostConstruct的注解處理器調用

[java] view plain copy
  1. /** 
  2.      * Actually create the specified bean. Pre-creation processing has already happened 
  3.      * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks. 
  4.      * <p>Differentiates between default bean instantiation, use of a 
  5.      * factory method, and autowiring a constructor. 
  6.      * @param beanName the name of the bean 
  7.      * @param mbd the merged bean definition for the bean 
  8.      * @param args explicit arguments to use for constructor or factory method invocation 
  9.      * @return a new instance of the bean 
  10.      * @throws BeanCreationException if the bean could not be created 
  11.      * @see #instantiateBean 
  12.      * @see #instantiateUsingFactoryMethod 
  13.      * @see #autowireConstructor 
  14.      */  
  15.     protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {  
  16.         // Instantiate the bean.  
  17.         BeanWrapper instanceWrapper = null;  
  18.         if (mbd.isSingleton()) {  
  19.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
  20.         }  
  21.         if (instanceWrapper == null) {  
  22.             instanceWrapper = createBeanInstance(beanName, mbd, args);  
  23.         }  
  24.         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);  
  25.         Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);  
  26.   
  27.         // Allow post-processors to modify the merged bean definition.  
  28.         synchronized (mbd.postProcessingLock) {  
  29.             if (!mbd.postProcessed) {  
  30.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
  31.                 mbd.postProcessed = true;  
  32.             }  
  33.         }  
  34.   
  35.         // Eagerly cache singletons to be able to resolve circular references  
  36.         // even when triggered by lifecycle interfaces like BeanFactoryAware.  
  37.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
  38.                 isSingletonCurrentlyInCreation(beanName));  
  39.         if (earlySingletonExposure) {  
  40.             if (logger.isDebugEnabled()) {  
  41.                 logger.debug("Eagerly caching bean '" + beanName +  
  42.                         "' to allow for resolving potential circular references");  
  43.             }  
  44.             addSingletonFactory(beanName, new ObjectFactory<Object>() {  
  45.                 @Override  
  46.                 public Object getObject() throws BeansException {  
  47.                     return getEarlyBeanReference(beanName, mbd, bean);  
  48.                 }  
  49.             });  
  50.         }  
  51.   
  52.         // Initialize the bean instance.  
  53.         Object exposedObject = bean;  
  54.         try {  
  55.             populateBean(beanName, mbd, instanceWrapper);  
  56.             if (exposedObject != null) {  
  57.                 exposedObject = initializeBean(beanName, exposedObject, mbd);  
  58.             }  
  59.         }  
  60.         catch (Throwable ex) {  
  61.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {  
  62.                 throw (BeanCreationException) ex;  
  63.             }  
  64.             else {  
  65.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);  
  66.             }  
  67.         }  
  68.   
  69.         if (earlySingletonExposure) {  
  70.             Object earlySingletonReference = getSingleton(beanName, false);  
  71.             if (earlySingletonReference != null) {  
  72.                 if (exposedObject == bean) {  
  73.                     exposedObject = earlySingletonReference;  
  74.                 }  
  75.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
  76.                     String[] dependentBeans = getDependentBeans(beanName);  
  77.                     Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);  
  78.                     for (String dependentBean : dependentBeans) {  
  79.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {  
  80.                             actualDependentBeans.add(dependentBean);  
  81.                         }  
  82.                     }  
  83.                     if (!actualDependentBeans.isEmpty()) {  
  84.                         throw new BeanCurrentlyInCreationException(beanName,  
  85.                                 "Bean with name '" + beanName + "' has been injected into other beans [" +  
  86.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
  87.                                 "] in its raw version as part of a circular reference, but has eventually been " +  
  88.                                 "wrapped. This means that said other beans do not use the final version of the " +  
  89.                                 "bean. This is often the result of over-eager type matching - consider using " +  
  90.                                 "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");  
  91.                     }  
  92.                 }  
  93.             }  
  94.         }  
  95.   
  96.         // Register bean as disposable.  
  97.         try {  
  98.             registerDisposableBeanIfNecessary(beanName, bean, mbd);  
  99.         }  
  100.         catch (BeanDefinitionValidationException ex) {  
  101.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);  
  102.         }  
  103.   
  104.         return exposedObject;  
  105.     }  
上述代碼包含了創建bean的所有步驟，直接看下bean的初始化initializeBean
 
[java] view plain copy
  1. /** 
  2.      * Initialize the given bean instance, applying factory callbacks 
  3.      * as well as init methods and bean post processors. 
  4.      * <p>Called from {@link #createBean} for traditionally defined beans, 
  5.      * and from {@link #initializeBean} for existing bean instances. 
  6.      * @param beanName the bean name in the factory (for debugging purposes) 
  7.      * @param bean the new bean instance we may need to initialize 
  8.      * @param mbd the bean definition that the bean was created with 
  9.      * (can also be {@code null}, if given an existing bean instance) 
  10.      * @return the initialized bean instance (potentially wrapped) 
  11.      * @see BeanNameAware 
  12.      * @see BeanClassLoaderAware 
  13.      * @see BeanFactoryAware 
  14.      * @see #applyBeanPostProcessorsBeforeInitialization 
  15.      * @see #invokeInitMethods 
  16.      * @see #applyBeanPostProcessorsAfterInitialization 
  17.      */  
  18.     protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {  
  19.         if (System.getSecurityManager() != null) {  
  20.             AccessController.doPrivileged(new PrivilegedAction<Object>() {  
  21.                 @Override  
  22.                 public Object run() {  
  23.                     invokeAwareMethods(beanName, bean);  
  24.                     return null;  
  25.                 }  
  26.             }, getAccessControlContext());  
  27.         }  
  28.         else {  
  29.             invokeAwareMethods(beanName, bean);  
  30.         }  
  31.   
  32.         Object wrappedBean = bean;  
  33.         if (mbd == null || !mbd.isSynthetic()) {  
  34.             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
  35.         }  
  36.   
  37.         try {  
  38.             invokeInitMethods(beanName, wrappedBean, mbd);  
  39.         }  
  40.         catch (Throwable ex) {  
  41.             throw new BeanCreationException(  
  42.                     (mbd != null ? mbd.getResourceDescription() : null),  
  43.                     beanName, "Invocation of init method failed", ex);  
  44.         }  
  45.   
  46.         if (mbd == null || !mbd.isSynthetic()) {  
  47.             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
  48.         }  
  49.         return wrappedBean;  
  50.     }  

初始化給定的bean實例，應用工廠回調以及init方法和bean post處理器。順便說一句，實現了InitializingBean接口的bean的afterPropertiseSet()方法是在
invokeInitMethods(beanName, wrappedBean, mbd);中進行調用的。接着看
[java] view plain copy
  1. @Override  
  2.     public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)  
  3.             throws BeansException {  
  4.   
  5.         Object result = existingBean;  
  6.         for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {  
  7.             result = beanProcessor.postProcessBeforeInitialization(result, beanName);  
  8.             if (result == null) {  
  9.                 return result;  
  10.             }  
  11.         }  
  12.         return result;  
  13.     }  

這里就用到了前面注冊的beanPostProcessors列表，於是就調用到了CommonAnnotationBeanPostProcessor中的postProcessBeforeInitialization()方法（繼承自InitDestroyAnnotationBeanPostProcessor.java）
 
[java] view plain copy
  1. @Override  
  2.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
  3.         LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());  
  4.         try {  
  5.             metadata.invokeInitMethods(bean, beanName);  
  6.         }  
  7.         catch (InvocationTargetException ex) {  
  8.             throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());  
  9.         }  
  10.         catch (Throwable ex) {  
  11.             throw new BeanCreationException(beanName, "Failed to invoke init method", ex);  
  12.         }  
  13.         return bean;  
  14.     }  

上述代碼也很簡單，就是獲取用@PostConstruct注解標注的method，然后調用，看下findLifecycleMetadata實現
[java] view plain copy
  1. private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {  
  2.         final boolean debug = logger.isDebugEnabled();  
  3.         LinkedList<LifecycleElement> initMethods = new LinkedList<LifecycleElement>();  
  4.         LinkedList<LifecycleElement> destroyMethods = new LinkedList<LifecycleElement>();  
  5.         Class<?> targetClass = clazz;  
  6.   
  7.         do {  
  8.             final LinkedList<LifecycleElement> currInitMethods = new LinkedList<LifecycleElement>();  
  9.             final LinkedList<LifecycleElement> currDestroyMethods = new LinkedList<LifecycleElement>();  
  10.   
  11.             ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {  
  12.                 @Override  
  13.                 public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {  
  14.                     if (initAnnotationType != null) {  
  15.                         if (method.getAnnotation(initAnnotationType) != null) {  
  16.                             LifecycleElement element = new LifecycleElement(method);  
  17.                             currInitMethods.add(element);  
  18.                             if (debug) {  
  19.                                 logger.debug("Found init method on class [" + clazz.getName() + "]: " + method);  
  20.                             }  
  21.                         }  
  22.                     }  
  23.                     if (destroyAnnotationType != null) {  
  24.                         if (method.getAnnotation(destroyAnnotationType) != null) {  
  25.                             currDestroyMethods.add(new LifecycleElement(method));  
  26.                             if (debug) {  
  27.                                 logger.debug("Found destroy method on class [" + clazz.getName() + "]: " + method);  
  28.                             }  
  29.                         }  
  30.                     }  
  31.                 }  
  32.             });  
  33.   
  34.             initMethods.addAll(0, currInitMethods);  
  35.             destroyMethods.addAll(currDestroyMethods);  
  36.             targetClass = targetClass.getSuperclass();  
  37.         }  
  38.         while (targetClass != null && targetClass != Object.class);  
  39.   
  40.         return new LifecycleMetadata(clazz, initMethods, destroyMethods);  
  41.     }  

是不是有種豁然開朗的感覺。
 
[java] view plain copy
  1. public void invokeInitMethods(Object target, String beanName) throws Throwable {  
  2.             Collection<LifecycleElement> initMethodsToIterate =  
  3.                     (this.checkedInitMethods != null ? this.checkedInitMethods : this.initMethods);  
  4.             if (!initMethodsToIterate.isEmpty()) {  
  5.                 boolean debug = logger.isDebugEnabled();  
  6.                 for (LifecycleElement element : initMethodsToIterate) {  
  7.                     if (debug) {  
  8.                         logger.debug("Invoking init method on bean '" + beanName + "': " + element.getMethod());  
  9.                     }  
  10.                     element.invoke(target);  
  11.                 }  
  12.             }  
  13.         }  

[java] view plain copy
  1. public void invoke(Object target) throws Throwable {  
  2.             ReflectionUtils.makeAccessible(this.method);  
  3.             this.method.invoke(target, (Object[]) null);  
  4.         }  

熟悉的java反射。至此整個Spring注解的工作原理就分析完了，總結如下：
 
1）利用asm技術掃描class文件，轉化成Spring bean結構，把符合掃描規則的（主要是是否有相關的注解標注，例如@Component）bean注冊到Spring 容器中beanFactory
2）注冊處理器，包括注解處理器
4）實例化處理器（包括注解處理器），並將其注冊到容器的beanPostProcessors列表中
5）創建bean的過程中個，屬性注入或者初始化bean時會調用對應的注解處理器進行處理
 
 
轉自：http://blog.csdn.net/honghailiang888/article/details/74981445


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Spring注解Component原理源碼解析 Spring Boot 自動配置注解源碼解析 spring源碼分析之spring注解@Aspect是如何工作的？ Spring源碼解析 – @Configuration配置類及注解Bean的解析 Spring Boot中@ConfigurationProperties注解實現原理源碼解析 Spring源碼解析之Configuration注解 Spring @CrossOrigin 注解原理(轉) spring源碼解析之AOP原理 spring基於注解和配置源碼解讀 Spring MVC工作原理 及注解說明
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM