spring 注解学习 spring annotation study

Spring容器的refresh()【创建刷新】； 1、prepareRefresh() 刷新前的预处理 1）、initPropertySources() 初始化一些属性设置 子类（自容器）自定义个性化的属性设置方法 2）、getEnvironment().validateRequiredProperties() 检验属性的合法等 3）、earlyApplicationEvents = new LinkedHashSet<>();保存容器中的一些早期的事件 2、obtainFreshBeanFactory();获取BeanFactory 1）、refreshBeanFactory() 刷新 BeanFactory 创建了一个 this.beanFactory = new DefaultListableBeanFactory(); 设置id; 2）、getBeanFactory();返回刚才 GenericApplicationContext 创建的 BeanFactory 对象 3）、将创建的 BeanFactory【DefaultListableBeanFactory】 返回 3、prepareBeanFactory(beanFactory); BeanFactory 的预准备工作（BeanFactory进行一些设置） 1）、设置 BeanFactory 类加载器、支持表达式解析器。。。 2）、添加部分 BeanPostProcessor【ApplicationContextAwareProcessor】 3）、设置忽略的自动装配的接口 EnvironmentAware EmbeddedValueResolverAware xxx 4）、注册可以解析的自动装配，我们能直接在任何组件中自动注入 BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext 5）、添加 BeanPostProcessor【ApplicationListenerDetector】 6）、添加编译时的 AspectJ 7）、给 BeanFactory 中注册一些能用的组件 environment【ConfigurableEnvironment】 systemProperties【Map<String, Object>】 systemEnvironment【Map<String, Object>】 4、postProcessBeanFactory(beanFactory) BeanFactory 准备工作完成后进行的后置处理工作 1）、子类通过重写这个方法来在 BeanFactory 创建并预准备完成以后做进一步的设置 =======================以上是 BeanFactory 的创建以及预准备工作 ============================================================================ 5、invokeBeanFactoryPostProcessors(BeanFactory);执行 BeanFactoryPostProcessors BeanFactoryPostProcessors BeanFactory的后置处理器，在BeanFactory标准初始化之后执行 两个接口，BeanFactoryPostProcessor BeanDefinitionRegistryPostProcessor 1）、invokeBeanFactoryPostProcessors 执行 BeanFactoryPostProcessor 方法 先执行 BeanDefinitionRegistryPostProcessor 的方法 1）、获取所有的 BeanDefinitionRegistryPostProcessor 2）、先执行实现了 PriorityOrdered 优先级接口的 BeanDefinitionRegistryPostProcessor postProcessor.postProcessBeanDefinitionRegistry(registry); 3）、在执行实现了 Ordered 顺序接口的 BeanDefinitionRegistryPostProcessor postProcessor.postProcessBeanDefinitionRegistry(registry); 4）、最后执行没有实现任何优先级或者是顺序接口的 BeanDefinitionRegistryPostProcessor postProcessor.postProcessBeanDefinitionRegistry(registry);

    再执行 BeanFactoryPostProcessor 的方法
    1）、获取所有的 BeanFactoryPostProcessor
    2）、先执行实现了 PriorityOrdered 优先级接口的 BeanFactoryPostProcessor
        postProcessor.postProcessBeanFactory(beanFactory);
    3）、在执行实现了 Ordered 顺序接口的 BeanFactoryPostProcessor
        postProcessor.postProcessBeanFactory(beanFactory);
    4）、最后执行没有实现任何优先级或者是顺序接口的 BeanFactoryPostProcessor
        postProcessor.postProcessBeanFactory(beanFactory);

6、registerBeanPostProcessors(beanFactory); 注册 BeanPostProcessor（Bean的后置处理器）【intercept bean creation】 拦截bean的创建过程 不同类型的 BeanPostProcessor 在bean创建前后的执行时机是不一样的 BeanPostProcessor DestructionAwareBeanPostProcessor InstantiationAwareBeanPostProcessor SmartInstantiationAwareBeanPostProcessor MergedBeanDefinitionPostProcessor【internalPostProcessors】

1）、获取所有的 BeanPostProcessor 后置处理器都默认可以通过 PriorityOrdered Ordered 接口来指定优先级
2）、先注册 PriorityOrdered 优先级接口的 BeanPostProcessor
    把每一个 BeanPostProcessor 添加到 BeanFactory 中
    beanFactory.addBeanPostProcessor(postProcessor);
