《Spring篇》--- 生命周期扩展点

最新推荐文章于 2024-04-22 11:59:32 发布
最新推荐文章于 2024-04-22 11:59:32 发布
阅读量429 收藏
点赞数 1
分类专栏： 个人笔记 文章标签： 后端 mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_zcy_my/article/details/121677163
版权

Spring生命周期扩展点

概要

一直以来，一直在项目中反复的使用了实现InitializingBean和**ApplicationListener<ContextRefreshedEvent>**中特定方法来对一些特殊的bean或者业务进行预处理，这里就结合和参考网上大佬的总结，来谈一下对Spring生命周期扩展点的一些说明。

执行顺序

执行顺序就是目录顺序。

1. ApplicationContextInitializer

接口
实现方法：

  • initialize(ConfigurableApplicationContext applicationContext)
public class TTT1 implements ApplicationContextInitializer {
    
    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
         System.out.println(111);
    }
}

调用时机： 配置初始化完成

  1. 用于在spring容器刷新之前初始化Spring ConfigurableApplicationContext的回调接口。（就是在容器刷新之前调用该类的 initialize 方法。并将 ConfigurableApplicationContext 类的实例传递给该方法）
  2. 通常用于需要对应用程序上下文进行编程初始化的web应用程序中。例如，根据上下文环境注册属性源或激活配置文件等。
  3. 可排序的（实现Ordered接口，或者添加@Order注解）

因为是在ApplicationContext之前调用的，所以无法由它管理初始化，只能通过配置。有3种方法

1.1 配置文件

context.initializer.classes=com.example.demo.test.TTT1

1.2 Main方法里

public class TTT2 {

    public static void main(String[] args) {
        SpringApplication sa = new SpringApplication(TTT2.class);
        sa.addInitializers(new TTT1());
        sa.run(args);
    }
}

日志打印情况：
加载优先级挺高

1.3 SpringBoot的SPI扩展—META-INF/spring.factories中配置

org.springframework.context.ApplicationContextInitializer=com.example.demo.test.TTT1

只会执行一次

2. @Import

注解
会在ApplicationContextInitializer 后执行，无论写在哪里
@Import(xx.class)
xx.class 要实现ImportBeanDefinitionRegistrar 接口

@Import(TTT3.class)
public class TTT2 {

    public static void main(String[] args) {
        SpringApplication sa = new SpringApplication(TTT2.class);
        sa.addInitializers(new TTT1());
        sa.run(args);

    }
}

日志结果
在这里插入图片描述

3. BeanDefinitionRegistryPostProcessor

接口 继承自 BeanFactoryPostProcessor
实现方法：

  • postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException
  • postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
public class TTT4 implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        
    }
}

调用时机：这个接口在读取项目中的beanDefinition之后执行，提供一个补充的扩展点
使用场景：你可以在这里动态注册自己的beanDefinition，可以加载classpath之外的bean

实现这个接口的类必须是被Spring容器管理的类，也就是类上要有@Component等注解
两个函数会在构造函数执行完之后执行

只会执行一次

4.BeanFactoryPostProcessor

接口
实现方法：

  • postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
public class TTT5 implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        
    }
}

调用时机：这个接口在读取项目中的beanDefinition之后执行，提供一个补充的扩展点
使用场景：你可以在这里动态注册自己的beanDefinition，可以加载classpath之外的bean

5.InstantiationAwareBeanPostProcessor

接口 实现InstantiationAwareBeanPostProcessor 继承与 BeanPostProcessor
实现方法：

postProcessBeforeInstantiation：实例化bean（构造函数）之前，相当于new这个bean之前
可以自定义实例化逻辑，如返回一个代理对象等，（如果此处返回的Bean不为null将中断后续Spring创建Bean的流程，且只执行postProcessAfterInitialization回调方法，如当AbstractAutoProxyCreator的实现者注册了TargetSourceCreator（创建自定义的TargetSource）将改变执行流程，不注册TargetSourceCreator我们默认使用的是SingletonTargetSource（即AOP代理直接保证目标对象），此处我们还可以使用如ThreadLocalTargetSource（线程绑定的Bean）、CommonsPoolTargetSource（实例池的Bean）等等，大家可以去spring官方文档了解TargetSource详情；
postProcessAfterInstantiation：实例化bean（构造函数）之后，相当于new这个bean之后
postProcessPropertyValues(5.1之前)：
postProcessProperties(5.1开始用这个)
bean已经实例化完成，在属性注入时阶段触发，@Autowired,@Resource等注解原理基于此方法实现
postProcessBeforeInitialization：初始化bean之前，相当于把bean注入spring上下文之前
postProcessAfterInitialization：初始化bean之后，相当于把bean注入spring上下文之后
使用场景：这个扩展点非常有用 ，无论是写中间件和业务中，都能利用这个特性。比如对实现了某一类接口的bean在各个生命期间进行收集，或者对某个类型的bean进行统一的设值等等。

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }

    /** @deprecated */
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

