Spring菜鳥教你看源碼沖面試

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
@Nullable
	private static Class<?> javaxInjectProviderClass;

	static {
		try {
			javaxInjectProviderClass =
					ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - Provider interface simply not supported then.
			javaxInjectProviderClass = null;
		}
	}


	/** Map from serialized id to factory instance. */
	private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
			new ConcurrentHashMap<>(8);

	/** Optional id for this factory, for serialization purposes. */
	@Nullable
	private String serializationId;

	/** Whether to allow re-registration of a different definition with the same name. */
	private boolean allowBeanDefinitionOverriding = true;

	/** Whether to allow eager class loading even for lazy-init beans. */
	private boolean allowEagerClassLoading = true;

	/** Optional OrderComparator for dependency Lists and arrays. */
	@Nullable
	private Comparator<Object> dependencyComparator;

	/** Resolver to use for checking if a bean definition is an autowire candidate. */
	private AutowireCandidateResolver autowireCandidateResolver = SimpleAutowireCandidateResolver.INSTANCE;

	/** Map from dependency type to corresponding autowired value. */
	private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

	/** Map of bean definition objects, keyed by bean name. */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

	/** Map from bean name to merged BeanDefinitionHolder. */
	private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256);

	/** Map of singleton and non-singleton bean names, keyed by dependency type. */
	private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

	/** Map of singleton-only bean names, keyed by dependency type. */
	private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

	/** List of bean definition names, in registration order. */
	private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

	/** List of names of manually registered singletons, in registration order. */
	private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

	/** Cached array of bean definition names in case of frozen configuration. */
	@Nullable
	private volatile String[] frozenBeanDefinitionNames;
................
...........
}

import org.springframework.aop.Advisor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.AopInfrastructureBean;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.framework.ProxyProcessorSupport;
import org.springframework.aop.framework.adapter.AdvisorAdapterRegistry;
import org.springframework.aop.framework.adapter.GlobalAdvisorAdapterRegistry;
import org.springframework.aop.target.SingletonTargetSource;

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport 
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
  /**
	 *設置公共攔截器。這些必須是當前工廠中的bean名稱
	 */
	public void setInterceptorNames(String... interceptorNames) {
		this.interceptorNames = interceptorNames;
	}
/**
	為給定的bean創建一個AOP代理
	 */
	protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {

		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);
    
		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);
		proxyFactory.setFrozen(this.freezeProxy);
    
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
		return proxyFactory.getProxy(getProxyClassLoader());
	}
  
  
}

/**
 工廠掛鉤，允許自定義修改新bean實例-例如，檢查標記接口或使用代理包裝bean。 <p>通常，通過標記接口*或類似對象填充bean的後處理器將實現{@link #postProcessBeforeInitialization}，而使用代理包裝bean的後處理器通常將實現{@link #postProcessAfterInitialization}。 <h3>註冊</h3> <p> {@ code ApplicationContext}可以在其bean定義中自動檢測{@code BeanPostProcessor} bean，並將這些後處理器應用於隨後創建的任何bean。普通的{@code BeanFactory}允許以編程方式註冊後處理器，並將其應用於通過bean工廠創建的所有bean
 */
public interface BeanPostProcessor {

	/**
	 在任何bean 初始化回調（如InitializingBean的{@code afterPropertiesSet} 或自定義的init-method）之前，將此{@code BeanPostProcessor}應用於給定的新bean實例<i> </ i>。該bean將已經用屬性值填充。 返回的bean實例也可能是原始實例的包裝;
	 */
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	/**
在任何bean 初始化回調（例如InitializingBean的{@code afterPropertiesSet} 或自定義的初始化方法）之後，將此{@code BeanPostProcessor}應用於給定的新bean實例。該bean將已經用屬性值填充。 返回的bean實例可能是原始實例的包裝。 對於FactoryBean，將為FactoryBean 實例和由FactoryBean創建的對象（從Spring 2.0開始）調用此回調。後處理器可以通過相應的{@code bean instanceof FactoryBean}檢查來決定是應用到FactoryBean還是創建的對象，還是兩者都應用。
	 */
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

public interface BeanFactoryPostProcessor {
	/**
	在標準初始化之後，修改應用程序上下文的內部bean工廠。所有bean定義都將被加載，但是還沒有實例化bean *。這甚至可以覆蓋或添加*屬性，甚至可以用於初始化bean。
	 */
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;}

public abstract class AbstractFactoryBean<T>
		implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
	/** Logger available to subclasses. */
	protected final Log logger = LogFactory.getLog(getClass());
	private boolean singleton = true;
	@Nullable
	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
	@Nullable
	private BeanFactory beanFactory;
	private boolean initialized = false;
	@Nullable
	private T singletonInstance;
	@Nullable
	private T earlySingletonInstance;

