obtainFreshBeanFactory()；

整体obtainFreshBeanFactory内部实现

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}

refreshBeanFactory();

// 关闭先前的bean工厂（如果有的话）
// 并为上下文周期的下一阶段初始化一个新的bean工厂
@Override
protected final void refreshBeanFactory() throws BeansException {
	if (hasBeanFactory()) {
	    destroyBeans();
		closeBeanFactory();
	}
	try {
	    DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		customizeBeanFactory(beanFactory);
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean "+
		  "definition source for " + getDisplayName(), ex);
	}
}

hasBeanFactory()

// 内部beanFactory的同步监视器
private final Object beanFactoryMonitor = new Object();
// 此 上下文的Bean工厂
private DefaultListableBeanFactory beanFactory;

// 此上下文是否持有一个bean factory
// 即 至少被使用一次且没有被关闭
protected final boolean hasBeanFactory() {
	synchronized (this.beanFactoryMonitor) {
		return (this.beanFactory != null);
	}
}

createBeanFactory();

// 为此上下文创建一个内部 bean 工厂。 每次refresh()尝试时调用。
// 默认实现创建一个DefaultListableBeanFactory ，
// 并将此上下文父级的内部 bean 工厂作为父 bean 工厂。 
// 可以在子类中覆盖，例如自定义 DefaultListableBeanFactory 的设置。
protected DefaultListableBeanFactory createBeanFactory() {
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

new DefaultListableBeanFactory(getInternalParentBeanFactory());

// 使用给定的父级创建一个新的 AbstractAutowireCapableBeanFactory。
public AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory) {
	this();
	setParentBeanFactory(parentBeanFactory);
}

getInternalParentBeanFactory());的内部实现如下：

// 如果实现了 ConfigurableApplicationContext，则返回父上下文的内部 bean 工厂；
//  否则，返回父上下文本身。
protected BeanFactory getInternalParentBeanFactory() {
  return (getParent() instanceof ConfigurableApplicationContext) ?
    ((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
}

getParent();的内部实现如下：

// Parent context
private ApplicationContext parent;

// 返回父上下文，如果没有父上下文（即此上下文是上下文层次结构的根），
// 则返回null 。
@Override
public ApplicationContext getParent() {
	return this.parent;
}

this();

public AbstractAutowireCapableBeanFactory() {
	super();
	ignoreDependencyInterface(BeanNameAware.class);
	ignoreDependencyInterface(BeanFactoryAware.class);
	ignoreDependencyInterface(BeanClassLoaderAware.class);
}

super();

public AbstractBeanFactory() { }

ignoreDependencyInterface(Class<?> ifc);

// 依赖接口忽略依赖检查和自动装配，默认情况下，仅忽略BeanFactory接口
private final Set<Class<?>> ignoreDependencyInterfaces = 
  new HashSet<Class<?>>();
public void ignoreDependencyInterface(Class<?> ifc) {
    this.ignoredDependencyInterfaces.add(ifc);
}

setParentBeanFactory(parentBeanFactory);

// Parent bean factory, for bean inheritance support.
private BeanFactory parentBeanFactory;

@Override
public void setParentBeanFactory(BeanFactory parentBeanFactory) {
	if (this.parentBeanFactory != null 
	      && this.parentBeanFactory != parentBeanFactory) 
	{
		throw new IllegalStateException("Already associated with parent BeanFactory: " 
		    + this.parentBeanFactory);
	}
	this.parentBeanFactory = parentBeanFactory;
}

beanFactory.setSerializationId(getId());

getId();的具体实现如下：

// 此上下文的唯一id
private String id = ObjectUtils.identityToString(this);

// 返回此应用程序上下文的唯一id
// 如果没有，则返回null
@Override
public String getId() {
	return this.id;
}

setSerializationId(getId());的具体实现如下：

// Map from serialized id to factory instance
private static final 
   Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
	  new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>(8);
	  
// Optional id for this factory, 
// for serialization purposes
private String serializationId;

public void setSerializationId(String serializationId) {
	if (serializationId != null) {
		serializableFactories.put(serializationId,
		   new WeakReference<DefaultListableBeanFactory>(this));
	}
	else if (this.serializationId != null) {
		serializableFactories.remove(this.serializationId);
	}
	this.serializationId = serializationId;
}

customizeBeanFactory(beanFactory);

private Boolean allowBeanDefinitionOverriding;

private Boolean allowCircularReferences;

// 自定义此上下文使用的内部bean工厂，每次refresh时调用
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
	if (this.allowBeanDefinitionOverriding != null) {
	  // 设置是否允许通过注册具有相同名称的不同定义来覆盖 bean 定义，
	  // 自动替换前者。 如果没有，将抛出异常。 这也适用于覆盖别名。
      // Default is "true".
	  beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
	}
	if (this.allowCircularReferences != null) {
	  // 设置是否允许 bean 之间的循环引用 - 并自动尝试解决它们。
      // 请注意，循环引用解析意味着所涉及的 bean 之一将收到对尚未完全初始化
      // 的另一个 bean 的引用。 这可能会导致对初始化的微妙和不那么微妙的副作用；
      // 不过，它确实适用于许多场景。
      // Default is "true". 关闭此选项以在遇到循环引用时抛出异常，完全禁止它们。 
      // 注意：通常建议不要依赖 bean 之间的循环引用。 重构您的应用程序逻辑，
      // 让所涉及的两个 bean 委托给封装其公共逻辑的第三个 bean	      
      beanFactory.setAllowCircularReferences(this.allowCircularReferences);
	}
}

loadBeanDefinitions(beanFactory);

// 通过 XmlBeanDefinitionReader 加载 bean 定义。
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
 throws BeansException, IOException 
{
	// 对于给定的beanFactory创建一个beanDefinitionReader
	XmlBeanDefinitionReader beanDefinitionReader = 
	    new XmlBeanDefinitionReader(beanFactory);

	// 使用此上下文的配置 bean 定义阅读器资源加载环境。
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// 允许子类提供阅读器的自定义初始化，
    // 然后继续实际加载 bean 定义。	
    initBeanDefinitionReader(beanDefinitionReader);
	loadBeanDefinitions(beanDefinitionReader);
}

initBeanDefinitionReader(beanDefinitionReader);

// 初始化用于加载此上下文的 bean 定义的 bean 定义读取器。
// 默认实现为空。
// 可以在子类中覆盖，例如关闭 XML 验证或使用不同的 XmlBeanDefinitionParser 实现。
protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
	reader.setValidating(this.validating);
}

loadBeanDefinitions(beanDefinitionReader);

// 使用给定的 XmlBeanDefinitionReader 加载 bean 定义。
// bean 工厂的生命周期由refreshBeanFactory方法处理； 
// 因此，此方法仅用于加载和/或注册 bean 定义。
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader)
  throws BeansException, IOException
{
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations);
	}
}

getBeanFactory();

// 内部beanFactory的同步监视器
private final Object beanFactoryMonitor = new Object();
// 此上下文的beanFactory
private DefaultListableBeanFactory beanFactory;

// 子类必须在此处返回其内部 bean 工厂。 他们应该有效地实现查找，
// 以便可以重复调用它而不会影响性能。
// 注意：子类在返回内部 bean 工厂之前应该检查上下文是否仍然处于活动状态。 
// 一旦上下文关闭，内部工厂通常应被视为不可用。
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
	synchronized (this.beanFactoryMonitor) {
		if (this.beanFactory == null) {
			throw new IllegalStateException(
			  "BeanFactory not initialized or already closed - " +
				"call 'refresh' before accessing beans via the ApplicationContext");
		}
		return this.beanFactory;
	}
}