request上下文是如何跟线程上下文绑定的，参考原理：【小家Spring】Spring MVC执行流程 FrameworkServlet、DispatcherServlet源码分析（processRequest、doDispatch）
小伙伴们以后要使用Servlet源生对象，不要只知道从方法入参里注入，看起来很不优雅，很不Spring MVC化，懂了这些原理来龙去脉后，相信可以放心的、安全的使用了~
从这方面可以看出，我们不得不佩服Spring的考虑周到。一个优秀的框架，绝对不仅仅是实现了某个功能而已，而是能让你用得舒服，用得爽 ，可扩展性非常强等一些附加属性~~~~比如下面的web容器AbstractRefreshableWebApplicationContext就会设置一些初始值：
@Override protected void initPropertySources() { ConfigurableEnvironment env = getEnvironment(); // 初始化web环境中的初始值（比如init等，这个后续会说） if (env instanceof ConfigurableWebEnvironment) { ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, null); } } @Override public ConfigurableEnvironment getEnvironment() { if (this.environment == null) { this.environment = createEnvironment(); } return this.environment; } // 这个方法需要注意一下，默认是StandardEnvironment，但是它是protected方法设计，所以之类可以重写（如下图） protected ConfigurableEnvironment createEnvironment() { return new StandardEnvironment(); } //StandardServletEnvironment.initPropertySources(this.servletContext, null) @Override public void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) { // 将 servletContext、servletConfig 添加到 propertySources里(ServletConfigPropertySource) //ServletConfigPropertySource作用：reads init parameters from ServletConfig WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig); }
它们都是web环境下的上下文，因此重写的方式也是一模一样：
//StandardServletEnvironment是web环境上下文里的Enviroment @Override protected ConfigurableEnvironment createEnvironment() { return new StandardServletEnvironment(); }
refresh() 第二步：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()
实际上就是重新创建一个bean工厂，并销毁原工厂。主要工作是创建DefaultListableBeanFactory实例，解析配置文件，注册Bean的定义信息
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { refreshBeanFactory(); ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (logger.isDebugEnabled()) { logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory); } return beanFactory; }
在spring中，基本上各司其职，每个类都有每个类的作用。其中refreshBeanFactory()是具体的刷新BeanFactory,负责这个工作做在类AbstractRefreshableApplicationContext#refreshBeanFactory中，顾名思义这是专门用来刷新的：
@Override protected final void refreshBeanFactory() throws BeansException { // 判断是否已经存在BeanFactory，存在则销毁所有Beans，并且关闭BeanFactory // 避免重复加载BeanFactory if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { // 创建具体的beanFactory，这里创建的是DefaultListableBeanFactory，最重要的beanFactory spring注册及加载bean就靠它 // createBeanFactory()这个方法，看下面，还有得说的 DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId()); // 这句比较简单，就是把当前旧容器的一些配置值复制给新容器 // allowBeanDefinitionOverriding属性是指是否允对一个名字相同但definition不同进行重新注册，默认是true。 // allowCircularReferences属性是指是否允许Bean之间循环引用，默认是true. // 这两个属性值初始值为空：复写此方法即可customizeBeanFactory customizeBeanFactory(beanFactory); // 这个就是最重要的了，加载所有的Bean配置信息，具体如下详细解释 // 它属于模版方法，由子类去实现加载的方式 loadBeanDefinitions(beanFactory); synchronized (this.beanFactoryMonitor) { this.beanFactory = beanFactory; } } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } }
createBeanFactory()
// 创建的时候就是new了一个工厂：DefaultListableBeanFactory 这个时候工厂里面所有东西都是默认值，很多还没有完成初始化属性的设置呢 protected DefaultListableBeanFactory createBeanFactory() { return new DefaultListableBeanFactory(getInternalParentBeanFactory()); } // 给设置父的BeanFactory，若存在的话 public AbstractAutowireCapableBeanFactory(@Nullable BeanFactory parentBeanFactory) { this(); setParentBeanFactory(parentBeanFactory); } // 父类空构造器有这么些语句 public AbstractAutowireCapableBeanFactory() { super(); // 这里是重点。忽略自动装配。这里指定的都是接口。什么意思呢？ // ignoreDependencyInterface的真正意思是在自动装配时忽略指定接口的实现类中，对外的依赖。（这里面注意：@Autowired和它的关系，其实是有坑的，后续会专门讲解这个坑） ignoreDependencyInterface(BeanNameAware.class); ignoreDependencyInterface(BeanFactoryAware.class); ignoreDependencyInterface(BeanClassLoaderAware.class); } //找到父的，若存在就返回 若存在父容器就存在父的BeanFactory @Nullable protected BeanFactory getInternalParentBeanFactory() { return (getParent() instanceof ConfigurableApplicationContext) ? ((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent(); }
AnnotationConfigWebApplicationContext#loadBeanDefinitions()方法，加载Bean的定义 （XmlWebApplicationContext的实现不一样，因为它是加载xml配置文件）
@Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) { // 初始化这个脚手架 其实就是直接new出实例。具体做的工作，下面有相关博文链接 AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory); ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory); // 生成Bean的名称的生成器，如果自己没有setBeanNameGenerator（可以自定义）,这里目前为null BeanNameGenerator beanNameGenerator = getBeanNameGenerator(); if (beanNameGenerator != null) { reader.setBeanNameGenerator(beanNameGenerator); scanner.setBeanNameGenerator(beanNameGenerator); //若我们注册了beanName生成器，那么就会注册进容器里面 beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator); } //这是给reader和scanner注册scope的解析器 此处为null ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver(); if (scopeMetadataResolver != null) { reader.setScopeMetadataResolver(scopeMetadataResolver); scanner.setScopeMetadataResolver(scopeMetadataResolver); } // 此处注意了：annotatedClasses和basePackages一般是选其一（当然看到此处，他们是可以并存的） //我们可以自己指定annotatedClasses 配置文件,同时也可以交给下面扫描 if (!this.annotatedClasses.isEmpty()) { // 这里会把所有的配置文件输出=======info日志 请注意观察控制台 if (logger.isInfoEnabled()) { logger.info("Registering annotated classes: [" + StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]"); } // 若是指明的Bean，就交给reader去处理，至于怎么处理，见上篇博文的doRegisterBean去怎么解析每一个Config Bean的 reader.register(ClassUtils.toClassArray(this.annotatedClasses)); } // 也可以是包扫描的方式，扫描配置文件的Bean if (!this.basePackages.isEmpty()) { // 输出对应的info日志 if (logger.isInfoEnabled()) { logger.info("Scanning base packages: [" + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]"); } // 这里重要了，scan方法具体做了什么事，上篇博文也有详细的介绍，请参阅 scanner.scan(StringUtils.toStringArray(this.basePackages)); } // 此处的意思是，也可以以全类名的形式注册。比如可以调用setConfigLocations设置（这在xml配置中使用较多） 可以是全类名，也可以是包路径 String[] configLocations = getConfigLocations(); if (configLocations != null) { for (String configLocation : configLocations) { try { Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader()); reader.register(clazz); } catch (ClassNotFoundException ex) { // 发现不是全类名，那就当作包扫描吧 int count = scanner.scan(configLocation); } } } }
最开始涉及到两个类的初始化，请参考博文：
【小家Spring】Spring容器加载Bean定义信息的两员大将：AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner
有了这篇博文解释这两个类先行，理解上面loadBeanDefinitions就简单太多了。至此，整个ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();这个步骤全部结束。
现在BeanFactory已经创建了，并且Config配置文件的Bean定义已经注册完成了**（备注：其它单例Bean是还没有解析的~~~~）**
显然，下面的步骤大都把BeanFactory传进去了，都是基于此Bean工厂的了~~~
refresh() 第三步：prepareBeanFactory(beanFactory)
这个方法是配置工厂的标准上下文特征
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 设置beanFactory的classLoader为当前context的classLoader beanFactory.setBeanClassLoader(getClassLoader()); // 设置EL表达式解析器（Bean初始化完成后填充属性时会用到） // spring3增加了表达式语言的支持，默认可以使用#{bean.xxx}的形式来调用相关属性值 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); // 设置属性注册解析器PropertyEditor 这个主要是对bean的属性等设置管理的一个工具 beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); // 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，从而在Aware接口实现类中的注入applicationContext等等 // 添加了一个处理aware相关接口的beanPostProcessor扩展，主要是使用beanPostProcessor的postProcessBeforeInitialization()前置处理方法实现aware相关接口的功能 // 类似的还有ResourceLoaderAware、ServletContextAware等等等等 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); // 下面是忽略的自动装配（也就是实现了这些接口的Bean，不要Autowired自动装配了） // 默认只有BeanFactoryAware被忽略,所以其它的需要自行设置 // 因为ApplicationContextAwareProcessor把这5个接口的实现工作做了（具体你可参见源码） 所以这里就直接忽略掉 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); // 设置几个"自动装配"规则======如下： // 如果是BeanFactory的类，就注册beanFactory // 如果是ResourceLoader、ApplicationEventPublisher、ApplicationContext等等就注入当前对象this(applicationContext对象) // 此处registerResolvableDependency()方法注意：它会把他们加入到DefaultListableBeanFactory的resolvableDependencies字段里面缓存这，供后面处理依赖注入的时候使用 DefaultListableBeanFactory#resolveDependency处理依赖关系 // 这也是为什么我们可以通过依赖注入的方式，直接注入这几个对象比如ApplicationContext可以直接依赖注入 // 但是需要注意的是：这些Bean，Spring的IOC容器里其实是没有的。beanFactory.getBeanDefinitionNames()和beanFactory.getSingletonNames()都是找不到他们的，所以特别需要理解这一点 // 至于容器中没有，但是我们还是可以@Autowired直接注入的有哪些，请看下图： beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); // 注册这个Bean的后置处理器：在Bean初始化后检查是否实现了ApplicationListener接口 // 是则加入当前的applicationContext的applicationListeners列表 这样后面广播事件也就方便了 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); // 检查容器中是否包含名称为loadTimeWeaver的bean，实际上是增加Aspectj的支持 // AspectJ采用编译期织入、类加载期织入两种方式进行切面的织入 // 类加载期织入简称为LTW（Load Time Weaving）,通过特殊的类加载器来代理JVM默认的类加载器实现 if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { // 添加BEAN后置处理器：LoadTimeWeaverAwareProcessor // 在BEAN初始化之前检查BEAN是否实现了LoadTimeWeaverAware接口， // 如果是，则进行加载时织入，即静态代理。 beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // Set a temporary ClassLoader for type matching. beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } // 注入一些其它信息的bean，比如environment、systemProperties、SystemEnvironment等 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } }
说个小细节：@Autowiredh和@Qualifier一起是用时，@Qualifier的值需保证容器里一定有，否则启动报错
这部分比较简单，就是设置一些标准的值，解释都放代码里了。
附：IOC容器中没有Bean，但是我们还是可以依赖注入的Bean如下（resolvableDependencies）：
