Spring框架中的IoC容器源码分析（上）

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置Spring ioc容器的配置文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <!--使用监听器启动Spring的IOC容器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--告诉ContextloaderListener知道我们使用注解的方式启动ioc容器-->
  <context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
  </context-param>
  <!--配置启动类的全限定类名-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>com.riemann.SpringConfig</param-value>
  </context-param>
  <!--使用监听器启动Spring的IOC容器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

<bean id="testBean" class="com.riemann.LazyBean" />
该bean默认的设置为:
<bean id="testBean" calss="com.riemann.LazyBean" lazy-init="false" />

<bean id="testBean" calss="com.riemann.LazyBean" lazy-init="true" />

// 可以让我们自定义Bean的创建过程(完成复杂Bean的定义) 
public interface FactoryBean<T> {

	@Nullable
	// 返回FactoryBean创建的Bean实例，如果isSingleton返回true，则该实例会放到Spring容器 的单例对象缓存池中Map
	T getObject() throws Exception;
	
	@Nullable
	// 返回FactoryBean创建的Bean类型 
	Class<?> getObjectType();
	
	// 返回作用域是否单例
	default boolean isSingleton() {
		return true;
	}
	
}

@Data
public class Company {

    private String name;
    private String address;
    private int scale;
    
}

public class CompanyFactoryBean implements FactoryBean<Company> {

	private String companyInfo; // 公司名称,地址,规模
	
	public void setCompanyInfo(String companyInfo) { 
		this.companyInfo = companyInfo;
	}
	
	@Override
	public Company getObject() throws Exception {
		// 模拟创建复杂对象Company
		Company company = new Company();
		String[] strings = companyInfo.split(","); 
		company.setName(strings[0]); 
		company.setAddress(strings[1]); 
		company.setScale(Integer.parseInt(strings[2]));
	    return company;
	}
	
	@Override
	public Class<?> getObjectType() { 
		return Company.class;
	}
	
	@Override
	public boolean isSingleton() {
		return true;
	} 
	
}

<bean id="companyBean" class="com.riemann.factory.CompanyFactoryBean"> 
	<property name="companyInfo" value="腾讯,南山科技园,60000"/>
</bean>

Object companyBean = applicationContext.getBean("companyBean"); System.out.println("bean:" + companyBean);
// 结果如下
bean:Company{name='腾讯', address='南山科技园', scale=60000}

Object companyBean = applicationContext.getBean("&companyBean"); 
System.out.println("bean:" + companyBean);
// 结果如下 
bean:com.riemann.factory.CompanyFactoryBean@53f6fd09

public interface BeanPostProcessor {

	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

@FunctionalInterface
public interface BeanFactoryPostProcessor {

	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

public class RiemannBean implements InitializingBean, ApplicationContextAware {

	private ItBean itBean;

	public void setItBean(ItBean itBean) {
		this.itBean = itBean;
	}

	public RiemannBean() {
		System.out.println("RiemannBean 构造器...");
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("RiemannBean afterPropertiesSet...");
	}

	public void print() {
		System.out.println("RiemannBean print方法业务逻辑执行...");
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		System.out.println("RiemannBean setApplicationContext...");
	}

}

public class MyBeanPostProcessor implements BeanPostProcessor {

	public MyBeanPostProcessor() {
		System.out.println("BeanPostProcessor 实现类构造函数...");
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if("riemannBean".equals(beanName)) {
			System.out.println("BeanPostProcessor 实现类 postProcessBeforeInitialization 方法被调用中...");
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if("riemannBean".equals(beanName)) {
			System.out.println("BeanPostProcessor 实现类 postProcessAfterInitialization 方法被调用中...");
		}
		return bean;
	}

}

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

	public MyBeanFactoryPostProcessor() {
		System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("BeanFactoryPostProcessor的实现方法调用中...");
	}

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="
	    http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
">

	
	<bean id="riemannBean" class="com.riemann.RiemannBean">
		<property name="ItBean" ref="itBean"/>
	</bean>
	<bean id="myBeanFactoryPostProcessor" class="com.riemann.MyBeanFactoryPostProcessor"/>
	<bean id="myBeanPostProcessor" class="com.riemann.MyBeanPostProcessor"/>
	<!--循环依赖问题-->
	<bean id="itBean" class="com.riemann.ItBean">
		<property name="riemannBean" ref="riemannBean"/>
	</bean>

</beans>

public class IocTest {

	/**
	 *  Ioc 容器源码分析基础案例
	 */
	@Test
	public void testIoC() {
		// ApplicationContext是容器的高级接口，BeanFacotry（顶级容器/根容器，规范了/定义了容器的基础行为）
		// Spring应用上下文，官方称之为 IoC容器（错误的认识：容器就是map而已；准确来说，map是ioc容器的一个成员，
		// 叫做单例池, singletonObjects,容器是一组组件和过程的集合，包括BeanFactory、单例池、BeanPostProcessor等以及之间的协作流程）

		/**
		 * Ioc容器创建管理Bean对象的，Spring Bean是有生命周期的
		 * 构造器执行、初始化方法执行、Bean后置处理器的before/after方法：AbstractApplicationContext#refresh#finishBeanFactoryInitialization
		 * Bean工厂后置处理器初始化、方法执行：AbstractApplicationContext#refresh#invokeBeanFactoryPostProcessors
		 * Bean后置处理器初始化：AbstractApplicationContext#refresh#registerBeanPostProcessors
		 */
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		RiemannBean riemannBean = applicationContext.getBean(RiemannBean.class);
		System.out.println(riemannBean);
	}

}

@Override
public void refresh() throws BeansException, IllegalStateException {
	/**
	 * 对象锁加锁
	 */
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		/**
		 * 刷新前的预处理
		 * 表示在真正做refresh操作之前需要准备做的事情：
		 *    设置Spring容器启动时间
		 *    开启活跃状态，撤销关闭状态
		 *    验证环境信息里一些必须存在的属性
		 */
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		/**
		 * 获取BeanFactory：默认实现是DefaultListableBeanFactory
		 * Bean获取并封装成BeanDefinition对象
		 * 加载BeanDefinition 并注册到BeanDefinitionRegistry
		 */
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		/**
		 * 获取BeanFactory的准备工作:BeanFactory进行一些设置，比如context的类加载器等。
		 */
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			/**
			 * BeanFactory准备工作完成后进行的后置处理工作
			 */
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			/**
			 * 实例化实现了BeanFactoryPostProcessor接口的Bean，并调用接口方法
			 */
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			/**
			 * 注册BeanPostProcessor(Bean的后置处理器)，在创建bean的前后等执行
			 */
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			/**
			 * 初始化MessageSource组件(做国际化功能、消息绑定、消息解析)
			 */
			initMessageSource();

			// Initialize event multicaster for this context.
			/**
			 * 初始化事件派发器
			 */
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			/**
			 * 子类重写这个方法,在容器刷新的时候可以自定义逻辑,如创建Tomcat、Jetty等WEB服务器
			 */
			onRefresh();

			// Check for listener beans and register them.
			/**
			 * 注册应用的监听器，就是注册实现了ApplicationListener接口的监听器bean
			 */
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			/**
			 * 初始化所有剩下的非懒加载的单例bean
			 * 初始化创建非懒加载方式的单例Bean实例（未设置属性）
			 * 填充属性
			 * 初始化方法调用（比如调用afterPropertiesSet方法、init-method方法）
			 * 调用BeanPostProcessor(Bean的后置处理器)对实例bean进行后置处理
			 */
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			/**
			 * 完成context的刷新，主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshEvent）
			 */
			finishRefresh();
		}

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

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}