Spring IOC 加载过程(一 加载xml)

最新推荐文章于 2022-04-21 17:46:13 发布
最新推荐文章于 2022-04-21 17:46:13 发布
阅读量652 收藏 1
点赞数 1
分类专栏： Spring 文章标签： Spring IOC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16677263/article/details/82387816
版权

Spring IOC 加载过程

看过很多次Spring容器的源码，每次都没有记录，每次都看到放弃，这次下决心要学习一下源码了，所以写一篇博文来记录，也希望有各路大神来指点不足之处，话不多说，下面开始！

  1. 加载Context
  2. 创建beanFactory
  3. 加载xml

Spring容器结构图
Spring容器结构图

加载Context

我是从一个web程序打断点一步一步跟代码走的，一个web程序的入口应该是web.xml文件

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:spring-config.xml</param-value>
</context-param>
<!-- 注册Spring ContextLoaderListener -->
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

web.xml中关于Spring的配置就这么简单，这里我们只看Spring的内容，暂时先不看SpringMVC(web)的内容
然后根据上面的配置进入代码（启动tomcat可以进入）

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
	public ContextLoaderListener() {
	}
	public ContextLoaderListener(WebApplicationContext context) {
		super(context);
	}
	/**
	 * 初始化Spring容器入口
	 */
	@Override
	public void contextInitialized(ServletContextEvent event) {
		initWebApplicationContext(event.getServletContext());
	}
	@Override
	public void contextDestroyed(ServletContextEvent event) {
		closeWebApplicationContext(event.getServletContext());
		ContextCleanupListener.cleanupAttributes(event.getServletContext());
	}

}

这里就是入口，其实就是执行了一个initWebApplicationContext(event.getServletContext())这个方法。我们进入方法来看：


	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
		/* 
		 *	WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = "org.springframework.web.context.WebApplicationContext.ROOT" servletContext中没有这个属性
		 */
		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
			throw new IllegalStateException(
					"Cannot initialize context because there is already a root application context present - " +
					"check whether you have multiple ContextLoader* definitions in your web.xml!");
		}

		Log logger = LogFactory.getLog(ContextLoader.class);
		servletContext.log("Initializing Spring root WebApplicationContext");
		if (logger.isInfoEnabled()) {
			logger.info("Root WebApplicationContext: initialization started");
		}
		//这里记录一个开始时间
		long startTime = System.currentTimeMillis();

		try {
			
			if (this.context == null) { //默认是null
				/*创建web应用上下文
				这里获取到的是默认给的 org.springframework.web.context.support.XmlWebApplicationContext这个类，
				创建web应用下文结束（创建了一个XmlWebApplicationContext对象）*/
				this.context = createWebApplicationContext(servletContext);
			}
			if (this.context instanceof ConfigurableWebApplicationContext) {
				//这里做一下转换
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				if (!cwac.isActive()) {//这里初始值是false
					if (cwac.getParent() == null) { //父容器为空，这里加载回来也是一个空，因为是初次加载还没有父容器
						ApplicationContext parent = loadParentContext(servletContext);
						cwac.setParent(parent);
					}
					//配置刷新Spring容器，这里是这个方法最重要的部分，我们后面解释
					configureAndRefreshWebApplicationContext(cwac, servletContext);
				}
			}
			//把初始化好的Sping容器 放到 sevlet 容器中 这个属性就是上面判断的属性
		   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
			//获取类加载器
			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
			if (ccl == ContextLoader.class.getClassLoader()) {
				currentContext = this.context;
			}
			else if (ccl != null) {
				currentContextPerThread.put(ccl, this.context);
			}

			if (logger.isDebugEnabled()) {
				logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
						WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
			}
			if (logger.isInfoEnabled()) {
				long elapsedTime = System.currentTimeMillis() - startTime;
				logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
			}

			return this.context;
		}
		catch (RuntimeException ex) {
			logger.error("Context initialization failed", ex);
			
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
			throw ex;
		}
		catch (Error err) {
			logger.error("Context initialization failed", err);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
			throw err;
		}
	}