请注意

这个接口的方法是对于所有被Spring管理的Bean而言的
如果：你有3个类 Bean1,Bean2,Bean3。
每初始化一个bean，上面的5个方法都会走一遍
如果 Bean 实现了BeanDefinitionRegistryPostProcessor 或 BeanFactoryPostProcessor
上面5个方法将不会接收到它

6.SmartInstantiationAwareBeanPostProcessor

接口 继承自 InstantiationAwareBeanPostProcessor
实现方法：

  • predictBeanType：该触发点发生在postProcessBeforeInstantiation之前，这个方法用于预测Bean的类型，返回第一个预测成功的Class类型，如果不能预测返回null；当你调用BeanFactory.getType(name)时当通过bean的名字无法得到bean类型信息时就调用该回调方法来决定类型信息。
  • 通过@Autowared注入的时候 会校验类型，也会调用这个方法
  • 通过@Reaource注入就不会调用这个方法
  • determineCandidateConstructors：该触发点发生在postProcessBeforeInstantiation之后，构造函数调用之前，用于确定该bean的构造函数之用，返回的是该bean的所有构造函数列表。用户可以扩展这个点，来自定义选择相应的构造器来实例化这个bean。
  • getEarlyBeanReference：该触发点发生在postProcessAfterInstantiation之后，当有循环依赖的场景，当bean实例化好之后，为了防止有循环依赖，会提前暴露回调方法，用于bean实例化的后置处理。这个方法就是在提前暴露的回调方法中触发。
public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
    @Nullable
    default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    @Nullable
    default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

使用场景：看类名Smart就知道，可以让你智能的处理，BeanType，Constructor, 循环依赖。

7.BeanFactoryAware

接口 继承自 Aware
实现方法：

  • setBeanFactory：获得BeanFactory，发生在bean的实例化之后，注入属性之后，postProcessBeforeInitialization 之前
public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory var1) throws BeansException;
}

8.ApplicationContextAwareProcessor

实现了 BeanPostProcessor
在Bean初始化之前注入一些属性
同时这个类 印证了 postProcessBeforeInitialization 的用法

class ApplicationContextAwareProcessor implements BeanPostProcessor {
    private final ConfigurableApplicationContext applicationContext;
    private final StringValueResolver embeddedValueResolver;

    public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
    }

    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (!(bean instanceof EnvironmentAware) && !(bean instanceof EmbeddedValueResolverAware) && !(bean instanceof ResourceLoaderAware) && !(bean instanceof ApplicationEventPublisherAware) && !(bean instanceof MessageSourceAware) && !(bean instanceof ApplicationContextAware) && !(bean instanceof ApplicationStartupAware)) {
            return bean;
        } else {
            AccessControlContext acc = null;
            if (System.getSecurityManager() != null) {
                acc = this.applicationContext.getBeanFactory().getAccessControlContext();
            }

            if (acc != null) {
                AccessController.doPrivileged(() -> {
                    this.invokeAwareInterfaces(bean);
                    return null;
                }, acc);
            } else {
                this.invokeAwareInterfaces(bean);
            }

            return bean;
        }
    }

    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
        }

        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }

        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
        }

        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
        }

        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
        }

        if (bean instanceof ApplicationStartupAware) {
            ((ApplicationStartupAware)bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
        }

        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
        }

    }
}

9.BeanNameAware

接口 继承自 Aware
***这个在 BeanFactory 之前注入 （spring5.2.1）
实现方法：

  • setBeanName
public interface BeanNameAware extends Aware {
    void setBeanName(String var1);
}

10.@PostConstruct

这个触发点是在postProcessBeforeInitialization之后，InitializingBean.afterPropertiesSet之前。

11.InitializingBean

实现方法：

  • afterPropertiesSet
  • 这个触发点是在postProcessAfterInitialization之前。

