1.前言
手写ClassPathXmlApplicationContext
在没手写一遍之前,看了十多次ClassPathXmlApplicationContext创建Bean过程,刚开始学习Spring在没有引导的情况下,虽然有收获,抓不住Spring核心,建议初学spring最好手写一遍,了解每个类、接口负责什么功能
由于Spring类较多,只列举个人认为关键部分,具体细节需要自己体会
代码
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
Person person = (Person) ctx.getBean("person");
xml配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="person" class="domain.Person">
<property name="name" value="wangwu"></property>
<property name="age" value="18"></property>
</bean>
<bean id="person1" class="domain.Person">
<property name="name" value="list"></property>
<property name="age" value="20"></property>
</bean>
</beans>
分为两个阶段 :
- 1.读取配置到注册表
- ApplicationContext ctx = new ClassPathXmlApplicationContext(“/applicationContext.xml”)
- 2.根据注册表反射创建bean
- Person person = (Person) ctx.getBean(“person”);
2. 源码阅读
debug很快进来最关键的部分AbstractApplicationContext中的refresh()方法
2.1.refresh()方法
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 准备此上下文以进行刷新。
//锁,日志,存储刷新前的ApplicationListeners
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
//告诉子类刷新内部bean工厂。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 准备bean工厂以便在此上下文中使用。
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 允许在上下文子类中对bean工厂进行后处理。
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 调用在上下文中注册为bean的工厂处理器。
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 注册拦截bean创建的bean处理器。
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 初始化此上下文的消息源。
initMessageSource();
// Initialize event multicaster for this context.
// 为此上下文初始化事件多播。
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 初始化特定上下文子类中的其他特殊bean。
onRefresh();
// Check for listener beans and register them.
// 检查侦听器bean并注册它们。
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化所有剩余的(不是懒汉式加载)单例。
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 最后一步:发布相应的事件。
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
// 重置Spring核心中的常用自检缓存,因为我们
// might not ever need metadata for singleton beans anymore...
// 可能不再需要单例bean的元数据。。。
resetCommonCaches();
}
}
}
2.1.1 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext{
/**
* 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.
*
* 此实现执行此上下文底层的实际刷新
* bean工厂,关闭前一个bean工厂(如果有的话),并为上下文生命周期的下一阶段初始化新的bean工厂
*
*/
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
//加载配置xml
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
}
debugger细心可以发现
可以看到loadBeanDefinitions(beanFactory);加载配置到注册表当中,可以深入研究是如何加载配置的
2.1.2 XmlBeanDefinitionReader具体的读取配置类流
因为配置可以有yml、xml等多种形式
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
2.1.3 DefaultBeanDefinitionDocumentReader
作用读取具体的bean定义,常量分别为import、alias、bean、beans
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
2.1.4 DefaultListableBeanFactory
DefaultListableBeanFactory 里面存放注册好的bean配置
DefaultListableBeanFactory
{
/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
}
registerBeanDefinition 方法中将读取到的配置放入注册表
可以发现类
this.beanDefinitionMap.put(beanName, beanDefinition);
根据这个方法可以发现springboot用于读取配置的实体类
2.2 创建bean
2.2.1 AbstractBeanFactory
AbstractBeanFactory.doGetBean方法负责反射创建bean
其中一段代码检查bean依赖的bean优先创建
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
2.2.2 AbstractAutowireCapableBeanFactory
/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}