下面我们看重点的方法configureAndRefreshWebApplicationContext(cwac, servletContext);这个方法，上代码

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
		//这里wac.getId() 是类中id属性，内部初始化的方法就是ObjectUtils.identityToString(wac)
		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
			// The application context id is still set to its original default value
			// -> assign a more useful id based on available information
			String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);//这里没有这个属性，为空
			if (idParam != null) {
				wac.setId(idParam);
			}
			else {
				// Generate default id...
				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
						ObjectUtils.getDisplayString(sc.getContextPath()));//设置一个新的id:org.springframework.web.context.WebApplicationContext:
			}
		}

		wac.setServletContext(sc);//将servletContext放入到Spring容器中
		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
		if (configLocationParam != null) {
			wac.setConfigLocation(configLocationParam);//设置配置文件路径，classpath:spring-config.xml 这是我们在web.xml中配置的
		}
		ConfigurableEnvironment env = wac.getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
		}

		customizeContext(sc, wac);//这里其实什么都没干，因为没有相应的配置
		//刷新容器。
		wac.refresh();
	}

创建beanFactory

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 做准备工作. 这里对一些必要属性做了验证。
			prepareRefresh();
			// 告诉子类刷新内部bean工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			//准备在这个上下文中使用bean工厂。
			prepareBeanFactory(beanFactory);
			try {
				// 允许在上下文子类中对bean工厂进行后处理。
				postProcessBeanFactory(beanFactory);
				// 调用在上下文中注册为bean的工厂处理器.
				invokeBeanFactoryPostProcessors(beanFactory);
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				// 初始化此上下文的消息源.
				initMessageSource();
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
				// Initialize other special beans in specific context subclasses.
				onRefresh();
				// Check for listener beans and register them.
				registerListeners();
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);
				// Last step: publish corresponding event.
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();
				// Reset 'active' flag.
				cancelRefresh(ex);
				// Propagate exception to caller.
				throw ex;
			}
			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

介绍obtainFreshBeanFactory()这个方法

/**
	 * Tell the subclass to refresh the internal bean factory.
	 * @return the fresh BeanFactory instance
	 * @see #refreshBeanFactory()
	 * @see #getBeanFactory()
	 */
	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		//刷新beanFactory
		refreshBeanFactory();
		//获取beanFactory
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

refreshBeanFactory()

protected final void refreshBeanFactory() throws BeansException {
		//清空原来的beanFactory()，其实这里也没有
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//创建beanFactory，这里如果有父容器会加载父容器的beanFactory为当前beanFactory的parentBeanFactory
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			//加载beanDefinitions 这里是对xml尽心校验并解析
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

加载xml

继续从上面的**loadBeanDefinitions(beanFactory)**这个方法开始

//类XmlWebApplicationContext
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// 为beanFactory创建一个beanDefinitionReader,用于读取xml,这里是xmlWebApplicatioContext类实现的这个方法，定义的是xmlBeanDefinitionReader
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	// 设置环境，资源加载器，资源处理类
	beanDefinitionReader.setEnvironment(getEnvironment());
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// 初始化beanDefinitionReader (这个方法没有实体，留给用户自己扩展)
	initBeanDefinitionReader(beanDefinitionReader);
	// 加载资源
	loadBeanDefinitions(beanDefinitionReader);
}

//加载资源 //类XmlWebApplicationContext
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		for (String configLocation : configLocations) {
			//根据配置文件目录加载
			reader.loadBeanDefinitions(configLocation);
		}
	}
}

//根据配置文件目录加载 类AbstractBeanDefinitionReader
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
	return loadBeanDefinitions(location, null);
｝

//这里才是最终实现 类AbstractBeanDefinitionReader
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
	//前面设置的RescourceLoader() 就是XmlWebApplicationContext对象 上面的结构图中最终实现了ResourcePatternResolver类
	ResourceLoader resourceLoader = getResourceLoader();
	if (resourceLoader == null) {
		throw new BeanDefinitionStoreException(
				"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
	}

	if (resourceLoader instanceof ResourcePatternResolver) {
		// Resource pattern matching available.
		try {
			//加载资源
			Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
			//注册bean 这里对xml进行校验 解析 注册bean
			int loadCount = loadBeanDefinitions(resources);
			if (actualResources != null) {
				for (Resource resource : resources) {
					actualResources.add(resource);
				}
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
			}
			return loadCount;
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"Could not resolve bean definition resource pattern [" + location + "]", ex);
		}
	}
	else {
		// Can only load single resources by absolute URL.
		Resource resource = resourceLoader.getResource(location);
		int loadCount = loadBeanDefinitions(resource);
		if (actualResources != null) {
			actualResources.add(resource);
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
		}
		return loadCount;
	}

