spring企业开发扩展机制（二）

最新推荐文章于 2023-02-15 14:20:12 发布
最新推荐文章于 2023-02-15 14:20:12 发布
阅读量338 收藏
点赞数 1
分类专栏： spring 文章标签： spring java ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RenaissanceSKY/article/details/108913862
版权

一、扩展原理

1.1 BeanFactoryPostPorcessor

  • BeanPostPorcessor：bean后置处理器，在bean创建对象初始化前后进行拦截操作

  • BeanFactoryPostPorcessor：beanFactory的后置处理器

    在beanFactory标准初始化之后调用，所有的bean定义已经保存加载到beanFactory中，但是bean的实例还未创建

  • 在refresh（）方法中的invokeBeanFactoryPostPorcessors(beanFactory)

1.执行时机

  1. ioc容器创建对象

  2. invokeBeanFactoryPostPorcessors（beanFactory）：执行BeanFactoryPostPorcessors

    ​ 如何找到所有的BeanFactoryPostPorcessor并执行他们的方法？

     1. 直接在beanFactory中找到所有类型是BeanFactoryPostPorcessor的组件，并执行他们的方法

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

1.2 BeanDefinitionRegistryPostProcessor

BeanDefinitionRegistryPostProcessor extends BeanFactoryPostPorcessor

接口方法：postPorcessBeanDefinitionRegistry（BeanDefinitionRegistry registry）

BeanDefinitionRegistry：bean定义的存储中心，以后beanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例（单例还是多例，类型是什么。。。。）

也可以注册一个新的bean

RootBeanDefinition root = new RootBeanDefinition();
registry.registerBeanDefinition("hello",root);

AbstractBeanDefinition bean = 
BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();

registry.registerBeanDefinition("hello",bean);

1. 执行时机

在所有bean定义信息将要被加载，bean实例还未创建 在BeanPostPorcessor之前

  1. IOC容器创建

  2. 调用refresh（）里面的invokeBeanFactoryPostPorcessors（beanFactroy）

  3. 先从容器中获取所有的BeanDefinitionRegistryPostPorcessor组件。

    1. 依次触发所有的postPorcessBeanDefinitionRegistry（）
    2. 再触发possPorcessBeanFactroy（）

  4. 再来从容器中找到BeanFactroyPostPorcessor组件，然后依次触发postPorcessBeanFactroy（）方法

1.3 ApplicationListener

监听容器中发布的事件，完成事件驱动开发

public interface ApplicationListener{}

监听ApplicationEvent及其子事件

1. 基于事件开发

  1. 写一个监听器来监听某个事件（ApplicationEvent下面的及其子类）

  2. 将监听器加入到容器中

  3. 只有有相应类型的发布，就能监听到这个事件

    ​ ContextRefreshEvent：容器刷新完成（所有bean都已经完全创建）会发布这个事件

  4. 发布一个事件

    public static void main(String[] args) {
        AnnotationConfigApplicationContext configApplicationContext = new AnnotationConfigApplicationContext();

        //发布一个事件
        configApplicationContext.publishEvent(new ApplicationEvent(new String()) {
        });

}

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

    //当容器中发布此事件以后，方法会触发
    public void onApplicationEvent(ApplicationEvent applicationEvent) {
        System.out.println("收到事件"+applicationEvent);
    }
}

1.2 内部原理

  1. ContextRefreshedEvent事件：

    1. 容器创建，调用refresh方法

    2. 调用finishRefresh（）：容器刷新完成执行

    3. 也可以自己发布事件，都会走下面的流程

      事件发布流程：

      • 调用pubilshEvent(new ContextRefreshedEvent（this）)

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

      2. multicasterEvent（）：派发事件

      3. 获取到所有的ApplicationListener

        for（final ApplicationListener<?> listener ： getApplicationListeners(event,type)）

        1. 如果有Executor，可以支持使用Executor进行异步派发

        2. 否则使用同步方法，直接执行listener方法

          拿到listener回调onApplicationEvent方法

【事件多播器（ApplicationEventMulticaster）】

