spring注解开发-扩展原理（源码）

1.BeanFactoryPostProcessor

BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的;

BeanFactoryPostProcessor：beanFactory的后置处理器；在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；即所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建；

BeanFactoryPostProcessor原理:

1）IOC容器创建对象

2）调用AbstractApplicationContext的refresh()方法；

3）调用AbstractApplicationContext的invokeBeanFactoryPostProcessors(beanFactory)方法，然后调用PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors()方法

如何找到所有的BeanFactoryPostProcessor并执行他们的方法；

1）、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法

2）、在初始化创建其他组件前面执行

2.BeanDefinitionRegistryPostProcessor

它是BeanFactoryPostProcessor的子接口；在所有bean定义信息将要被加载，bean实例还未创建的时候触发；

所以它优先于BeanFactoryPostProcessor执行；利用BeanDefinitionRegistryPostProcessor可以给容器中再额外添加一些组件；

BeanDefinitionRegistry： Bean定义信息的保存中心，以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例；

BeanDefinitionRegistryPostProcessor原理:

1）IOC容器创建对象

2）调用AbstractApplicationContext的refresh()方法中的invokeBeanFactoryPostProcessors(beanFactory)；

3）从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。

//PostProcessorRegistrationDelegate.class
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

3.1）调用invokeBeanDefinitionRegistryPostProcessors依次触发所有的postProcessBeanDefinitionRegistry()方法

//PostProcessorRegistrationDelegate.class
private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
        Iterator var2 = postProcessors.iterator();
        while(var2.hasNext()) {
            BeanDefinitionRegistryPostProcessor postProcessor = (BeanDefinitionRegistryPostProcessor)var2.next();
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }

    }

3.2）再来触发BeanFactoryPostProcessor的postProcessBeanFactory()方法；

//PostProcessorRegistrationDelegate.class
private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
        Iterator var2 = postProcessors.iterator();

        while(var2.hasNext()) {
            BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var2.next();
            postProcessor.postProcessBeanFactory(beanFactory);
        }

    }

4）再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法

//PostProcessorRegistrationDelegate.class
private static void invokeBeanFactoryPostProcessors(
            Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

        for (BeanFactoryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanFactory(beanFactory);
        }
    }

3.ApplicationListener

public interface ApplicationListener<E extends ApplicationEvent>

监听 ApplicationEvent 及其下面的子事件；

实现步骤：

1）写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

2）把监听器加入到容器； @Component

3）只要容器中有相关事件的发布，我们就能监听到这个事件；

ContextRefreshedEvent：容器刷新完成（所有bean都完全创建）会发布这个事件；

ContextClosedEvent：关闭容器会发布这个事件；

4）、发布一个事件：applicationContext.publishEvent()；

applicationContext.publishEvent(new ApplicationEvent(new String("发布事件")) {
        });

事件原理：

1）ContextRefreshedEvent事件：

1.1）容器创建对象：refresh()；

1.2）finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件

//AbstractApplicationContext.class
publishEvent(new ContextRefreshedEvent(this));

2）自己发布事件；

3）容器关闭会发布ContextClosedEvent；

【发布事件】

publishEvent(new ContextRefreshedEvent(this));

1）获取事件的多播器（派发器）：getApplicationEventMulticaster()

2）multicastEvent派发事件(原理见下);

3）获取到所有的ApplicationListener【原理见下】；

for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {

3.1）、如果有Executor，可以支持使用Executor进行异步派发；

Executor executor = getTaskExecutor();

3.2）、否则，同步的方式直接执行listener方法；invokeListener(listener,event);拿到listener回调onApplicationEvent方法；

【事件多播器（派发器）】

1.1）容器创建对象：refresh()；

1.2）在refresh中调用initApplicationEventMulticaster();初始化applicationEventMulticaster

1.2.1）先去容器中找有没有id=“applicationEventMulticaster”的组件；

1.2.2）如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);并且加入到容器中，我们就可以在其他组件要派发事件时候，自动注入这个applicationEventMulticaster；

【容器中有哪些监听器】

1）容器创建对象：refresh();

2）registerListeners();从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中；

String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
//将listener注册到ApplicationEventMulticaster中
   getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

注解实现监听

@EventListener

//可以写多个
@EventListener(classes={ApplicationEvent.class})
public void listen(ApplicationEvent event){
        System.out.println("UserService监听事件:"+event);
    }

@EventListener原理：

使用EventListenerMethodProcessor处理器来解析方法上的@EventListener；

SmartInitializingSingleton 原理：

1）ioc容器创建对象并refresh()；

2）finishBeanFactoryInitialization(beanFactory);调用preInstantiateSingletons，初始化剩下的单实例bean；

2.1）先创建所有的单实例bean；getBean();

//DefaultListableBeanFactory implement ConfigurableListableBeanFactory
//实现了方法preInstantiateSingletons
for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean<?>) factory).isEagerInit();
                            }
                        }, getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }

2.2）获取所有创建好的单实例bean，判断是否是SmartInitializingSingleton类型的；如果是就调用afterSingletonsInstantiated();

//DefaultListableBeanFactory implement ConfigurableListableBeanFactory
//实现了方法preInstantiateSingletons
for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            smartSingleton.afterSingletonsInstantiated();
                            return null;
                        }
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }

3）调用EventListenerMethodProcessor实现的 SmartInitializingSingleton接口的afterSingletonsInstantiated方法

