Spring中的BeanDefinition注冊流程詳解
更新時間：2023年12月02日 09:58:40 作者：weixin_34406086
這篇文章主要介紹了Spring中的BeanDefinition注冊流程詳解, NamespaceHandler簡單來說就是命名空間處理器,Spring為了開放性提供了NamespaceHandler機制,這樣我們就可以根據(jù)需求自己來處理我們設置的標簽元素,需要的朋友可以參考下
前言
NamespaceHandler簡單來說就是命名空間處理器，Spring為了開放性提供了NamespaceHandler機制，這樣我們就可以根據(jù)需求自己來處理我們設置的標簽元素。
本文章解析<context:component-scan base-package="xxxxx"/>如何完成bean定義注冊的以及擴展點講解。
BeanDefinition注冊流程
測試代碼：
ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
TestService cs = context.getBean(TestService.class);
xml：
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- <context:annotation-config />
<aop:aspectj-autoproxy /> -->
<context:component-scan base-package="com.study.mike.spring.service"/>
<!-- <context:exclude-filter type="annotation" expression=""/>
<context:include-filter type="annotation" expression=""/>
</context:component-scan> -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations" value="classpath:application.properties"/>
</bean>
<alias name="testService" alias="combat"/>
</beans>流程
先看幾個主要的方法：
1、ClassPathXmlApplicationContext構造器
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
//設置父容器
super(parent);
//設置配置文件spring.xml
setConfigLocations(configLocations);
//是否刷新容器
if (refresh) {
//執(zhí)行刷新方法
refresh();
}
}
2、AbstractRefreshableApplicationContext#refreshBeanFactory()刷新工廠方法，此方法執(zhí)行此上下文的基礎bean工廠的實際刷新，關閉先前的bean工廠（如果有）并初始化上一個生命周期的下一階段的新bean工廠。
@Override
protected final void refreshBeanFactory() throws BeansException {
//如果存在容器就銷毀容器
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//創(chuàng)建bean容器
DefaultListableBeanFactory beanFactory = createBeanFactory();
//設置序列號id
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
//加載bean定義
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
3、AbstractRefreshableApplicationContext#loadBeanDefinitions(DefaultListableBeanFactory beanFactory)，通過XmlBeanDefinitionReader加載bean定義
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
//使用此context的資源加載環(huán)境配置bean定義讀取器
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
//允許子類提供讀取器的自定義初始化
initBeanDefinitionReader(beanDefinitionReader);
//繼續(xù)實際加載bean定義
loadBeanDefinitions(beanDefinitionReader);
}4、AbstractXmlApplicationContext#loadBeanDefinitions(XmlBeanDefinitionReader reader)，這個方法加載和/或注冊bean定義。
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//獲取到配置文件循環(huán)加載
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
//獲取到配置文件（spring.xml）循環(huán)加載,這里獲取的是ClassPathXmlApplicationContext的構造器
中setConfigLocations(configLocations)設置的文件路徑;
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}5、 XmlBeanDefinitionReader#registerBeanDefinitions(Document doc, Resource resource)，注冊DOM文檔中bean定義。
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
//createReaderContext(resource) 很關鍵
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
this.sourceExtractor, this, getNamespaceHandlerResolver());
}
//懶惰地創(chuàng)建一個默認的NamespaceHandlerResolver，如果之前沒有設置的話
public NamespaceHandlerResolver getNamespaceHandlerResolver() {
if (this.namespaceHandlerResolver == null) {
this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
}
return this.namespaceHandlerResolver;
}
protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
ClassLoader cl =
(getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
//DefaultNamespaceHandlerResolver類中會將加載META-INF/spring.handlers里面配置的：詳見下圖
return new DefaultNamespaceHandlerResolver(cl);}紅框圈住的都是spring里面自己的擴展實現(xiàn)。例如：
aop對應處理的標簽:
<aop:config>
<aop:pointcut id="loggerCutpoint"
expression=
"execution(* com.how2java.service.ProductService.*(..)) "/>
<aop:aspect id="logAspect" ref="loggerAspect">
<aop:after pointcut-ref="loggerCutpoint" method="log"/>
</aop:aspect>
</aop:config> 怎么區(qū)分<aop:config/>由AopNamespaceHandler處理呢？接下來就會講到，parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)這個方法。
6、DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions(Element root)，在給定的根<beans />元素中注冊每個bean定義。這個方法里面有個關鍵點!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)啟用環(huán)境，比如：
我配置這個標簽下面的beans是dev環(huán)境的，我啟用環(huán)境是prd，那么dev下的bean是不會被加載的。
protected void doRegisterBeanDefinitions(Element root) {
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
//獲取beans所屬環(huán)境
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
//配置為Profile="dev,prd"的轉成數(shù)組。
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
//判斷當前beans標簽的profile和啟用環(huán)境是否匹配，不匹配直接返回。
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isDebugEnabled()) {
logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
//前置處理，spring沒有實現(xiàn)
preProcessXml(root);
//正式解析
parseBeanDefinitions(root, this.delegate);
//后置處理，spring沒有實現(xiàn)
postProcessXml(root);
this.delegate = parent;
}
7、DefaultBeanDefinitionDocumentReader#parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)，解析文檔中根級別的元素。
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
//這里就是判斷是由默認的解析器去解析，還是由其他擴展NamespaceHandler處理。
if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
8、BeanDefinitionParserDelegate#parseCustomElement(Element ele, @Nullable BeanDefinition containingBd)
@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
//這里的readerContext就是前面我說的很關鍵的地方，createReaderContext(resource),
接著看resolve(namespaceUri);
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}9、DefaultNamespaceHandlerResolver#resolve(String namespaceUri)。
@Override
@Nullable
public NamespaceHandler resolve(String namespaceUri) {
//獲取所有配置到spring.handlers（多個配置文件）里面的命名空間->類，
例："http://www.springframework.org/schema/aop" -> "org.springframework.aop.config.AopNamespaceHandler"
Map<String, Object> handlerMappings = getHandlerMappings();
//根據(jù)命名空間獲取到對應的處理類.
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
}
else if (handlerOrClassName instanceof NamespaceHandler) {
return (NamespaceHandler) handlerOrClassName;
}
else {
//加載類
String className = (String) handlerOrClassName;
try {
Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
}
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
//初始化解析器。
namespaceHandler.init();
//重新put進handlerMappings，方便下次獲取時直接是類不是string
handlerMappings.put(namespaceUri, namespaceHandler);
return namespaceHandler;
}
catch (ClassNotFoundException ex) {
throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
"] for namespace [" + namespaceUri + "]", ex);
}
catch (LinkageError err) {
throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
className + "] for namespace [" + namespaceUri + "]", err);
}
}
}10、初始化解析器
public class ContextNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
//這個就是解析<context:component-scan base-package="xxxxx"/>標簽的解析器
registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
}
}什么時候去執(zhí)行這個解析呢？
在BeanDefinitionParserDelegate#parseCustomElement(Element ele, @Nullable BeanDefinition containingBd)方法里面的最后一步：
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
我們看一下這個解析方法是怎么執(zhí)行的。會調到NamespaceHandlerSupport#parse(Element element, ParserContext parserContext)這個方法.
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
BeanDefinitionParser parser = findParserForElement(element, parserContext);
//parser.parse(element, parserContext)就會調到ComponentScanBeanDefinitionParser#parse方法
return (parser != null ? parser.parse(element, parserContext) : null);
}
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
//獲取到要掃描的包.
String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
//開始掃描,繼續(xù)看
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
//不知道這么為什么是返回的null,源碼就是這樣很奇怪。
return null;
}
11、ClassPathBeanDefinitionScanner#doScan(String... basePackages)，掃描注冊。
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) {
//掃描到bean定義
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//注冊bean定義
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}12、DefaultListableBeanFactory#registerBeanDefinition(String beanName, BeanDefinition beanDefinition)真正注冊bean定義，注冊bean定義的工作就此完成。
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
//判斷是否是抽象bean定義,是做其他的處理.
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
//beanDefinitionMap就是放bean定義的對象,判斷bean定義是否存在.
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
//放入最新的bean定義,注冊bean定義的工作就此完成
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}此次講了，BeanDefinition注冊流程、擴展點NamespaceHandler以及里面的用的策略模式、啟用環(huán)境相關的，容器刷新AbstractApplicationContext#refresh()的第二步ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
其他的注冊流程注解、絕對路徑配置文件，都是大同小異。
到此這篇關于Spring中的BeanDefinition注冊流程詳解的文章就介紹到這了,更多相關BeanDefinition注冊流程內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家介紹了Spark Streaming編程初級實踐詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-04-04
項目中對圖片的處理與查看是必不可少的，本文將講解如何通過項目路徑來獲取到本機電腦的圖片資源，本文通過示例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友參考下吧2023-08-08
這篇文章主要為大家介紹了InputStream數(shù)據(jù)結構示例解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-10-10
分頁是常見的一種功能,本文主要介紹了MyBatis-Plus?Page分頁不生效的問題解決,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2024-07-07
這篇文章主要介紹了java中的按位與(&)用法說明，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-08-08
Hutool是一個小而全的Java工具類庫，通過靜態(tài)方法封裝，降低相關API的學習成本，提高工作效率，涵蓋了Java開發(fā)開發(fā)中的方方面面，使用Hutool可節(jié)省開發(fā)人員對項目中公用類和公用工具方法的封裝時間，使開發(fā)專注于業(yè)務，同時可以最大限度的避免封裝不完善帶來的bug2023-02-02
這篇文章主要介紹了5個并發(fā)處理技巧代碼示例，具有一定參考價值，需要的朋友可以了解下。2017-10-10
這篇文章主要介紹了java接口基礎知識，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-04-04
Restful就是一個資源定位及資源操作的風格,不是標準也不是協(xié)議,只是一種風格,是對http協(xié)議的詮釋,下面這篇文章主要給大家介紹了關于SpringMVC對Restful風格支持的相關資料,需要的朋友可以參考下2022-01-01
Java中static和static?final的區(qū)別詳解
這篇文章主要介紹了Java中static和static?final的區(qū)別詳解,開發(fā)時我們經(jīng)常用到static以及static?final來修飾我們的字段變量,那么他們到底有什么區(qū)別呢？其實他們的區(qū)別可以用使用字節(jié)碼文件來解析,需要的朋友可以參考下2023-10-10