背景
使用了很久Spring，但对Spring的内在实现并不了解，正好最近有些时间，研究下Spring的源码
首先写一个测试方法
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("beans.xml")); User userTest = (User) bf.getBean("testBean"); System.out.println(userTest.getEmail());和对应的配置文件beans.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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:myName="http://www.wjs.com/schema/user" 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 http://www.wjs.com/schema/user http://www.wjs.com/schema/user.xsd"> <bean id = "testBean" class="com.zero.pojo.User"> <property name="userName" value="zhang"></property> <property name="email" value = "18"></property> </bean></beans>以上代码的功能使用过Spring的都能猜出来
- 读取配置文件beans.xml
- 根据beans.xml中的配置找到对应的类，并进行实例化
- 调用实例化后的类
现在开始调试代码
1.1初始化ClassPathResource
new ClassPathResource("beans.xml")
进入代码时首先执行了new ClassPathResource("beans.xml")，在这里加载了配置文件路径到ClassPathResource的path属性中。
public ClassPathResource(String path) { this(path, (ClassLoader)null); } public ClassPathResource(String path, @Nullable ClassLoader classLoader) { Assert.notNull(path, "Path must not be null"); String pathToUse = StringUtils.cleanPath(path); if (pathToUse.startsWith("/")) { pathToUse = pathToUse.substring(1); } this.path = pathToUse; this.classLoader = classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader(); }1.2初始化XmlBeanFactory
new XmlBeanFactory(new ClassPathResource("beans.xml"))
初始化ClassPathResource后，开始初始化XmlBeanFactory，在构造函数内部再调用构造函数，this.reader.loadBeanDefinitions(resource);这个才是资源加载的真正实现
public XmlBeanFactory(Resource resource) throws BeansException { //调用XmlBeanFactory(Resource, BeanFactory)构造方法 this(resource, (BeanFactory)null); } public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException { super(parentBeanFactory); this.reader = new XmlBeanDefinitionReader(this); this.reader.loadBeanDefinitions(resource); }1.2.1调用AbstractAutowireCapableBeanFactory的构造方法
super(parentBeanFactory);
不过在此之前还有一个super(parentBeanFactory);它会一直调用到AbstractAutowireCapableBeanFactory的构造方法中，这里的ignoreDependencyInterface的主要功能是忽略给定接口的自动装配功能， 当有忽略的接口类，自动装配会忽略这部分类的初始化装配，因为某种情况下，此时的接口实现类不能初始化
public AbstractAutowireCapableBeanFactory() { this.instantiationStrategy = new CglibSubclassingInstantiationStrategy(); this.parameterNameDiscoverer = new DefaultParameterNameDiscoverer(); this.allowCircularReferences = true; this.allowRawInjectionDespiteWrapping = false; this.ignoredDependencyTypes = new HashSet(); this.ignoredDependencyInterfaces = new HashSet(); this.currentlyCreatedBean = new NamedThreadLocal("Currently created bean"); this.factoryBeanInstanceCache = new ConcurrentHashMap(); this.factoryMethodCandidateCache = new ConcurrentHashMap(); this.filteredPropertyDescriptorsCache = new ConcurrentHashMap(); this.ignoreDependencyInterface(BeanNameAware.class); this.ignoreDependencyInterface(BeanFactoryAware.class); this.ignoreDependencyInterface(BeanClassLoaderAware.class); }1.2.2设置变量reader
this.reader = new XmlBeanDefinitionReader(this);
执行完父类的构造方法后，开始设置变量this.reader = new XmlBeanDefinitionReader(this);
public XmlBeanDefinitionReader(BeanDefinitionRegistry registry) { //执行AbstractBeanDefinitionReader构造方法 super(registry); this.errorHandler = new SimpleSaxErrorHandler(this.logger); this.validationModeDetector = new XmlValidationModeDetector(); this.resourcesCurrentlyBeingLoaded = new NamedThreadLocal("XML bean definition resources currently being loaded"); } //设置resourceLoader和environment protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); this.registry = registry; //设置resourceLoader if (this.registry instanceof ResourceLoader) { this.resourceLoader = (ResourceLoader)this.registry; } else { this.resourceLoader = new PathMatchingResourcePatternResolver(); } //设置environment if (this.registry instanceof EnvironmentCapable) { this.environment = ((EnvironmentCapable)this.registry).getEnvironment(); } else { this.environment = new StandardEnvironment(); } }1.2.3资源加载
this.reader.loadBeanDefinitions(resource);
设置完变量后开始执行this.reader.loadBeanDefinitions(resource)进行资源加载
方法pkg：org.springframework.beans.factory.xml
- 封装资源文件，当进入XmlBeanDefinitionReader后首先对参数Resource使用EncodedResource类进行封装
- 获取输入流，从Resource中获取对应InputStream并构造InputSource
- 通过构造的InputSource实例和Resource实例继续调用函数doLoadBeanDefinitions
loadBeanDefinitions具体实现过程
构造好encodedResource对象后，再次转入loadBeanDefinitions，这个方法内部才是真正的数据准备阶段
对传入的resource参数做封装，目的是考虑到Resource可能存在编码要求的情况，其次，通过SAX读取XML文件的方式来准备InputSource对象，最后将准备的数据通过参数传入真正的核心处理部分this.doLoadBeanDefinitions(inputSource, encodedResource.getResource())
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { return this.loadBeanDefinitions(new EncodedResource(resource)); } 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<>(4); this.resourcesCurrentlyBeingLoaded.set(currentResources); } if (!currentResources.add(encodedResource)) { throw new BeanDefinitionStoreException( "Detected cyclic loading of " + encodedResource + " - check your import definitions!"); } try { //从encodedResource中获取已经封装的Resource对象并再次从Resource中获取其中的inputStream InputStream inputStream = encodedResource.getResource().getInputStream(); try { //InputSource这个类不来自Spring，全路径是org.xml.sax.InputSource 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(); } } }1.3加载XML文件根据得到的Document信息注册Bean
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
doLoadBeanDefinitions
- 加载XML文件，并得到对应的Document Document doc = doLoadDocument(inputSource, resource);
- 根据返回的Document注册Bean信息 return registerBeanDefinitions(doc, resource)
这些步骤支撑整个Spring容器部分的实现
/** * Actually load bean definitions from the specified XML file. * @param inputSource the SAX InputSource to read from * @param resource the resource descriptor for the XML file * @return the number of bean definitions found * @throws BeanDefinitionStoreException in case of loading or parsing errors * @see #doLoadDocument * @see #registerBeanDefinitions */ 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); } }doLoadDocument
- 获取XML文件的验证模式 DTD(文档类型定义)还是XSD (XML Schema语言) this.getValidationModeForResource(resource)
加载XML文件，得到对应Document
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception { return this.documentLoader.loadDocument(inputSource, this.getEntityResolver(), this.errorHandler, this.getValidationModeForResource(resource), this.isNamespaceAware()); }
1.3.1获取资源的验证模式
this.getValidationModeForResource(resource)
/** * Gets the validation mode for the specified {@link Resource}. If no explicit * validation mode has been configured then the validation mode is * {@link #detectValidationMode detected}. * <p>Override this method if you would like full control over the validation * mode, even when something other than {@link #VALIDATION_AUTO} was set. */ protected int getValidationModeForResource(Resource resource) { 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; }1.3.2自动判断资源认证模式
自动判断实际就是获取资源的输入流，判断是否包含DOCTPE
DTD模式XML文件带有<!DOCTYPE beans PU.... 而XSD不带
int detectedMode = detectValidationMode(resource);
/** * Detect the validation mode for the XML document in the supplied {@link InputStream}. * Note that the supplied {@link InputStream} is closed by this method before returning. * @param inputStream the InputStream to parse * @throws IOException in case of I/O failure * @see #VALIDATION_DTD * @see #VALIDATION_XSD */ public int detectValidationMode(InputStream inputStream) throws IOException { // Peek into the file to look for DOCTYPE. BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); try { boolean isDtdValidated = false; String content; while ((content = reader.readLine()) != null) { content = consumeCommentTokens(content); if (this.inComment || !StringUtils.hasText(content)) { continue; } if (hasDoctype(content)) { isDtdValidated = true; break; } if (hasOpeningTag(content)) { // End of meaningful data... break; } } return (isDtdValidated ? VALIDATION_DTD : VALIDATION_XSD); } catch (CharConversionException ex) { // Choked on some character encoding... // Leave the decision up to the caller. return VALIDATION_AUTO; } finally { reader.close(); } }hasDoctype(content)
/** * Does the content contain the DTD DOCTYPE declaration? */ private boolean hasDoctype(String content) { return content.contains(DOCTYPE); }1.4加载Document
- 加载Document
this.documentLoader.loadDocument(inputSource, this.getEntityResolver(), this.errorHandler, this.getValidationModeForResource(resource), this.isNamespaceAware());
/** * Load the {@link Document} at the supplied {@link InputSource} using the standard JAXP-configured * XML parser. */ @Override 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); }创建DocumentBuilderFactory，再通过DocumentBuilderFactory创建DocumentBuilder，进而解析inputSource来返回Document
1.5注册Bean信息
- 根据返回的Document注册Bean信息
在将文件转换为Document后，接下来就是提取和注册bean，当程序已经有了XML文件的Document实例和上下文信息后
int count = this.registerBeanDefinitions(doc, resource);
/** * Register the bean definitions contained in the given DOM document. * Called by {@code loadBeanDefinitions}. * <p>Creates a new instance of the parser class and invokes * {@code registerBeanDefinitions} on it. * @param doc the DOM document * @param resource the resource descriptor (for context information) * @return the number of bean definitions found * @throws BeanDefinitionStoreException in case of parsing errors * @see #loadBeanDefinitions * @see #setDocumentReaderClass * @see BeanDefinitionDocumentReader#registerBeanDefinitions */ public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { //使用DefaultBeanDefinitionDocumentReader实例化BeanDefinitionDocumentReader BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); //记录统计前BeanDefinition的加载个数 int countBefore = getRegistry().getBeanDefinitionCount(); //加载及注册bean documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); //记录本次加载的BeanDefinition个数 return getRegistry().getBeanDefinitionCount() - countBefore; }1.5.1实例化createBeanDefinitionDocumentReader
createBeanDefinitionDocumentReader
BeanDefinitionDocumentReader是一个接口，实例化工作是在createBeanDefinitionDocumentReader中执行，通过此方法，BeanDefinitionDocumentReader已经转变成了DefaultBeanDefinitionDocumentReader
createBeanDefinitionDocumentReader
private Class<? extends BeanDefinitionDocumentReader> documentReaderClass = DefaultBeanDefinitionDocumentReader.class; /** * Create the {@link BeanDefinitionDocumentReader} to use for actually * reading bean definitions from an XML document. * <p>The default implementation instantiates the specified "documentReaderClass". * @see #setDocumentReaderClass */ protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() { return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass)); } public static <T> T instantiateClass(Class<T> clazz) throws BeanInstantiationException { Assert.notNull(clazz, "Class must not be null"); if (clazz.isInterface()) { throw new BeanInstantiationException(clazz, "Specified class is an interface"); } else { try { return instantiateClass(clazz.getDeclaredConstructor()); } catch (NoSuchMethodException var3) { Constructor<T> ctor = findPrimaryConstructor(clazz); if (ctor != null) { return instantiateClass(ctor); } else { throw new BeanInstantiationException(clazz, "No default constructor found", var3); } } catch (LinkageError var4) { throw new BeanInstantiationException(clazz, "Unresolvable class definition", var4); } } }1.5.2BeanDefinition的注册
进入DefaultBeanDefinitionDocumentReader后，开始提取root，并将提取到的root作为参数进行BeanDefinition的注册
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
/** * This implementation parses bean definitions according to the "spring-beans" XSD * (or DTD, historically). * <p>Opens a DOM Document; then initializes the default settings * specified at the {@code <beans/>} level; then parses the contained bean definitions. */ @Override public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { this.readerContext = readerContext; logger.debug("Loading bean definitions"); Element root = doc.getDocumentElement(); doRegisterBeanDefinitions(root); }doRegisterBeanDefinitions(root);
这里就是逻辑的核心
doRegisterBeanDefinitions(root);
/** * Register each bean definition within the given root {@code <beans/>} element. * 在给定的根{@code <beans />}元素中注册每个bean定义 */ protected void doRegisterBeanDefinitions(Element root) { // Any nested <beans> elements will cause recursion in this method. In // order to propagate and preserve <beans> default-* attributes correctly, // keep track of the current (parent) delegate, which may be null. Create // the new (child) delegate with a reference to the parent for fallback purposes, // then ultimately reset this.delegate back to its original (parent) reference. // this behavior emulates a stack of delegates without actually necessitating one. BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate(getReaderContext(), root, parent); if (this.delegate.isDefaultNamespace(root)) { //处理profile属性，使用profile来读取不同的配置文件，切换使用不同的环境（DEV/PRD） 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; } } } //解析前处理，留给子类实现,模板方法模式，如果继承自DefaultBeanDefinitionDocumentReader的子类需要在Bean解析前后做操作，只需要重写这两个类就行了 preProcessXml(root); parseBeanDefinitions(root, this.delegate); //解析后处理，留给子类实现 postProcessXml(root); this.delegate = parent; }1.5.3解析profile属性
处理profile属性，使用profile来读取不同的配置文件，切换使用不同的环境（DEV/PRD）
root.getAttribute(PROFILE_ATTRIBUTE);
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);1.5.4解析并注册BeanDefinition
parseBeanDefinitions(root, this.delegate);
处理掉profile后，就可以开始进行XML的读取了，Spring的XML配置文件中有两大类Bean声明，默认命名空间和自定义命名空间，接下来就是判断命名空间类型并进行相应解析
- 默认命名空间
<bean id = "testBean" class="com.zero.pojo.User"> <property name="userName" value="zhang"></property> <property name="email" value = "18"></property> </bean>- 自定义命名空间
<myName:user id="testBean" userName="name" email="A"/>parseBeanDefinitions(root, this.delegate);
/** * Parse the elements at the root level in the document: * "import", "alias", "bean". * @param root the DOM root element of the document */ 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; //对bean的处理 //默认命名空间 if (delegate.isDefaultNamespace(ele)) { parseDefaultElement(ele, delegate); } //自定义命名空间 else { delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } }