以spring比较新的5.02版本为例，以xml配置的方式来看IOC容器的启动–创建容器–解析xml–向容器注册bean–实例化bean的过程
创建ApplicationContext容器启动刷新方法
ApplicationContext context = new ClassPathXmlApplicationContext("beanLife.xml");
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
super(parent);
this.setConfigLocations(configLocations);
if (refresh) {
this.refresh();
}
}
==> AbstractApplicationContext:
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//1、调用容器准备刷新的方法，获取容器的当时时间，设置容器启动状态
prepareRefresh();
//2、⭐重点：创建默认IOC容器DefaultListableBeanFactory,并加载xml文件，
//解析xml文件，将bean信息装载成BeanDefinition类，并放到beanDefinitionMap和beanDefinitionNames中；
//注意此时bean信息只是注册到容器中了，并没有实例化
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//3、为BeanFactory配置容器特性，例如类加载器、事件处理器等
prepareBeanFactory(beanFactory);
try {
//4、由容器的实现类去扩展，可以添加特殊的BeanPostProcess处理器
postProcessBeanFactory(beanFactory);
//5、调用所有注册的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);
//6、为BeanFactory注册BeanPost事件处理器，添加到容器的beanPostProcessors集合中
//在初始化bean后，会调用beanPostProcessors集合中PostProcessor处理器
registerBeanPostProcessors(beanFactory);
//7、初始化信息源，设置messageSource属性，和国际化相关. 没啥讲的
initMessageSource();
//8、初始化容器事件传播器.设置applicationEventMulticaster属性
initApplicationEventMulticaster();
//9、由子类扩展，调用某些特殊Bean初始化方法
onRefresh();
//10、为事件传播器applicationEventMulticaster注册事件监听器.
registerListeners();
//11、⭐重点：初始化所有注册的Bean
//读取2步中注册到beanDefinitionNames中的Bean，调用doGetBean实例化并对属性赋值，
//赋值过程中也会解决循环依赖的问题；循环依赖有时间可以再写篇文章讲
finishBeanFactoryInitialization(beanFactory);
//12、初始化容器的生命周期事件处理器，并发布ContextRefreshedEvent事件
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.
//13、销毁已创建的Bean
destroyBeans();
//14、取消refresh操作，重置容器的同步标识。
cancelRefresh(ex);
throw ex;
}
finally {
//15、重设公共缓存
resetCommonCaches();
}
}
结合注释，每个方法都跟进去看一遍，就能看懂。
重要的几步，我来跟一下代码，其中为了方便看，我省略一些不重要的过程和代码
⭐⭐⭐⭐⭐⭐
第2步：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
👇
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory()方法，具体实现调用子类容器的refreshBeanFactory()方法
refreshBeanFactory();
...
...
}
👇
protected final void refreshBeanFactory() throws BeansException {
...
try {
//创建DefaultListableBeanFactory IOC容器
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
//对IOC容器进行定制化，如设置启动参数，开启注解的自动装配等
customizeBeanFactory(beanFactory);
//调用载入Bean定义的方法，主要这里又使用了一个委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
...
}
}
👇
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
...
...
//下面就是要读取xml配置文件并且解析bean的过程
loadBeanDefinitions(beanDefinitionReader);
}
👇
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
...
...
try {
//将资源文件转为InputStream的IO流
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
//从InputStream中得到XML的解析源
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//这里是具体的读取过程
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
...
}
}
catch (IOException ex) {
...
}
finally {
...
}
}
👇
protected void doRegisterBeanDefinitions(Element root) {
...
//在解析Bean定义之前，进行自定义的解析，增强解析过程的可扩展性
preProcessXml(root);
//从Document的根元素开始进行Bean定义的Document对象
parseBeanDefinitions(root, this.delegate);
//在解析Bean定义之后，进行自定义的解析，增加解析过程的可扩展性
postProcessXml(root);
this.delegate = parent;
}
👇
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//如果元素节点是<Import>导入元素，进行导入解析
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
//如果元素节点是<Alias>别名元素，进行别名解析
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//⭐解析普通的<Bean>元素
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
👇
//解析Bean定义资源Document对象的普通元素
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//⭐重要：把bean信息解析成BeanDefinition，自己点进去看
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//⭐⭐重要：向Spring IOC容器注册解析得到的Bean定义
//跟进去看，最后是进入DefaultListableBeanFactory,注册到beanDefinitionMaph和beanDefinitionNames中
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
//在完成向Spring IOC容器注册解析得到的Bean定义之后，发送注册事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
到此会把Bean全部解析完并注册完
⭐⭐⭐⭐⭐⭐
第11步 : finishBeanFactoryInitialization(beanFactory);
⭐⭐⭐⭐⭐⭐
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
...
...
//为了类型匹配，停止使用临时的类加载器
beanFactory.setTempClassLoader(null);
//缓存容器中所有注册的BeanDefinition元数据，以防被修改
beanFactory.freezeConfiguration();
//对配置了lazy-init属性的单态模式Bean进行预实例化处理
beanFactory.preInstantiateSingletons();
}
👇
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
//⭐注意看：第2步时注册到beanDefinitionNames中的bean名称，现在取出来进行实例化
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
//获取指定名称的Bean定义
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//Bean不是抽象的，是单态模式的，且lazy-init属性配置为false
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//如果指定名称的bean是创建容器的Bean
if (isFactoryBean(beanName)) {
//FACTORY_BEAN_PREFIX=”&”，当Bean名称前面加”&”符号
//时，获取的是产生容器对象本身，而不是容器产生的Bean.
//调用getBean方法，触发容器对Bean实例化和依赖注入过程
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
//标识是否需要预实例化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
//一个匿名内部类
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) () ->
((SmartFactoryBean<?>) factory).isEagerInit(),
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
//调用getBean方法，触发容器对Bean实例化和依赖注入过程
getBean(beanName);
}
}
else {
getBean(beanName);
}
}
}
...
}
👇
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
...
//先从容器中取是否已经有被创建过Bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
...
//如果容器中存在，就直接返回bean
}
else {
//容器中没有正在创建的单例模式Bean，进行真正的创建
...
...
try {
...
//创建单例模式Bean的实例对象
if (mbd.isSingleton()) {
//这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
//⭐⭐注意：进入这个getSingleton()跟一下
sharedInstance = getSingleton(beanName, () -> {
try {
//创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
//显式地从容器单例模式Bean缓存中清除实例对象
destroySingleton(beanName);
throw ex;
}
});
//获取给定Bean的实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//IOC容器创建原型模式Bean实例对象
else if (mbd.isPrototype()) {
...
else {
...
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
...
return (T) bean;
}
👇
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
...
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//⭐getObject()方法会调用上一步匿名内部类中的createBean()，下一步进入这个方法
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
//⭐⭐注意这里： 新创建的singletonObject，会被添加到IOC容器中
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
👇
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
try {
//如果Bean配置了初始化前和初始化后的处理器，则试图返回一个需要创建Bean的代理对象
//猜想：这里可能跟AOP功能有关，如果有切面，就创建代理对象返回，不执行真正的bean创建，你们可以自行验证
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return ben;
}
}...
try {
//创建Bean的入口
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
...
}
👇
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
//封装被创建的Bean对象
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
//获取实例化对象的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//调用PostProcessor后置处理器
...
//⭐⭐⭐⭐向容器中缓存单例模式的Bean对象
//注意：这里spring是如何解决循环依赖的：先将实例化但是还没注入属性的bean提前暴露出来可以使用,
//这样在注入属性值时才不至于相互等待另外一方初始化完
//补充一个大的知识：IOC容器解决循环依赖的三级缓存--3个Map：
//1级： singletonObjects = new ConcurrentHashMap<>(256); 这是IOC容器主要存放bean的map
//2级： earlySingletonObjects = new ConcurrentHashMap<>(16); 存放提前暴露的bean的map
//3级： singletonFactories = new ConcurrentHashMap<>(16); 存放获取暴露的bean的factory的map
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
//Bean对象的初始化，注入属性
Object exposedObject = bean;
try {
//将Bean实例对象封装，并且Bean定义中配置的属性值赋值给实例对象
populateBean(beanName, mbd, instanceWrapper);
//初始化Bean对象，调用初始化方法
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
...
}
if (earlySingletonExposure) {
//获取指定名称的已注册的单例模式Bean对象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
//根据名称获取的已注册的Bean和正在实例化的Bean是同一个
if (exposedObject == bean) {
//当前实例化的Bean初始化完成
exposedObject = earlySingletonReference;
}
//当前Bean依赖其他Bean，并且当发生循环引用时不允许新创建实例对象
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
//获取当前Bean所依赖的其他Bean
for (String dependentBean : dependentBeans) {
//对依赖Bean进行类型检查
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
...
}
}
}
...
return exposedObject;
}
到此bean已经被创建，并且也注入了属性，然后被加入到了IOC容器中。
最后，增加一点对IOC容器的理解，要很好的理解DefaultListableBeanFactory 才能理解容器，Spring启动的过程，就是在对容器各个属性进行操作的过程：
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
/** Map from serialized id to factory instance */
private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
new ConcurrentHashMap<>(8);
/** 容器编号 */
@Nullable
private String serializationId;
/** 允许bean覆盖，可以在xml配置此属性 */
private boolean allowBeanDefinitionOverriding = true;
/** ⭐⭐解析xml注册bean信息到这个Map中（重要！） */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
/** ⭐⭐解析xml注册bean信息，把bean的名称添加到这个Map中（重要！） */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
=================================另外继承了DefaultSingletonBeanRegistry===============================
/** ⭐⭐IOC容器，存放实例化后的bean(重要！) */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** ⭐3级缓存 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** ⭐2级缓存 */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
/** 注册的bean */
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
/** 正在创建的bean */
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/** 一次性的bean */
private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
/** Map between containing bean names: bean name --> Set of bean names that the bean contains */
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
/** 依赖的bean */
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
/** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
}
以上就是我的一些理解，觉得不错麻烦给个赞，谢谢👍
194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