加载xml资源 对xml 校验解析 返回Document

//类AbstractBeanDefinitionReader
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
	Assert.notNull(resources, "Resource array must not be null");
	int counter = 0;
	for (Resource resource : resources) {
		counter += loadBeanDefinitions(resource);
	}
	return counter;
}
/*
* 类XmlBeanDefinitionReader 这里对资源进行了编码 转换为EncodeResource 
* Resource接口和EncodeResource类 都实现了InputStreamSource接口
*/
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
	return loadBeanDefinitions(new EncodedResource(resource));
}
/*
* 类XmlBeanDefinitionReader  
*/
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isInfoEnabled()) {
			logger.info("Loading XML bean definitions from " + encodedResource.getResource());
		}

		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		//初始化一个Set集合,设置到当前对象中
		if (currentResources == null) {
			currentResources = new HashSet<EncodedResource>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		//将encodedResource放到上面初始化的集合中
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				//这里对xml转化的流读取解析
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}
/*
* 类XmlBeanDefinitionReader 这里只有两个方法，下面都是处理的异常
*/
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
	try {
		Document doc = doLoadDocument(inputSource, resource);
		return registerBeanDefinitions(doc, resource);
	}
	catch (BeanDefinitionStoreException ex) {
		throw ex;
	}
	catch (SAXParseException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
	}
	catch (SAXException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"XML document from " + resource + " is invalid", ex);
	}
	catch (ParserConfigurationException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Parser configuration exception parsing XML from " + resource, ex);
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"IOException parsing XML document from " + resource, ex);
	}
	catch (Throwable ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Unexpected exception parsing XML document from " + resource, ex);
	}
}
/*
* 类XmlBeanDefinitionReader 这里是把xml解析成Document
* 这个方法传的参数很多。包括上面传过来的inputSource 当前对象的资源处理器，错误处理器，xml验证模式,
* 还有一个默认为false的boolean,暂且不管他是干什么的
*/
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
			getValidationModeForResource(resource), isNamespaceAware());
}
/*
* 类XmlBeanDefinitionReader
* 获取验证模式
* VALIDATION_AUTO = 1 
*/
protected int getValidationModeForResource(Resource resource) {
	//这里获取的是validationMode这个属性 private int validationMode = VALIDATION_AUTO;默认为1
	int validationModeToUse = getValidationMode();
	if (validationModeToUse != VALIDATION_AUTO) {
		return validationModeToUse;
	}
	int detectedMode = detectValidationMode(resource);//这里根据配置文件获取验证模式
	if (detectedMode != VALIDATION_AUTO) {
		return detectedMode;
	}
	// Hmm, we didn't get a clear indication... Let's assume XSD,
	// since apparently no DTD declaration has been found up until
	// detection stopped (before finding the document's root tag).
	return VALIDATION_XSD;
}

/*
* 类XmlBeanDefinitionReader
* 根据配置文件获取验证模式
*/
protected int detectValidationMode(Resource resource) {
	if (resource.isOpen()) {
		throw new BeanDefinitionStoreException(
				"Passed-in Resource [" + resource + "] contains an open stream: " +
				"cannot determine validation mode automatically. Either pass in a Resource " +
				"that is able to create fresh streams, or explicitly specify the validationMode " +
				"on your XmlBeanDefinitionReader instance.");
	}

	InputStream inputStream;
	try {
		inputStream = resource.getInputStream();
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(
				"Unable to determine validation mode for [" + resource + "]: cannot open InputStream. " +
				"Did you attempt to load directly from a SAX InputSource without specifying the " +
				"validationMode on your XmlBeanDefinitionReader instance?", ex);
	}

	try {
		//根据xml内容 如果第一行有“DOCTYPE”则DTD 否则XSD
		return this.validationModeDetector.detectValidationMode(inputStream);
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException("Unable to determine validation mode for [" +
				resource + "]: an error occurred whilst reading from the InputStream.", ex);
	}
}
/*
* 类DefaultDocumentLoader 这里就是解析xml了 最终返回一个Document
*/
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
			ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

	DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
	if (logger.isDebugEnabled()) {
		logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
	}
	DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
	return builder.parse(inputSource);
}

下面是注册Bean加载到容器中 重点 重点 重点

