之前就IOC的原理及使用有了一定的认识，作为Spring核心特性之一，IOC是很有必要重点掌握的。这次沉淀将会开启IOC源码阅读的序幕。
对于源码的理解，以注释添加在对应代码块上方
一、IOC概念回顾
IOC（Inversion of Control），即“控制反转”，IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。那么到底“谁控制谁，控制什么，为什么是反转，哪些方面反转了”：
●谁控制谁，控制什么：IOC出现之前我们程序员会直接在对象内部通过new创建对象，是程序主动去创建依赖对象；而IOC是通过一个容器来创建，即由IOC容器来控制对象的创建；谁控制谁？是IOC 容器控制对象；控制什么？那就是主要控制了外部资源获取（不仅仅是对象，还包括文件等）。
●为何是反转，哪些方面反转了：传统应用程序是由我们程序员在一个对象中主动控制从而直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为什么是反转？因为由容器帮我们查找及注入依赖对象，对于对象是被动的接受了依赖对象，所以叫做反转；哪些方面反转了？依赖对象在获取时被反转了。
二、源码剖析
1. SpringDemo
以我spring入门的demo为例：
public static void main( String[] args ){
String xmlPath="src//main/resources/spring.xml";
ApplicationContext context = new FileSystemXmlApplicationContext(xmlPath);
((Car)context.getBean("car")).whistle();
}
注：该代码位置必须在spring-context模块下
类ApplicatContext的构造方法中包含了容器的启动，IOC的初始化。
spring为ApplicationContext提供的3种实现分别为：
- ClassPathXmlApplicationContext 在class路径下加载 classpath:***.xml。
- FileSystemXmlApplicationContext 可以指定磁盘任意资源路径。
- XmlWebApplicationContext 是专为Web工程定制的。
而ApplicatContext 的标准实现是 FileSystemXmlApplicationContext。
打好断点，开始刨根问底源码的剖析。
2. 源码剖析入口FileSystemXmlApplicationContext
/**
* Create a new FileSystemXmlApplicationContext, loading the definitions
* from the given XML files and automatically refreshing the context.
* @param configLocations array of file paths
* @throws BeansException if context creation failed
*/public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
this(configLocations, true, null);
}
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
// 调用父类容器的构造方法(super(parent)方法)为容器设置好Bean资源加载器。
super(parent);
//设置Bean定义资源文件的定位路径。
setConfigLocations(configLocations);
if (refresh) {
//刷新容器。
refresh();
}
}
由以上代码我们可以感觉到，refresh 方法才是初始化容器的重要方法：
Spring IOC容器对Bean定义资源的载入是从refresh()函数开始的其作用是：在创建IOC容器前，如果容器已经存在，则需销毁和关闭已有的容器，为的是保证在refresh之后使用的是新建的IOC容器。我们进入该方法看看：该方法是 FileSystemXmlApplicationContext 的父类 AbstractApplicationContext 中的方法。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//调用容器准备刷新的方法
prepareRefresh();
/**调用子类中refreshBeanFactory()方法
*启动Bean定义资源文件的过程
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//为BeanFactory配置容器特性
prepareBeanFactory(beanFactory);
try {
//为容器的子类指定事件处理器
postProcessBeanFactory(beanFactory);
//调用所有注册的BeanFactoryPostProcessor的Bean
invokeBeanFactoryPostProcessors(beanFactory);
/**为BeanFactory注册BeanPost事件处理器.
*BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件
*/
registerBeanPostProcessors(beanFactory);
//初始化信息源
initMessageSource();
//初始化容器事件传播器.
initApplicationEventMulticaster();
//调用子类Bean初始化方法
onRefresh();
//为事件传播器注册事件监听器.
registerListeners();
finishBeanFactoryInitialization(beanFactory);
/**初始化容器的生命周期事件处理器
*并发布容器的生命周期事件
*/
finishRefresh();
}
catch (BeansException ex) {
destroyBeans();
cancelRefresh(ex);
throw ex;
}
}
}
refresh()方法的步骤：
- 构建BeanFactory，从而产生所需的 Bean。
- 注册事件处理器。
- 常见Bean实例对象初始化。
- 触发被监听的事件的监听器。
子类容器的refreshBeanFactory()方法执行Spring IOC容器载入Bean定义资源文件的整个过程，所以整个refresh()中代码：
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
之后的代码都是注册容器的信息源和生命周期事件，载入过程就是由上面这行代码启动。
obtainFreshBeanFactory()方法调用AbstractApplicationContext的子类容器中的refreshBeanFactory()方法，此方法负责启动容器载入Bean定义资源文件的过程如下：
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//父类定义了抽象的refreshBeanFactory()方法，具体实现调用子类容器的refreshBeanFactory()方法
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
refreshBeanFactory()方法源码如下：
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
// 如果已经有容器存在就销毁
destroyBeans();
closeBeanFactory();
}
try {
// 创建IOC容器
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 设置序列化
beanFactory.setSerializationId(getId());
/** 定制化IOC容器，如：
* 设置启动参数，开启注解的自动装配
*/
customizeBeanFactory(beanFactory);
// 使用BeanFactory加载bean定义，具体的实现在子类容器中
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
refreshBeanFactory()方法的步骤：
- 已经有容器存在就销毁Beans并关闭beanFactory。
- 创建DefaultListableBeanFactory，即BeanFactory的默认实现。
- 调用loadBeanDefinitions(beanFactory)装载bean。
refreshBeanFactory()代码中有一段代码：
// 使用BeanFactory加载bean定义，具体的实现在子类容器中
loadBeanDefinitions(beanFactory);
loadBeanDefinitions(beanFactory)，看名字是加载 Definitions， Definition 是核心之一，代表着IOC 中的基本数据结构。该方法为抽象方法，AbstractRefreshableApplicationContext中只定义了抽象的loadBeanDefinitions方法，容器真正调用的是其子类AbstractXmlApplicationContext对该方法的实现，loadBeanDefinitions方法的源码如下：
//实现父类抽象的载入Bean定义方法
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
//创建Bean读取器，并通过回调机制set到容器中，容器通过读取器读取Bean定义资源
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
/**为Bean读取器设置Spring资源加载器，AbstractXmlApplicationContext的
*祖先父类AbstractApplicationContext继承DefaultResourceLoader，
*因此，容器本身也是一个资源加载器
*/
beanDefinitionReader.setResourceLoader(this);
//为Bean读取器设置xml解析器
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
//当Bean读取器读取Bean定义的Xml资源文件时，启用Xml的校验机制
initBeanDefinitionReader(beanDefinitionReader);
//Bean读取器真正实现加载的方法
loadBeanDefinitions(beanDefinitionReader);
}
loadBeanDefinitions()方法的步骤：
- 创建Bean读取器，用于读取XML中配置。
- 设置环境，资源加载器。
- 初始化，加载。
其中真正实现加载Bean定义资源的方法为loadBeanDefinitions(XmlBeanDefinitionReader reader)：
//Xml Bean读取器加载Bean定义资源
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//获取Bean定义资源的定位
Resource[] configResources = getConfigResources();
/**如果Bean定义资源的定位不为空，
*Bean读取器调用其父类AbstractBeanDefinitionReader读取定位到的Bean定义资源
*/
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
/**如果子类中获取的Bean定义资源定位为空，
*则获取FileSystemXmlApplicationContext构造方法中setConfigLocations方法设置的资源
*/
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}
由于Demo中我们使用FileSystemXmlApplicationContext，getConfigResources的返回值为null，所以程序直接跳过第一个if分支，直接执行reader.loadBeanDefinitions(configLocations)分支。
Bean读取器方法loadBeanDefinitions实现：
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
//获取在IOC容器初始化过程中set的资源加载器
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader == null) {
throw new BeanDefinitionStoreException(
"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
}
if (resourceLoader instanceof ResourcePatternResolver) {
try {
/**将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源
*加载多个指定位置的Bean定义资源文件
*/
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
//调用其子类XmlBeanDefinitionReader的方法，实现加载功能
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 {
/**将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源
*加载单个指定位置的Bean定义资源文件
*/
Resource resource = resourceLoader.getResource(location);
//调用其子类XmlBeanDefinitionReader的方法，实现加载功能
int loadCount = loadBeanDefinitions(resource);
if (actualResources != null) {
actualResources.add(resource);
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
}
return loadCount;
}
}
该方法做了两件事：
- 调用资源加载器的获取资源方法resourceLoader.getResource(location)，获取到要加载的资源。
- 真正执行加载功能是其子类XmlBeanDefinitionReader的loadBeanDefinitions方法。
未完跟进中......（IOC容器初始化：Bean的解析和注册）
XmlBeanDefinitionReader通过调用其父类DefaultResourceLoader的getResource方法获取要加载的资源，源码如下
public Resource getResource(String location) {
Assert.notNull(location, "Location must not be null");
//如果是类路径标识，需通过ClassPathResource 得到bean文件的Resource对象
if (location.startsWith(CLASSPATH_URL_PREFIX)) {
return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
}
try {
// 如果是URL标识，通过UrlResource 作为bean文件的Resource对象
URL url = new URL(location);
return new UrlResource(url);
}
catch (MalformedURLException ex) {
}
/**若既不是classpath标识，也不是URL标识，则调用
*容器本身的getResourceByPath方法获取bean文件的Resource对象
*/
return getResourceByPath(location);
}
我们可以按照这个逻辑对IOC 配置文件从任何地方加载进行加载。
Spring中提供的响应的资源抽象：
●ClassPathResource
●URLResource
●FileSystemResource
上述的是定位Resource 的一个过程，而这只是加载过程的一部分.
可以看到方法loadBeanDefinitions(String location, Set<Resource> actualResources) 中调用了方法 loadBeanDefinitions(Resource resource)，如下：
//XmlBeanDefinitionReader加载Resource的入口方法
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
//将读入的XML资源进行编码处理
return loadBeanDefinitions(new EncodedResource(resource));
}
方法loadBeanDefinitions(EncodedResource encodedResource)部分源码：
//这里是载入XML形式Bean定义资源文件方法
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
.......
try {
//将资源文件转为InputStream的IO流
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 {
//关闭从Resource中得到的IO流
inputStream.close();
}
}
读取过程由方法doLoadBeanDefinitions(InputSource inputSource, Resource resource)实现：
//读取过程具体实现
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
源码实现：
//从特定XML文件中实际载入Bean定义资源
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
//将XML文件转换为DOM对象，documentLoader实现解析过程
Document doc = doLoadDocument(inputSource, resource);
//启动Spring IOC容器对Bean定义解析过程，会使用到Spring的Bean配置规则
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);
}
}
至此已完成Spring IOC容器根据定位的Bean定义资源文件，将其加载读入并转换为Document对象的过程。
doLoadBeanDefinitions()方法的步骤：
- 将XML文件转换为DOM对象。
- registerBeanDefinitions方法启动Spring IOC容器对Bean定义解析过程。
接下来需要剖析的就是如何解析为Spring IOC管理的Bean对象并将其注册到容器中：
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
//获得容器中注册的Bean数量
int countBefore = getRegistry().getBeanDefinitionCount();
//解析过程入口，具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
//统计解析的Bean数量
return getRegistry().getBeanDefinitionCount() - countBefore;
}
BeanDefinitionDocumentReader接口通过registerBeanDefinitions方法调用其实现类DefaultBeanDefinitionDocumentReader对Document对象进行解析，解析过程入口：
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
//获得Document的根元素
Element root = doc.getDocumentElement();
/**具体的解析过程由BeanDefinitionParserDelegate实现，
*BeanDefinitionParserDelegate中定义了Spring Bean定义XML文件的各种元素
*/
BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);
preProcessXml(root);
//从Document的根元素开始进行Bean定义的Document对象
parseBeanDefinitions(root, delegate);
postProcessXml(root);
}
该方法最核心的逻辑就是调用 parseBeanDefinitions(root, this.delegate)，该方法具体实现：
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//如果Bean定义的Document对象使用了Spring默认的XML命名空间
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
//获取Bean定义的Document对象根元素的所有子节点
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)) {
/**如果Bean定义的Document对象使用了Spring默认的XML命名空间
*使用Spring的Bean规则解析元素节点
*/
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
/**如果没有使用Spring默认的XML命名空间，
*则使用用户自定义的解析规则解析元素节点
*/
delegate.parseCustomElement(root);
}
}
此方法使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象。
parseDefaultElement方法的实现：
//使用Spring的Bean规则解析Document元素节点
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
/**如果元素节点既不是导入元素<Import>，也不是别名元素<Alias>，即普通的<Bean>元素，
*则按照Spring的Bean规则解析元素
*/
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
}
可以看到解析bean规则的方法为processBeanDefinition，如下：
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
/**BeanDefinitionHolder是对BeanDefinition的封装，即Bean定义的封装类，
*对Document对象中<Bean>元素的解析由BeanDefinitionParserDelegate实现
*/
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//向Spring IOC容器注册解析得到的Bean定义，这是Bean定义向IoC容器注册的入口
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
//发送注册事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
processBeanDefinition()方法的步骤：
- 定义Bean的封装类。
- 向Spring IOC容器注册解析得到的Bean定义。
- 执行容器通知事件。
静态方法BeanDefinitionReaderUtils.registerBeanDefinition 向Spring IOC容器注册解析得到的Bean定义，这是Bean定义向IoC容器注册的入口，剖析如下：
//将解析的BeanDefinitionHold注册到容器中
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
//获取解析的BeanDefinition的名称
String beanName = definitionHolder.getBeanName();
//向IOC容器注册BeanDefinition
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//如果解析的BeanDefinition有别名，向容器为其注册别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String aliase : aliases) {
registry.registerAlias(beanName, aliase);
}
}
}
registerBeanDefinition()方法的步骤：
- 从bean的持有者那里获取了beanName。
- 注册bean的名字和 BeanDefinition。
方法registerBeanDefinition实现注册bean的名字和 BeanDefinition，该方法是DefaultListableBeanFactory向IOC容器注册bean的最后一步，使用一个 ConcurrentHashMap存放IOC容器中注册解析的BeanName和BeanDefinition。实现：
//定义ConcurrentHashMap存储注册的BeanName和BeanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
//校验解析的BeanDefiniton
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
//线程同步保证数据的一致性
synchronized (this.beanDefinitionMap) {
Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
/**如果有同名的BeanDefinition已经在IOC容器中注册，
*并且不允许覆盖已注册的Bean，则抛出注册失败异常
*/
if (oldBeanDefinition != null) {
if (!this.allowBeanDefinitionOverriding) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
else {
//如果允许覆盖，则后注册的覆盖先注册的
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
}
/**如果IOC容器中没有已经注册同名的bean，
*按正常注册流程注册
*/
else {
this.beanDefinitionNames.add(beanName);
this.frozenBeanDefinitionNames = null;
}
this.beanDefinitionMap.put(beanName, beanDefinition);
//重置所有已注册过BeanDefinition的缓存
resetBeanDefinition(beanName);
}
}
到目前为止，Bean定义资源文件中配置的Bean经过解析后，已注册到IOC容器中，由容器管理，完成了IOC容器初始化的全部工作。
至此IOC容器中已构建起了Bean的配置信息，这些BeanDefinition信息已可以使用并可被检索。
IOC容器的作用就是对这些注册的BeanDefinition信息进行处理和维护。BeanDefinition信息是IOC容器控制反转的基础，正是有了这些注册的数据，容器才可以进行依赖注入。
未完跟进中......（IOC容器的依赖注入）
IOC容器的依赖注入
当Spring IOC容器完成了Bean定义资源的定位、载入和解析注册以后，IOC容器中已经管理类Bean定义的相关数据，但此时IOC容器还未对所管理的Bean进行依赖注入。
通常IOC容器触发依赖注入在以下两种情况发生：
- 当用户第一次通过getBean方法向IOC容索要Bean的时候；
- 当用户在Bean定义资源中为<Bean>元素配置了lazy-init属性，即让容器在解析注册Bean定义时进行预实例化的时候。
BeanFactory接口定义了Spring IOC容器的基本功能规范，是Spring IOC容器应遵守的最底层和最基本的编程规范，同时接口中定义了几个getBean方法，即用户向IOC容器索取管理的Bean的方法，通过分析其子类的具体实现，理解Spring IOC容器在用户索取Bean时如何完成依赖注入。
以我spring入门的demo为例：
public static void main( String[] args ){
String xmlPath="src//main/resources/spring.xml";
ApplicationContext context = new FileSystemXmlApplicationContext(xmlPath);
((Car)context.getBean("car")).whistle();
}
我们进入getBean方法中，看看其具体实现：
//获取IOC容器中指定名称的Bean
public Object getBean(String name) throws BeansException {
//doGetBean是真正向IOC容器获取被管理Bean的实现过程
return doGetBean(name, null, null, false);
}
//获取IOC容器中指定名称和类型的Bean
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
//doGetBean是真正向IOC容器获取被管理Bean的实现过程
return doGetBean(name, requiredType, null, false);
}
//获取IOC容器中指定名称和参数的Bean
public Object getBean(String name, Object... args) throws BeansException {
//doGetBean是真正向IOC容器获取被管理Bean的实现过程
return doGetBean(name, null, args, false);
}
//获取IOC容器中指定名称、类型和参数的Bean
public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
//doGetBean是真正向IOC容器获取被管理Bean的实现过程
return doGetBean(name, requiredType, args, false);
}
从上述代码可以得知，方法doGetBean才是真正向IOC容器获取被管理bean的实现方法，如下：
//真正实现向IOC容器获取Bean的方法，也是触发依赖注入功能的地方
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
/**根据指定名称获取被管理Bean名称，首先剥离指定名称中对容器的相关依赖
*如果指定的是别名，需要将别名转换为规范的bean名称
*/
final String beanName = transformedBeanName(name);
Object bean;
/**先从缓存中取是否已经有被创建过的单态类型的Bean，
*对于单态模式的Bean整个IOC容器中只创建一次，不需要重复创建
*/
Object sharedInstance = getSingleton(beanName);
//IOC容器创建单态模式Bean实例对象
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
/**如果指定名称的Bean在容器中已存在单态模式的Bean被创建，
*直接返回已经创建的Bean
*/
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//获取给定Bean的实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
/**如果没有正在创建的单态模式Bean，
*缓存中已经有已经创建的原型模式Bean，
*但是由于循环引用的问题导致实例化对象失败
*/
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
/**对IOC容器中是否存在指定名称的BeanDefinition进行检查，
*首先检查是否能在当前的BeanFactory中获取的所需要的Bean，
*如果不能，则委托当前容器的父级容器去查找，
*若仍然找不到，则沿着容器的继承体系向父级容器查找
*/
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果当前容器的父级容器存在，同时当前容器中不存在指定名称的Bean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//解析指定Bean名称的原始名称
String nameToLookup = originalBeanName(name);
if (args != null) {
//若参数不为null，委派父级容器根据指定原始名称和显式的参数进行查找
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
//若参数为null，那么委派父级容器根据指定原始名称和所需类型查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
/**根据指定bean名称获取其父级的bean定义，
*主要是为了解决bean继承时子类合并父类公共属性的问题
*/
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//获取当前bean所有依赖bean的名称
String[] dependsOn = mbd.getDependsOn();
//如果当前bean有依赖bean，即当前bean依赖其他的bean
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
//获取当前bean的依赖bean，递归调用getBean方法
getBean(dependsOnBean);
//将被依赖的bean注册给当前依赖的bean
registerDependentBean(dependsOnBean, beanName);
}
}
//创建单态模式bean的实例对象
if (mbd.isSingleton()) {
//匿名内部类实现创建bean实例对象，并注册给所依赖的对象
sharedInstance = getSingleton(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
try {
/**创建一个指定bean实例对象，
*如果有父级继承，则合并子类和父类的定义
*/
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
//显式地从容器单态模式Bean缓存中清除实例对象
destroySingleton(beanName);
throw ex;
}
}
});
//获取给定bean的实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//IOC容器创建原型模式bean实例对象
else if (mbd.isPrototype()) {
//如果是原型模式，则每次都会创建一个新的对象
Object prototypeInstance = null;
try {
/**回调beforePrototypeCreation方法，
*默认的功能：注册当前创建的原型对象
*/
beforePrototypeCreation(beanName);
//创建指定bean对象实例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
/**回调afterPrototypeCreation方法，
*默认的功能：告诉IOC容器指定bean的原型对象不再创建了
*/
afterPrototypeCreation(beanName);
}
//获取给定Bean的实例对象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
/**如果要创建的bean既不是单态模式，也不是原型模式，
*则根据bean定义资源中配置的生命周期范围，选择实例化bean的合适方法
*/
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
//如果bean定义资源中没有配置生命周期范围，则bean定义不合法
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
try {
//匿名内部类实现获取一个指定生命周期范围的实例
Object scopedInstance = scope.get(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
//获取给定Bean的实例对象
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; " +
"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return (T) bean;
}
注：
1.BeanFactory和FactoryBean的区别：BeanFactory是管理容器中Bean的工厂，而FactoryBean是创建对象的工厂Bean，两者之间有区别；
2.原型模式(Prototype)即每次都会创建一个新的对象。
上述是向IOC容器获取Bean方法，步骤如下：
1.如果bean定义的单例模式(Singleton)，则容器在创建之前先从缓存中查找，以确保整个容器中只存在一个实例对象；
2.如果Bean定义的是原型模式(Prototype)，则容器每次都会创建一个新的实例对象。
具体的Bean实例对象的创建过程由实现了ObejctFactory接口的匿名内部类的createBean方法完成，ObejctFactory使用委派模式，具体的Bean实例创建过程交由其实现类AbstractAutowireCapableBeanFactory完成。
接下来继续分析AbstractAutowireCapableBeanFactory的createBean方法的源码，目的是理解其创建Bean实例的具体实现过程。
AbstractAutowireCapableBeanFactory负责创建Bean实例对象，其实现了ObejctFactory接口，创建容器指定的Bean实例对象，同时还对创建的Bean实例对象进行初始化处理。其创建Bean实例对象的方法源码如下：
//创建bean实例对象
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
//判断需要创建的bean是否可实例化
resolveBeanClass(mbd, beanName);
//校验和准备bean中的方法覆盖
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
/**如果bean配置了初始化前和初始化后的处理器，
*则返回一个需要创建bean的代理对象
*/
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//创建bean的入口
Object beanInstance = doCreateBean(beanName, mbd, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
而真正创建bean的方法如下：
//真正创建bean的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
//封装被创建的bean对象
BeanWrapper instanceWrapper = null;
//如果bean是单态模式的，先从容器中缓存中获取同名bean
if (mbd.isSingleton()){
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建bean的实例对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
//调用PostProcessor后置处理器
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
//向容器中缓存单态模式的bean对象，以防循环引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//匿名内部类实现，为了防止循环引用
addSingletonFactory(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
/**bean对象的初始化，依赖注入在此触发
*这个exposedObject在初始化完成之后返回作为依赖注入完成后的bean
*/
Object exposedObject = bean;
try {
//将bean实例对象封装，并且bean定义中配置的属性值赋值给实例对象
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//初始化bean对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
//获取指定名称的已注册的单例模式bean对象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
//如果根据名称获取已注册的bean和正在实例化的bean相同
if (exposedObject == bean) {
//当前实例化的Bean初始化完成
exposedObject = earlySingletonReference;
}
//当前bean依赖其他bean，同时当发生循环引用时不允许新创建实例对象
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
//获取当前bean所依赖的其他bean
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
//注册完成依赖注入的bean
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
通过对方法源码的分析，可以看到具体的依赖注入实现在以下两个方法中：
1.createBeanInstance：创建bean所包含的java对象实例。
2.populateBean ：对bean属性的依赖注入进行处理。
下面继续分析这两个方法的代码实现。
createBeanInstance方法创建Bean的java实例对象，根据指定的初始化策略，使用静态工厂、工厂方法或者容器的自动装配特性生成java实例对象，源码如下：
//创建bean的实例对象
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
//首先检查确认bean是可实例化的
Class beanClass = resolveBeanClass(mbd, beanName);
//通过工厂方法对bean进行实例化
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
if (mbd.getFactoryMethodName() != null) {
//调用工厂方法实例化
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//通过容器的自动装配方法进行实例化
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
/**配置了自动装配属性，使用容器的自动装配实例化
*容器的自动装配是根据参数类型匹配bean的构造方法
*/
return autowireConstructor(beanName, mbd, null, null);
}
else {
//使用默认的无参构造方法实例化
return instantiateBean(beanName, mbd);
}
}
//使用bean的构造方法进行实例化
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//通过容器的自动装配特性，调用匹配的构造方法实例化
return autowireConstructor(beanName, mbd, ctors, args);
}
//通过默认的无参构造方法实例化
return instantiateBean(beanName, mbd);
}
//通过默认的无参构造方法实例化bean对象
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
//获取系统的安全管理接口，JDK标准的安全管理API
if (System.getSecurityManager() != null) {
//匿名内置类实现，根据实例化策略创建实例对象
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
//将实例化的对象封装起来
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
经过上述分析，我们不难发现对使用工厂方法和自动装配特性的bean的实例化相对比较清楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作。
但对于最常使用的默认无参构造方法就需要使用相应的初始化策略(JDK的反射机制或者CGLIB)来进行初始化了。
未完跟进中......（默认的无参构造方法创建Bean实例化对象）
在使用默认的无参构造方法创建bean的实例化对象的方法instantiateBean中调用了类SimpleInstantiationStrategy中的实例化bean的方法，源码如下：
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
方法instantiate的具体实现：
//使用初始化策略实例化bean对象
public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
//如果bean定义中不存在方法覆盖，则不需要CGLIB父类方法
if (beanDefinition.getMethodOverrides().isEmpty()) {
Constructor<?> constructorToUse;
synchronized (beanDefinition.constructorArgumentLock) {
//获取对象的构造方法或工厂方法
constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
//如果没有构造方法同时也没有工厂方法
if (constructorToUse == null) {
//使用JDK的反射机制，判断需实例化的bean是否为接口
final Class clazz = beanDefinition.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
//匿名内部类实现，通过反射机制获取bean的构造方法
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
public Constructor run() throws Exception {
return clazz.getDeclaredConstructor((Class[]) null);
}
});
}
else {
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Exception ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
//通过BeanUtils实例化，通过反射机制进行实例化
return BeanUtils.instantiateClass(constructorToUse);
}
else {
//通过CGLIB来实例化对象
return instantiateWithMethodInjection(beanDefinition, beanName, owner);
}
}
上述代码步骤：
- 如果bean存在方法被覆盖的情况，那么通过JDK的反射机制进行实例化。
- 否则，通过CGLIB实例化。
可以看到方法instantiateWithMethodInjection执行了通过CGLIB来实例化对象，其具体实现是在SimpleInstantiationStrategy的子类CglibSubclassingInstantiationStrategy中：
//通过CGLIB实例化bean对象
public Object instantiate(Constructor ctor, Object[] args) {
Enhancer enhancer = new Enhancer();
//将bean本身作为其基类
enhancer.setSuperclass(this.beanDefinition.getBeanClass());
enhancer.setCallbackFilter(new CallbackFilterImpl());
enhancer.setCallbacks(new Callback[] {
NoOp.INSTANCE,
new LookupOverrideMethodInterceptor(),
new ReplaceOverrideMethodInterceptor()
});
//通过CGLIB的create方法生成实例对象
return (ctor == null) ?
enhancer.create() :
enhancer.create(ctor.getParameterTypes(), args);
}
这里涉及到CGLIB动态代理，我们简单来看下代理相关：
CGLIB是一个常用的字节码生成器的类库，它提供了一系列API实现java字节码的生成和转换功能。我们在学习JDK的动态代理时都知道，JDK的动态代理只能针对接口，如果一个类没有实现任何接口，要对其进行动态代理只能使用CGLIB。
静态代理的缺点很明显：
一个代理类只能对一个业务接口的实现类进行包装，如果有多个业务接口的话就要定义很多实现类和代理类才行。而且，如果代理类对业务方法的预处理、调用后操作都是一样的（比如：调用前输出提示、调用后自动关闭连接），则多个代理类就会有很多重复代码。这时我们可以定义这样一个代理类，它能代理所有实现类的方法调用：根据传进来的业务实现类和方法名进行具体调用，即动态代理。
动态代理分为JDK动态代理和CGLIB动态代理：
JDK动态代理的代理对象在创建时，需要使用业务实现类所实现的接口作为参数（因为在后面代理方法时需要根据接口内的方法名进行调用）。如果业务实现类是没有实现接口而是直接定义业务方法的话，就无法使用JDK动态代理了。并且，如果业务实现类中新增了接口中没有的方法，这些方法是无法被代理的（因为无法被调用）。此时应该交给CGLIB来处理：CGLIB是针对类来实现代理的，原理是通过继承业务类，对指定的业务类生成一个动态代理子类，并覆盖其中业务方法实现代理。