for (Method method : annotatedMethods.keySet()) {
                    for (EventListenerFactory factory : factories) {
                        if (factory.supportsMethod(method)) {
                            Method methodToUse = AopUtils.selectInvocableMethod(
                                    method, this.applicationContext.getType(beanName));
                            ApplicationListener<?> applicationListener =
                                    factory.createApplicationListener(beanName, targetType, methodToUse);
                            if (applicationListener instanceof ApplicationListenerMethodAdapter) {
                                ((ApplicationListenerMethodAdapter) applicationListener)
                                        .init(this.applicationContext, this.evaluator);
                            }
                            this.applicationContext.addApplicationListener(applicationListener);
                            break;
                        }
                    }

原文地址：https://www.cnblogs.com/ntbww93/p/10104996.html

时间： 2024-07-31 23:13:43

spring注解开发-扩展原理（源码）的相关文章

做一个合格的程序猿之浅析Spring AOP源码（十八） Spring AOP开发大作战源码解析

其实上一篇文章价值很小,也有重复造轮子的嫌疑,网上AOP的实例很多,不胜枚举,其实我要说的并不是这个,我想要说的就是上一节中spring的配置文件: 我们这边并没有用到我们上几节分析的哪几个AOP的主要实现类:ProxyFactoryBean.java , ProxyFactory.java ,AspectJProxyFactory.java ,在我们这个配置文件中,根本没有显示的去配置这些类,那么spring到底是怎么做到的呢? 大家可以这么想,spring到底是怎么去杀害目标对象的呢?真正的

Spring Boot 揭秘与实战 源码分析 - 工作原理剖析

文章目录 1. EnableAutoConfiguration 帮助我们做了什么 2. 配置参数类 – FreeMarkerProperties 3. 自动配置类 – FreeMarkerAutoConfiguration4. 扩展阅读 3.1. 核心注解 3.2. 注入 Bean 结合<Spring Boot 揭秘与实战 源码分析 - 开箱即用,内藏玄机>一文,我们再来深入的理解 Spring Boot 的工作原理. 在<Spring Boot 揭秘与实战 源码分析 - 开箱即用,内藏

Spring Boot 揭秘与实战 源码分析 - 开箱即用，内藏玄机

文章目录 1. 开箱即用,内藏玄机 2. 总结 3. 源代码 Spring Boot提供了很多"开箱即用"的依赖模块,那么,Spring Boot 如何巧妙的做到开箱即用,自动配置的呢? 开箱即用,内藏玄机 Spring Boot提供了很多"开箱即用"的依赖模块,都是以spring-boot-starter-xx作为命名的.例如,之前提到的 spring-boot-starter-redis.spring-boot-starter-data-mongodb.spri

VC++环境下多文档模板应用程序开发（带源码）

我们以前见到的关于VC++环境下利用APP Wizard 自动生成的MDI的应用程序只支持打开同一文档类型的多个文件,但是不能够同时打开不同种类型的文档.网上的这种公开资料比较少,我在知网上查阅了相关的资料.下面我根据这些资料做一下总结(辛辛苦苦一个一个字码出来的). 下面设计一个能够处理两种文档类型的应用程序:第一种文档类型:TXT文档,第二种文档类型:Bub的文档类型. 第一种的文档类型TXT,是利用APP Wizard自动生成的,只不过是在设置的时候将文档类型设置为TXT类型,并且使生成的

Android源码开发利器——Java源码调试(基于4.1.2)

原文地址:http://blog.csdn.net/jinzhuojun/article/details/8868038 调试Android Java源码 草帽的后花园--Neo 写在之前的话:这里主要是以调试Java源码为主,应该说是在system_process之后的源码,这对于调试和修改frameworks层的人来说真是一个利器,但至于为什么在system_process之后,我还在分析,如果有结果我会更新此文章,并正在尝试调试C++的代码,就是native中的代码,如果这个可行那将会大大

Mybatis Interceptor 拦截器原理 源码分析

Mybatis采用责任链模式,通过动态代理组织多个拦截器(插件),通过这些拦截器可以改变Mybatis的默认行为(诸如SQL重写之类的),由于插件会深入到Mybatis的核心,因此在编写自己的插件前最好了解下它的原理,以便写出安全高效的插件. 代理链的生成 Mybatis支持对Executor.StatementHandler.PameterHandler和ResultSetHandler进行拦截,也就是说会对这4种对象进行代理. 通过查看Configuration类的源代码我们可以看到,每次都

spring注解开发及AOP

Spring的bean管理(注解) 注解介绍 1 代码里面特殊标记,使用注解可以完成功能 2 注解写法 @注解名称(属性名称=属性值) 3 注解使用在类上面,方法上面 和 属性上面 Spring注解开发准备 1 导入jar包 (1)导入基本的jar包 (2)导入aop的jar包 2 创建类,创建方法 3 创建spring配置文件,引入约束 (1)第一天做ioc基本功能,引入约束beans (2)做spring的ioc注解开发,引入新的约束 <beans xmlns:xsi="http://

iOS开发-博客导出工具开发教程(附带源码)

前言: 作为一名学生, 作为一名iOS开发学习者, 我个人浏览信息包括博客, 更多的选择移动终端.然而, csdn并没有现成的客户端(不过有个web版的). 之前曾经看到一款开源的导出工具, 但是它是基于Windows平台的.导出的也仅仅是PDF格式.而且, 对于文章的导出, 需要精确URL.无法做到边浏览别导出. 另外, 我想实现的是, 可以在没有网络的情况下, 浏览自己收藏的文章.并且, 对于自己收藏的文章, 可以分类管理. 最关键的是, 对于自己的文章, 可以做一个备份.我曾经遇到过这样一

Annotation（三）——Spring注解开发

Spring框架的核心功能IoC(Inversion of Control),也就是通过Spring容器进行对象的管理,以及对象之间组合关系的映射.通常情况下我们会在xml配置文件中进行action,service,dao等层的声明,然后并告知框架我们想要的注入方式,然后在类中声明要组合类的get,set方法.而通过Spring框架中注解的运用也就主要是解决这类问题的.而框架中另一个核心知识AOP,一种面向横切面的方法编程,在程序中一般都是进行一次设置就可以的,所以都还放在配置文件中.例如声明式