/*
* 类XmlBeanDefinitionReader
*/
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	//创建一个DefaultBeanDefinitionDocumentReader对象 实现了BeanDefinitionDocumentReader 接口
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	//getRegistry()这个方法是获取当前对象的beanFactory 
	// getBeanDefinitionCount() 获取beanFactory中beanDefinitionMap()（ConcurrentHashMap） 的size,初始化之前为0
	//这里是获取之前注册的bean
	int countBefore = getRegistry().getBeanDefinitionCount();
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	//返回这次注册的对象的数量
	return getRegistry().getBeanDefinitionCount() - countBefore;
}
/*
* 类DefaultBeanDefinitionDocumentReader
* 注册bean
*/
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	logger.debug("Loading bean definitions");
	//获取根节点
	Element root = doc.getDocumentElement();
	//注册bean
	doRegisterBeanDefinitions(root);
}
/*
*类DefaultBeanDefinitionDocumentReader
* 到这里是不是觉得读到根节点了 终于要开始了？ 呵呵 你小看他了,还有延伸
*/
protected void doRegisterBeanDefinitions(Element root) {
	BeanDefinitionParserDelegate parent = this.delegate; //上面方法刚实例化出来，这个属性还是null
	//这里创建一个对象，你可以理解为这个类是真正解析Element的工作类（确实是这样的）
	//创建这个对象的方法后面再看，这里先往下面走
	this.delegate = createDelegate(getReaderContext(), root, parent);
	//刚才创建对象的时候 把root传进去了，这里获取到的值是true
	if (this.delegate.isDefaultNamespace(root)) {
		//PROFILE_ATTRIBUTE = "profile" root节点里没有这个属性 返回false
		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
		if (StringUtils.hasText(profileSpec)) {
			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
				if (logger.isInfoEnabled()) {
					logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}
	//准备解析xml方法,这个方法是空的 留给用户自己扩展
	preProcessXml(root);
	//解析xml （这里才是重点！！）
	parseBeanDefinitions(root, this.delegate);
	//解析完成，下一步流程 也是空的，留给用户自己扩展
	postProcessXml(root);
	//设置当前对象内的解析对象属性为当前对象的parent 默认为空
	this.delegate = parent;
}

然后我们看这个方法createDelegate(getReaderContext(), root, parent)

/*
* 类DefaultBeanDefinitionDocumentReader 创建解析类
*/
protected BeanDefinitionParserDelegate createDelegate(
	XmlReaderContext readerContext, Element root, BeanDefinitionParserDelegate parentDelegate) {

	BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
	delegate.initDefaults(root, parentDelegate);
	return delegate;
}

/*
* BeanDefinitionParserDelegate 初始默认值
*
public void initDefaults(Element root, BeanDefinitionParserDelegate parent) {
	populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root);
	this.readerContext.fireDefaultsRegistered(this.defaults);
}

/*
* BeanDefinitionParserDelegate 设置一些默认值，这里我们都没有配置，基本都是默认的，后面解析的时候会用到
*/
protected void populateDefaults(DocumentDefaultsDefinition defaults, DocumentDefaultsDefinition parentDefaults, Element root) {
	//从参数根节点即<beans>节点中获取default-lazy-init参数  
	String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);
	如果lazyInit的值为default,如果parentDefaults不为null则侧其中获取lazyInit，否则设置为false  
	if (DEFAULT_VALUE.equals(lazyInit)) {
		// Potentially inherited from outer <beans> sections, otherwise falling back to false.
		lazyInit = (parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE);
	}
	defaults.setLazyInit(lazyInit);

	String merge = root.getAttribute(DEFAULT_MERGE_ATTRIBUTE);
	if (DEFAULT_VALUE.equals(merge)) {
		// Potentially inherited from outer <beans> sections, otherwise falling back to false.
		merge = (parentDefaults != null ? parentDefaults.getMerge() : FALSE_VALUE);
	}
	defaults.setMerge(merge);

	String autowire = root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE);
	if (DEFAULT_VALUE.equals(autowire)) {
		// Potentially inherited from outer <beans> sections, otherwise falling back to 'no'.
		autowire = (parentDefaults != null ? parentDefaults.getAutowire() : AUTOWIRE_NO_VALUE);
	}
	defaults.setAutowire(autowire);

	// Don't fall back to parentDefaults for dependency-check as it's no longer supported in
	// <beans> as of 3.0. Therefore, no nested <beans> would ever need to fall back to it.
	defaults.setDependencyCheck(root.getAttribute(DEFAULT_DEPENDENCY_CHECK_ATTRIBUTE));

	if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {
		defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));
	}
	else if (parentDefaults != null) {
		defaults.setAutowireCandidates(parentDefaults.getAutowireCandidates());
	}

	if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {
		defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));
	}
	else if (parentDefaults != null) {
		defaults.setInitMethod(parentDefaults.getInitMethod());
	}

	if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {
		defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));
	}
	else if (parentDefaults != null) {
		defaults.setDestroyMethod(parentDefaults.getDestroyMethod());
	}

	defaults.setSource(this.readerContext.extractSource(root));
}

