• 《Spring技术内幕》笔记-第二章 IoC容器的实现

    简单介绍

    1，在Spring中，SpringIoC提供了一个主要的JavaBean容器。通过IoC模式管理依赖关系。并通过依赖注入和AOP切面增强了为JavaBean这样子的POJO提供事务管理，生命周期管理等功能。

    2，Spring IoC的设计中，主要包括两个基本的容器系列：

        -1，BeanFactory系列。该序列实现了容器的基本功能。

        -2。ApplicationContext应用上下文。


    Spring IoC容器的设计

    1，例如以下图，IoC容器的接口设计图。

        


    2，简单介绍

        -1，从BeanFactory到HierarchicalbeanFactory再到ConfigurableBeanFactory是一条基本的BeanFactory设计路径。BeanFactory定义了基本的IoC容器接口。

    HierarchicalBeanFactory接口继承了BeanFactory接口，并再其基础上添加了getParentBeanFactory()接口功能，使得BeanFactory具备双亲IoC管理功能。ConfigurableBeanFactory主要定义了对BeanFactory的配置功能。


        -2。以ApplicationContext为核心的接口设计。

    BeanFactory的应用场景

        BeanFactory是最主要的IoC容器。


        用户在使用容器的时候能够通过&符来获取FactoryBean本身。FactoryBean跟普通Bean不同。通过BeanFactory类的getBean方法直接获取到的并非该FactoryBean的实例，而是 该FactoryBean中方法getObject返回的对象。

    但我们能够通过其他途径获取到该FactoryBean的实例。方法就是在通过 getBean方法获取实例时在參数name前面加上“&”符号就可以。

        

    1. String FACTORY_BEAN_PREFIX = "&";


        1。BeanFactory的主要接口，以及其作用例如以下：

        -1。容器推断是否包括指定名字的bean。

    1. boolean containsBean(String name);

        -2，推断指定的bean是否是prototype类型。

    1. boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

        -3。推断指定的bean是否是singleton。

    1. boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

        -4，推断指定的bean是否与给定类型相匹配。

    1. boolean isTypeMatch(String name, Class<?
      > targetType) throws NoSuchBeanDefinitionException;

        -5，获取指定Bean的类型。

    1. Class<?
      > getType(String name) throws NoSuchBeanDefinitionException;

        -6。指定bean的全部别名。

    1. String[] getAliases(String name);

    2，BeanFactory的容器设计原理。

        BeanFactory接口提供了使用IoC的规范，而且Spring实现了一系列容器的实现供开发者使用。

    以XmlBeanFactory为例。例如以下为XmlBeanFactory的继承结构图。



    下面是XmlBeanFactory的代码，在Spring 4中。该类已经不推荐被使用了。

    1. @Deprecated
    2. @SuppressWarnings({"serial", "all"})
    3. public class XmlBeanFactory extends DefaultListableBeanFactory {
    4. 

    5. 	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
    6. 

    7. 

    8. 	/**
    9. 	 * 通过给定的资源创建一个XmlBeanFactory实例。
    10. 	 */
    11. 	public XmlBeanFactory(Resource resource) throws BeansException {
    12. 		this(resource, null);
    13. 	}
    14. 

    15. 	/**
    16. 	 * Create a new XmlBeanFactory with the given input stream,
    17. 	 * which must be parsable using DOM.
    18. 	 */
    19. 	public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
    20. 		super(parentBeanFactory);
    21. 		this.reader.loadBeanDefinitions(resource);
    22. 	}
    23. 

    24. }

        该类继承了DefaultListableBeanFactory类。DefaultListableBeanFactory该类实现一个最为基础的IoC容器。

        例如以下是一个简单的使用方法举例：


    1. ClassPathResource re = new ClassPathResource("bean.xml");
    2. 		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    3. 		XmlBeanDefinitionReader xdr = new XmlBeanDefinitionReader(beanFactory);
    4. 		xdr.loadBeanDefinitions(re);
    5. 		System.out.println(xdr.getRegistry());


    ApplicationContext的应用场景

       1。 ApplicationContext在BeanFactory的基础上添加了非常多新的特性：

        -1。支持不同的信息源。ApplicationContext扩展了MessageSource接口，这些为国际化提供服务。


        -2，訪问资源。对ResourceLoader和Resource的支持。能够从不同的地方获取到资源。


        -3。支持应用事件。

    继承ApplicationEventPublisher，从而引入的事件机制。

    与Bean的生命周期结合，方便管理Bean。


        -4，在ApplicationContext添加附加服务。

        2，ApplicationContext设计原理，以FileSystemApplicationContext为例。


    1. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    2. 			throws BeansException {
    3. 

    4. 		super(parent);
    5. 		setConfigLocations(configLocations);
    6. 		if (refresh) {
    7. 			refresh();
    8. 		}
    9. 	}

        在实例化该应用中，调用了AbstractApplicationContext的refresh方法。该方法是IoC容器启动的主要方法。

        另一个主要方法是：


    1. 	@Override
    2. 	protected Resource getResourceByPath(String path) {
    3. 		if (path != null && path.startsWith("/")) {
    4. 			path = path.substring(1);
    5. 		}
    6. 		return new FileSystemResource(path);
    7. 	}

    该方法通过FileSystemResource获取资源路径。

    IoC容器的初始化过程

        简单来说IoC的初始化是由AbstractApplicationContext的refresh方法实现的。整个启动过程包含三个部分。BeanDefinition的Resource定位、加载和注冊三个基本部分。Spring将三个模块分开。并使用不同的模块完毕。

        第一个过程是Resource定位过程。这个Resource定位是指Spring找到我们定义的Bean配置的xml文件。

        第二步。BeanDefinition的加载。这个过程是把用户定义好的Bean表示成IoC容器内部的数据结构，而这个数据结构就是BeanDefinition。详细说。BeanDefination实际就是POJO在容器中的抽象，通过这个BeanDefinition定义的数据结构，使IoC容器可以方便的对POJO对象。也就是Bean进行管理。

        第三步，是向IoC容器注冊这些BeanDefinition的过程。这个过程通过调用BeanDefinationRegistry接口实现。

    这个注冊过程把加载过程（第二步）得到的BeanDefinition向容器注冊。IoC内部，将BeanDefinition注入到一个HashMap中去，IoC容器就是通过HashMap来持有这些BeanDefinition数据的。

        一般，IoC的初始化过程，不包含依赖注入。依赖注入一般发生在应用第一次通过getBean向容器获取Bean的时候。

    1，BeanDefinition的Resource定位。

      在使用DefaultListableBeanFactory的时候，首先须要使用Resource来进行资源定位容器使用的BeanDefinition。

        使用ClassPathResource进行资源定位。

    1. ClassPathResource re = new ClassPathResource("bean.xml");

        在此处定义的资源文件不能被DefaultListableBeanFactory直接使用，通过BeanDefinitionReader来读取。

    1. DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    2. XmlBeanDefinitionReader xdr = new XmlBeanDefinitionReader(beanFactory);
    3. xdr.loadBeanDefinitions(re);

    在此处我们发现使用比較麻烦。所以使用ApplicationContext，由于在ApplicationContext中。Spring为我们提供了一系列的资源定位，比方FileSystemXmlApplicationContext。


        以FileSystemXmlApplicationContext为例，解说相应的源代码。

        该构造函数通过文件路劲来生成相应的FileSystemXmlApplicationContext

    1. public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
    2. 		this(new String[] {configLocation}, true, null);
    3. 	}

    通过refresh方法来加载BeanDefinition。



    1. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    2. 			throws BeansException {
    3. 

    4. 		super(parent);
    5. 		setConfigLocations(configLocations);
    6. 		if (refresh) {
    7. 			refresh();
    8. 		}
    9. 	}

    通过文件系统来获取资源。


    1. @Override
    2. 	protected Resource getResourceByPath(String path) {
    3. 		if (path != null && path.startsWith("/")) {
    4. 			path = path.substring(1);
    5. 		}
    6. 		return new FileSystemResource(path);
    7. 	}

    2，BeanDefinition的加载和解析。

        对IoC容器来说。加载过程相当于把BeanDefinition在IoC容器中转换成一个Spring内部数据结构的过程。IoC对对象的管理都是通过对其持有的BeanDefination进行相关操作来实现的。

    这些BeanDefinition是通过HashMap来维护的。

    1. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    2. 			throws BeansException {
    3. 		super(parent);
    4. 		setConfigLocations(configLocations);
    5. 		if (refresh) {
    6. 			refresh();
    7. 		}
    8. 	}


        如上代码，refresh()方法启动了容器初始化。是加载BeanDefination的入口方法。
        refresh()详细的代码结构例如以下：

    1. @Override
    2. 	public void refresh() throws BeansException, IllegalStateException {
    3. 		synchronized (this.startupShutdownMonitor) {
    4. 			// Prepare this context for refreshing.
    5. 			prepareRefresh();
    6. 

    7. 			// Tell the subclass to refresh the internal bean factory.

    8. //在子类中启动refreshBeanFactory()的地方。
    9. 			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    10. 

    11. 			// Prepare the bean factory for use in this context.
    12. 			prepareBeanFactory(beanFactory);
    13. 

    14. try {
    15. 				// Allows post-processing of the bean factory in context subclasses.

    16. //设置BeanFactory的后置处理。
      

    17. 				postProcessBeanFactory(beanFactory);
    18. 

    19. 				// Invoke factory processors registered as beans in the context.

    20. //调用BeanFactory的后置处理器。这些处理器是在Bean定义中向容器注冊的

    21. 				invokeBeanFactoryPostProcessors(beanFactory);
    22. 

    23. 				// Register bean processors that intercept bean creation.

    24. //注冊Bean的后处理器。在Bean的创建过程中调用

    25. 				registerBeanPostProcessors(beanFactory);
    26. 

    27. // Initialize message source for this context.

    28. //对上下文中的消息源初始化

    29. 				initMessageSource();
    30. 

    31. 				// Initialize event multicaster for this context.

    32. //初始化上下文中的时间机制
    33. 				initApplicationEventMulticaster();
    34. 

    35. 				// Initialize other special beans in specific context subclasses.

    36. //初始化其它Bean

    37. 				onRefresh();
    38. 

    39. 				// Check for listener beans and register them.

    40. //检查监听bean并注冊

    41. 				registerListeners();
    42. 

    43. 				// Instantiate all remaining (non-lazy-init) singletons.

    44. //实例化全部(non-lazy-init) 单例。
    45. 				finishBeanFactoryInitialization(beanFactory);
    46. 

    47. 				// Last step: publish corresponding event.

    48. //公布容器事件。结束

    49. 				finishRefresh();
    50. 			}
    51. 

    52. 			catch (BeansException ex) {
    53. 				// Destroy already created singletons to avoid dangling resources.

    54. //防止Bean资源占用，销毁已经创建的单例。
    55. 				destroyBeans();
    56. 

    57. 				// Reset 'active' flag.

    58. //重置active标志

    59. 				cancelRefresh(ex);
    60. 

    61. 				// Propagate exception to caller.
    62. 				throw ex;
    63. 			}
    64. 		}
    65. 	}


    -1。prepareRefresh()：

    1. /**
    2. 	 * Prepare this context for refreshing, setting its startup date and
    3. 	 * active flag as well as performing any initialization of property sources.
    4. 	 */
    5. 	protected void prepareRefresh() {
    6. 		this.startupDate = System.currentTimeMillis();
    7. 

    8. 		synchronized (this.activeMonitor) {
    9. 			this.active = true;
    10. 		}
    11. 

    12. 		if (logger.isInfoEnabled()) {
    13. 			logger.info("Refreshing " + this);
    14. 		}
    15. 

    16. 		// Initialize any placeholder property sources in the context environment
    17. 		initPropertySources();
    18. 

    19. 		// Validate that all properties marked as required are resolvable
    20. 		// see ConfigurablePropertyResolver#setRequiredProperties
    21. 		getEnvironment().validateRequiredProperties();
    22. 	}

    -2。启动refreshBeanFactory()：

    1. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    1. /**
    2. 	 * Tell the subclass to refresh the internal bean factory.
    3. 	 * @return the fresh BeanFactory instance
    4. 	 * @see #refreshBeanFactory()
    5. 	 * @see #getBeanFactory()
    6. 	 */
    7. 	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    8. 		refreshBeanFactory();
    9. 		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    10. 		if (logger.isDebugEnabled()) {
    11. 			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    12. 		}
    13. 		return beanFactory;
    14. 	}

    终于调用，AbstractRefreshableApplicationContext中的refreshBeanFactory()方法。


    1. 

    2. 	/**
    3. 	 * This implementation performs an actual refresh of this context's underlying
    4. 	 * bean factory, shutting down the previous bean factory (if any) and
    5. 	 * initializing a fresh bean factory for the next phase of the context's lifecycle.
    6. 	 */
    7. 	@Override
    8. 	protected final void refreshBeanFactory() throws BeansException {
    9. 		if (hasBeanFactory()) {//假设已经存在BeanFactory
    10. 			destroyBeans();//销毁
    11. 			closeBeanFactory();
    12. 		}
    13. 		try { //创建IoC容器
    14. 			DefaultListableBeanFactory beanFactory = createBeanFactory();
    15. 			beanFactory.setSerializationId(getId());
    16. 			customizeBeanFactory(beanFactory);
    17. 			loadBeanDefinitions(beanFactory);//加载BeanFactory。抽象方法
    18. 			synchronized (this.beanFactoryMonitor) {
    19. 				this.beanFactory = beanFactory;
    20. 			}
    21. 		}
    22. 		catch (IOException ex) {
    23. 			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    24. 		}
    25. 	}

    这里调用的loadBeanDefinations()是一个抽象方法，详细实如今AbstractXmlApplicationContext。

    1. /**
    2. 	 * Loads the bean definitions via an XmlBeanDefinitionReader.
    3. 	 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
    4. 	 * @see #initBeanDefinitionReader
    5. 	 * @see #loadBeanDefinitions
    6. 	 */
    7. 	@Override
    8. 	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    9. 		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
    10. 		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    11. 

    12. 		// Configure the bean definition reader with this context's
    13. 		// resource loading environment.
    14. 		beanDefinitionReader.setEnvironment(this.getEnvironment());
    15. 		beanDefinitionReader.setResourceLoader(this);
    16. 		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    17. 

    18. 		// Allow a subclass to provide custom initialization of the reader,
    19. 		// then proceed with actually loading the bean definitions.
    20. 		initBeanDefinitionReader(beanDefinitionReader);
    21. 		loadBeanDefinitions(beanDefinitionReader);
    22. 	}

    接着就是调用loadBeanDefinations的地方，首先得到BeanDefinition信息的Resource定位，然后调用XmlBeanDefinitionReader来读取，详细过程托付给BeanDefinitionReader来完毕的。

    XML文件则是通过XmlBeanDefinitionReader来加载BeanDefination到容器中。

        ​注：在XmlBeanDefinationReader中找到的loadBeanDefination()方法。与书中的代码块不同。

    此处可能是Spring版本号的问题。

    1. public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    2. 		Assert.notNull(encodedResource, "EncodedResource must not be null");
    3. 		if (logger.isInfoEnabled()) {
    4. 			logger.info("Loading XML bean definitions from " + encodedResource.getResource());
    5. 		}
    6. 

    7. 		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    8. 		if (currentResources == null) {
    9. 			currentResources = new HashSet<EncodedResource>(4);
    10. 			this.resourcesCurrentlyBeingLoaded.set(currentResources);
    11. 		}
    12. 		if (!currentResources.add(encodedResource)) {
    13. 			throw new BeanDefinitionStoreException(
    14. 					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    15. 		}
    16. 		try {//输入流读取资源
    17. 			InputStream inputStream = encodedResource.getResource().getInputStream();
    18. 			try {
    19. 				InputSource inputSource = new InputSource(inputStream);
    20. 				if (encodedResource.getEncoding() != null) {
    21. 					inputSource.setEncoding(encodedResource.getEncoding());
    22. 				}//调用解析XML文件
    23. 				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
    24. 			}
    25. 			finally {
    26. 				inputStream.close();
    27. 			}
    28. 		}
    29. 		catch (IOException ex) {
    30. 			throw new BeanDefinitionStoreException(
    31. 					"IOException parsing XML document from " + encodedResource.getResource(), ex);
    32. 		}
    33. 		finally {
    34. 			currentResources.remove(encodedResource);
    35. 			if (currentResources.isEmpty()) {
    36. 				this.resourcesCurrentlyBeingLoaded.remove();
    37. 			}
    38. 		}
    39. 	}

    doLoadBeanDefinitions()方法：

    1. 	protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    2. 			throws BeanDefinitionStoreException {
    3. 		try {
    4.                     //载入文件
    5. 			Document doc = doLoadDocument(inputSource, resource);
    6.                     //启动具体的解析过程
    7. 			return registerBeanDefinitions(doc, resource);
    8. 		}
    9. 		catch (BeanDefinitionStoreException ex) {
    10. 			throw ex;
    11. 		}
    12. 		catch (SAXParseException ex) {
    13. 			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
    14. 					"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
    15. 		}
    16. 		catch (SAXException ex) {
    17. 			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
    18. 					"XML document from " + resource + " is invalid", ex);
    19. 		}
    20. 		catch (ParserConfigurationException ex) {
    21. 			throw new BeanDefinitionStoreException(resource.getDescription(),
    22. 					"Parser configuration exception parsing XML from " + resource, ex);
    23. 		}
    24. 		catch (IOException ex) {
    25. 			throw new BeanDefinitionStoreException(resource.getDescription(),
    26. 					"IOException parsing XML document from " + resource, ex);
    27. 		}
    28. 		catch (Throwable ex) {
    29. 			throw new BeanDefinitionStoreException(resource.getDescription(),
    30. 					"Unexpected exception parsing XML document from " + resource, ex);
    31. 		}
    32. 	}

    registerbeanDefinitions()方法代码：

    1. public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    2.          //获取XML文档读取
    3. 		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    4. 		documentReader.setEnvironment(this.getEnvironment());
    5. 		int countBefore = getRegistry().getBeanDefinitionCount();
    6.              //详细解析过程
    7. 		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    8. 		return getRegistry().getBeanDefinitionCount() - countBefore;
    9. 	}

    BeanDefinition加载过程中，首先调用XML解析器，生成XML解析对象。然后再进行详细的解析。

    createBeanDefinitionDocumentReader()方法：

    1. 	protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
    2. 		return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
    3. 	}

    获取到详细的解析器。然后托付给BeanDefinitionParserDelegate来完毕详细的解析。例如以下查看DefaultBeanDefinitionDocuementReader中的processBeanDefinition(Element , BeanDefinitionParserDelegate)方法：

    1. protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    2. 		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

    3. //BeanDefinitionHolder是对BeanDefinition的封装。

    4. 		if (bdHolder != null) {
    5. 			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    6. 			try {
    7. 				// Register the final decorated instance.

    8. //向IoC容器注冊解析到的BeanDefinition。
    9. 				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
    10. 			}
    11. 			catch (BeanDefinitionStoreException ex) {
    12. 				getReaderContext().error("Failed to register bean definition with name '" +
    13. 						bdHolder.getBeanName() + "'", ele, ex);
    14. 			}
    15. 			// Send registration event.
    16. 			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    17. 		}
    18. 	}

    BeanDefinitionHolder：

    1. public class BeanDefinitionHolder implements BeanMetadataElement {
    2. 

    3. 	private final BeanDefinition beanDefinition;
    4. 

    5. 	private final String beanName;
    6. 

    7. 	private final String[] aliases;
    8. 

    9. ........

    在BeanDefinitionParserDelegate类中，定义了对各种SpringBean类的处理。

    查看其相应的parseBeanDefinitionElement方法：

    1. public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    2. 		String id = ele.getAttribute(ID_ATTRIBUTE);//bean元素中的ID
    3. 		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//bean元素中的name
    4. 

    5. 		List<String> aliases = new ArrayList<String>();//aliases
    6. 		if (StringUtils.hasLength(nameAttr)) {
    7. 			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
    8. 			aliases.addAll(Arrays.asList(nameArr));
    9. 		}
    10. 

    11. 		String beanName = id;
    12. 		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
    13. 			beanName = aliases.remove(0);
    14. 			if (logger.isDebugEnabled()) {
    15. 				logger.debug("No XML 'id' specified - using '" + beanName +
    16. 						"' as bean name and " + aliases + " as aliases");
    17. 			}
    18. 		}
    19. 

    20. 		if (containingBean == null) {
    21. 			checkNameUniqueness(beanName, aliases, ele);
    22. 		}
    23. 

    24. 		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);//具体解析过程，返回AbstractBeanDefinition对象，该对象定义了Bean的基本属性
    25. 		if (beanDefinition != null) {
    26. 			if (!StringUtils.hasText(beanName)) {
    27. 				try {
    28. 					if (containingBean != null) {
    29. 						beanName = BeanDefinitionReaderUtils.generateBeanName(
    30. 								beanDefinition, this.readerContext.getRegistry(), true);
    31. 					}
    32. 					else {
    33. 						beanName = this.readerContext.generateBeanName(beanDefinition);
    34. 						// Register an alias for the plain bean class name, if still possible,
    35. 						// if the generator returned the class name plus a suffix.
    36. 						// This is expected for Spring 1.2/2.0 backwards compatibility.
    37. 						String beanClassName = beanDefinition.getBeanClassName();
    38. 						if (beanClassName != null &&
    39. 								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
    40. 								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
    41. 							aliases.add(beanClassName);
    42. 						}
    43. 					}
    44. 					if (logger.isDebugEnabled()) {
    45. 						logger.debug("Neither XML 'id' nor 'name' specified - " +
    46. 								"using generated bean name [" + beanName + "]");
    47. 					}
    48. 				}
    49. 				catch (Exception ex) {
    50. 					error(ex.getMessage(), ele);
    51. 					return null;
    52. 				}
    53. 			}
    54. 			String[] aliasesArray = StringUtils.toStringArray(aliases);
    55. 			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    56. 		}
    57. 

    58. 		return null;
    59. 	}

    查看详细的解析代码，parseBeanDefinitionEleent方法：

    1. public AbstractBeanDefinition parseBeanDefinitionElement(
    2. 			Element ele, String beanName, BeanDefinition containingBean) {
    3. 

    4. 		this.parseState.push(new BeanEntry(beanName));
    5. 

    6. 		String className = null;
    7. 		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
    8. 			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    9. 		}
    10. 

    11. 		try {
    12. 			String parent = null;
    13. 			if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
    14. 				parent = ele.getAttribute(PARENT_ATTRIBUTE);
    15. 			}
    16.                        //生成BeanDefinition对象
    17. 			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    18.                    //解析属性，并设置Description信息
    19. 			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
    20. 			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
    21.                      //解析bean元素信息
    22. 			parseMetaElements(ele, bd);
    23. 			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    24. 			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    25.                    //构造函数
    26. 			parseConstructorArgElements(ele, bd);
    27.                  //成员变量
    28. 			parsePropertyElements(ele, bd);
    29. 			parseQualifierElements(ele, bd);
    30.                
    31. 			bd.setResource(this.readerContext.getResource());
    32. 			bd.setSource(extractSource(ele));
    33. 

    34. 			return bd;
    35. 		}
    36. 		catch (ClassNotFoundException ex) {
    37. 			error("Bean class [" + className + "] not found", ele, ex);
    38. 		}
    39. 		catch (NoClassDefFoundError err) {
    40. 			error("Class that bean class [" + className + "] depends on not found", ele, err);
    41. 		}
    42. 		catch (Throwable ex) {
    43. 			error("Unexpected failure during bean definition parsing", ele, ex);
    44. 		}
    45. 		finally {
    46. 			this.parseState.pop();
    47. 		}
    48. 

    49. 		return null;
    50. 	}

    当中相应的各种异常信息，可能我们在编程工作中常常遇到。

    1. 	public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
    2. 		NodeList nl = beanEle.getChildNodes();
    3. 		for (int i = 0; i < nl.getLength(); i++) {
    4. 			Node node = nl.item(i);
    5. 			if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
    6. 				parsePropertyElement((Element) node, bd);//解析
    7. 			}
    8. 		}
    9. 	}

    1. /**
    2. 	 * Parse a property element.
    3. 	 */
    4. 	public void parsePropertyElement(Element ele, BeanDefinition bd) {
    5. 		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);//获取property名字
    6. 		if (!StringUtils.hasLength(propertyName)) {
    7. 			error("Tag 'property' must have a 'name' attribute", ele);
    8. 			return;
    9. 		}
    10. 		this.parseState.push(new PropertyEntry(propertyName));
    11. 		try {
    12. 			if (bd.getPropertyValues().contains(propertyName)) {//是否包括
    13. 				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
    14. 				return;
    15. 			}
    16. 			Object val = parsePropertyValue(ele, bd, propertyName);//解析
    17. 			PropertyValue pv = new PropertyValue(propertyName, val);//获取值
    18. 			parseMetaElements(ele, pv);
    19. 			pv.setSource(extractSource(ele));
    20. 			bd.getPropertyValues().addPropertyValue(pv);
    21. 		}
    22. 		finally {
    23. 			this.parseState.pop();
    24. 		}
    25. 	}
    1. public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
    2. 		String elementName = (propertyName != null) ?
    3. 						"<property> element for property '" + propertyName + "'" :
    4. 						"<constructor-arg> element";
    5. 

    6. 		// Should only have one child element: ref, value, list, etc.
    7. 		NodeList nl = ele.getChildNodes();//xml文档解析
    8. 		Element subElement = null;
    9. 		for (int i = 0; i < nl.getLength(); i++) {
    10. 			Node node = nl.item(i);
    11. 			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
    12. 					!nodeNameEquals(node, META_ELEMENT)) {
    13. 				// Child element is what we're looking for.
    14. 				if (subElement != null) {
    15. 					error(elementName + " must not contain more than one sub-element", ele);
    16. 				}
    17. 				else {
    18. 					subElement = (Element) node;
    19. 				}
    20. 			}
    21. 		}
    22. 

    23. 		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);//是否是ref引用
    24. 		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);//值引用
    25. 		if ((hasRefAttribute && hasValueAttribute) ||
    26. 				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
    27. 			error(elementName +
    28. 					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
    29. 		}
    30. 

    31. 		if (hasRefAttribute) {//ref引用
    32. 			String refName = ele.getAttribute(REF_ATTRIBUTE);
    33. 			if (!StringUtils.hasText(refName)) {
    34. 				error(elementName + " contains empty 'ref' attribute", ele);
    35. 			}
    36. 			RuntimeBeanReference ref = new RuntimeBeanReference(refName);
    37. 			ref.setSource(extractSource(ele));
    38. 			return ref;
    39. 		}//value 引用
    40. 		else if (hasValueAttribute) {
    41. 			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
    42. 			valueHolder.setSource(extractSource(ele));
    43. 			return valueHolder;
    44. 		}//假设还有子元素。触发对子元素的解析
    45. 		else if (subElement != null) {
    46. 			return parsePropertySubElement(subElement, bd);
    47. 		}
    48. 		else {
    49. 			// Neither child element nor "ref" or "value" attribute found.
    50. 			error(elementName + " must specify a ref or value", ele);
    51. 			return null;
    52. 		}
    53. 	}

    3，BeanDefinition在IoC容器中的注冊

    BeanDefinition完毕加载和解析过程后。须要对其进行注冊操作。

    注冊是在DefaultListableBeanFactory中，通过HashMap来加载Beandefinition的。

    1. /** Map of bean definition objects, keyed by bean name */
    2. 	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);

    调用顺序：XmlBeanDefinitionReader调用loadBeanDefinitions(EncodedResource)方法，然后到registerBeanDefinitions()方法。在该方法中registerBeanDefinitions()方法被调用。在DefaultListableBeanFactory中，实现了BeanDefinitionRegistry接口。

    1. @Override
    2. 	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    3. 			throws BeanDefinitionStoreException {
    4. 

    5. 		Assert.hasText(beanName, "Bean name must not be empty");
    6. 		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    7. 

    8. 		if (beanDefinition instanceof AbstractBeanDefinition) {
    9. 			try {
    10. 				((AbstractBeanDefinition) beanDefinition).validate();
    11. 			}
    12. 			catch (BeanDefinitionValidationException ex) {
    13. 				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    14. 						"Validation of bean definition failed", ex);
    15. 			}
    16. 		}
    17. 

    18. 		synchronized (this.beanDefinitionMap) {//是否存在同样名字
    19. 			BeanDefinition oldBeanDefinition = this.beanDefinitionMap.get(beanName);
    20. 			if (oldBeanDefinition != null) {
    21. 				if (!this.allowBeanDefinitionOverriding) {
    22. 					throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    23. 							"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
    24. 							"': There is already [" + oldBeanDefinition + "] bound.");
    25. 				}
    26. 				else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
    27. 					// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    28. 					if (this.logger.isWarnEnabled()) {
    29. 						this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
    30. 								" with a framework-generated bean definition ': replacing [" +
    31. 								oldBeanDefinition + "] with [" + beanDefinition + "]");
    32. 					}
    33. 				}
    34. 				else {
    35. 					if (this.logger.isInfoEnabled()) {
    36. 						this.logger.info("Overriding bean definition for bean '" + beanName +
    37. 								"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
    38. 					}
    39. 				}
    40. 			}
    41. 			else {//注冊bean。将bean的name放入List
    42. 				this.beanDefinitionNames.add(beanName);
    43. 				this.frozenBeanDefinitionNames = null;
    44. 			}

    45. //map中增加
    46. 			this.beanDefinitionMap.put(beanName, beanDefinition);
    47. 		}
    48. 

    49. 		resetBeanDefinition(beanName);
    50. 	}
    完毕了注冊。就完毕了IoC容器的初始化。

    在使用的IoC容器的DefaultListableBeanFactory中已经建立了Bean的配置信息，并且这些BeanDefinition已经能够被容器使用，他们都在beanDefinitionMap中被检索和使用。容器的作用就是对这些信息进行维护和处理。

    IoC容器的依赖注入    ​    ​

        ​依赖注入是用户第一次向Ioc容器索要Bean的时候触发的。除非通过lazy-init控制Bean的记载时机。

        ​从DefaultListableBeanFactory的基类AbstractBeanFactory的getBean方法開始查看实现。

    1. @Override
    2. 	public Object getBean(String name) throws BeansException {
    3. 		return doGetBean(name, null, null, false);
    4. 	}
    5. 

    6. 	@Override
    7. 	public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    8. 		return doGetBean(name, requiredType, null, false);
    9. 	}
    10. 

    11. 	@Override
    12. 	public Object getBean(String name, Object... args) throws BeansException {
    13. 		return doGetBean(name, null, args, false);
    14. 	}

    查看doGetBean方法：

    1. 

    2. protected <T> T doGetBean(
    3. 		final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
    4. 		throws BeansException {
    5. 

    6. 	final String beanName = transformedBeanName(name);
    7. 	Object bean;
    8. 

    9. 	// Eagerly check singleton cache for manually registered singletons.
    10. 	//从缓存入手。处理单例bean
    11. 	Object sharedInstance = getSingleton(beanName);
    12. 	if (sharedInstance != null && args == null) {
    13. 		if (logger.isDebugEnabled()) {
    14. 			if (isSingletonCurrentlyInCreation(beanName)) {
    15. 				logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
    16. 						"' that is not fully initialized yet - a consequence of a circular reference");
    17. 			}
    18. 			else {
    19. 				logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
    20. 			}
    21. 		}
    22. 		//对FactoryBean的处理，获取FactoryBean的相关实例。
    23. 		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    24. 	}
    25. 

    26. 	else {
    27. 		// Fail if we're already creating this bean instance:
    28. 		// We're assumably within a circular reference.
    29. 		if (isPrototypeCurrentlyInCreation(beanName)) {
    30. 			throw new BeanCurrentlyInCreationException(beanName);
    31. 		}
    32. 

    33. 		// Check if bean definition exists in this factory.
    34. 		//减产是否已经存在相应的BeanDefinition对象
    35. 		BeanFactory parentBeanFactory = getParentBeanFactory();
    36. 		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    37. 			// Not found -> check parent.
    38. 			String nameToLookup = originalBeanName(name);
    39. 			if (args != null) {
    40. 				// Delegation to parent with explicit args.
    41. 				return (T) parentBeanFactory.getBean(nameToLookup, args);
    42. 			}
    43. 			else {
    44. 				// No args -> delegate to standard getBean method.
    45. 				return parentBeanFactory.getBean(nameToLookup, requiredType);
    46. 			}
    47. 		}
    48. 

    49. 		if (!typeCheckOnly) {
    50. 			markBeanAsCreated(beanName);
    51. 		}
    52. 

    53. 		try {
    54. 			//依据Bean的名字获取BeanDefinition
    55. 			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    56. 			checkMergedBeanDefinition(mbd, beanName, args);
    57. 

    58. 			// Guarantee initialization of beans that the current bean depends on.
    59. 			//获取当前bean的全部依赖bean
    60. 			String[] dependsOn = mbd.getDependsOn();
    61. 			if (dependsOn != null) {
    62. 				for (String dependsOnBean : dependsOn) {
    63. 					if (isDependent(beanName, dependsOnBean)) {
    64. 						throw new BeanCreationException("Circular depends-on relationship between '" +
    65. 								beanName + "' and '" + dependsOnBean + "'");
    66. 					}
    67. 					registerDependentBean(dependsOnBean, beanName);//注冊依赖bean
    68. 					getBean(dependsOnBean);//获取bean的递归调用
    69. 				}
    70. 			}
    71. 

    72. 			// Create bean instance.
    73. 			//创建单例bean
    74. 			if (mbd.isSingleton()) {
    75. 				sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
    76. 					@Override
    77. 					public Object getObject() throws BeansException {
    78. 						try {
    79. 							return createBean(beanName, mbd, args);
    80. 						}
    81. 						catch (BeansException ex) {
    82. 							// Explicitly remove instance from singleton cache: It might have been put there
    83. 							// eagerly by the creation process, to allow for circular reference resolution.
    84. 							// Also remove any beans that received a temporary reference to the bean.
    85. 							destroySingleton(beanName);
    86. 							throw ex;
    87. 						}
    88. 					}
    89. 				});
    90. 				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    91. 			}
    92. 

    93. 			else if (mbd.isPrototype()) {// property bean
    94. 				// It's a prototype -> create a new instance.
    95. 				Object prototypeInstance = null;
    96. 				try {
    97. 					beforePrototypeCreation(beanName);
    98. 					prototypeInstance = createBean(beanName, mbd, args);
    99. 				}
    100. 				finally {
    101. 					afterPrototypeCreation(beanName);
    102. 				}
    103. 				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    104. 			}
    105. 

    106. 			else {
    107. 				String scopeName = mbd.getScope();//其它scope
    108. 				final Scope scope = this.scopes.get(scopeName);
    109. 				if (scope == null) {
    110. 					throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
    111. 				}
    112. 				try {
    113. 					Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
    114. 						@Override
    115. 						public Object getObject() throws BeansException {
    116. 							beforePrototypeCreation(beanName);
    117. 							try {
    118. 								return createBean(beanName, mbd, args);
    119. 							}
    120. 							finally {
    121. 								afterPrototypeCreation(beanName);
    122. 							}
    123. 						}
    124. 					});
    125. 					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    126. 				}
    127. 				catch (IllegalStateException ex) {
    128. 					throw new BeanCreationException(beanName,
    129. 							"Scope '" + scopeName + "' is not active for the current thread; " +
    130. 							"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
    131. 							ex);
    132. 				}
    133. 			}
    134. 		}
    135. 		catch (BeansException ex) {
    136. 			cleanupAfterBeanCreationFailure(beanName);
    137. 			throw ex;
    138. 		}
    139. 	}
    140. 

    141. 	// Check if required type matches the type of the actual bean instance.
    142. 	//检查bean的类型。
    143. 	if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
    144. 		try {
    145. 			return getTypeConverter().convertIfNecessary(bean, requiredType);
    146. 		}
    147. 		catch (TypeMismatchException ex) {
    148. 			if (logger.isDebugEnabled()) {
    149. 				logger.debug("Failed to convert bean '" + name + "' to required type [" +
    150. 						ClassUtils.getQualifiedName(requiredType) + "]", ex);
    151. 			}
    152. 			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    153. 		}
    154. 	}
    155. 	return (T) bean;
    156. }

    这种方法就是依赖注入的入口，由于他触发了依赖注入。

    虽然能够以最简单的方法来描写叙述Spring IoC容器，即Spring容器就是一个HashMap，通过HashMap来管理BeanDefinition对象。

    在getBean()的时候，会触发createBean()来进创建须要的Bean对象。

        ​终于的调用，到AbstractAutowireCapableBeanFactory的createBean()方法，代码例如以下：

    1. /**
    2. 	 * Central method of this class: creates a bean instance,
    3. 	 * populates the bean instance, applies post-processors, etc.
    4. 	 * @see #doCreateBean
    5. 	 */
    6. 	@Override
    7. 	protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    8. 			throws BeanCreationException {
    9. 

    10. 		if (logger.isDebugEnabled()) {
    11. 			logger.debug("Creating instance of bean '" + beanName + "'");
    12. 		}
    13. 		// Make sure bean class is actually resolved at this point.

    14. //推断须要创建的Bean是否可实例化，这个类是否可通过类装载器来加载
    15. 		resolveBeanClass(mbd, beanName);
    16. 

    17. 		// Prepare method overrides.
    18. 		try {
    19. 			mbd.prepareMethodOverrides();
    20. 		}
    21. 		catch (BeanDefinitionValidationException ex) {
    22. 			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
    23. 					beanName, "Validation of method overrides failed", ex);
    24. 		}
    25. 

    26. 		try {
    27. 			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.

    28. //假设Bean配置了BeanPostProcessors，则返回代理对象
    29. 			Object bean = resolveBeforeInstantiation(beanName, mbd);
    30. 			if (bean != null) {
    31. 				return bean;
    32. 			}
    33. 		}
    34. 		catch (Throwable ex) {
    35. 			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    36. 					"BeanPostProcessor before instantiation of bean failed", ex);
    37. 		}

    38. //创建bean

    39. 

    40. 		Object beanInstance = doCreateBean(beanName, mbd, args);
    41. 		if (logger.isDebugEnabled()) {
    42. 			logger.debug("Finished creating instance of bean '" + beanName + "'");
    43. 		}
    44. 		return beanInstance;
    45. 	}

    再查看doCreateBean()方法：

    1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    2. 		// Instantiate the bean.
    3. 		BeanWrapper instanceWrapper = null;
    4. 		if (mbd.isSingleton()) {//假设是单例的。则移除缓存中的同name bean
    5. 			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    6. 		}
    7. 		if (instanceWrapper == null) {//创建Bean
    8. 			instanceWrapper = createBeanInstance(beanName, mbd, args);
    9. 		}
    10. 		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    11. 		Class<?
      > beanType = (instanceWrapper != null ?
       instanceWrapper.getWrappedClass() : null);
    12. 

    13. 		// Allow post-processors to modify the merged bean definition.
    14. 		synchronized (mbd.postProcessingLock) {
    15. 			if (!mbd.postProcessed) {
    16. 				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    17. 				mbd.postProcessed = true;
    18. 			}
    19. 		}
    20. 

    21. 		// Eagerly cache singletons to be able to resolve circular references
    22. 		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    23. 		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    24. 				isSingletonCurrentlyInCreation(beanName));
    25. 		if (earlySingletonExposure) {
    26. 			if (logger.isDebugEnabled()) {
    27. 				logger.debug("Eagerly caching bean '" + beanName +
    28. 						"' to allow for resolving potential circular references");
    29. 			}
    30. 			addSingletonFactory(beanName, new ObjectFactory<Object>() {
    31. 				@Override
    32. 				public Object getObject() throws BeansException {
    33. 					return getEarlyBeanReference(beanName, mbd, bean);
    34. 				}
    35. 			});
    36. 		}
    37. 

    38. 		// Initialize the bean instance.初始化bean。通常在此处发生依赖注入
    39. 		Object exposedObject = bean;
    40. 		try {
    41. 			populateBean(beanName, mbd, instanceWrapper);
    42. 			if (exposedObject != null) {
    43. 				exposedObject = initializeBean(beanName, exposedObject, mbd);
    44. 			}
    45. 		}
    46. 		catch (Throwable ex) {
    47. 			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
    48. 				throw (BeanCreationException) ex;
    49. 			}
    50. 			else {
    51. 				throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    52. 			}
    53. 		}
    54. 

    55. 		if (earlySingletonExposure) {
    56. 			Object earlySingletonReference = getSingleton(beanName, false);
    57. 			if (earlySingletonReference != null) {
    58. 				if (exposedObject == bean) {
    59. 					exposedObject = earlySingletonReference;
    60. 				}
    61. 				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    62. 					String[] dependentBeans = getDependentBeans(beanName);
    63. 					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
    64. 					for (String dependentBean : dependentBeans) {
    65. 						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
    66. 							actualDependentBeans.add(dependentBean);
    67. 						}
    68. 					}
    69. 					if (!actualDependentBeans.isEmpty()) {
    70. 						throw new BeanCurrentlyInCreationException(beanName,
    71. 								"Bean with name '" + beanName + "' has been injected into other beans [" +
    72. 								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    73. 								"] in its raw version as part of a circular reference, but has eventually been " +
    74. 								"wrapped. This means that said other beans do not use the final version of the " +
    75. 								"bean. This is often the result of over-eager type matching - consider using " +
    76. 								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    77. 					}
    78. 				}
    79. 			}
    80. 		}
    81. 

    82. 		// Register bean as disposable.
    83. 		try {
    84. 			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    85. 		}
    86. 		catch (BeanDefinitionValidationException ex) {
    87. 			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    88. 		}
    89. 

    90. 		return exposedObject;
    91. 	}

    与依赖注入相关的两个方法：createBeanInstance和populateBean。

     

    1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    2. 		// Make sure bean class is actually resolved at this point.

    3. //确认须要创建实例的类能够实例化
    4. 		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    5. 

    6. 		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
    7. 			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    8. 					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    9. 		}

    10. //工厂方法实例化
    11. 		if (mbd.getFactoryMethodName() != null)  {
    12. return instantiateUsingFactoryMethod(beanName, mbd, args);
    13. 		}
    14. 

    15. 		// Shortcut when re-creating the same bean...
    16. 		boolean resolved = false;
    17. 		boolean autowireNecessary = false;
    18. 		if (args == null) {
    19. 			synchronized (mbd.constructorArgumentLock) {
    20. 				if (mbd.resolvedConstructorOrFactoryMethod != null) {
    21. 					resolved = true;
    22. 					autowireNecessary = mbd.constructorArgumentsResolved;
    23. 				}
    24. 			}
    25. 		}
    26. 		if (resolved) {
    27. 			if (autowireNecessary) {
    28. 				return autowireConstructor(beanName, mbd, null, null);
    29. 			}
    30. 			else {
    31. 				return instantiateBean(beanName, mbd);
    32. 			}
    33. 		}
    34. 

    35. 		//构造函数实例化
    36. 		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    37. 		if (ctors != null ||
    38. 				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
    39. 				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
    40. 			return autowireConstructor(beanName, mbd, ctors, args);
    41. 		}
    42. 

    43. 		// 使用无參构造函数
    44. 		return instantiateBean(beanName, mbd);
    45. 	}
    1. protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {

    2. //使用CGLIB对bean进行实例化。
      

    3. 		try {
    4. 			Object beanInstance;
    5. 			final BeanFactory parent = this;
    6. 			if (System.getSecurityManager() != null) {
    7. 				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
    8. 					@Override
    9. 					public Object run() {
    10. 						return getInstantiationStrategy().instantiate(mbd, beanName, parent);
    11. 					}
    12. 				}, getAccessControlContext());
    13. 			}
    14. 			else {
    15. 				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    16. 			}
    17. 			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    18. 			initBeanWrapper(bw);
    19. 			return bw;
    20. 		}
    21. 		catch (Throwable ex) {
    22. 			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    23. 		}
    24. 	}

    在Bean实例化后，就是相关的依赖关系。

        ​依赖注入的发生是在BeanWrapper的setPropertyValues中实现。详细实现是在BeanWrapper的子类，BeanWrapperImpl中实现。


    以上便是整个IoC过程创建Bean的总体思路。与书中相比，省略了部分代码。

    ApplicationContext和Bean的初始化及销毁

        ​ApplicationContext的启动是在AbstractApplicationContext中实现。

        ​相同的销毁操作是在doClose()方法中完毕。

    1. protected void doClose() {
    2. 		boolean actuallyClose;
    3. 		synchronized (this.activeMonitor) {
    4. 			actuallyClose = this.active && !this.closed;
    5. 			this.closed = true;
    6. 		}
    7. 

    8. 		if (actuallyClose) {
    9. 			if (logger.isInfoEnabled()) {
    10. 				logger.info("Closing " + this);
    11. 			}
    12. 

    13. 			LiveBeansView.unregisterApplicationContext(this);
    14. 

    15. 			try {
    16. 				// Publish shutdown event.
    17. 				publishEvent(new ContextClosedEvent(this));
    18. 			}
    19. 			catch (Throwable ex) {
    20. 				logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
    21. 			}
    22. 

    23. 			// Stop all Lifecycle beans, to avoid delays during individual destruction.
    24. 			try {
    25. 				getLifecycleProcessor().onClose();
    26. 			}
    27. 			catch (Throwable ex) {
    28. 				logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
    29. 			}
    30. 

    31. 			// Destroy all cached singletons in the context's BeanFactory.
    32. 			destroyBeans();
    33. 

    34. 			// Close the state of this context itself.
    35. 			closeBeanFactory();
    36. 

    37. 			// Let subclasses do some final clean-up if they wish...
    38. 			onClose();
    39. 

    40. 			synchronized (this.activeMonitor) {
    41. 				this.active = false;
    42. 			}
    43. 		}
    44. 	}

        ​Bean的销毁和创建，Spring通过IoC管理Bean的生命周期来实现。

    Spring中Bean的生命周期包括：

        ​    ​-1。Bean实例的创建。


        ​    ​-2，为Bean实例设置属性。


        ​    ​-3。调用Bean的初始化方法。

        ​    ​-4，通过IoC获取Bean。


        ​    ​-5，当容器关闭的时候调用bean的销毁方法。

    总结

        ​BeanDefinition的定位。对IoC容器来说，它为管理POJO直接的关系提供了帮助，但也要依据Spring的定义规则提供Bean定义信息。在Bean定义方面，Spring为用户提供了非常大的灵活性。在初始化过程中，首先须要定义到这些有效地Bean定义信息。这里Spring使用Resource接口来统一这些信息。而定位由ResourceLoader完毕。

        ​容器的初始化。容器的初始化过程是在refresh()方法中完毕的。这个refresh()相当于容器的初始化函数。在初始化中，比較重要的就是对Bean信息的加载和注冊功能。

    ​
  • 相关阅读:
    Mybatis 内置 Java 类型别名与 typeHandlers
    泛型方法前为什么要加<T>
    jdbcTemplate学习（四）
    jdbcTemplate学习（三）
    jdbcTemplate学习（二）
    jdbcTemplate学习（一）
    博客园markdown toc
    office，ps 等入门教程链接
    mysql 手动加锁测试
    拆机联想ideapad s500
  • 原文地址：https://www.cnblogs.com/llguanli/p/6940239.html
Copyright © 2020-2023  润新知