Spring概述

BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

protected void onRefresh(ApplicationContext context) {
    this.initStrategies(context);
}

protected void initStrategies(ApplicationContext context) {
    this.initMultipartResolver(context);
    this.initLocaleResolver(context);
    this.initThemeResolver(context);
    this.initHandlerMappings(context);
    this.initHandlerAdapters(context);
    this.initHandlerExceptionResolvers(context);
    this.initRequestToViewNameTranslator(context);
    this.initViewResolvers(context);
    this.initFlashMapManager(context);
}

//使用 CGLIB 进行 Bean 对象实例化
public Object instantiate(@Nullable Constructor<?> ctor, @Nullable Object... args) {
    //创建代理子类
    Class<?> subclass = createEnhancedSubclass(this.beanDefinition); Object instance;
    if (ctor == null) {
        instance = BeanUtils.instantiateClass(subclass); }
        else { 
            try {
                   Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
                   instance = enhancedSubclassConstructor.newInstance(args);
                }
                catch (Exception ex) {
                throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
                "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
                } 
        }
        Factory factory = (Factory) instance; factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
                   new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
                   new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
             return instance;
            }
        private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) { //CGLIB 中的类
        Enhancer enhancer = new Enhancer();
        //将 Bean 本身作为其基类 enhancer.setSuperclass(beanDefinition.getBeanClass()); enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        if (this.owner instanceof ConfigurableBeanFactory) {
        ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader(); enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
        }
        enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition)); enhancer.setCallbackTypes(CALLBACK_TYPES);
        //使用 CGLIB 的 createClass 方法生成实例对象
        return enhancer.createClass();
    } 
}

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
	//保存一个读取注解的 Bean 定义读取器,并将其设置到容器中 
    private final AnnotatedBeanDefinitionReader reader;
	//保存一个扫描指定类路径中注解 Bean 定义的扫描器,并将其设置到容器中 
    private final ClassPathBeanDefinitionScanner scanner;
	//默认构造函数,初始化一个空容器,容器不包含任何 Bean 信息,需要在稍后通过调用其 register() //方法注册配置类,并调用 refresh()方法刷新容器,触发容器对注解 Bean 的载入、解析和注册过程 
    public AnnotationConfigApplicationContext() {
         this.reader = new AnnotatedBeanDefinitionReader(this);
         this.scanner = new ClassPathBeanDefinitionScanner(this);
       }
   public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
         super(beanFactory);
         this.reader = new AnnotatedBeanDefinitionReader(this);
         this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
	//最常用的构造函数,通过将涉及到的配置类传递给该构造函数,以实现将相应配置类中的 Bean 自动注册到容器中 
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
         this();
         register(annotatedClasses);
         refresh();
    }
	//该构造函数会自动扫描以给定的包及其子包下的所有类,并自动识别所有的 Spring Bean,将其注册到容器中 
    public AnnotationConfigApplicationContext(String... basePackages) {
         this();
         scan(basePackages);
         refresh();
    }
   @Override
   public void setEnvironment(ConfigurableEnvironment environment) {
     super.setEnvironment(environment);
     this.reader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
   }
	//为容器的注解 Bean 读取器和注解 Bean 扫描器设置 Bean 名称产生器
	public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
         this.reader.setBeanNameGenerator(beanNameGenerator);
         this.scanner.setBeanNameGenerator(beanNameGenerator);
         getBeanFactory().registerSingleton(
    AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }
	//为容器的注解 Bean 读取器和注解 Bean 扫描器设置作用范围元信息解析器
	public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) {
     this.reader.setScopeMetadataResolver(scopeMetadataResolver);
     this.scanner.setScopeMetadataResolver(scopeMetadataResolver);
   }
	//为容器注册一个要被处理的注解 Bean,新注册的 Bean,必须手动调用容器的 //refresh()方法刷新容器,触发容器对新注册的 Bean 的处理
	public void register(Class<?>... annotatedClasses) {
    	Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
         this.reader.register(annotatedClasses);
       }
    //扫描指定包路径及其子包下的注解类,为了使新添加的类被处理,必须手动调用 //refresh()方法刷新容器
    public void scan(String... basePackages) {
    	Assert.notEmpty(basePackages, "At least one base package must be specified");
         this.scanner.scan(basePackages);
   	}
... 

}