ApplicationEventMulticaster

  1. 容器创建对象：refresh（）

  2. 调用initApplicationEventMulticaster（）：初始化ApplicationEventMulticaster

    1. 先去容器找有没有id="applicationEventMulticaster"的组件；

    2. 如果没有创建一个SimpleApplicationEventMulticaster（beanFactroy）

      并且加入到容器中，就可以在其他组件要派发事件，自动注入这个applicationEventMultister

【容器中有哪些监听器】

  • refresh（）方法中

  • registerListener（）【check for listener beans and register them】

    • 从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中

      //获取所有类型的监听器

      String [] listenerBeanNames = getBeanNamesForType(ApplicationListener.class,true,false)

      //将listener注册到ApplicationEventMulticaster中

      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName)

1.4 @EventListener和SmartInitalizingSingleton

@EventListener：可以将业务层进行监听事件的发生

@Service
public class UserService{
    
    
    //定义一个监听方法，用来监听事件的发生
    @EventListener(classes = {ApplicationEvent.class})
    public void listener(ApplicationEvent event){
        sout(event);
    }
    
}

注解原理：利用EventListenerMethodProcessor来进行处理

SmartInitalizingSingleton：接口

方法：afterSingletonsInstantiated

​ 会在单实例bean创建阶段完成之后

EventListenerMethodPorcessor处理器来解析@EventListener

1. 执行流程

  1. ioc容器创建对象并refresh容器

  2. finishBeanFactroyInitialzation(beanFactroy)：初始化剩下单实例bean

    1. 先创建所有的单实例bean；getBean（）

    2. 获取所有创建好的单实例bean，判断是否是SmartInitalizingSingleton类型的

      如果是就调用afterSingletonsInstantiated（）

二、spring容器源码

1.1 BeanFactroy预处理

  1. prepareRefresh（） 刷新预处理

    1. initPropertySources（）：初始化一些属性设置；此方法是一个空实现。留给子类自定义属性个性化的属性设置
    2. getEnviroment().validateRequiredProperties()：校验属性的合法等
    3. earlyApplicationEvents = new LinkedHashSet：保存容器中早期的事件

  2. obtainFreshBeanFactory()：获取beanFactroy

    1. refreshBeanFactroy：刷新beanFactroy。核心是创建了一个beanFactroy对象

      创建了一个this.beanFactroy = new DefaultListableBeanFactory()

    2. getBeanFactory：返回刚才GenericApplicationContext创建的BeanFactory对象

    3. 将创建的BeanFactory返回 【默认DefaultListableBeanFactory】

  3. prepareBeanFactory(beanFactory)：对BeanFactory的预准备工作（BeanFactroy进行一些设置）

    1. 设置BeanFactroy的类加载器、支持表达式…

    2. 添加部分BeanPostPorcessor【ApplicationContextAwareProcessor】

    3. 设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxxx

    4. 注册可以解析的自动装配；可以在任何组件中自动注入:BeanFactroy、ResourceLoader、ApplicationEventPublisher、ApplicationContext

    5. 添加BeanPostPorcessor【ApplicationListenerDetector】

    6. 添加编译时的AspectJ支持

    7. 给BeanFactroy中注册一些能用的组件；

      environment【ConfigurationEnvironment】

      systemProperties【Map<String,Object>】

      systemEnvironment【Map<String,Object>】

    	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		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 interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// Register default environment beans.
		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());
		}
	}

  4. postProcessBeanFactory(beanFactroy)：BeanFactroy准备工作完成后进行的后置处理工作

    1. 子类通过重写这个方法来在BeanFactroy创建并预准备完成以后做进一步的设置

