不要再问Spring是如何解决循环依赖了

　　1、什么是循环依赖？
　　循环依赖主要来次三个方面，第一种A相互依赖，第二种是 A依赖B，B依赖A，第三种是A依赖B，B依赖C，C依赖A。
　　总结一句话就是对象之间形成环形依赖。
　　代码如下：
　　第一种：public class A {     private A a; }
　　第二种：public class A {     private B b; } class B {     private A a; }
　　第三种：public class A {     private B b; } class B {     private C c; } class C {     private A a; } 2、Spring 三级缓存是什么？第一级缓存：singletonObjects，用于缓存成品的bean，保证 Spring 的单例属性。第二级缓存：earlySingletonObjects，用于保存实例化完成的半成品 bean 实例,包括AOP代理对象。第三级缓存：singletonFactories，Map>，Map 的 Value 是一个对象的代理工厂，用来存放对象的代理工厂用于保存 bean 创建工厂，以便后面有机会创建代理对象。为＂打破循环＂而生，存放的是生成半成品单例 Bean 的工厂方法。
　　要想说清楚三级缓存，我们先来看Spring bean 的生命周期，看bean的创建过程。
　　核心几个类我们从AnnotationConfigApplicationContext上下文为基础来讲解bean的生命周期，AnnotationConfigApplicationContext是基于注解的上下文，看下这核心构造器。 	/** 	 * Create a new AnnotationConfigApplicationContext, deriving bean definitions 	 * from the given component classes and automatically refreshing the context. 	 * @param componentClasses one or more component classes — for example, 	 * {@link Configuration @Configuration} classes 	 */ 	public AnnotationConfigApplicationContext(Class<?>... componentClasses) { 		this(); 		register(componentClasses); 		refresh(); 	}
　　再看refresh()public void refresh() throws BeansException, IllegalStateException { 		synchronized (this.startupShutdownMonitor) { 			StartupStep contextRefresh = this.applicationStartup.start(＂spring.context.refresh＂);  			// Prepare this context for refreshing. 			prepareRefresh();  			// Tell the subclass to refresh the internal bean factory. 			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  			// Prepare the bean factory for use in this context. 			prepareBeanFactory(beanFactory);  			try { 				// Allows post-processing of the bean factory in context subclasses. 				postProcessBeanFactory(beanFactory);  				StartupStep beanPostProcess = this.applicationStartup.start(＂spring.context.beans.post-process＂); 				// Invoke factory processors registered as beans in the context. 				invokeBeanFactoryPostProcessors(beanFactory);  				// Register bean processors that intercept bean creation. 				registerBeanPostProcessors(beanFactory); 				beanPostProcess.end();  				// Initialize message source for this context. 				initMessageSource();  				// Initialize event multicaster for this context. 				initApplicationEventMulticaster();  				// Initialize other special beans in specific context subclasses. 				onRefresh();  				// Check for listener beans and register them. 				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 				// might not ever need metadata for singleton beans anymore... 				resetCommonCaches(); 				contextRefresh.end(); 			} 		} 	}
　　核心主要是finishBeanFactoryInitialization()，其中beanFactory.preInstantiateSingletons()该方法中会生成所有非懒加载的单例bean。 	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)); 		}  		// Register a default embedded value resolver if no BeanFactoryPostProcessor 		// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before: 		// at this point, primarily for resolution in annotation attribute values. 		if (!beanFactory.hasEmbeddedValueResolver()) { 			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); 		}  		// 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(); 	}public void preInstantiateSingletons() throws BeansException {     if (logger.isTraceEnabled()) {     logger.trace(＂Pre-instantiating singletons in ＂ + this); }  // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List beanNames = new ArrayList<>(this.beanDefinitionNames);  // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) {     RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);     if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {         if (isFactoryBean(beanName)) {             Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);             if (bean instanceof FactoryBean) {                 FactoryBean<?> factory = (FactoryBean<?>) bean;                 boolean isEagerInit;                 if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {                     isEagerInit = AccessController.doPrivileged(                         (PrivilegedAction) ((SmartFactoryBean<?>) factory)::isEagerInit,                         getAccessControlContext());                 }                 else {                     isEagerInit = (factory instanceof SmartFactoryBean &&                                    ((SmartFactoryBean<?>) factory).isEagerInit());                 }                 if (isEagerInit) {                     getBean(beanName);                 }             }         }         else {             getBean(beanName);         }     } }  // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) {     Object singletonInstance = getSingleton(beanName);     if (singletonInstance instanceof SmartInitializingSingleton) {         StartupStep smartInitialize = this.getApplicationStartup().start(＂spring.beans.smart-initialize＂)             .tag(＂beanName＂, beanName);         SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;         if (System.getSecurityManager() != null) {             AccessController.doPrivileged((PrivilegedAction