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();
}