	/**
   設置是否應該創建一個單例，或者在每個請求上創建一個新對象*否則。默認值為{@code true}（單例）。
	 */
	public void setSingleton(boolean singleton) {
		this.singleton = singleton;
	}
	@Override
	public boolean isSingleton() {
		return this.singleton;
	}
	@Override
	public void setBeanClassLoader(ClassLoader classLoader) {
		this.beanClassLoader = classLoader;
	}
	@Override
	public void setBeanFactory(@Nullable BeanFactory beanFactory) {
		this.beanFactory = beanFactory;
	}
	/**
	 返回運行該bean的BeanFactory
	 */
	@Nullable
	protected BeanFactory getBeanFactory() {
		return this.beanFactory;
	}

	/**
   從運行該bean的BeanFactory獲取一個bean類型轉換器
	 */
	protected TypeConverter getBeanTypeConverter() {
		BeanFactory beanFactory = getBeanFactory();
		if (beanFactory instanceof ConfigurableBeanFactory) {
			return ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
		}
		else {
			return new SimpleTypeConverter();
		}
	}
  /**
    公開單例實例（用於通過“早期單例”代理訪問）。返回此FactoryBean持有的單例實例
	 */
	@Nullable
	private T getSingletonInstance() throws IllegalStateException {
		Assert.state(this.initialized, "Singleton instance not initialized yet");
		return this.singletonInstance;
	}
}

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

	/**
   返回此應用程序上下文的唯一ID
	 */
	@Nullable
	String getId();

	/**
	返回此上下文所屬的已部署應用程序的名稱
	 */
	String getApplicationName();

	/**
   返回此上下文的顯示名稱
	 */
	String getDisplayName();

	/**
	返回首次加載此上下文時的時間戳
	 */
	long getStartupDate();

	/**
	 返回父級上下文，如果沒有父級，則返回{@code null}
	 */
	@Nullable
	ApplicationContext getParent();

	/**
	針對此上下文公開AutowireCapableBeanFactory功能。 * <p>應用程序代碼通常不使用此功能，除非是為瞭*初始化存在於應用程序上下文之外的bean實例，*將Spring bean生命周期（全部或部分）應用於它們。 * <p>或者，通過{@link ConfigurableApplicationContext}接口公開的內部BeanFactory也提供對{{link AutowireCapableBeanFactory}接口的訪問。本方法主要*用作ApplicationContext接口上的便捷特定工具。 * <p> <b>註意：從4.2開始，在關閉應用程序上下文之後，此方法將始終拋出IllegalStateException *。</ b>在當前的Spring Framework *版本中，隻有可刷新的應用程序上下文才具有這種行為；從4.2開始，*所有應用程序上下文實現都將必須遵守。 * @為此上下文返回AutowireCapableBeanFactory *如果上下文不支持{@link AutowireCapableBeanFactory}接口，或者尚不具有支持自動連線功能的bean工廠，則拋出IllegalStateException（例如，如果{@code refresh（）}具有*從未調用過），或者上下文已經關閉* @see ConfigurableApplicationContext＃refresh（）* @see ConfigurableApplicationContext＃getBeanFactory（）* /
	 */
	AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

public interface WebApplicationContext extends ApplicationContext {

	/**
	Context屬性，用於在成功啟動時將根WebApplicationContext綁定到該屬性。 * <p>註意：如果根上下文的啟動失敗，則此屬性可以包含*異常或錯誤作為值。使用WebApplicationContextUtils方便*查找根WebApplicationContext。
	 */
	String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";

	/**
	請求范圍的范圍標識符：“ request”。 *除瞭標準范圍“ singleton”和“ prototype”之外，還受支持。
	 */
	String SCOPE_REQUEST = "request";

	/**
	會話范圍的范圍標識符：“session”。 *除瞭標準范圍“ singleton”和“ prototype”之外，還受支持。
	 */
	String SCOPE_SESSION = "session";

	/**
	全局Web應用程序范圍的范圍標識符：“application”。 *除瞭標準范圍“ singleton”和“ prototype”之外，還受支持。
	 */
	String SCOPE_APPLICATION = "application";

	/**
	工廠中ServletContext環境Bean的名稱
	 */
	String SERVLET_CONTEXT_BEAN_NAME = "servletContext";

	/**
	工廠中ServletContext init-params環境Bean的名稱
	 */
	String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";

	/**
	工廠中ServletContext屬性環境bean的名稱
	 */
	String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";


	/**
	返回此應用程序的標準Servlet API ServletContext
	 */
	@Nullable
	ServletContext getServletContext();
}