当然还有一个 init-method （不常用）
执行顺序是
postProcessBeforeInitialization
@PostConstruct > InitializingBean > init-method
postProcessAfterInitialization

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

12.FactoryBean

接口
实现方法：

  • getObject： 返回一个对象的实例
  • getObjectType：返回FactoryBean管理的对象类型

故名思意：这个接口就是用来管理Bean 的生产的
但其实也可以通过@Bean来完成同样的功能
不过实现FactoryBean语义上更明确一些例如 DataSourceFactoryBean，一看就知道跟数据库相关

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }

13.SmartInitializingSingleton

接口
实现方法：

  • afterSingletonsInstantiated：

在所有单例Bean加载完后调用, 因此你可以通过ApplicationContext 来拿到所有加载好的Bean，并对他们进行一些处理

只会执行一次

public interface SmartInitializingSingleton {
    void afterSingletonsInstantiated();
}

14.ApplicationRunner

接口
实现方法：

  • run: 接受ApplicationArguments 参数
@FunctionalInterface
public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}

在项目启动完之后执行
只会执行一次

15.CommandLineRunner

接口
实现方法：

  • run: 接受命令行参数
@FunctionalInterface
public interface CommandLineRunner {
    void run(String... args) throws Exception;
}

在项目启动完之后执行
只会执行一次

16.@PreDestroy

Bean被销毁之前执行

17.DisposableBean

接口
实现方法：

  • destroy
  • Bean被销毁之前执行

执行顺序
@PreDestroy > DisposableBean.destroy > destory-method

18.ApplicationListener

ApplicationEvent以及Listener是Spring为我们提供的一个事件监听、订阅的实现，内部实现原理是观察者设计模式，设计初衷也是为了系统业务逻辑之间的解耦，提高可扩展性以及可维护性。

通过 ApplicationEvent 类和 ApplicationListener 接口来提供在 ApplicationContext 中处理事件。如果一个 bean 实现 ApplicationListener，那么每次 ApplicationEvent 被发布到 ApplicationContext 上，那个 bean 会被通知。

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E var1);

    static <T> ApplicationListener<PayloadApplicationEvent<T>> forPayload(Consumer<T> consumer) {
        return (event) -> {
            consumer.accept(event.getPayload());
        };
    }
}
序号Spring 内置事件 & 描述
1ContextRefreshedEvent ApplicationContext 被初始化或刷新时，该事件被发布。这也可以在 ConfigurableApplicationContext 接口中使用 refresh() 方法来发生。
2ContextStartedEvent当使用 ConfigurableApplicationContext 接口中的 start() 方法启动 ApplicationContext 时，该事件被发布。你可以调查你的数据库，或者你可以在接受到这个事件后重启任何停止的应用程序。
3ContextStoppedEvent当使用 ConfigurableApplicationContext 接口中的 stop() 方法停止 ApplicationContext 时，发布这个事件。你可以在接受到这个事件后做必要的清理的工作。
4ContextClosedEvent当使用 ConfigurableApplicationContext 接口中的 close() 方法关闭 ApplicationContext 时，该事件被发布。一个已关闭的上下文到达生命周期末端；它不能被刷新或重启。
5RequestHandledEvent这是一个 web-specific 事件，告诉所有 bean HTTP 请求已经被服务。

具体可参考：使用ApplicationEvent和Listener快速实现业务解耦，Spring执行ApplicationEvent事件顺序ServletWebServerInitializedEvent

19.@Configuration，@Bean

这两个注解并不是 spring生命周期里的
但，确实我们经常用到的

@Configuration

  • @Configuration：它本身就是一个@Component能被spring容器扫描到,所以它的加载时机与普通Bean是一样的，不同的是它内部被标注为@Bean的方法
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration

@Bean

作用与@Component一样，用它标记的方法会被当成一个工场方法，来生产Bean
在工厂方法里你可以调用非空构造函数，来创建一个复杂类的Bean
你还可以为同一个类创建多个对象
最常见的就是多数据源配置

    @Primary
    @Bean(name = "ds1")
    @ConfigurationProperties(prefix = "spring.datasource1")
    public DruidDataSource getDataSource1() {
        return DataSourceBuilder.create().type(DruidDataSource.class).build();
    }

    @Bean(name = "ds2")
    @ConfigurationProperties(prefix = "spring.datasource2")
    public DruidDataSource getDataSource2() {
        return DataSourceBuilder.create().type(DruidDataSource.class).build();
    }

参考文献

spring 生命周期 扩展点