1.2执行BeanFactoryPostPorcessor

  1. invokeBeanFactroyPostProcessors(beanFactory)：执行beanFactroyPostPorcessor的方法

    beanFactroyPostPorcessor：BeanFactroy的后置处理器；在beanFactroy标准初始化之后执行的

    两个子接口：BeanFactroyProcessor、BeanDefinitionRegistryPostPorcessor

    执行顺序：

    1. PostProcessorRegistrationDelegate.invokeBeanFactoryPostPorcessors:执行BeanFactroyPorcessor方法

      先执行BeanDefinitionRegistryPostProcessor

      1. 获取所有的BeanDefinitionRegistryPostProcessor；

      2. 先执行实现了 PriorityOrdered优先级接口的BeanDefinitionRegistryPostPorcessor

        执行postProcessor.postProcessBeanDefinitionRegistry(registry)

      3. 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor

        执行postProcessor.postProcessBeanDefinitionRegistry(registry)

      4. 最后执行没有实现任何优先级顺序的BeanDefinitionRegistryPostProcessors；

        执行postProcessor.postProcessBeanDefinitionRegistry(registry)

    2. 再执行BeanFactoryPostProcessor的方法

      1. 获取所有的BeanDefinitionRegistryPostProcessor；

      2. 先执行实现了 PriorityOrdered优先级接口的BeanFactoryPostProcessor

        执行postProcessor.postProcessBeanDefinitionRegistry(registry)

      3. 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor

        执行postProcessor.postProcessBeanDefinitionRegistry(registry)

      4. 最后执行没有实现任何优先级顺序的BeanFactoryPostProcessor；

        执行postProcessor.postProcessBeanDefinitionRegistry(registry)

1.3 注册BeanPostProcessor

作用：注册BeanPostProcessor（Bean的后置处理器）【intercept bean creation】

不同接口类型的BeanPostProcessor：在bean创建的前后执行时机是不一样的

​ BeanPostProcessor

​ DestructionAwareBeanPostProcessor（销毁方法的后置处理器）

​ InstantiationAwareBeanPostProcessor

​ SmartInstantiationAwareBeanPostProcessor

​ MergedBeanDefinitionPostProcessor【记录在internalPostProcessors】

  1. 获取所有的 BeanPostProcessor；后置处理器都有优先级 PriorityOrdered、Ordered

  2. 先注册PriorityOrdered；把每一个BeanPostProcessor添加到BeanFactroy中

    beanFactroy.addBeanPostProcessor(postProcessor)

  3. 再注册实现了Ordered接口的

  4. 最后注册，没有实现任何优先级接口的

  5. 最终注册MergedBeanDefinitionPostProcessor；

  6. 最终还注册一个ApplicationListenerDetector；来检查bean创建完成后，是否是ApplicationListener

    applicationContext.addApplicationListener((ApplicationListener<?>) bean)

1.4 initMessageSource

初始化messageSource组件（国际化功能，消息绑定和消息解析）

  1. 获取BeanFactory

  2. 看容器中是否有ID为messageSource组件

  3. 如果有就拿来用，如果没有就拿一个默认的DelegatingMessageSource

    MessageSource：取出国际化配置文件中的某个key值；能按照区域信息获取

  4. 把创建好的MessageSource注册到容器中，以后获取国际化配置文件值的时候，可以注入MessageSource中

    beanFactroy.registrySingleton(MESSAGE_SOURCE_BEAN_NAME，this.messageSource)

    调用 String getMessage（String code，Object[] args，String defaultMessage，Locale locale）

1.5 initApplicationEventMuticaster

初始化事件派发器

  1. 获取BeanFactroy
  2. 从BeanFactroy中获取applicationEventMulticaster的组件
  3. 如果没有配置，就创建一个SimpleApplicationEventMulticaster
  4. 将创建的ApplicationEventMulticaster注入到容器中，以后其他组件直接自动注入即可

1.6 onRefresh

作用：留给子容器的

  1. 重写onRefresh方法，容器刷新的时候自定义逻辑

1.7 registerListeners

给容器中将所有项目的监听器ApplicationListener注册进来

  1. 从容器中拿到所有的ApplicationListener组件

  2. 将每个监听器添加到事件派发器

    getApplicationEventMulticaster.addApplicationListenerBean(listenerBeanName)

  3. 派发之前步骤产生的事件；

1.8 finishBeanFactroyInitialization(beanFactroy) 重点！！！！！

