关于java:腾讯T6万字长文体系化讲解Spring源码码农太透彻了学会了

上一篇是分享的是《Spring SPI 机制总结》，这篇给大家分享《spring 源码系列之 BeanDefinition》，这篇文章略长，纯干货，大家筹备好，发车啦。

1. BeanDefinition 简介
BeanDefinition 有三个实现类，ChildBeanDefinition、GenericBeanDefinition、RootBeanDefinition，三者都继承 AbstractBeanDefinition，对三个子类独特的类信息进行形象。如果配置文件中定义了父和子，则父用 RootBeanDefinition 示意，子用 ChildBeanDefinition 示意，而没有父的就应用 RootBeanDefinition 示意。GenericBeanDefinition 为一站式服务类。
2. BeanDefinition 的属性
用 BeanDefintionParserDelegate 的办法 parseBeanDefinitionAttributes 办法。

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
            @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
        // 解析 scope 标签
        if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {error("Old 1.x'singleton'attribute in use - upgrade to'scope'declaration", ele);
        }
        else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
        }
        else if (containingBean != null) {
            // Take default from containing bean in case of an inner bean definition.
            bd.setScope(containingBean.getScope());
        }

        // 解析 abstract 标签
        if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
        }

        // 解析 lazy-init 标签
        String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
        if (isDefaultValue(lazyInit)) {lazyInit = this.defaults.getLazyInit();
        }
        bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

        // 解析 autowire 标签
        String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
        bd.setAutowireMode(getAutowireMode(autowire));

        // 解析 depends-on 标签
        if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
            bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
        }

        // 解析 autowire-candidate 标签
        String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
        if (isDefaultValue(autowireCandidate)) {String candidatePattern = this.defaults.getAutowireCandidates();
            if (candidatePattern != null) {String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
                bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
            }
        }
        else {bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
        }

        // 解析 primary 标签
        if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
        }

        // 解析 init-method 标签
        if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
            bd.setInitMethodName(initMethodName);
        }
        else if (this.defaults.getInitMethod() != null) {bd.setInitMethodName(this.defaults.getInitMethod());
            bd.setEnforceInitMethod(false);
        }

        // 解析 destroy-method 标签
        if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
            bd.setDestroyMethodName(destroyMethodName);
        }
        else if (this.defaults.getDestroyMethod() != null) {bd.setDestroyMethodName(this.defaults.getDestroyMethod());
            bd.setEnforceDestroyMethod(false);
        }

        // 解析 factory-method 标签
        if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
        }

        // 解析 factory-bean 标签
        if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
        }

        return bd;
    }

因为 BeanDefinition 的实现类都继承自父类 AbstractBeanDefinition，父类中有三个援用的属性 ConstructorArgumentValues、MutablePropertyValues、MethodOverrides，所以 GenericBeanDefinition 最终蕴含的属性如下图：

id：Bean 的惟一标识名。它必须是非法的 XMLID，在整个 XML 文档中惟一；
name：用来为 id 创立一个或多个别名。它能够是任意的字母合乎。多个别名之间用逗号或空格离开；
class：用来定义类的全限定名（包名+类名）。只有子类 Bean 不必定义该属性；
parent：子类 Bean 定义它所援用它的父类 Bean，这是后面的 class 属性生效，子类 Bean 会继承父类 Bean 的所有属性，子类 Bean 也能够笼罩父类 Bean 的属性，留神：子类 Bean 和父类 Bean 是同一个 Java 类；
abstract（默认为 ”false”）：用来定义 Bean 是否为形象 Bean。它示意这个 Bean 将不会被实例化，个别用于父类 Bean，因为父类 Bean 次要是供子类 Bean 继承应用；
lazy-init（默认为 ”false”）：用来定义这个 Bean 是否实现懒初始化。如果为 ”false”，它将在 BeanFactory 启动时初始化所有的 SingletonBean。反之，如果为 ”true”, 它只在 Bean 申请时才开始创立 SingletonBean；
autowire（主动拆卸，默认为 ”default”）：它定义了 Bean 的主动装载形式；–“no”：不应用主动拆卸性能；–“byName”：通过 Bean 的属性名实现主动拆卸;–“byType”：通过 Bean 的类型实现主动拆卸;–“constructor”：相似于 byType，但它是用于构造函数的参数的主动组装;–“autodetect”：通过 Bean 类的检查机制（introspection）决定是应用 ”constructor” 还是应用 ”byType”。
depends-on（依赖对象）：这个 Bean 在初始化时依赖的对象，这个对象会在这个 Bean 初始化之前创立；
init-method：用来定义 Bean 的初始化办法，它会在 Bean 组装之后调用。它必须是一个无参数的办法；
destroy-method：用来定义 Bean 的销毁办法，它在 BeanFactory 敞开时调用。同样，它也必须是一个无参数的办法。它只能利用于 singletonBean。
factory-method：定义创立该 Bean 对象的工厂办法。它用于上面的 ”factory-bean”，示意这个 Bean 是通过工厂办法创立，此时，”class” 属性生效。
factory-bean: 定义创立该 Bean 对象的工厂类。如果应用了 ”factory-bean” 则 ”class” 属性生效
autowire-candidate：采纳 xml 格局配置 bean 时，将元素的 autowire-candidate 属性设置为 false，这样容器在查找主动拆卸对象时，将不思考该 bean，即它不会被思考作为其它 bean 主动拆卸的候选者，然而该 bean 自身还是能够应用主动拆卸来注入其它 bean 的；
MutablePropertyValues：用于封装标签的信息，其实类外面就是有一个 list，list 外面是 PropertyValue 对象，PropertyValue 就是一个 name 和 value 属性，用于封装标签的名称和值信息
ConstructorArgumentValues：用于封装标签的信息，其实类外面就是有一个 map，map 中用构造函数的参数程序作为 key，值作为 value 存储到 map 中；
MethodOverrides：用于封装 lookup-method 和 replaced-method 标签的信息，同样的类外面有一个 Set 对象增加 LookupOverride 对象和 ReplaceOverride 对象。