CSDN_zcy_my
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Bean的生命周期以及Spring的扩展点
诺浅的专栏
09-14 637
缘起 作为Java框架界的常青树，Spring有着无与伦比的魅力，我一直都觉得Spring的源码是Java所有框架里面最复杂的源码，也是最有艺术的源码（个人见解，不对请指正），能够把Spring的源码通读，是我一直以来的梦想。 Spring Bean的生命周期，是面试考点中出现非常频繁的一道面试题，要回答这个面试题，你当然可以简单的说 实例化 属性赋值 初始化 销毁 但如果仅仅是这样回答的话肯定是拿不到满分的。 实际上Spring的强大之处就是Spring为程序员提供了很多的扩展点，程序员可以参与进Be
2022年优秀-Spring业务逻辑层技术.pptx
11-14
- **生命周期管理**：Spring容器可以控制bean的初始化、销毁等生命周期事件，提供了一种灵活的方式来管理对象的生命周期。 3. **Spring框架功能** - **事务管理**：Spring提供了声明式事务管理，使得开发者无需在...
spring整个生命周期涉及拓展点
weixin_38312719的博客
05-09 168
概述 spring整个生命周期，包括spring整个容器的生命周期，也包括spring容器里面单个bean的生命周期，每个阶段spring都给我们留下了拓展接口，方便我们更加灵活定制化spring容器以及容器里面的每个bean spring容器生命周期整理 在这里插入代码片 spring容器bean生命周期整理 在这里插入代码片 ...
一文详解Spring启动阶段的那些扩展点（下）
最新发布
weixin_43966424的博客
04-22 977
SpringBoot项目启动流程中Bean的初始化、SmartInitializingSingleton、CommandlineRunner和ApplicationRunner等扩展点的原理讲解和案例分析
详解spring生命周期的扩展点
逍遥子
10-03 408
详解spring生命周期的扩展点，加速你追赶高手的脚步 详解spring生命周期的扩展点
spring bean的生命周期及各扩展点
peerless_fu的博客
07-27 727
原文链接：简书https://www.jianshu.com/p/1dec08d290c1 Spring Bean的生命周期是Spring面试热点问题。这个问题即考察对Spring的微观了解，又考察对Spring的宏观认识，想要答好并不容易！本文希望能够从源码角度入手，帮助面试者彻底搞定Spring Bean的生命周期。 只有四个！ 是的，Spring Bean的生命周期只有这四个阶段。把这四个阶段和每个阶段对应的扩展点糅合在一起虽然没有问题，但是这样非常凌乱，难以记忆。要彻底搞清楚Spring的生.
Spring在Bean的生命周期中的扩展点
chouzou5531的博客
08-04 197
Spring生命周期中在启动过程中由配置文件转变为系统中能够执行的对象。这个过程中主要步骤有 创建Bean，设置属性。两个关键点将系统中的步骤分为了三个时期中的扩展点。BeanDefintion对象中记录了Bean的基础信息。 一：创建Bean之前， 这个过程是在实例化Cla...
Spring生命周期回调与容器扩展详解
08-28
总之，Spring生命周期回调和容器扩展是强大的工具，可以帮助我们更好地控制bean的行为，实现业务逻辑的定制化。无论是通过XML配置的`init-method`，还是使用注解`@PostConstruct`，或者是利用`BeanPostProcessor`和`...
spring2.5-英文文档1
08-04
Spring 2.5引入了更多的Bean作用域，如prototype（原型）和session，使得开发者可以更灵活地控制Bean的生命周期。 - 更简单的XML配置（Easier XML configuration） 2.5版本的XML配置变得更直观，通过引入如`...
SpringCloud---Eureka(服务发现).docx
08-27
Eureka 通过注册中心来管理服务的生命周期，提供了服务发现、实例管理、健康检查等功能。 微服务架构的设计原则是面向服务的架构（SOA），它将应用程序的不同功能单元（称为服务）通过这些服务之间定义良好的接口和...
java-spring面试题大全
06-14
- **依赖注入和IoC**：通过IoC容器，Spring管理对象的生命周期和依赖关系，简化了代码的编写。 - **开源免费**：Spring是开源的，拥有庞大的社区支持，持续更新和优化。 - **对象管理**：Spring通过集中化的对象...
mini-spring：mini-spring是简化版的spring框架，能帮助您快速熟悉spring原型和掌握spring的核心原理。取下spring的核心逻辑，代码极度简化，保留spring的核心功能，如IoC和AOP，资源加载器，事件监听器，类型转换，容器扩展点，bean生命周期和作用域，应用多维等核心功能
02-05
提取了Spring的核心逻辑，极大地简化了代码，并完善了Spring的核心功能，例如IoC和AOP，资源加载器，事件侦听器，类型转换，容器扩展点，Bean生命周期和作用域以及应用程序上下文，被保留。 如果这个项目可以为您...
spring-framework-2.5.4.zip
07-01
在2.5.4中，Spring提供了更灵活的Bean生命周期控制，包括初始化回调、销毁回调以及自定义生命周期接口，使得开发者能更好地控制对象的生命周期。 5. **国际化与本地化** Spring 2.5.4加强了对多语言环境的支持，...
Hibernate-Spring-Struts面试题目
09-08
其中，IoC（控制反转）和DI（依赖注入）是Spring的核心特性，它们帮助开发者管理对象的生命周期和依赖关系。 【Hibernate ORM 知识点】 Hibernate 是一个流行的Java持久化框架，用于简化数据库操作。它的主要优点...
spring_in_action-sixth-edition.pdf
12-10
Spring 生命周期是指 Spring 应用程序从启动到关闭的整个过程。Spring 生命周期包括应用程序的初始化、启动、运行和关闭等阶段。 11. Spring 配置 Spring 配置是指使用 Spring 框架的配置机制，帮助开发者快速构建...
spring、spring-mvc学习总结-.pdf
02-28
核心容器由 BeanFactory 和 ApplicationContext 组成，负责管理对象的生命周期和依赖关系。BeanFactory 提供了IOC容器的基本功能，而ApplicationContext 则提供了更丰富的企业级服务，如消息源、国际化支持等。 ...
【Spring】Spring中bean生命周期重要的四个扩展点
纸上得来终觉浅，绝知此事要躬行
04-05 3453
一.BeanDefinitionRegistryPostProcessor扩展点 1. 重写 postProcessBeanDefinitionRegistry BeanDefinitionRegistryPostProcessor 继承自 BeanFactoryPostProcessor 需要重写 postProcessBeanDefinitionRegistry 方法 2.获取BeanDefinitionRegistry,增删改BeanDefinition 能过实现 BeanDefinitionR
秒懂SpringBoot之Spring对象生命周期与扩展点浅尝辄止
ShuSheng007的程序人生
10-06 593
IOC与AOP是Spring框架最重要的两个思想。其中的IOC使得我们可以将对象及其依赖交由Spring容器来管理，极大的解放了我们的生产力。但凡事都有两面性，我们在逃避义务的同时也就意味着放弃了控制的权利，以前对象和依赖都是由我们负责处理，我们想怎么弄就怎么弄，但现在交给了spring这个大兄弟，我们做了甩手掌柜，那我们就失去了控制的权利。幸好Spring这个大兄弟比较厚道，给我们留下了若干个扩展点，这些扩展点就是它给我们干预被托管对象的机会，所以我们一定要抓住。
SpringBean生命周期及其扩展点
a2231476020的博客
09-09 221
@Component public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("BeanPostProcessor--->postProcess
spring生命周期
07-27
Spring框架的生命周期是指在应用程序中使用Spring时，各个Spring组件的创建、初始化、使用和销毁的过程。 1. 实例化：当Spring容器启动时，会根据配置文件或注解创建相应的Bean对象。 2. 属性注入：在实例化后，Spring会通过依赖注入的方式将相应的属性值注入到Bean对象中。 3. 初始化：在属性注入完成后，Spring会调用初始化方法对Bean进行一些初始化操作。可以通过实现InitializingBean接口或在配置文件中指定init-method来定义初始化方法。 4. 使用：初始化完成后，Bean对象就可以被应用程序使用了。 5. 销毁：当应用程序关闭时，Spring会调用销毁方法对Bean进行清理工作。可以通过实现DisposableBean接口或在配置文件中指定destroy-method来定义销毁方法。 需要注意的是，Spring容器管理的Bean的生命周期是由Spring容器控制的，不同类型的Bean有不同的生命周期管理方式。例如，单例Bean在容器启动时就会被创建，而原型Bean则是每次请求时都会创建一个新的实例。 另外，Spring还提供了一些扩展点，可以通过实现相应接口来在Bean的生命周期的不同阶段进行自定义操作，例如BeanPostProcessor接口可以在Bean实例化和初始化的前后进行自定义处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值