初始化所有剩下的单实例bean

  1. beanFactroy.preInstantiateSingletons()：初始化所有剩下的单实例Bean

    1. List beanNames = new ArrayList(this.beanDefinitionNames);获取所有的容器的bean，依次进行初始化和创建对象

    2. 拿到Bean的定义信息 RootBeanDefinition db = getMergedLocalBeanDefinition(beanName)

      Bean不是抽象的，是单实例的，是非懒加载的

    3. 判断是否是FactroyBean；是否是实现FactroyBean接口的Bean，如果是调用getObject方法

      如果不是工厂Bean，利用getBean创建对象

      getBean(beanName)的步骤

      1. 调用doGetBean

      2. 先获取缓存中保存的单实例bean，如果能获取到说明以前创建过。（所有创建的单实例Bean都会被缓存）

        从final Map<String,Object> singletonObjects = new ConcurrentHashMap<Stirng,Object>(256)获取的

      3. 缓存是空的。开始bean的创建流程

      4. 标记当前Bean已经被创建 markBeanAsCreated防止多线程同时操作

      5. 获取Bean的定义信息

        final RootBeanDefinition mdb = getMergedLocalBeanDefinition(beanName)

      6. 获取当前Bean依赖的其他Bean

        1. 什么叫依赖bean

          <bean id="person" class="com.atguigu.bean.Person" depends-on="user,book">

决定创建顺序

      7. 启动单实例Bean的创建流程

        1. 调用createBean(beanName,mbd,args)
        sharedInstance = getSingleton(beanName,new ObjectFactroy<Object>){
    @Override
    public Object getObject throws BeansException{
        try{
            return createBean(beanName,mbd,args);
        }
        catch(BeanException ex){
            destroySingleton(beanName);
            throw ex;
        }
    }
}

        1. Object bean = resolveBeforeInstantiation(beanName,mbdToUse)

          给BeanPostProcessors 一个机会 返回一个bean代理对象

          是InstantiationAwareBeanPostProcessor：提前执行的逻辑

          先触发：postProcessBeforeInstantiation（）

          如果有返回值：触发postProcessAfterInitialization（）

        2. 如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象

        3. Object beanInstance = doCreateBean（beanName，mbdToUse，args）

          1. 【创建Bean实例】，createBeanInstance（beanName，mbd，args ）

            利用工厂方法或者对象的构造器创建出Bean实例

          2. applyMergedBeanDefinitionPostProcessors（mbd，beanType，beanName）

            调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法

          3. 【为bean的属性赋值】populateBean（beanName，mbd，instanceWrapper）：

            赋值之前

            1. 拿到InstantiationAwareBeanPostProcessor后置处理器；

              执行postProcessAfterInstantiation（）

            2. 再拿到InstantiationAwareBeanPostProcessor后置处理器；

              执行postProcessPropertyValues（）

            3. applyPropertyValues（beanName，mbd，bw，pvs）：为属性setter方法等赋值

          4. 【Bean初始化】initializeBean（beanName，exposedObject，mbd）

            1. 【执行Aware接口】invokeAwareMethods（beanName，bean）：执行xxxAware接口的方法

              BeanNameAware、BeanClassLoaderAware、BeanFactroyAware

            2. 【后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization（wrappedBean，beanName）

              BeanPostPorcessor.postPorcessBeforeInitialization（）

            3. 【执行初始化方法】invokeInitMethods（beanName，wrappedBean，mbd）

              1. 是否是InitializingBean接口的实现；执行接口规定的初始化
              2. 是否自定义初始化方法

            4. 【执行初始化之后方法】applyBeanPostProcessorsAfterInitialization

              BeanPostProcessor.postProcessAfterInitialization（）

          5. 注册Bean的销毁方法

        4. 将创建的Bean添加到缓存中singletonObjects；

          ioc容器就是这些Map；很多的Map保存了单实例bean，环境信息。。。。

    4. 所有的Bean都利用getBean创建完成以后

      检查所有的Bean是否是SmartInitializingSingleton接口的；

      如果是就执行 afterSingletonsInstantiated方法

1.9 容器创建完成 finishRefresh

完成BeanFactroy的初始化创建工作；IOC容器彻底创建完成

  1. initLifecycleProcessor（）；初始化生命周期有关的后置处理器；LifecycleProcessor

    默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；

    如果没有使用默认的 new DefaultLifecycleProcessor（）

    写一个LifecycleProcessor的实现类，可以在BeanFactroy刷新完成或关闭之后进行一些调用。

    void onRefresh（）、void onClose（）

  2. getLifecycleProcessor.onRefresh()：拿到前面定义的生命周期处理器（监听BeanFactroy）；回调onRefresh

  3. publishEvent(new ContextRefreshedEvent(this))：发布容器刷新完成事件

  4. LiveBeanView.registerApplicationContext(this)

