共计 18981 个字符,预计需要花费 48 分钟才能阅读完成。
上一篇是分享的是《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 类如下:
@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》的分享。
也欢送大家交换探讨,该文章若有不正确的中央,心愿大家多多包涵。
你们的反对就是我最大的能源,如果对大家有帮忙给个赞哦~~~