3. component-scan 标签解析过程

3.1 流程概览

3.2 具体过程

后面一文提到，自定义标签解析 BeanDefinitionParserDelegate 类，执行 parseCustomElement 办法；

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
                // 获取 namespaceURI
        String namespaceUri = getNamespaceURI(ele);
        if (namespaceUri == null) {return null;}
                // 解析 namespaceURI 对应的 handler 类
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler == null) {error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        }
                // 执行 handler 的解析办法
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    }

上述过程次要实现以下步骤：
step1: 获取 namespaceURI；
step2: 解析 namespaceURI 对应的 handler 类；
step3：执行 handler 办法解析。step1 与 step2 前文已剖析，以 component-scan 为例，剖析 step3，代码进入 ComponentScanBeanDefinitionParser 的 parse 办法

public BeanDefinition parse(Element element, ParserContext parserContext) {
        /**
         * 1. 包扫描.class 后缀的文件
         * 2. 判断类上是否有注解
         * 3. GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
         *         genericBeanDefinition.setBeanClass(BeanClass.class);
         * 4. 实现 beanDefinition 的注册
         */
        String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
        basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
        String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
                ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

        // Actually scan for bean definitions and register them.
        // 创立扫描器
        ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
        // 扫描器扫描
        Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
        // 注册 bean 蕴含的组件
        registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

        return null;
    }

上述过程总共分为三步：
step1：configureScanner 办法创立扫描器；
step2：doScan 办法扫描器扫描；
step3：registerComponents 注册 bean 蕴含的组件。

进入上述 step2，进入 ClassPathBeanDefinitionScanner 的 doScan 办法,

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) {
            // 扫描有注解的类并封装成 beanDefinition 对象
            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) {
                    // 反对 @Lazy @Primary @DependOn 注解
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                if (checkCandidate(beanName, candidate)) {BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }

上述 doScan 办法次要做了以下三步：
step1: findCandidateComponents 扫描有注解的类并封装成 beanDefinition 对象；
step2: processCommonDefinitionAnnotations 办法反对 @Lazy @Primary @DependOn 注解；
step3：注册 BeanDefinition。

持续进入上述 step1 中的 findCandidateComponents 办法，来到 ClassPathScanningCandidateComponentProvider 类的 scanCandidateComponents 办法，实现以下步骤：
step1: getResources 递归获取.class 后缀的文件；
step2: getMetadataReader 办法，获取元数据 AnnotationMetadataReadingVisitor 对象，该元数据收集了扫描类的任何信息；
step3：判断 includeFilters 是否跟元数据中的注解匹配，如果匹配就实例化该类，创立 BeanDefinition 对象。

后面还有一个步骤 step3：registerComponents 注册 bean 蕴含的组件还未剖析，进入该办法

protected void registerComponents(XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {Object source = readerContext.extractSource(element);
        CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);

        for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
        }


        boolean annotationConfig = true;
        if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {annotationConfig = Boolean.parseBoolean(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
        }
        if (annotationConfig) {
            // 如果类中的属性有注解，注册注解配置处理器
            Set<BeanDefinitionHolder> processorDefinitions =
                    AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
            for (BeanDefinitionHolder processorDefinition : processorDefinitions) {compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
            }
        }

        readerContext.fireComponentRegistered(compositeDef);
    }

随后进入 AnnotationConfigUtils.registerAnnotationConfigProcessors，

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);

        // @Configuration 注解的处理器 ConfigurationClassPostProcessor
        if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // @Autowired 注解的处理器 AutowiredAnnotationBeanPostProcessor
        if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // CommonAnnotationBeanPostProcessor 处理器.
        if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
        if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {RootBeanDefinition def = new RootBeanDefinition();
            try {
                def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                        AnnotationConfigUtils.class.getClassLoader()));
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException("Cannot load optional framework class:" + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
            }
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
        }

        return beanDefs;
    }