三、总结

  1. spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；

    1. xml注册Bean
    2. 注解注册Bean @Service @Component @Bean

  2. spring容器会在合适的时机创建这些bean

    1. 用到Bean的时候；利用getBean创建Bean，创建好以后保存到容器中
    2. 统一创建剩下所有Bean的时候；finishBeanFactroyInitialization（）

  3. 后置处理器（BeanPostProcessor）

    1. 每一个Bean创建完成都会使用各种后置处理器进行处理；增强Bean的功能

      AutowiredAnnotationBeanPostProcessor：处理自动注入功能

      AnnotationAwareAspectJAutoProxyCreator：来做AOP功能

  4. 事件驱动模型

    ApplicationListener：事件监听

    ApplicationEventMulticaster；事件派发

RenaissanceSKY
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个自动配置的实现
SHGU
09-05 467
原理 @Configuration 从Spring3.0，@Configuration用于定义配置类，可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。 ...
SpringBoot中的SmartInitializingSingleton接口的使用
daxues_的博客
07-12 1882
SmartInitializingSingleton 接口 的常规使用
Springboot扩展点之SmartInitializingSingleton
凡夫编程
02-15 6720
这篇文章会重点分析一下SmartInitializingSingleton扩展点的功能 特性、实现方式 、工作原理。SmartInitializingSingleton扩展点内只有一个扩展方法，且执行时机在Spring Bean的生命周期里比较靠后，很重要，但是也很简单。 功能特性：1、SmartInitializingSingleton主要用于在Spring容器启动完成时进行扩展操作，即afterSingletonsInstantiated()； 2、实现SmartInitializingSing
Spring源码 - 核心接口SmartInitializingSingleton&InitializingBean
目目沐沐
01-15 5万+
Spring源码 - 核心接口SmartInitializingSingleton&InitializingBean
SpringBoot中15个常用启动扩展点，你用过几个？
m0_73311735的博客
09-22 963
我们从这些spring&springboot的扩展点当中，大致可以窥视到整个bean的生命周期。在业务开发或者写中间件业务的时候，可以合理利用spring提供给我们的扩展点，在spring启动的各个阶段内做一些事情。以达到自定义初始化的目的。此篇总结，如果有错误或者疏漏的地方，恳请指正。
Spring容器扩展机制的实现原理
08-26
Spring容器扩展机制的实现原理 Spring框架的核心组件之一是IoC容器，它负责管理容器中所有bean的生命周期。在bean生命周期的不同阶段，Spring提供了不同的扩展点来改变bean的命运。这些扩展点使得开发者可以在容器...
Spring-Boot插件式开发框架，为动态扩展系统而生的插件开发框架
06-01
SpringBoot插件式开发框架是基于SpringBoot框架构建的一种创新性开发模式，旨在解决系统动态扩展和模块化管理的问题。这种框架充分利用了SpringBoot的简洁、高效特性，为开发者提供了快速构建可插拔功能的能力。下面...
JBPM与Spring集成开发指南.docx
11-16
总之，JBPM与Spring的集成开发能够为企业的业务流程自动化提供强大的支持，通过Spring的灵活性管理和控制JBPM，实现高效、灵活的业务流程管理。开发者需要熟悉两者的特性和API，以便于在实际项目中构建出符合需求的...
Spring中XML schema扩展机制的深入讲解
08-27
了解并掌握Spring的XML Schema扩展机制，不仅可以帮助我们理解Dubbo等框架的内部工作原理，还能让我们在自定义配置或开发框架时更加得心应手。 总的来说，Spring的XML Schema扩展机制是一项强大的工具，它使得XML...
使用Spring事件机制实现异步的方法
08-27
使用Spring事件机制可以实现松散耦合的设计理念，提高代码的可维护性和可扩展性。开发者可以根据需要自定义事件和事件监听器，实现灵活的异步处理机制。 Spring事件机制的优点包括： * 松散耦合的设计理念，提高...
spring bean生命周期四---Spring Bean 初始化阶段（Initialization）
qq_36697880的博客
02-19 2066
目录 概述 一、initializeBean 2.1、invokeAwareMethods - 激活 Aware 方法 2.2、Spring Bean 初始化前阶段 第七次调用后置处理器 2.3、invokeInitMethods - 激活自定义的init方法 2.4、Spring Bean 初始化后阶段 第八次调用后置处理器postProcessAfterInitialization 三、Spring Bean 初始化完成阶段 四、测试代码案例： 概述 本文是笔者阅读Sprin..
Spring核心接口InitializingBean与SmartInitializingSingleton
ATM的博客
11-08 397
3、在Spring初始化bean的时候，如果该bean实现了InitializingBean接口，并且同时在配置文件中指定了init-method，系统则是先调用afterPropertieSet()方法，然后再调用init-method中指定的方法。1、InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。
Spring5源码 - 13 Spring事件监听机制_@EventListener源码解析
小工匠
10-31 1万+
文章目录Pre概览@EventListener Pre Spring5源码 - 10 Spring事件监听机制_应用篇 Spring5源码 - 11 Spring事件监听机制_源码篇 Spring5源码 - 12 Spring事件监听机制_异步事件监听应用及源码解析 通过上面三篇文章的学习，是不是发现没有看到Spring是如何解析@EventListener注解的呢？ Let’s go ~~~ 概览 @EventListener ...
初探Spring的事件监听机制
ITlikeyou的博客
03-31 680
本文主要是聊一聊Spring中的事件机制 1、 事件监听你以为就一个@EventListener? 首先，在容器刷新的this阶段，Spring有了白手起家的4个组件：ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、EventListenerMethodProcessor、DefaultEventListenerFactory，对于这四个组件：ConfigurationClassPostProcessor是来处理配.
【Spring源码】- 06 扩展点之SmartInitializingSingleton
god_86的专栏
04-18 4192
执行时机SmartInitializingSingleton主要用于在IoC容器基本启动完成时进行扩展，这时非Lazy的Singleton都已被初始化完成。所以，在该扩展点执行Lista...
Spring中bean的生命周期（最详细）
热门推荐
qq_35634181的博客
02-26 14万+
Spring Bean的生命周期是Spring面试热点问题。Spring Bean的生命周期指的是从一个普通的Java类变成Bean的过程，深知Spring源码的人都知道这个给面试官讲的话大可讲30分钟以上，如果你不没有学习过Spring的源码，可能就知道Aware接口和调用init方法这样的生命周期，所以这个问题既考察对Spring的微观了解，又考察对Spring的宏观认识，想要答好并不容易！本文希望能够从源码角度入手，帮助面试者彻底搞定Spring Bean的生命周期。 首先你要明白一点，Sp
Bean实例化过程分析
朱玉强的博客
03-24 759
在上一篇博客中介绍了Spring初始化加载流程，本篇博客将在上篇博客的基础上，详细介绍一下Bean的实例化过程，如果没有看过上篇博客（Spring初始化流程加载分析）的朋友可以先看一下。一个Bean对象在实例化之前，需要准备好相关的信息，bean的类型，bean实体对象中相关属性的值，恰好这些信息在解析xml配置文件的时候都是可以获得的，这些信息都将会保存在BeanFactory中。下面我们开始分析
IOC容器其他相关特性设计与实现
T Yuan
05-12 677
ApplicationContext和Bean初始化、销毁 启动过程在AbstractApplicationContext中 准备过程在prepareBeanFactory方法，为容器配置了ClassLoader、PropertyEditor和BeanPostProcessorprotected void prepareBeanFactory(ConfigurableListableBeanFa
Spring 中 BeanDefinition 的注册
weixin_46144481的博客
07-14 701
本文我们来了解下 spring 中 BeanDefinition 的注册 在 spring 中对 bean 的注册主要有两种方式： 第一种是通过配置来注册我们的bean，对应的方法是 DefaultListableBeanFactory 里的 registerBeanDefinition() 方法 第二种是直接注册一个单例 bean，对应的方法则是 DefaultListableBeanFactory 里的 registerSingleton() 方法 下面我们分别来看看这两个方法 registerBe
Spring知识点总结大全
最新发布
09-19
Spring知识点总结大全深入探讨了Java企业级开发中Spring框架的重要性和应用。首先，Spring起源于对EJB框架的不满，EJB存在过于复杂、依赖性高和侵入性强的问题，这促使Spring的出现，旨在简化企业级程序开发并提供更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值