3）、再注册 Ordered 接口的
4）、最后注册没有实现任何优先级接口的
5）、最终注册 MergedBeanDefinitionPostProcessor【internalPostProcessors】
6）、注册一个 ApplicationListenerDetector 来在bean创建完成后检查是否 ApplicationListener 如果是
    applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7、initMessageSource(); 初始化 MessageSource 组件（做国际化功能 消息绑定 消息解析） 1）、获取 BeanFactory 2）、看容器中是否有ID为 messageSource 的，类型是 MessageSource 的组件 如果有赋值给 messageSource 属性，如果没有自己创建一个 DelegatingMessageSource MessageSource，取出国际化配置文件中的某个key值，能按区域信息获取 3）、把创建好的 MessageSource 注册在容器中，以后获取国际化配置的值的时候， 可以自动注入 MessageSource beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource); MessageSource.getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale); 8、initApplicationEventMulticaster();初始化事件派发器； 1）、获取 BeanFactory 2）、尝试从 BeanFactory 中获取 applicationEventMulticaster（ApplicationEventMulticaster类型） 的组件 3）、如果没有配置 创建一个 SimpleApplicationEventMulticaster 组件 4）、将创建的 ApplicationEventMulticaster 添加到 BeanFactory 中，以后其他组件直接自动注入 9、onRefresh();留给子容器（子类） 1）、子类重写这个方法，在容器刷新时候可以自定义逻辑 10、registerListeners() 给容器中将所有项目里的 ApplicationListener 注册进来 1）、从容器中拿到所有的 ApplicationListener 组件 2）、将每个监听器添加到事件派发器中 getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); 3）、派发之前步骤产生的事件 11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的的单实例bean 1、beanFactory.preInstantiateSingletons(); 初始化剩下的单实例bean 1）、获取容器中的所有bean 依次进行初始化和创建对象 2）、获取bean的定义信息 RootBeanDefinition 3）、bean 不是抽象的 是单实例 不是懒加载 1）、判断是否是 FactoryBean 是否是实现 FactoryBean接口的bean 2）、不是工厂bean 利用getBean(beanName); 创建对象 0、getBean(beanName);ioc.getBean(); 1、doGetBean(name, null, null, false); 2、getSingleton(beanName); singletonObjects 先获取缓存中保存的单实例bean，如果能获取到说明这个bean之前被创建过（所有创建过的单实例bean都会被缓存起来） 从 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); 3、缓存中获取不到，开始bean的创建对象流程 4、标记当前bean已被创建 5、获取bean的定义信息 6、【获取当前bean依赖的其他bean；如果有按照getBean把依赖的bean先创建出来】 String[] dependsOn = mbd.getDependsOn(); 7、启动单实例bean的创建流程 1）、createBean(beanName, mbd, args);创建bean 2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 让beanPostProcessor先拦截返回代理对象-> 【InstantiationAwareBeanPostProcessor 提前执行】 触发 Object result = InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(beanClass, beanName); 先触发 postProcessBeforeInstantiation()方法 如果有返回值 再触发 postProcessAfterInitialization()方法 3）、如果前面的 InstantiationAwareBeanPostProcessor 没有返回代理对象 调用4） 4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args); 1）、创建bean 实例 createBeanInstance(beanName, mbd, args); 利用工厂方法或者对象的构造器创建出Bean实例 2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 调用 MergedBeanDefinitionPostProcessor 的 postProcessMergedBeanDefinition(mbd, beanType, beanName); 3）、【bean的属性赋值】populateBean(beanName, mbd, instanceWrapper); 赋值之前 1）、拿到 InstantiationAwareBeanPostProcessor 后置处理器 postProcessAfterInstantiation() 2）、拿到 InstantiationAwareBeanPostProcessor 后置处理器 postProcessPropertyValues() ========赋值之前======= 3）、应用 bean属性的值 为属性利用setter方法等进行赋值 applyPropertyValues(beanName, mbd, bw, pvs); 4）【bean的初始化】 initializeBean(beanName, exposedObject, mbd); 1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean); 执行xxxAware接口的方法 BeanNameAware\BeanClassLoaderAware\BeanFactoryAware 2）、【执行后置处理器初始化之前方法】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); BeanPostProcessor.postProcessBeforeInitialization() 3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd); 1）、是否是 InitializingBean 接口的实现，执行接口规定的初始化 2）、看是否自定义初始化方法， 4）、【执行后置处理器初始化之后方法】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); BeanPostProcessor.postProcessAfterInitialization() 5）、注册bean的销毁方法 5）、将创建的bean添加到缓存中 singletonObjects IOC容器就是这些map 很多的map里面保存了单实例bean，环境信息。。。。 所有bean都利用getBean创建完成以后 检查所有的bean是否是 SmartInitializingSingleton 如果是 就执行 afterSingletonsInstantiated 12、finishRefresh();完成 beanfatory 初始化创建工作，iOC容器就创建完成 1）、initLifecycleProcessor();初始化生命周期有关的后置处理器 lifecycleProcessor 默认从容器中找是否有 lifecycleProcessor 的组件 如果没有使用默认的生命周期组件 DefaultLifecycleProcessor 加入到容器中 写一个 lifecycleProcessor 实现类 可以在beanfactory 的 onRefresh onClose 进行调用 2）、getLifecycleProcessor().onRefresh(); 拿到前面定义的生命周期处理器(beanfatory)，回调onRefresh() 方法 3）、publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件 4）、LiveBeansView.registerApplicationContext(this);

============总结===========
1）、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息
    1）、xml注册bean<bean>
    2）、注解注册bean，@service @component @bean
2）、spring容器会合适的创建这些bean
    1）、用到这个bean的时候，利用getBean创建bean，创建好后保存到容器中
    2）、统一创建剩下的所有bean的时候，finishBeanFactoryInitialization
3）、后置处理器，
    1）、每一个bean创建完成，都会使用各种后置处理器进行处理，来增强bean的功能
       AutowiredAnnotationBeanPostProcessor 处理自动注入功能
       AnnotationAwareAspectJAutoProxyCreator 给bean创建代理对象 来做AOP功能
       xxxx。。。
       增强功能注解
       AsyncAnnotationBeanPostProcessor
       。。。。
4）、事件驱动模型
     ApplicationListener 事件监听
     ApplicationEventMulticaster 事件的派发