上一篇是分享的是《Spring SPI 机制总结》，这篇给大家分享《spring 源码系列之 BeanDefinition》，这篇文章略长，纯干货，大家准备好，发车啦。
【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 类如下：
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》的分享。
也欢迎大家交流探讨，该文章若有不正确的地方，希望大家多多包涵。
你们的支持就是我最大的动力，如果对大家有帮忙给个赞哦~~~
评论