Spring源码学习--AbstractApplicationContext（八）

不念不忘少年蓝@ 2022-09-27 06:26 235阅读 0赞

ApplicationContext体系：

![Image 1][]

AbstractApplicationContext是Spring应用上下文中最重要的一个类，这个抽象类中提供了几乎ApplicationContext的所有操作。主要有容器工厂的处理，事件的发送广播，监听器添加，容器初始化操作refresh方法，然后就是bean的生成获取方法接口等。主要还是提供了一些方法，复杂的操作也是没有太多。

我们就不详细分析源码了，源码如下：

/**
     * 具有较多实现操作的类，
     */
    public abstract class AbstractApplicationContext extends DefaultResourceLoader
    		implements ConfigurableApplicationContext, DisposableBean {
    
    	
    	public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
    
    	
    	public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
    
    	
    	public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
    
    
    	static {
    		
    		ContextClosedEvent.class.getName();
    	}
    
    
    
    	protected final Log logger = LogFactory.getLog(getClass());
    
    	private String id = ObjectUtils.identityToString(this);
    
    	private String displayName = ObjectUtils.identityToString(this);
    
    	private ApplicationContext parent;
    
    	private ConfigurableEnvironment environment;
    
    	private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors =
    			new ArrayList<BeanFactoryPostProcessor>();
    
    	private long startupDate;
    
    	private final AtomicBoolean active = new AtomicBoolean();
    
    	private final AtomicBoolean closed = new AtomicBoolean();
    
    	private final Object startupShutdownMonitor = new Object();
    
    	private Thread shutdownHook;
    
    	private ResourcePatternResolver resourcePatternResolver;
    
    	private LifecycleProcessor lifecycleProcessor;
    
    	private MessageSource messageSource;
    
    	private ApplicationEventMulticaster applicationEventMulticaster;
    
    	private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<ApplicationListener<?>>();
    
    	private Set<ApplicationEvent> earlyApplicationEvents;
    
    	public AbstractApplicationContext() {
    		this.resourcePatternResolver = getResourcePatternResolver();
    	}
    
    	public AbstractApplicationContext(ApplicationContext parent) {
    		this();
    		setParent(parent);
    	}
    
    	
    	@Override
    	public void setId(String id) {
    		this.id = id;
    	}
    
    	@Override
    	public String getId() {
    		return this.id;
    	}
    
    	@Override
    	public String getApplicationName() {
    		return "";
    	}
    
    	public void setDisplayName(String displayName) {
    		Assert.hasLength(displayName, "Display name must not be empty");
    		this.displayName = displayName;
    	}
    
    	@Override
    	public String getDisplayName() {
    		return this.displayName;
    	}
    
    	@Override
    	public ApplicationContext getParent() {
    		return this.parent;
    	}
    
    
    	@Override
    	public ConfigurableEnvironment getEnvironment() {
    		if (this.environment == null) {
    			this.environment = createEnvironment();
    		}
    		return this.environment;
    	}
    
    
    	@Override
    	public void setEnvironment(ConfigurableEnvironment environment) {
    		this.environment = environment;
    	}
    
    	//获取工厂
    	@Override
    	public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
    		return getBeanFactory();
    	}
    
    	@Override
    	public long getStartupDate() {
    		return this.startupDate;
    	}
    
    	//发送事件
    	@Override
    	public void publishEvent(ApplicationEvent event) {
    		publishEvent(event, null);
    	}
    	//发送事件
    	@Override
    	public void publishEvent(Object event) {
    		publishEvent(event, null);
    	}
    		
    	//广播事件
    	protected void publishEvent(Object event, ResolvableType eventType) {
    		Assert.notNull(event, "Event must not be null");
    		if (logger.isTraceEnabled()) {
    			logger.trace("Publishing event in " + getDisplayName() + ": " + event);
    		}
    
    		// Decorate event as an ApplicationEvent if necessary
    		ApplicationEvent applicationEvent;
    		if (event instanceof ApplicationEvent) {
    			applicationEvent = (ApplicationEvent) event;
    		}
    		else {
    			applicationEvent = new PayloadApplicationEvent<Object>(this, event);
    			if (eventType == null) {
    				eventType = ResolvableType.forClassWithGenerics(PayloadApplicationEvent.class, event.getClass());
    			}
    		}
    
    		// Multicast right now if possible - or lazily once the multicaster is initialized
    		if (this.earlyApplicationEvents != null) {
    			this.earlyApplicationEvents.add(applicationEvent);
    		}
    		else {
    			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    		}
    
    		// Publish event via parent context as well...
    		if (this.parent != null) {
    			if (this.parent instanceof AbstractApplicationContext) {
    				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
    			}
    			else {
    				this.parent.publishEvent(event);
    			}
    		}
    	}
    
    	ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
    		if (this.applicationEventMulticaster == null) {
    			throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +
    					"call 'refresh' before multicasting events via the context: " + this);
    		}
    		return this.applicationEventMulticaster;
    	}
    
    	LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
    		if (this.lifecycleProcessor == null) {
    			throw new IllegalStateException("LifecycleProcessor not initialized - " +
    					"call 'refresh' before invoking lifecycle methods via the context: " + this);
    		}
    		return this.lifecycleProcessor;
    	}
    	
    	protected ResourcePatternResolver getResourcePatternResolver() {
    		return new PathMatchingResourcePatternResolver(this);
    	}
    
    	@Override
    	public void setParent(ApplicationContext parent) {
    		this.parent = parent;
    		if (parent != null) {
    			Environment parentEnvironment = parent.getEnvironment();
    			if (parentEnvironment instanceof ConfigurableEnvironment) {
    				getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
    			}
    		}
    	}
    
    	@Override
    	public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor beanFactoryPostProcessor) {
    		this.beanFactoryPostProcessors.add(beanFactoryPostProcessor);
    	}
    
    	public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
    		return this.beanFactoryPostProcessors;
    	}
    
    	//添加监听器
    	@Override
    	public void addApplicationListener(ApplicationListener<?> listener) {
    		if (this.applicationEventMulticaster != null) {
    			this.applicationEventMulticaster.addApplicationListener(listener);
    		}
    		else {
    			this.applicationListeners.add(listener);
    		}
    	}
    
    	public Collection<ApplicationListener<?>> getApplicationListeners() {
    		return this.applicationListeners;
    	}
    
    	protected ConfigurableEnvironment createEnvironment() {
    		return new StandardEnvironment();
    	}
    
    	@Override
    	public void refresh() throws BeansException, IllegalStateException {
    		synchronized (this.startupShutdownMonitor) {
    			//调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识 
    			prepareRefresh();
    
    			//告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入从  
    6           //子类的refreshBeanFactory()方法启动  
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			//为BeanFactory配置容器特性，例如类加载器、事件处理器等 
    			prepareBeanFactory(beanFactory);
    
    			try {
    				//为容器的某些子类指定特殊的BeanPost事件处理器 
    				postProcessBeanFactory(beanFactory);
    
    				//调用所有注册的BeanFactoryPostProcessor的Bean  
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				//为BeanFactory注册BeanPost事件处理器.  
    16              //BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件
    				registerBeanPostProcessors(beanFactory);
    
    				//初始化信息源，和国际化相关.  
    				initMessageSource();
    
    				//初始化容器事件传播器.  
    				initApplicationEventMulticaster();
    
    				//调用子类的某些特殊Bean初始化方法
    				onRefresh();
    
    				//为事件传播器注册事件监听器.  
    				registerListeners();
    
    				 //初始化所有剩余的单态Bean.  
    				finishBeanFactoryInitialization(beanFactory);
    
    				//初始化容器的生命周期事件处理器，并发布容器的生命周期事件  
    				finishRefresh();
    			}
    
    			catch (BeansException ex) {
    				if (logger.isWarnEnabled()) {
    					logger.warn("Exception encountered during context initialization - " +
    							"cancelling refresh attempt: " + ex);
    				}
    
    				//销毁以创建的单态Bean  
    				destroyBeans();
    
    				//取消refresh操作，重置容器的同步标识. 
    				cancelRefresh(ex);
    
    				// Propagate exception to caller.
    				throw ex;
    			}
    
    			finally {
    				
    				resetCommonCaches();
    			}
    		}
    	}
    
    	
    	protected void prepareRefresh() {
    		this.startupDate = System.currentTimeMillis();
    		this.closed.set(false);
    		this.active.set(true);
    
    		if (logger.isInfoEnabled()) {
    			logger.info("Refreshing " + this);
    		}
    
    		// Initialize any placeholder property sources in the context environment
    		initPropertySources();
    
    		// Validate that all properties marked as required are resolvable
    		// see ConfigurablePropertyResolver#setRequiredProperties
    		getEnvironment().validateRequiredProperties();
    
    		// Allow for the collection of early ApplicationEvents,
    		// to be published once the multicaster is available...
    		this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
    	}
    
    	
    	protected void initPropertySources() {
    		// For subclasses: do nothing by default.
    	}
    
    	
    	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    		//这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory()方法，具体实现调用子类容器的refreshBeanFactory()方法
    		//这里会调用子类的refreshBeanFactory方法，其实就是创建BeanFactory，这里就包含很多操作，包括xml文件的解析，bean注入，以及beanFactory的生成
    		refreshBeanFactory();
    		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    		if (logger.isDebugEnabled()) {
    			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    		}
    		return beanFactory;
    	}
    
    	
    	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    		// Tell the internal bean factory to use the context's class loader etc.
    		beanFactory.setBeanClassLoader(getClassLoader());
    		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
    		// Configure the bean factory with context callbacks.
    		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    		beanFactory.ignoreDependencyInterface(EnvironmentAware.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);
    
    		// 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());
    		}
    	}
    
    	
    	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    	}
    
    	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    	}
    
    	
    	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    	}
    
    	protected void initMessageSource() {
    		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
    			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
    			// Make MessageSource aware of parent MessageSource.
    			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
    				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
    				if (hms.getParentMessageSource() == null) {
    					// Only set parent context as parent MessageSource if no parent MessageSource
    					// registered already.
    					hms.setParentMessageSource(getInternalParentMessageSource());
    				}
    			}
    			if (logger.isDebugEnabled()) {
    				logger.debug("Using MessageSource [" + this.messageSource + "]");
    			}
    		}
    		else {
    			// Use empty MessageSource to be able to accept getMessage calls.
    			DelegatingMessageSource dms = new DelegatingMessageSource();
    			dms.setParentMessageSource(getInternalParentMessageSource());
    			this.messageSource = dms;
    			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    			if (logger.isDebugEnabled()) {
    				logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
    						"': using default [" + this.messageSource + "]");
    			}
    		}
    	}
    
    	protected void initApplicationEventMulticaster() {
    		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
    			this.applicationEventMulticaster =
    					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    			if (logger.isDebugEnabled()) {
    				logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
    			}
    		}
    		else {
    			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
    			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    			if (logger.isDebugEnabled()) {
    				logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
    						APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
    						"': using default [" + this.applicationEventMulticaster + "]");
    			}
    		}
    	}
    	
    	protected void initLifecycleProcessor() {
    		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    		if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
    			this.lifecycleProcessor =
    					beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
    			if (logger.isDebugEnabled()) {
    				logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
    			}
    		}
    		else {
    			DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
    			defaultProcessor.setBeanFactory(beanFactory);
    			this.lifecycleProcessor = defaultProcessor;
    			beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
    			if (logger.isDebugEnabled()) {
    				logger.debug("Unable to locate LifecycleProcessor with name '" +
    						LIFECYCLE_PROCESSOR_BEAN_NAME +
    						"': using default [" + this.lifecycleProcessor + "]");
    			}
    		}
    	}
    	
    	protected void onRefresh() throws BeansException {
    		// For subclasses: do nothing by default.
    	}
    
    	protected void registerListeners() {
    		// Register statically specified listeners first.
    		for (ApplicationListener<?> listener : getApplicationListeners()) {
    			getApplicationEventMulticaster().addApplicationListener(listener);
    		}
    
    		// Do not initialize FactoryBeans here: We need to leave all regular beans
    		// uninitialized to let post-processors apply to them!
    		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    		for (String listenerBeanName : listenerBeanNames) {
    			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    		}
    
    		// Publish early application events now that we finally have a multicaster...
    		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    		this.earlyApplicationEvents = null;
    		if (earlyEventsToProcess != null) {
    			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
    				getApplicationEventMulticaster().multicastEvent(earlyEvent);
    			}
    		}
    	}
    
    	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    		// Initialize conversion service for this context.
    		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
    			beanFactory.setConversionService(
    					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    		}
    
    		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    		for (String weaverAwareName : weaverAwareNames) {
    			getBean(weaverAwareName);
    		}
    
    		// Stop using the temporary ClassLoader for type matching.
    		beanFactory.setTempClassLoader(null);
    
    		// Allow for caching all bean definition metadata, not expecting further changes.
    		beanFactory.freezeConfiguration();
    
    		// Instantiate all remaining (non-lazy-init) singletons.
    		beanFactory.preInstantiateSingletons();
    	}
    
    	protected void finishRefresh() {
    		// Initialize lifecycle processor for this context.
    		initLifecycleProcessor();
    
    		// Propagate refresh to lifecycle processor first.
    		getLifecycleProcessor().onRefresh();
    
    		// Publish the final event.
    		publishEvent(new ContextRefreshedEvent(this));
    
    		// Participate in LiveBeansView MBean, if active.
    		LiveBeansView.registerApplicationContext(this);
    	}
    
    	protected void cancelRefresh(BeansException ex) {
    		this.active.set(false);
    	}
    
    	protected void resetCommonCaches() {
    		ReflectionUtils.clearCache();
    		ResolvableType.clearCache();
    		CachedIntrospectionResults.clearClassLoader(getClassLoader());
    	}
    
    	@Override
    	public void registerShutdownHook() {
    		if (this.shutdownHook == null) {
    			// No shutdown hook registered yet.
    			this.shutdownHook = new Thread() {
    				@Override
    				public void run() {
    					synchronized (startupShutdownMonitor) {
    						doClose();
    					}
    				}
    			};
    			Runtime.getRuntime().addShutdownHook(this.shutdownHook);
    		}
    	}
    
    	@Override
    	public void destroy() {
    		close();
    	}
    
    	@Override
    	public void close() {
    		synchronized (this.startupShutdownMonitor) {
    			doClose();
    			// If we registered a JVM shutdown hook, we don't need it anymore now:
    			// We've already explicitly closed the context.
    			if (this.shutdownHook != null) {
    				try {
    					Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
    				}
    				catch (IllegalStateException ex) {
    					// ignore - VM is already shutting down
    				}
    			}
    		}
    	}
    
    	protected void doClose() {
    		if (this.active.get() && this.closed.compareAndSet(false, true)) {
    			if (logger.isInfoEnabled()) {
    				logger.info("Closing " + this);
    			}
    
    			LiveBeansView.unregisterApplicationContext(this);
    
    			try {
    				// Publish shutdown event.
    				publishEvent(new ContextClosedEvent(this));
    			}
    			catch (Throwable ex) {
    				logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
    			}
    
    			// Stop all Lifecycle beans, to avoid delays during individual destruction.
    			try {
    				getLifecycleProcessor().onClose();
    			}
    			catch (Throwable ex) {
    				logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
    			}
    
    			// Destroy all cached singletons in the context's BeanFactory.
    			destroyBeans();
    
    			// Close the state of this context itself.
    			closeBeanFactory();
    
    			// Let subclasses do some final clean-up if they wish...
    			onClose();
    
    			this.active.set(false);
    		}
    	}
    
    	
    	protected void destroyBeans() {
    		getBeanFactory().destroySingletons();
    	}
    
    	protected void onClose() {
    		// For subclasses: do nothing by default.
    	}
    
    	@Override
    	public boolean isActive() {
    		return this.active.get();
    	}
    
    	protected void assertBeanFactoryActive() {
    		if (!this.active.get()) {
    			if (this.closed.get()) {
    				throw new IllegalStateException(getDisplayName() + " has been closed already");
    			}
    			else {
    				throw new IllegalStateException(getDisplayName() + " has not been refreshed yet");
    			}
    		}
    	}
    
    	@Override
    	public Object getBean(String name) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(name);
    	}
    
    	@Override
    	public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(name, requiredType);
    	}
    
    	@Override
    	public <T> T getBean(Class<T> requiredType) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(requiredType);
    	}
    
    	@Override
    	public Object getBean(String name, Object... args) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(name, args);
    	}
    
    	@Override
    	public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(requiredType, args);
    	}
    
    	@Override
    	public boolean containsBean(String name) {
    		return getBeanFactory().containsBean(name);
    	}
    
    	@Override
    	public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
    		assertBeanFactoryActive();
    		return getBeanFactory().isSingleton(name);
    	}
    
    	@Override
    	public boolean isPrototype(String name) throws NoSuchBeanDefinitionException {
    		assertBeanFactoryActive();
    		return getBeanFactory().isPrototype(name);
    	}
    
    	@Override
    	public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
    		assertBeanFactoryActive();
    		return getBeanFactory().isTypeMatch(name, typeToMatch);
    	}
    
    	@Override
    	public boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException {
    		assertBeanFactoryActive();
    		return getBeanFactory().isTypeMatch(name, typeToMatch);
    	}
    
    	@Override
    	public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getType(name);
    	}
    
    	@Override
    	public String[] getAliases(String name) {
    		return getBeanFactory().getAliases(name);
    	}
    
    
    	//---------------------------------------------------------------------
    	// Implementation of ListableBeanFactory interface
    	//---------------------------------------------------------------------
    
    	@Override
    	public boolean containsBeanDefinition(String beanName) {
    		return getBeanFactory().containsBeanDefinition(beanName);
    	}
    
    	@Override
    	public int getBeanDefinitionCount() {
    		return getBeanFactory().getBeanDefinitionCount();
    	}
    
    	@Override
    	public String[] getBeanDefinitionNames() {
    		return getBeanFactory().getBeanDefinitionNames();
    	}
    
    	@Override
    	public String[] getBeanNamesForType(ResolvableType type) {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBeanNamesForType(type);
    	}
    
    	@Override
    	public String[] getBeanNamesForType(Class<?> type) {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBeanNamesForType(type);
    	}
    
    	@Override
    	public String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
    	}
    
    	@Override
    	public <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBeansOfType(type);
    	}
    
    	@Override
    	public <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
    			throws BeansException {
    
    		assertBeanFactoryActive();
    		return getBeanFactory().getBeansOfType(type, includeNonSingletons, allowEagerInit);
    	}
    
    	@Override
    	public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBeanNamesForAnnotation(annotationType);
    	}
    
    	@Override
    	public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
    			throws BeansException {
    
    		assertBeanFactoryActive();
    		return getBeanFactory().getBeansWithAnnotation(annotationType);
    	}
    
    	@Override
    	public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
    			throws NoSuchBeanDefinitionException{
    
    		assertBeanFactoryActive();
    		return getBeanFactory().findAnnotationOnBean(beanName, annotationType);
    	}
    
    
    	//---------------------------------------------------------------------
    	// Implementation of HierarchicalBeanFactory interface
    	//---------------------------------------------------------------------
    
    	@Override
    	public BeanFactory getParentBeanFactory() {
    		return getParent();
    	}
    
    	@Override
    	public boolean containsLocalBean(String name) {
    		return getBeanFactory().containsLocalBean(name);
    	}
    	
    	protected BeanFactory getInternalParentBeanFactory() {
    		return (getParent() instanceof ConfigurableApplicationContext) ?
    				((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
    	}
    
    	@Override
    	public String getMessage(String code, Object args[], String defaultMessage, Locale locale) {
    		return getMessageSource().getMessage(code, args, defaultMessage, locale);
    	}
    
    	@Override
    	public String getMessage(String code, Object args[], Locale locale) throws NoSuchMessageException {
    		return getMessageSource().getMessage(code, args, locale);
    	}
    
    	@Override
    	public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
    		return getMessageSource().getMessage(resolvable, locale);
    	}
    
    	private MessageSource getMessageSource() throws IllegalStateException {
    		if (this.messageSource == null) {
    			throw new IllegalStateException("MessageSource not initialized - " +
    					"call 'refresh' before accessing messages via the context: " + this);
    		}
    		return this.messageSource;
    	}
    
    	protected MessageSource getInternalParentMessageSource() {
    		return (getParent() instanceof AbstractApplicationContext) ?
    			((AbstractApplicationContext) getParent()).messageSource : getParent();
    	}
    
    	@Override
    	public Resource[] getResources(String locationPattern) throws IOException {
    		return this.resourcePatternResolver.getResources(locationPattern);
    	}
    
    	@Override
    	public void start() {
    		getLifecycleProcessor().start();
    		publishEvent(new ContextStartedEvent(this));
    	}
    
    	@Override
    	public void stop() {
    		getLifecycleProcessor().stop();
    		publishEvent(new ContextStoppedEvent(this));
    	}
    
    	@Override
    	public boolean isRunning() {
    		return (this.lifecycleProcessor != null && this.lifecycleProcessor.isRunning());
    	}
    
    
    
    	protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
    
    	protected abstract void closeBeanFactory();
    
    	@Override
    	public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
    
    	@Override
    	public String toString() {
    		StringBuilder sb = new StringBuilder(getDisplayName());
    		sb.append(": startup date [").append(new Date(getStartupDate()));
    		sb.append("]; ");
    		ApplicationContext parent = getParent();
    		if (parent == null) {
    			sb.append("root of context hierarchy");
    		}
    		else {
    			sb.append("parent: ").append(parent.getDisplayName());
    		}
    		return sb.toString();
    	}
    
    }

[Image 1]: