前面了解了xmlBeanFactory，那么接下来，我们就去看一下真正常用的类：classPathXmlApplicationContext。
classPathXmlApplicationContext拥有比xmlBeanFactory更多的功能。
ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext("beans.xml");（1）
UserEntity bean = (UserEntity) factory.getBean("user");（2）
//这么简单就获取到了bean。
//下面一段是全局的关键性代码
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//准备刷新上下文环境
prepareRefresh();
//初始化beanFactory，解析xml
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//对beanFactory进行填充
prepareBeanFactory(beanFactory);
try {
//工厂的处理器：空实现
postProcessBeanFactory(beanFactory);
//激活处理器
invokeBeanFactoryPostProcessors(beanFactory);
//注册bean的拦截器
registerBeanPostProcessors(beanFactory);
// 初始化message
initMessageSource();
// 初始化应用消息广播器
initApplicationEventMulticaster();
//留给子类来初始化其他的bean
onRefresh();
//
registerListeners();
//初始化剩下的单例
finishBeanFactoryInitialization(beanFactory);
//完成刷新
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 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();
}
}
}
//以上内容来自书本,等后面我学习完毕以后再回来重新加上自己的认识。经过上面的步骤之后，环境就已经准备好了，那么接下来，我们就每个方法的去看一下。
1.对环境变量，系统变量的验证
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
//空实现，留个子类进行处理（可以自定义逻辑）
initPropertySources();
//对文件进行验证
getEnvironment().validateRequiredProperties();
//目前来说，上面两个方法，对于现在的我来说，认为意义不大。
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}2.加载beanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//核心加载beanFactory
refreshBeanFactory();
//就是getter（）方法
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
protected final void refreshBeanFactory() throws BeansException {
//判断是否存在BeanFactory，如果再次加载，就应该摧毁之前的BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//生成beanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
//设置序列化id：遗留
beanFactory.setSerializationId(getId());
//定制化beanFactory，例如，你可以强制不允许循环依赖，不允许覆盖bean
customizeBeanFactory(beanFactory);
//初始化Document，BeanDefinitionReader（就是对xml进行解析）
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
//是否允许覆盖同名称的不同定义的对象
if (this.allowBeanDefinitionOverriding != null) {
beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
//是否允许循环依赖
if (this.allowCircularReferences != null) {
beanFactory.setAllowCircularReferences(this.allowCircularReferences);
}
}
3.对于BeanFactory的拓展
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//设置classLoader
beanFactory.setBeanClassLoader(getClassLoader());
//对于表达式（SpEL）的拓展：例如写的：#{xx.xx}等等
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//属性注册器：例如 Date类型，你不能简单注入，需要通过编辑器进行转换。
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
//bean初始化的前后置处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//工厂的处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
剩下的以后再补充