解析的方法parseBeanDefinitions(root, this.delegate);

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {//这里是true 按根节点来解析
			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;
					if (delegate.isDefaultNamespace(ele)) {//节点是否是默认命名空间
						parseDefaultElement(ele, delegate);//具体解析 默认命名空间 标签<bean>
					}
					else {
						delegate.parseCustomElement(ele);//具体解析 自定义标签 <context:...
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

具体解析，后面再写。

爱生活爱玩
关注
专栏目录
spring源码之Ioc容器加载过程详解
bugNoneNull的博客
09-23 986
一、前言 针对于spring源码的初步学习，我认为首先应该掌握四大块，基于四大块全部掌握的基础上在进行扩展深入研究学习，具体四块如下： 1.Ioc容器加载的过程 2.spring如何解决循环依赖 3.spring Aop的实现 4.spring 事务管理实现 我觉得如果掌握了上面的四点，那么我们基本上就可以很自豪的说精通spring了，也算掌握了spring大概一半的内容了。 本文主要研究Ioc容器的加载过程。 二、什么是Ioc容器？ 我们常说Ioc是一个容器，是的，ioc就是一个容器，并
Spring实现一个简单的SpringIOC容器
08-30
Spring的IOC（Inversion of Control，控制反转）容器是其核心特性之一，它负责管理和装配应用程序中的对象。本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计...
Spring IoC加载流程讲解
01-12
Spring IoC加载流程讲解以及IoC思想和依赖倒置原则
Spring IOC加载流程
热门推荐
骑个小蜗牛的博客
03-26 1万+
Spring IOC、Spring Bean加载过程、Spring三级缓存、循环依赖、动态代理
SpringIoC加载流程
BX666666的博客
03-06 573
IoC容器是Spring的核心模块，是抽象了对象管理、依赖关系管理的框架解决方案。 在Spring IoC容器的设计中，有两个主要的容器系列，一个是实现了BeanFactory接口的简单容器系列，这系列容器只实现了容器的最基本功能；另一个是ApplicationContext应用上下文，它作为容器的高级形态而存在，除了BeanFactory的基本功能，还提供了更多丰富的功能，常用的有ClassPa...
Spring源码剖析3：Spring IOC容器的加载过程
jinchengll的博客
05-16 365
1.目标： 熟练使用spring，并分析其源码，了解其中的思想。这篇主要介绍spring ioc 容器的加载 2.前提条件： 会使用debug 3.源码分析方法： Intellj idea debug 模式下源码追溯 通过ClassPathXmlApplicationContext 进行xml 件的读取，从每个堆栈中读取程序的运行信息 4.注意： 由于Spring的类继承体系比较复杂,不能全部贴图，所以只将分析源码之后发现的最主要的类继承结构类图贴在下方。 5.关于Spring Ioc Demo： 我们从d
spring ioc加载流程源码分析
brandon333的博客
12-22 252
前言 Spring 最重要的概念是 IOC 和 AOP，其中IOC又是Spring中的根基： spring源码地址https://github.com/spring-projects/spring-framework 建议选择Tags, 版本选最新的RELEASE版即可 本文版本5.2.7.RELEASE 源码下下来之后编译好,编译过程中可能会出现问题,针对问题搜索引擎解决. 新建一个自己的模块用于调试 这里我们采用注解方式的上下文启动容器 创建配置类 IocConfig @Con.
详解Spring简单容器中的Bean基本加载过程
08-30
Spring 简单容器中的 Bean ...Spring 简单容器中的 Bean 基本加载过程是一个复杂的过程，它涉及到 XML 文件的解析、bean 的注册和加载等多个步骤。只有了解这个过程，才能更好地使用 Spring 框架来开发企业级应用程序。
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器的启动流程是一个复杂的过程，它涉及到许多步骤和组件。AbstractApplicationContext 的 refresh 方法是 IOC 容器的核心所在，它实现了容器的启动逻辑。ClassPathXmlApplicationContext 和 ...
Spring IOC启动resources定位与加载过程
u010571316的专栏
11-28 819
调用栈 涉及类：FileSystemXmlApplicationContext： AbstractApplicationContext: AbstractRefreshableApplicationContext: AbstractXmlApplicationContext:
spring中xml标签加载解析的一般过程
long636的专栏
10-21 1147
默认标签的解析过程： DefaultBeanDefinitonDocumentReader class中processBeanDefinition (1)     该方法先解析element元素获得BeanDefinitionHolder, (2)     由BeanDefintionParserDelegate对于holder进行装饰加工 (3)     由BeanDefinitionR
spring中IOC容器中的xml加载过程
long636的专栏
10-20 819
对于spring的控制反转，很大程度上得益于对象的依赖注入。或者是利用JAVABEAN的方式，进行利用配置文件中设置来进行在需要时的对象注入。很多时候我们都是使用的是xml的配置文件，因此spring对于从xml文件的操作到bean的注入，这一些列过程的研究，其中一部分就是本次的写作内容。
Spring IOC源码解析 xml篇
llljw的博客
01-16 257
Spring中使用ClassPathXmlApplicationContext加载XML文件 public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring.xml"); Ju...
spring源码---IOC:解析xml
阿七
06-15 298
接着上一篇，写道refresh()，在这个方法里面有14个方法，加载流程，我们一个一个的进去看一看到底发生了什么。 第一个方法：prepareRefresh(); 功能：调用容器准备刷新的方法，获取容器的当前时间，同时给容器设置同步表示。 参考：https://www.cnblogs.com/feng-jq/p/10282179.html protected void prepareRefresh() { //切换到活动状态。 this.startupDate = System.current
Spring_Ioc基本配置使用（基于xml）
qq_41931364的博客
07-20 647
Spring_Ioc1、IOC简介1.1、什么是IOC2、容器2.1、容器概述 1、IOC简介 1.1、什么是IOC IOC是Inversion of Control的缩写，多数书籍翻译成“控制反转”。 是Spring框架里面管理对象的一个容器。 2、容器 2.1、容器概述 ApplicationContext是Spring容器IOC实现的代表，它负责实例化、配置和组装Bean。容器通过读取配置元数据获取有关实例化、配置和组装哪些对象的说明。配置元数据可以使用xml、Java注解活Java代码来呈现，它允许
Spring 手动加载XML配置的bean
ouzuting的博客
04-26 803
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); xmlBeanDefinitionReader.setValid...
spring 解析xml加载bean的整个过程
xupeng874395012的博客
04-12 1994
第一步从spring的容器刷新开始 org.springframework.context.support.AbstractApplicationContext#refresh ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); org.springframework.cont...
IOC与DI系列：3 基于XMl的IOC的实现过程
纵横千里 捭阖四方 的专栏
04-07 260
1.IOC的概念 通俗地说，IOC就是读取xml或者注解配置的类信息，将其存储到一个Map里，然后将这些类进行初始化，也放到Map里，程序在使用的时候直接从Map里读取就好了。读取的过程就是IOC，根据依赖关系进行完整初始化的过程就是DI。而最后的这个map就是Spring容器。 规范一点说，IOC就是把原先代码里需要实现的对象创建，依赖和管理的工作交给容器帮我们做。 那么必然我们需要创建一个容器，同时需要一种描述来让容器知道需要创建的对象与对象之间的关系。这个描述就是配置文件或者注解。 DI依赖注入就是指
spring5-ioc容器-xml解析-操作bean
qq_14930709的博客
04-21 441
spring5-什么是IOC容器，利用IOC容器操作Bean属性，创建Bean对象等
Spring IOC容器：解析XML中Bean的加载与获取过程
"这篇文档详细解释了Spring框架中XML配置文件中的Bean如何被加载和获取，从静态定义到成为可使用的对象的过程。" 在Spring框架中，Bean的加载过程是核心的IoC...理解这一过程对于深入学习Spring框架至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值