# spring-ioc

public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext();
        applicationContext.setAllowCircularReferences(true);
        applicationContext.setConfigLocation("spring-beans.xml");
        applicationContext.refresh();
        FXNewsProvider newsProvider = (FXNewsProvider) applicationContext.getBean("djNewsProvider");
        newsProvider.getAndPersistNews();
    }

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 记录容器的启动时间、标记“已启动”状态
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
            //解析配置文件成BeanDefine map集合，创建BeanFactory并存储BeanDefine，此处并未进行bean实例化
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 配置classLoader，设置PostProcessor，设置一些ignore依赖接口（不自动注入）
			prepareBeanFactory(beanFactory);

			try {
				// 非重点
				postProcessBeanFactory(beanFactory);

				// 调用配置的BFP，配置的所有BFP都会在这个地方被执行
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册配置的BP到容器中，注意不会执行BP，BP只会在Bean实例化前后被调用
				registerBeanPostProcessors(beanFactory);

				// 初始化MessageSouce到容器中（系统国际化会用到）
				initMessageSource();

				// 初始化applicationEventMulticaster到容器中
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
                //模版方法，可以被重写，主要进行其他特殊bean的初始化操作
				onRefresh();

				// 注册listener  暂过
				registerListeners();

				// 初始化剩下的所有非懒加载的单例模式对象，重点
				finishBeanFactoryInitialization(beanFactory);

				// 最后一步，发布refresh完成事件，主要是调用配置的lifecycleProcessor
				finishRefresh();
			}
		}
	}

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 初始化conversionService，这个用途可以是进行传输类型转化，比如常用的前端传日期类型到后端，可以使用他进行处理
		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));
		}
......

		// 防止配置被修改，进行冻结
		beanFactory.freezeConfiguration();

		// 重点是这个，接着深入
		beanFactory.preInstantiateSingletons();
	}

public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}
 ......       

		if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {

        //AccessController.doPrivileged是特权模式，如果系统设置安全验证，会对包含的方法进行权限判断，没权限会抛出异常
		isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
	
......    

		else {
            // 关键方法 对应到 doGetBean
			getBean(beanName);
		}
......

		// 针对单例bean 如果实现SmartInitializingSingleton，会执行回调函数afterSingletonsInstantiated
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				} else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

              ......
				// 初始化依赖bean
				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);
						}
					}
				}
               .....
				// 重要！！！！
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
                            //关键方法
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
                ......

......
		if (instanceWrapper == null) {
            //这里实例化 Bean，这里非常关键
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

......
      try {
            // 负责属性装配，因为前面的实例只是实例化了，并没有设值，这里就是设值
			populateBean(beanName, mbd, instanceWrapper);
            //还记得 init-method 吗？还有 InitializingBean 接口？还有 BeanPostProcessor 接口？
            // 这里就是处理 bean 初始化完成后的各种回调
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}  

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged(new PrivilegedAction<Object>() {
         @Override
         public Object run() {
            invokeAwareMethods(beanName, bean);
            return null;
         }
      }, getAccessControlContext());
   }
   else {
      // 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      // BeanPostProcessor 的 postProcessBeforeInitialization 回调
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   try {
      // 处理 bean 中定义的 init-method，
      // 或者如果 bean 实现了 InitializingBean 接口，调用 afterPropertiesSet() 方法
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }

   if (mbd == null || !mbd.isSynthetic()) {
      // BeanPostProcessor 的 postProcessAfterInitialization 回调
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }
   return wrappedBean;
}

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext();
        // applicationContext.setAllowCircularReferences(false);
        applicationContext.setConfigLocation("spring-beans.xml");
        applicationContext.refresh();
        FXNewsProvider newsProvider = (FXNewsProvider) applicationContext.getBean("djNewsProvider");
        newsProvider.getAndPersistNews();
    }

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext();
        applicationContext.setAllowCircularReferences(false);
        applicationContext.setConfigLocation("spring-beans.xml");
        applicationContext.refresh();
        FXNewsProvider newsProvider = (FXNewsProvider) applicationContext.getBean("djNewsProvider");
        newsProvider.getAndPersistNews();
    }

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.

		//注意看注释部分，Eagerly（early？官方注释错误） cache singletons to be able to resolve circular references  循环依赖主要通过ealy缓存解决
		//allowCircularReferences 默认为true，允许循环依赖，可以配置
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

        // 和想象的一样，early缓存发生在实例化完成之后，属性设置之前。
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

......
beforeSingletonCreation(beanName);
......
afterSingletonCreation(beanName);
......

......
/** 当前正在创建的bean名称集合 
存储的主要是正在实例化的bean

*/
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));


//每次创建单例bean之前都会检查
	protected void beforeSingletonCreation(String beanName) {
		//关键代码this.singletonsCurrentlyInCreation.add(beanName) 如果已经存在正创建集合中 会返回false，这时候会抛出上面所说的循环引用异常
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

protected void afterSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}
......

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
......
		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
......