spirng学习之xml加载bean

最新推荐文章于 2023-04-27 23:27:31 发布

hq091117

最新推荐文章于 2023-04-27 23:27:31 发布

阅读量259

点赞数

分类专栏： spring 文章标签： spring

原文链接：https://www.jianshu.com/p/8af06eda4fcf

版权

spring 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

spring加载xml文件中定义的bean过程

首先我们知道加载类是ClassPathXmlApplicationContext，

入口：

 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Object object = context.getBean(Object.class);

ClassPathXmlApplicationContext的构造函数需要传入xml文件的路径,我们点进去

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
	}

--------------------------------------点this------------------------------


public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
//我们看refresh方法
			refresh();
		}
	}

构造函数主要看refresh方法，Spring bean解析就在refresh方法，Spring所有的初始化都在这个方法中完成，该方法在AbstractApplicationContext实现

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 做准备工作
			prepareRefresh();

			// 核心是这个，
            //创建beanFactory
//调用AbstractApplicationContext的obtainFreshBeanFactory方法获取obtainFreshBeanFactory
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			//bean工厂准备
			prepareBeanFactory(beanFactory);

			try {
				//允许在context子类中对bean工厂进行后处理
				postProcessBeanFactory(beanFactory);
                //调用在上下文中注册为Bean的工厂处理器
			    invokeBeanFactoryPostProcessors(beanFactory);
                //在Bean创建前拦截注册Bean处理器
				registerBeanPostProcessors(beanFactory);
                //为上下文初始化信息源
				initMessageSource();
                //为上下文初始化事件
				initApplicationEventMulticaster();
                在特定上下文子类中初始化其他特殊的bean
				onRefresh();
                //注册监听器
				registerListeners();
                //实例化所有剩余的单例（非延迟加载的）
				finishBeanFactoryInitialization(beanFactory);
                //完成发布事件，
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				destroyBeans();

				cancelRefresh(ex);

				throw ex;
			}

			finally {
				resetCommonCaches();
			}
		}
	}

创建beanFactory，调用AbstractApplicationContext的obtainFreshBeanFactory方法获取obtainFreshBeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

这个方法关注refreshBeanFactory方法

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
@Override
	protected final void refreshBeanFactory() throws BeansException {
        //如果beanFactory存在就销毁
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
            //创建DefaultListableBeanFactory
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
            //定制beanFactory，由AbstractRefreshableApplicationContext实现
			customizeBeanFactory(beanFactory);
            //加载bean,由AbstractXmlApplicationContext实现
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
}

refreshBeanFactory是在AbstractRefreshableApplicationContext这个类中的

我们直接看加载bean代码,loadBeanDefinitions方法

public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // 创建BeanFactory对应的beanDefinitionReader 
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        // 初始化beanDefinitionReader并且通过beanDefinitionReader加载BeanDefinitions
        initBeanDefinitionReader(beanDefinitionReader);
        loadBeanDefinitions(beanDefinitionReader);
    }

    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        Resource[] configResources = getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
        String[] configLocations = getConfigLocations();
        if (configLocations != null) {
            reader.loadBeanDefinitions(configLocations);
        }
    }
}

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory)，这个是用于去读取xml文件的

reader.loadBeanDefinitions(configResources);使用XmlBeanDefinitionReader的loadBeanDefinitions方法读取xml文件并切加载BeanDefinition。

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
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();
		if (currentResources == null) {
			currentResources = new HashSet<EncodedResource>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		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());
				}
				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();
			}
		}
	}

}

我们看doLoadBeanDefinitions这个方法，这个就一个

Document doc = doLoadDocument(inputSource, resource);
return registerBeanDefinitions(doc, resource);

我的理解是这里开始解析xml文件，获取根节点

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

registerBeanDefinitions方法：

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();
		doRegisterBeanDefinitions(root);
	}

protected void doRegisterBeanDefinitions(Element root) {
	
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			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;
				}
			}
		}

		preProcessXml(root);
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}

一路下来，我们看parseBeanDefinitions这个方法

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;
					if (delegate.isDefaultNamespace(ele)) {
                        //这是一种
						parseDefaultElement(ele, delegate);
					}
					else {
                        //第二种解析方法
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

parseDefaultElement方法主要解析bean

public static final String NESTED_BEANS_ELEMENT = "beans";

	public static final String ALIAS_ELEMENT = "alias";

	public static final String NAME_ATTRIBUTE = "name";

	public static final String ALIAS_ATTRIBUTE = "alias";

	public static final String IMPORT_ELEMENT = "import";

	public static final String RESOURCE_ATTRIBUTE = "resource";

	public static final String PROFILE_ATTRIBUTE = "profile";	


private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

parseCustomerElement主要解析<component-scan>

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

		// Actually scan for bean definitions and register them.
		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

		return null;
	}

ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);这个主要是扫描bean，

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
		for (String basePackage : basePackages) {
			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);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

基本思路，ClassPathXmlApplicationContext构造函数加载xml文件，创建beanfactory（ConfigurableListableBeanFactory）然后通过系列的XML解析，以及针对每种不同的节点类型使用不同的加载方式，其中component-scan用于指定扫描类的对应有一个Scanner，它会通过ClassLoader的getResources方法来获取到class的路径信息，那么class的路径都能获取到，然后加载类。

以上是从classpath加载xml文件的bean过程，其实还有其他几种：

ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml");

这个是从文件系统中加载xml文件的bean的上下文过程，其源码跟上面的其实基本是一样的，refesh方法开始公用，都是abstract的方法

ApplicationContext context1 = new XmlWebApplicationContext();

这个是加载web应用的xml文件，其实里面是固定加载一个路径下的xml文件

public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml";
public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/";
public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml";

所以我们看的web应用会有/web-inf/applicationContext.xml文件。

ApplicationContext context2 = new AnnotationConfigApplicationContext(applicationTest.class);

这个是加载注解配置类的，在springboot里用的多，

@Configuration
public class AppConfig{
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}

在启动类里加扫描注解，扫描到这个就行

学习资料：https://blog.csdn.net/xieyuooo/article/details/9089441

https://www.jianshu.com/p/8af06eda4fcf

hq091117

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spirng学习之xml加载bean

spring加载xml文件中定义的bean过程首先我们知道加载类是ClassPathXmlApplicationContext，入口： ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); Object object = context.getBean(Object.class);ClassPathXmlApplicationContext的构造函数需
复制链接

扫一扫