目录
1、ConfigurableApplicationContext
3、AbstractRefreshableApplicationContext
之前已经分析过Spring中不会直接使用BeanFactory(或者DefaultListableBeanFactory),而是使用ApplicationContext作为扩展容器。主要的实现是AbstractApplicationContext中的模板方法refresh方法,而不同的ApplicationContext子类实现不同的模板方法的步骤。
一、ApplicationContext
先看看接口定义:
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory,
HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher,
ResourcePatternResolver {
@Nullable
String getId();
String getApplicationName();
String getDisplayName();
long getStartupDate();
@Nullable
ApplicationContext getParent();
AutowireCapableBeanFactory getAutowireCapableBeanFactory()
throws IllegalStateException;
}
1、接口方法
定义了每一个ApplicationContext都有一个id,一个名称,显示名称,启动时间,父容器,已经BeanFactory(也就是ApplicationContext与BeanFactory的关系)。
2、实现接口
1)、EnvironmentCapable
Environment getEnvironment();
只有一个接口,定义了ApplicationContext启动时的环境。
2)、ListableBeanFactory
之前分析过,定义了BeanDefinition的相关接口。BeanFactory的实现类是DefaultListableBeanFactory,这里真正调用的也是里面的实现方法。
3)、HierarchicalBeanFactory
之前分析过,定义的是父子类的接口。BeanFactory的实现类是AbstractBeanFactory,同样是调用该方法实现。
4)、MessageSource
定义国际化相关的东西,根据不同的Locale获取不同的信息,回头可以专门分析该部分。
5)、ApplicationEventPublisher
观察者模式的事件发生机制,详细可以参见:Spring源码-事件监听机制(实现EventListener接口)。
6)、ResourcePatternResolver
public interface ResourcePatternResolver extends ResourceLoader {
String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
Resource[] getResources(String locationPattern) throws IOException;
}
再看看ResourceLoader
public interface ResourceLoader {
/** Pseudo URL prefix for loading from the class path: "classpath:". */
String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;
Resource getResource(String location);
@Nullable
ClassLoader getClassLoader();
}
比较清楚了,加载Spring Resource。只是先说明一下,CLASSPATH_URL_PREFIX 为classpath:.,加载的是classpath下所有的资源,而CLASSPATH_ALL_URL_PREFIX 为classpath*:加载包含了所有jar包下的resources下(classpath)的资源。
二、ApplicationContext主要实现类
之前用的比价多的是ClassPathXmlApplicationContext和AnnotationConfigWebApplicationContext;SpringBoot之后根据初始化时不同的webApplicationType类型,初始化为AnnotationConfigApplicationContext或AnnotationConfigServletWebServerApplicationContext或AnnotationConfigReactiveWebServerApplicationContext类型。
实现类非常的多,但是都会发现主要是AbstractApplicationContext的子类,并且模板方法refresh在该类中定义,所以需要分析ConfigurableApplicationContext接口和AbstractApplicationContext抽象类,之前的版本还需要看看AbstractRefreshableApplicationContext,spring Boot相关版本还需要看看GenericApplicationContext。
1、ConfigurableApplicationContext
public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
String CONFIG_LOCATION_DELIMITERS = ",; \t\n";
String CONVERSION_SERVICE_BEAN_NAME = "conversionService";
String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver";
String ENVIRONMENT_BEAN_NAME = "environment";
String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";
String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";
String SHUTDOWN_HOOK_THREAD_NAME = "SpringContextShutdownHook";
void setId(String id);
void setParent(@Nullable ApplicationContext parent);
void setEnvironment(ConfigurableEnvironment environment);
@Override
ConfigurableEnvironment getEnvironment();
void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);
void addApplicationListener(ApplicationListener<?> listener);
void addProtocolResolver(ProtocolResolver resolver);
void refresh() throws BeansException, IllegalStateException;
void registerShutdownHook();
@Override
void close();
boolean isActive();
/**
* @see #isActive()
* @see #refresh()
* @see #close()
* @see #addBeanFactoryPostProcessor
*/
ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
}
1)、Lifecycle
实现了Lifecycle接口,也就是Spring容器的生命周期,比较简单的生命周期(启动,停止、是否在运行中)看一下接口
public interface Lifecycle {
void start();
void stop();
boolean isRunning();
}
只要是看看其实现接口(又增加了两个接口,正在调用refresh方法相关)和类:
public interface LifecycleProcessor extends Lifecycle {
void onRefresh();
void onClose();
}
public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactoryAware {
private final Log logger = LogFactory.getLog(getClass());
private volatile long timeoutPerShutdownPhase = 30000;
private volatile boolean running;
@Nullable
private volatile ConfigurableListableBeanFactory;
// 省略其他的实现,在其他专门进行分析
}
2、AbstractApplicationContext
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
/**
* Name of the MessageSource bean in the factory.
* If none is supplied, message resolution is delegated to the parent.
* @see MessageSource
*/
public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
/**
* Name of the LifecycleProcessor bean in the factory.
* If none is supplied, a DefaultLifecycleProcessor is used.
* @see org.springframework.context.LifecycleProcessor
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
/**
* Name of the ApplicationEventMulticaster bean in the factory.
* If none is supplied, a default SimpleApplicationEventMulticaster is used.
* @see org.springframework.context.event.ApplicationEventMulticaster
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
static {
// Eagerly load the ContextClosedEvent class to avoid weird classloader issues
// on application shutdown in WebLogic 8.1. (Reported by Dustin Woods.)
ContextClosedEvent.class.getName();
}
/** Logger used by this class. Available to subclasses. */
protected final Log logger = LogFactory.getLog(getClass());
/** Unique id for this context, if any. */
private String id = ObjectUtils.identityToString(this);
/** Display name. */
private String displayName = ObjectUtils.identityToString(this);
/** Parent context. */
@Nullable
private ApplicationContext parent;
/** Environment used by this context. */
@Nullable
private ConfigurableEnvironment environment;
/** BeanFactoryPostProcessors to apply on refresh. */
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();
/** System time in milliseconds when this context started. */
private long startupDate;
/** Flag that indicates whether this context is currently active. */
private final AtomicBoolean active = new AtomicBoolean();
/** Flag that indicates whether this context has been closed already. */
private final AtomicBoolean closed = new AtomicBoolean();
/** Synchronization monitor for the "refresh" and "destroy". */
private final Object startupShutdownMonitor = new Object();
/** Reference to the JVM shutdown hook, if registered. */
@Nullable
private Thread shutdownHook;
/** ResourcePatternResolver used by this context. */
private ResourcePatternResolver resourcePatternResolver;
/** LifecycleProcessor 管理bean的生命周期的容器 */
@Nullable
private LifecycleProcessor lifecycleProcessor;
/** 委派我们自定义实现的 国际化MessageSource */
@Nullable
private MessageSource messageSource;
/** 事件发送器,默认初始化为 SimpleApplicationEventMulticaster 类型 */
@Nullable
private ApplicationEventMulticaster applicationEventMulticaster;
/** 静态指定的监听器 */
private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
/** Local listeners registered before refresh.(refresh之前就已经注册的) */
@Nullable
private Set<ApplicationListener<?>> earlyApplicationListeners;
// 早期的事件发生,与生命周期相关的;不是我们自定义的事件
@Nullable
private Set<ApplicationEvent> earlyApplicationEvents;
}
AbstractApplicationContext实现了接口ConfigurableApplicationContext的所有定义的接口方法,并且集成自DefaultResourceLoader上面分析过其父类ResourceLoader,当前是对上面的实现。
public class DefaultResourceLoader implements ResourceLoader {
@Nullable
private ClassLoader classLoader;
// 定义的长度为4,所以基本上后面会往里加入的数量基本定了
private final Set<ProtocolResolver> protocolResolvers = new LinkedHashSet<>(4);
private final Map<Class<?>, Map<Resource, ?>> resourceCaches = new ConcurrentHashMap<>(4);
// 无参数构造,直接调用 Thread.currentThread().getContextClassLoader()
public DefaultResourceLoader() {
this.classLoader = ClassUtils.getDefaultClassLoader();
}
}
3、AbstractRefreshableApplicationContext
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
@Nullable
private Boolean allowBeanDefinitionOverriding;
@Nullable
private Boolean allowCircularReferences;
/**
* Bean factory for this context.
*/
@Nullable
private DefaultListableBeanFactory beanFactory;
/**
* Synchronization monitor for the internal BeanFactory.
*/
private final Object beanFactoryMonitor = new Object();
}
定义了是否覆盖BeanDefinition,以及是否支持循环依赖。
4、GenericApplicationContext
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
private final DefaultListableBeanFactory beanFactory;
@Nullable
private ResourceLoader resourceLoader;
private boolean customClassLoader = false;
private final AtomicBoolean refreshed = new AtomicBoolean();
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
}
实现了BeanDefinitionRegistry接口,则子类又拥有了BeanDefinition相关的功能。