public AbstractRefreshableApplicationContext() 
{

}

Create a new AbstractRefreshableApplicationContext with no parent.

 public AbstractRefreshableApplicationContext(ApplicationContext parent) 
{
		super(parent);
}

Create a new AbstractRefreshableApplicationContext with the given parent context.

Parameters:

parent - the parent context

 protected final  void closeBeanFactory() 
{
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = null;
		}
}

 protected DefaultListableBeanFactory createBeanFactory() 
{
		return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

Create an internal bean factory for this context. Called for each #refresh() attempt.

The default implementation creates a org.springframework.beans.factory.support.DefaultListableBeanFactory with the internal bean factory of this context's parent as parent bean factory. Can be overridden in subclasses, for example to customize DefaultListableBeanFactory's settings.

 protected  void customizeBeanFactory(DefaultListableBeanFactory beanFactory) 
{
		if (this.allowBeanDefinitionOverriding != null) {
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding.booleanValue());
		}
		if (this.allowCircularReferences != null) {
			beanFactory.setAllowCircularReferences(this.allowCircularReferences.booleanValue());
		}
}

Customize the internal bean factory used by this context. Called for each #refresh() attempt.

The default implementation applies this context's "allowBeanDefinitionOverriding" and "allowCircularReferences" settings, if specified. Can be overridden in subclasses to customize any of DefaultListableBeanFactory 's settings.

 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;
		}
}

 protected final boolean hasBeanFactory() 
{
		synchronized (this.beanFactoryMonitor) {
			return (this.beanFactory != null);
		}
}

Determine whether this context currently holds a bean factory, i.e. has been refreshed at least once and not been closed yet.

 abstract protected  void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException, BeansException
Load bean definitions into the given bean factory, typically through
delegating to one or more bean definition readers.

 protected final  void refreshBeanFactory() throws BeansException 
{
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			customizeBeanFactory(beanFactory);
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException(
					"I/O error parsing XML document for application context [" + getDisplayName() + "]", ex);
		}
}

This implementation performs an actual refresh of this context's underlying bean factory, shutting down the previous bean factory (if any) and initializing a fresh bean factory for the next phase of the context's lifecycle.

 public  void setAllowBeanDefinitionOverriding(boolean allowBeanDefinitionOverriding) 
{
		this.allowBeanDefinitionOverriding = Boolean.valueOf(allowBeanDefinitionOverriding);
}

Set whether it should be allowed to override bean definitions by registering a different definition with the same name, automatically replacing the former. If not, an exception will be thrown. Default is "true".

 public  void setAllowCircularReferences(boolean allowCircularReferences) 
{
		this.allowCircularReferences = Boolean.valueOf(allowCircularReferences);
}

Set whether to allow circular references between beans - and automatically try to resolve them.

Default is "true". Turn this off to throw an exception when encountering a circular reference, disallowing them completely.