手把手教你看 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 {
    /**
   *設(shè)置公共攔截器。這些必須是當(dāng)前工廠中的bean名稱
   */
  public void setInterceptorNames(String... interceptorNames) {
    this.interceptorNames = interceptorNames;
  }
/**
  為給定的bean創(chuàng)建一個(gè)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實(shí)例-例如，檢查標(biāo)記接口或使用代理包裝bean。<p>通常，通過(guò)標(biāo)記接口*或類似對(duì)象填充bean的后處理器將實(shí)現(xiàn){@link #postProcessBeforeInitialization}，而使用代理包裝bean的后處理器通常將實(shí)現(xiàn){@link #postProcessAfterInitialization}。<h3>注冊(cè)</h3> <p> {@ code ApplicationContext}可以在其bean定義中自動(dòng)檢測(cè){@code BeanPostProcessor} bean，并將這些后處理器應(yīng)用于隨后創(chuàng)建的任何bean。普通的{@code BeanFactory}允許以編程方式注冊(cè)后處理器，并將其應(yīng)用于通過(guò)bean工廠創(chuàng)建的所有bean
 */
public interface BeanPostProcessor {

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

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

}

public interface BeanFactoryPostProcessor {
  /**
  在標(biāo)準(zhǔn)初始化之后，修改應(yīng)用程序上下文的內(nèi)部bean工廠。所有bean定義都將被加載，但是還沒(méi)有實(shí)例化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;

  /**
      設(shè)置是否應(yīng)該創(chuàng)建一個(gè)單例，或者在每個(gè)請(qǐng)求上創(chuàng)建一個(gè)新對(duì)象*否則。默認(rèn)值為{@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;
  }
  /**
   返回運(yùn)行該bean的BeanFactory
   */
  @Nullable
  protected BeanFactory getBeanFactory() {
    return this.beanFactory;
  }

  /**
      從運(yùn)行該bean的BeanFactory獲取一個(gè)bean類型轉(zhuǎn)換器
   */
  protected TypeConverter getBeanTypeConverter() {
    BeanFactory beanFactory = getBeanFactory();
    if (beanFactory instanceof ConfigurableBeanFactory) {
      return ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
    }
    else {
      return new SimpleTypeConverter();
    }
  }
    /**
       公開(kāi)單例實(shí)例（用于通過(guò)“早期單例”代理訪問(wèn)）。返回此FactoryBean持有的單例實(shí)例
   */
  @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 {

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

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

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

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

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

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

public interface WebApplicationContext extends ApplicationContext {

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

  /**
  請(qǐng)求范圍的范圍標(biāo)識(shí)符：“ request”。*除了標(biāo)準(zhǔn)范圍“ singleton”和“ prototype”之外，還受支持。
   */
  String SCOPE_REQUEST = "request";

  /**
  會(huì)話范圍的范圍標(biāo)識(shí)符：“session”。*除了標(biāo)準(zhǔn)范圍“ singleton”和“ prototype”之外，還受支持。
   */
  String SCOPE_SESSION = "session";

  /**
  全局Web應(yīng)用程序范圍的范圍標(biāo)識(shí)符：“application”。*除了標(biāo)準(zhǔn)范圍“ singleton”和“ prototype”之外，還受支持。
   */
  String SCOPE_APPLICATION = "application";

  /**
  工廠中ServletContext環(huán)境Bean的名稱
   */
  String SERVLET_CONTEXT_BEAN_NAME = "servletContext";

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

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


  /**
  返回此應(yīng)用程序的標(biāo)準(zhǔn)Servlet API ServletContext
   */
  @Nullable
  ServletContext getServletContext();
}