下面提到了三类处理器 ConfigurationClassPostProcessor，AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，别离对不同注解作解决，最初封装到 BeanDefinition 中，注册到容器。

进入 ConfigurationClassPostProcessor 的 processConfigBeanDefinitions 办法，如下:

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        ......
        // 解析所有加了 @Configuration 注解的类
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);

        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
        Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
        do {
            // 解析 @Component @ComponentScan @ComponentScans @Bean @Import @ImportResource
            parser.parse(candidates);
            parser.validate();

            ......
    }

上述办法次要解析加了 @Configuration 的类，以及 @Component @ComponentScan @ComponentScans @Bean @Import @ImportResource 注解，后者是通过 parse 办法实现的，进入 parse 办法一路走下来回到 processConfigurationClass 办法，如下图

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
        ......
        do {sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
        }
        while (sourceClass != null);
                ......
    }

随后进入 doProcessConfigurationClass 办法，实现 @Component @ComponentScan @ComponentScans @Bean @Import @ImportResource 注解解析。

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

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

        // 解析 @PropertySource
        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 @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) {
                // 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());
                    }
                }
            }
        }

        // 解析 @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));
        }

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

同样跟踪 AutowiredAnnotationBeanPostProcessor 类，能够看到该类实现 @Autowired @Value 的解析，如下图：

public AutowiredAnnotationBeanPostProcessor() {this.autowiredAnnotationTypes.add(Autowired.class);
        this.autowiredAnnotationTypes.add(Value.class);
        try {this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
                    ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
            logger.trace("JSR-330'javax.inject.Inject'annotation found and supported for autowiring");
        }
        catch (ClassNotFoundException ex) {// JSR-330 API not available - simply skip.}
    }

相似跟踪 CommonAnnotationBeanPostProcessor 类，能够看到该类实现 @Resource @PostConstruct @PreDestroy 的解析，如下图：

static {webServiceRefClass = loadAnnotationType("javax.xml.ws.WebServiceRef");
        ejbClass = loadAnnotationType("javax.ejb.EJB");

        resourceAnnotationTypes.add(Resource.class);
        if (webServiceRefClass != null) {resourceAnnotationTypes.add(webServiceRefClass);
        }
        if (ejbClass != null) {resourceAnnotationTypes.add(ejbClass);
        }
    }
......
 
public CommonAnnotationBeanPostProcessor() {setOrder(Ordered.LOWEST_PRECEDENCE - 3);
        setInitAnnotationType(PostConstruct.class);
        setDestroyAnnotationType(PreDestroy.class);
        ignoreResourceType("javax.xml.ws.WebServiceContext");
    }

4. 示例

创立一个 BeanDefinitionTest 类，实现 BeanDefinitionRegistryPostProcessor 接口，并在办法中实现设置 Bean 的类型为 BeanClass，而后设置 BeanClass 对象的 username 属性与值，最初注册到容器中，代码如下

@Component
    public class BeanDefinitionTest implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
        genericBeanDefinition.setBeanClass(BeanClass.class);

        MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
        propertyValues.addPropertyValue("username","wzj");

        registry.registerBeanDefinition("beanClass",genericBeanDefinition);
    }

BeanClass 类如下：

@Data
public class BeanClass {private String username;}

测试类如下：

public class TestSpring {

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void testComponentScan() {applicationContext = new AnnotationConfigApplicationContext("com.wzj");
        BeanClass beanClass = (BeanClass)applicationContext.getBean("beanClass");
        BeanDefinitionTest beanDefinitionTest = (BeanDefinitionTest)applicationContext.getBean("beanDefinitionTest");
        System.out.println("BeanClass-->" + beanClass.getUsername());
        System.out.println("BeanDefinitionTest-->" + beanDefinitionTest.getClass());
    }

代码目录构造如下与运行后果如下

5. 总结

本文以 conmponent-scan 标签为例，剖析了次要流程，并联合源码讲述了 BeanDefinition 属性的解析、封装、以及最初注册到容器中，最初以一个思维导图总结每个流程中的大抵步骤

另外，动态看源码可关注主流程，并做正文，动静 debug 示例进入源码可直观感触运行期间的值，源码剖析不易，搞清楚主流程与思维比源码自身更重要。

以上就是《spring 源码系列之 BeanDefinition》的分享。

也欢送大家交换探讨，该文章若有不正确的中央，心愿大家多多包涵。

你们的反对就是我最大的能源，如果对大家有帮忙给个赞哦~~~

关于java:腾讯T6万字长文体系化讲解Spring源码码农太透彻了学会了

【spring 源码系列】之【BeanDefinition】

Just My Socks（注册教程内含优惠码）

关于java:腾讯T6万字长文体系化讲解Spring源码码农太透彻了学会了

【spring 源码系列】之【BeanDefinition】

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）